C语言能实现多线程么

可以通过调用C语言函数库pthread里的函数，创建多线程。

多线程是指程序中包含多个执行流，即在一个程序中可以同时运行多个不同的线程来执行不同的任务，也就是说允许单个程序创建多个并行执行的线程来完成各自的任务。

C语言最初并未设计多线程的机制，随着软硬件的发展及需求的发展，C语言才开发了线程库以支持多线程的 *** 作和应用。

可以通过以下原则解决：

1、设置线程池的最大线程数

2、设置线程池的并发处理线程数量

3、设置线程池最大的队列线程数

4、做好线程池的线程清理工作

做好这几点，理论上没问题了，具体还得看编程者代码的质量。

PS：服务器不可能为每一个请求都创建线程，得考虑到最大负载，当达到临界值的时候，服务器返回繁忙状态，拒绝服务即可，当然这是简单的处理办法。

1、使用pthread库执行多线程，这个是Linux下的线程库 Windows下应该有自己的API，不过这种东西一般还是以Linux为标准。pthread_create()创建一个线程，传入fun()的函数指针就行了。然后这个Beep()的需求要进行线程间通信，可以用共享内存的方法，设一个bool变量flag共享，然后beep的时候设为false，beep完设成true。fun()里面每次看一下这个flag，是false的话就不做动作等下一秒，基本可以满足需求。

2、例程：

#include <stdioh>

#include <sys/timeh>

#include <stringh>

#define MAX 10

pthread_t thread[2];

pthread_mutex_t mut;

int number=0, i;

void thread1()

{

printf ("thread1 : I'm thread 1\n");

for (i = 0; i < MAX; i++)

{

printf("thread1 : number = %d\n",number);

pthread_mutex_lock(&mut);

number++;

pthread_mutex_unlock(&mut);

sleep(2);

}

printf("thread1 :主函数在等我完成任务吗？\n");

pthread_exit(NULL);

}

void thread2()

{

printf("thread2 : I'm thread 2\n");

for (i = 0; i < MAX; i++)

{

printf("thread2 : number = %d\n",number);

pthread_mutex_lock(&mut);

number++;

pthread_mutex_unlock(&mut);

sleep(3);

}

printf("thread2 :主函数在等我完成任务吗？\n");

pthread_exit(NULL);

}

void thread_create(void)

{

int temp;

memset(&thread, 0, sizeof(thread)); //comment1

/创建线程/

if((temp = pthread_create(&thread[0], NULL, thread1, NULL)) != 0) //comment2

printf("线程1创建失败!\n");

else

printf("线程1被创建\n");

if((temp = pthread_create(&thread[1], NULL, thread2, NULL)) != 0) //comment3

printf("线程2创建失败");

else

printf("线程2被创建\n");

}

void thread_wait(void)

{

/等待线程结束/

if(thread[0] !=0) { //comment4

pthread_join(thread[0],NULL);

printf("线程1已经结束\n");

}

if(thread[1] !=0) { //comment5

pthread_join(thread[1],NULL);

printf("线程2已经结束\n");

}

}

int main()

{

/用默认属性初始化互斥锁/

pthread_mutex_init(&mut,NULL);

printf("我是主函数哦，我正在创建线程，呵呵\n");

thread_create();

printf("我是主函数哦，我正在等待线程完成任务阿，呵呵\n");

thread_wait();

return 0;

}

#ifndef THREAD_H_  

#define THREAD_H_  

#include <unistdh>  

#include <pthreadh>  

class Runnable  

{  

public:  

//运行实体  

virtual void run() = 0;  

};  

//线程类  

class Thread: public Runnable  

{  

private:  

//线程初始化号  

static int thread_init_number;  

//当前线程初始化序号  

int current_thread_init_number;  

//线程体  

Runnable target;  

//当前线程的线程ID  

pthread_t tid;  

//线程的状态  

int thread_status;  

//线程属性  

pthread_attr_t attr;  

//线程优先级  

sched_param param;  

//获取执行方法的指针  

static void run0(void pVoid);  

//内部执行方法  

void run1();  

//获取线程序号  

static int get_next_thread_num();  

public:  

//线程的状态－新建  

static const int THREAD_STATUS_NEW = 0;  

//线程的状态－正在运行  

static const int THREAD_STATUS_RUNNING = 1;  

//线程的状态－运行结束  

static const int THREAD_STATUS_EXIT = -1;  

//构造函数  

Thread();  

//构造函数  

Thread(Runnable target);  

//析构  

~Thread();  

//线程的运行体  

void run();  

//开始执行线程  

bool start();  

//获取线程状态  

int get_state();  

//等待线程直至退出  

void join();  

//等待线程退出或者超时  

void join(unsigned long millis_time);  

//比较两个线程时候相同，通过current_thread_init_number判断  

bool operator ==(const Thread other_pthread);  

//获取this线程ID  

pthread_t get_thread_id();  

//获取当前线程ID  

static pthread_t get_current_thread_id();  

//当前线程是否和某个线程相等，通过tid判断  

static bool is_equals(Thread iTarget);  

//设置线程的类型:绑定/非绑定  

void set_thread_scope(bool isSystem);  

//获取线程的类型:绑定/非绑定  

bool get_thread_scope();  

//设置线程的优先级，1－99，其中99为实时，意外的为普通  

void set_thread_priority(int priority);  

//获取线程的优先级  

int get_thread_priority();  

};  

int Thread::thread_init_number = 1;  

inline int Thread::get_next_thread_num()  

{  

return thread_init_number++;  

}  

void Thread::run0(void pVoid)  

{  

Thread p = (Thread) pVoid;  

p->run1();  

return p;  

}  

void Thread::run1()  

{  

thread_status = THREAD_STATUS_RUNNING;  

tid = pthread_self();  

run();  

thread_status = THREAD_STATUS_EXIT;  

tid = 0;  

pthread_exit(NULL);  

}  

void Thread::run()  

{  

if (target != NULL)  

{  

  (target)run();  

}  

}  

Thread::Thread()  

{  

tid = 0;  

thread_status = THREAD_STATUS_NEW;  

current_thread_init_number = get_next_thread_num();  

pthread_attr_init(&attr);  

}  

Thread::Thread(Runnable iTarget)  

{  

target = iTarget;  

tid = 0;  

thread_status = THREAD_STATUS_NEW;  

current_thread_init_number = get_next_thread_num();  

pthread_attr_init(&attr);  

}  

Thread::~Thread()  

{  

pthread_attr_destroy(&attr);  

}  

bool Thread::start()  

{  

return pthread_create(&tid, &attr, run0, this);  

}  

inline pthread_t Thread::get_current_thread_id()  

{  

return pthread_self();  

}  

inline pthread_t Thread::get_thread_id()  

{  

return tid;  

}  

inline int Thread::get_state()  

{  

return thread_status;  

}  

void Thread::join()  

{  

if (tid > 0)  

{  

  pthread_join(tid,NULL);  

}  

}  

void Thread::join(unsigned long millis_time)  

{  

if (tid == 0)  

{  

  return;  

}  

if (millis_time == 0)  

{  

  join();  

}  

else  

{  

  unsigned long k = 0;  

  while (thread_status != THREAD_STATUS_EXIT && k <= millis_time)  

  {  

   usleep(100);  

   k++;  

  }  

}  

}  

bool Thread::operator ==(const Thread other_pthread)  

{  

if(other_pthread==NULL)  

{  

  return false;  

}if(current_thread_init_number==(other_pthread)current_thread_init_number)  

{  

  return true;  

}  

return false;  

}  

bool Thread::is_equals(Thread iTarget)  

{  

if (iTarget == NULL)  

{  

  return false;  

}  

return pthread_self() == iTarget->tid;  

}  

void Thread::set_thread_scope(bool isSystem)  

{  

if (isSystem)  

{  

  pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM);  

}  

else  

{  

  pthread_attr_setscope(&attr, PTHREAD_SCOPE_PROCESS);  

}  

}  

void Thread::set_thread_priority(int priority)  

{  

pthread_attr_getschedparam(&attr,&param);  

param__sched_priority = priority;  

pthread_attr_setschedparam(&attr,&param);  

}  

int Thread::get_thread_priority(){  

pthread_attr_getschedparam(&attr,&param);  

return param__sched_priority;  

}  

#endif / THREAD_H_ /

1、首先 printf 根据链接的运行时库不同，是分担线程和多线程版本，你这个应该链接多线程版本，否则会出现这种奇怪的错误。

2、这种传递参数是可行的。将结构体的指针作为这个唯一的参数传过去就可以了

要注意变量的作用域。

C语言的全局变量是所有线程都可以访问的内存数据，当我们想存放和频繁获取一些线程相关的数据时，比如当前线程的id和状态等信息，如果只是用全局变量来实现，会有一些性能上的损耗，就是每次获取时都要去遍历所有的线程信息来查找当前线程的信息。

（windows msvc compiler）

调用API GetSystemInfo可以获得，具体去搜索下如何用。定义相同数量的线程，就用一个FOR循环，调用CREATETHREAD就行了，最好使用库提供的线程函数替代这个API。

最好使用库提供的线程函数替代这个API这句话的意思是，CREATETHREAD这个API在每一个库下都有不同的实现，比如MFC中有AfxBeginThread起相同的作用。为什么要这么做，因为不同的库实现的机理不同，有一些需要在线程开始时初始化的属性，但是 *** 作系统的API是不知道这些的，可能出现一些问题，具体有哪些问题这里不提了，你查MFC手册，里面有详细说明。

以上就是关于C语言能实现多线程么全部的内容，包括:C语言能实现多线程么、如何使用C信号QML多线程问题，怎么解决、用C语言如何实现多线程同时运行的情况下，各个线程输出不同的随机数等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！