① linux c 编写一个多线程。。。
多线程程序的编写，是和操作系统和语言都有关系的。
1。首先，操作系统需要支持多线程，很久之前的古老的操作系统是不支持多任务多线程的。当然，当前的操作系统都是支持多线程的。但是，不同的操作系统具体如何支持的细节是不太一样的，也有效率之别。
2。语言方面，
2.1 C/C++在语言本身是不支持多线程开发的，但是能够进行API调用；同时现在有很多C++方面的库，通常也是跨平台的，比如Boost，OpenMP，MPI之类；
vc2010在2010年4月12号发布了，vc2010里面微软增加了一个并行开发的库。
2.2 C#和Java在语言本身层面上就支持多线程开发了。说得更直接一些，就是语言函数库里提供了封装包，用起来很方便。
多线程开发，其实最关键的是操作系统层面的运作机理。Windows和unix/linux上很多概念是相似的，但是有些细节方面是有所出入的。需要针对操作系统，学习内部机制。
开发库，开发语言都是相对次要的一个层面。可以选择你喜欢的语言。
因为操作系统底层API的不同，如果直接调用API开发，那肯定不会就有移植性的。但是现在有一些库（比如Boost）是可移植的，基于这些库就可以达到可移植。
用C/C++在Windows和Linux下面编写多线程程序,概念是相通的，具体细节是有一些差别的。但是你在windows上很有经验了之后，再在Linux上做，肯定很快就能搞定的。
② 浅谈linux 多线程编程和 windows 多线程编程的异同
很早以前就想写写linux下多线程编程和windows下的多线程编程了，但是每当写时又不知道从哪个地方写起，怎样把自己知道的东西都写出来，下面我就谈谈linux多线程及线程同步，并将它和windows的多线程进行比较，看看他们之间有什么相同点和不同的地方。
其实最开始我是搞windows下编程的，包括windows编程，windows 驱动，包括usb驱动，ndis驱动,pci驱动，1394驱动等等，同时也一条龙服务，做windows下的应用程序开发，后面慢慢的我又对linux开发产生比较深的兴趣和爱好，就转到搞linux开发了。在接下来的我还会写一些博客，主要是写linux编程和windows编程的区别吧，现在想写的是linux下usb驱动和windows下usb驱动开发的区别，这些都是后话，等我将linux多线程和windows多线程讲解完后，我再写一篇usb驱动，谈谈windows 和linux usb驱动的东东。好了，言归正传。开始将多线程了。
首先我们讲讲为什么要采用多线程编程，其实并不是所有的程序都必须采用多线程，有些时候采用多线程，性能还没有单线程好。所以我们要搞清楚，什么时候采用多线程。采用多线程的好处如下：
(1)因为多线程彼此之间采用相同的地址空间，共享大部分的数据，这样和多进程相比，代价比较节俭，因为多进程的话，启动新的进程必须分配给它独立的地址空间，这样需要数据表来维护代码段，数据段和堆栈段等等。
(2)多线程和多进程相比，一个明显的优点就是线程之间的通信了，对不同进程来说，它们具有独立的数据空间，要进行数据的传递只能通过通信的方式进行，这种方式不仅费时，而且很不方便。但是对于多线程就不一样了。他们之间可以直接共享数据，比如最简单的方式就是共享全局变量。但是共享全部变量也要注意哦，呵呵，必须注意同步，不然后果你知道的。呵呵。
(3)在多cpu的情况下，不同的线程可以运行不同的cpu下，这样就完全并行了。
反正我觉得在这种情况下，采用多线程比较理想。比如说你要做一个任务分2个步骤，你为提高工作效率，你可以多线程技术，开辟2个线程，第一个线程就做第一步的工作，第2个线程就做第2步的工作。但是你这个时候要注意同步了。因为只有第一步做完才能做第2步的工作。这时，我们可以采用同步技术进行线程之间的通信。
针对这种情况，我们首先讲讲多线程之间的通信，在windows平台下，多线程之间通信采用的方法主要有：
(1)共享全局变量,这种方法是最容易想到的，呵呵，那就首先讲讲吧，比如说吧，上面的问题，第一步要向第2步传递收据，我们可以之间共享全局变量，让两个线程之间传递数据，这时主要考虑的就是同步了，因为你后面的线程在对数据进行操作的时候，你第一个线程又改变了数据的内容，你不同步保护，后果很严重的。你也知道，这种情况就是读脏数据了。在这种情况下，我们最容易想到的同步方法就是设置一个bool flag了，比如说在第2个线程还没有用完数据前，第一个线程不能写入。有时在2个线程所需的时间不相同的时候，怎样达到最大效率的同步，就比较麻烦了。咱们可以多开几个缓冲区进行操作。就像生产者消费者一样了。如果是2个线程一直在跑的，由于时间不一致，缓冲区迟早会溢出的。在这种情况下就要考虑了，是不让数据写入还是让数据覆盖掉老的数据，这时候就要具体问题具体分析了。就此打住，呵呵。就是用bool变量控制同步，linux 和windows是一样的。
既然讲道了这里，就再讲讲其它同步的方法。同样 针对上面的这个问题，共享全局变量同步问题。除了采用bool变量外，最容易想到的方法就是互斥量了。呵呵，也就是传说中的加锁了。windows下加锁和linux下加锁是类似的。采用互斥量进行同步，要想进入那段代码，就先必须获得互斥量。
linux上互斥量的函数是：
windows下互斥量的函数有：createmutex 创建一个互斥量，然后就是获得互斥量waitforsingleobject函数，用完了就释放互斥量ReleaseMutex(hMutex)，当减到0的时候 内核会才会释放其对象。下面是windows下与互斥的几个函数原型。
HANDLE WINAPI CreateMutex(
__in LPSECURITY_ATTRIBUTES lpMutexAttributes,
__in BOOL bInitialOwner,
__in LPCTSTR lpName
);
可以可用来创建一个有名或无名的互斥量对象
第一参数 可以指向一个结构体SECURITY_ATTRIBUTES一般可以设为null；
第二参数 指当时的函数是不是感应感应状态 FALSE为当前拥有者不会创建互斥
第三参数 指明是否是有名的互斥对象 如果是无名 用null就好。
DWORD WINAPI WaitForSingleObject(
__in HANDLE hHandle,
__in DWORD dwMilliseconds
);
第一个是 创建的互斥对象的句柄。第二个是 表示将在多少时间之后返回 如果设为宏INFINITE 则不会返回 直到用户自己定义返回。
对于linux操作系统，互斥也是类似的，只是函数不同罢了。在linux下，和互斥相关的几个函数也要闪亮登场了。
pthread_mutex_init函数：初始化一个互斥锁；
pthread_mutex_destroy函数：注销一个互斥锁；
pthread_mutex_lock函数：加锁，如果不成功，阻塞等待；
pthread_mutex_unlock函数：解锁；
pthread_mutex_trylock函数：测试加锁，如果不成功就立即返回，错误码为EBUSY;
至于这些函数的用法，google上一搜，就出来了，呵呵，在这里不多讲了。windows下还有一个可以用来保护数据的方法，也是线程同步的方式
就是临界区了。临界区和互斥类似。它们之间的区别是，临界区速度快，但是它只能用来同步同一个进程内的多个线程。临界区的获取和释放函数如下：
EnterCriticalSection() 进入临界区; LeaveCriticalSection()离开临界区。 对于多线程共享内存的东东就讲到这里了。
(2)采用消息机制进行多线程通信和同步，windows下面的的消息机制的函数用的多的就是postmessage了。Linux下的消息机制，我用的较少，就不在这里说了，如果谁熟悉的，也告诉我，呵呵。
(3)windows下的另外一种线程通信方法就是事件和信号量了。同样针对我开始举得例子，2个线程同步，他们之间传递信息，可以采用事件(Event)或信号量(Semaphore),比如第一个线程完成生产的数据后，就必须告诉第2个线程，他已经把数据准备好了，你可以来取走了。第2个线程就把数据取走。呵呵，这里可以采用消息机制，当第一个线程准备好数据后，就直接postmessage给第2个线程，按理说采用postmessage一个线程就可以搞定这个问题了。呵呵，不是重点，省略不讲了。
对于linux，也有类似的方法，就是条件变量了，呵呵，这里windows和linux就有不同了。要特别讲讲才行。
对于windows，采用事件和信号量同步时候，都会使用waitforsingleobject进行等待的，这个函数的第一个参数是一个句柄，在这里可以是Event句柄，或Semaphore句柄，第2个参数就是等待的延迟，最终等多久，单位是ms，如果这个参数为INFINITE，那么就是无限等待了。释放信号量的函数为ReleaseSemaphore（）；释放事件的函数为SetEvent。当然使用这些东西都要初始化的。这里就不讲了。Msdn一搜，神马都出来了，呵呵。神马都是浮云！
对于linux操作系统，是采用条件变量来实现类似的功能的。Linux的条件变量一般都是和互斥锁一起使用的，主要的函数有：
pthread_mutex_lock ,
pthread_mutex_unlock,
pthread_cond_init
pthread_cond_signal
pthread_cond_wait
pthread_cond_timewait
为了和windows操作系统进行对比，我用以下表格进行比较：
对照以上表格,总结如下：
(1) Pthread_cleanup_push,Pthread_cleanup_pop：
这一对函数push和pop的作用是当出现异常退出时，做一些清除操作，即当在push和pop函数之间异常退出，包括调用pthread_exit退出，都会执行push里面的清除函数，如果有多个push，注意是是栈，先执行后面的那个函数，在执行前面的函数，但是注意当在这2个函数之间通过return 退出的话，执不执行push后的函数就看pop函数中的参数是不是为0了。还有当没有异常退出时，等同于在这里面return退出的情况，即：当pop函数参数不为0时，执行清除操作，当pop函数参数为0时，不执行push函数中的清除函数。
（2）linux的pthread_cond_signal和SetEvent的不同点
Pthread_cond_singal释放信号后，当没有Pthread_cond_wait，信号马上复位了，这点和SetEvent不同，SetEvent是不会复位的。详解如下：
条件变量的置位和复位有2种常用模型：第一种模型是当条件变量置位时(signaled)以后，如果当前没有线程在等待，其状态会保持为置位(signaled)，直到有等待的线程进入被触发,其状态才会变为unsignaled,这种模型以采用Windows平台上的Auto-set Event 为代表。
第2种模型则是Linux平台的pthread所采用的模型，当条件变量置位(signaled)以后，即使当前没有任何线程在等待，其状态也会恢复为复位(unsignaled)状态。
条件变量在Linux平台上的这种模型很难说好坏，在实际应用中，我们可以对
代码稍加改进就可以避免这种差异的发生。由于这种差异只会发生在触发没有被线程等待在条件变量的时刻，因此我们只需要掌握好触发的时机即可。最简单的做法是增加一个计数器记录等待线程的个数，在决定触发条件变量前检查该变量即可。
示例 使用 pthread_cond_wait() 和 pthread_cond_signal()
pthread_mutex_t count_lock;
pthread_cond_t count_nonzero;
unsigned count;
decrement_count()
{
pthread_mutex_lock(&count_lock);
while (count == 0)
pthread_cond_wait(&count_nonzero, &count_lock);
count = count - 1;
pthread_mutex_unlock(&count_lock);
}
increment_count()
{
pthread_mutex_lock(&count_lock);
if (count == 0)
pthread_cond_signal(&count_nonzero);
count = count + 1;
pthread_mutex_unlock(&count_lock);
}
(3) 注意Pthread_cond_wait条件返回时互斥锁的解锁问题
extern int pthread_cond_wait __P ((pthread_cond_t *__cond,pthread_mutex_t *__mutex));
调用这个函数时,线程解开mutex指向的锁并被条件变量cond阻塞。线程可以被函数pthread_cond_signal和函数 pthread_cond_broadcast唤醒线程被唤醒后，它将重新检查判断条件是否满足，如果还不满足，一般说来线程应该仍阻塞在这里，被等待被下一次唤醒。如果在多线程中采用pthread_cond_wait来等待时，会首先释放互斥锁，当等待的信号到来时，再次获得互斥锁，因此在之后要注意手动解锁。举例如下：
#include
#include
#include
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; /*初始化互斥锁*/
pthread_cond_t cond = PTHREAD_COND_INITIALIZER; //初始化条件变量
void *thread1(void *);
void *thread2(void *);
int i=1;
int main(void)
{
pthread_t t_a;
pthread_t t_b;
pthread_create(&t_a,NULL,thread1,(void *)NULL);/*创建进程t_a*/
pthread_create(&t_b,NULL,thread2,(void *)NULL); /*创建进程t_b*/
pthread_join(t_b, NULL);/*等待进程t_b结束*/
pthread_mutex_destroy(&mutex);
pthread_cond_destroy(&cond);
exit(0);
}
void *thread1(void *junk)
{
for(i=1;i<=9;i++)
{
printf("IN one\n");
pthread_mutex_lock(&mutex);//
if(i%3==0)
pthread_cond_signal(&cond);/*，发送信号，通知t_b进程*/
else
printf("thead1:%d\n",i);
pthread_mutex_unlock(&mutex);//*解锁互斥量*/
printf("Up Mutex\n");
sleep(3);
}
}
void *thread2(void *junk)
{
while(i<9)
{
printf("IN two \n");
pthread_mutex_lock(&mutex);
if(i%3!=0)
pthread_cond_wait(&cond,&mutex);/*等待*/
printf("thread2:%d\n",i);
pthread_mutex_unlock(&mutex);
printf("Down Mutex\n");
sleep(3);
}
}
输出如下：
IN one
thead1:1
Up Mutex
IN two
IN one
thead1:2
Up Mutex
IN one
thread2:3
Down Mutex
Up Mutex
IN one
thead1:4
Up Mutex
IN two
IN one
thead1:5
Up Mutex
IN one
Up Mutex
thread2:6
Down Mutex
IN two
thread2:6
Down Mutex
IN one
thead1:7
Up Mutex
IN one
thead1:8
Up Mutex
IN two
IN one
Up Mutex
thread2:9
Down Mutex
注意蓝色的地方，有2个thread2:6，其实当这个程序多执行几次，i=3和i=6时有可能多打印几个，这里就是竞争锁造成的了。
(4)另外要注意的Pthread_cond_timedwait等待的是绝对时间，这个和WaitForSingleObject是不同的，Pthread_cond_timedwait在网上也有讨论。如下：这个问题比较经典，我把它搬过来。
thread_a ：
pthread_mutex_lock(&mutex);
//do something
pthread_mutex_unlock(&mutex)
thread_b：
pthread_mutex_lock(&mutex);
//do something
pthread_cond_timedwait(&cond, &mutex, &tm);
pthread_mutex_unlock(&mutex)
有如上两个线程thread_a, thread_b,现在如果a已经进入了临界区，而b同时超时了，那么b会从pthread_cond_timedwait返回吗？如果能返回，那岂不是a,b都在临界区？如果不能返回，那pthread_cond_timedwait的定时岂不是就不准了？
大家讨论有价值的2点如下：
（1） pthread_cond_timedwait (pthread_cond_t *cv, pthread_mutex_t *external_mutex, const struct timespec *abstime) -- This function is a time-based variant of pthread_cond_wait. It waits up to abstime amount of time for cv to be notified. If abstime elapses before cv is notified, the function returns back to the caller with an ETIME result, signifying that a timeout has occurred. Even in the case of timeouts, the external_mutex will be locked when pthread_cond_timedwait returns.
（2） 2.1 pthread_cond_timedwait行为和pthread_cond_wait一样，在返回的时候都要再次lock mutex.
2 .2pthread_cond_timedwait所谓的如果没有等到条件变量，超时就返回，并不确切。
如果pthread_cond_timedwait超时到了，但是这个时候不能lock临界区，pthread_cond_timedwait并不会立即返回，但是在pthread_cond_timedwait返回的时候，它仍在临界区中，且此时返回值为ETIMEDOUT。
关于pthread_cond_timedwait超时返回的问题，我也认同观点2。
附录：
int pthread_create(pthread_t *restrict tidp,const pthread_attr_t *restrict_attr,void*（*start_rtn)(void*),void *restrict arg);
返回值：若成功则返回0，否则返回出错编号
返回成功时，由tidp指向的内存单元被设置为新创建线程的线程ID。attr参数用于制定各种不同的线程属性。新创建的线程从start_rtn函数的地址开始运行，该函数只有一个无指针参数arg，如果需要向start_rtn函数传递的参数不止一个，那么需要把这些参数放到一个结构中，然后把这个结构的地址作为arg的参数传入。
linux下用C开发多线程程序，Linux系统下的多线程遵循POSIX线程接口，称为pthread。
由 restrict 修饰的指针是最初唯一对指针所指向的对象进行存取的方法，仅当第二个指针基于第一个时，才能对对象进行存取。对对象的存取都限定于基于由 restrict 修饰的指针表达式中。 由 restrict 修饰的指针主要用于函数形参，或指向由 malloc() 分配的内存空间。restrict 数据类型不改变程序的语义。 编译器能通过作出 restrict 修饰的指针是存取对象的唯一方法的假设，更好地优化某些类型的例程。
第一个参数为指向线程标识符的指针。
第二个参数用来设置线程属性。
第三个参数是线程运行函数的起始地址。
第四个参数是运行函数的参数。
因为pthread不是linux系统的库，所以在编译时注意加上-lpthread参数，以调用静态链接库。
终止线程：
如果在进程中任何一个线程中调用exit或_exit,那么整个进行会终止，线程正常的退出方式有：
（1） 线程从启动例程中返回(return)
（2） 线程可以被另一个进程终止（kill）；
（3） 线程自己调用pthread_exit函数
#include
pthread_exit
线程等待：
int pthread_join(pthread_t tid,void **rval_ptr)
函数pthread_join用来等待一个线程的结束。函数原型为：
extern int pthread_join __P (pthread_t __th, void **__thread_return);
第一个参数为被等待的线程标识符，第二个参数为一个用户定义的指针，它可以用来存储被等待线程的返回值。这个函数是一个线程阻塞的函数，调用它的函数将一直等待到被等待的线程结束为止，当函数返回时，被等待线程的资源被收回。
对于windows线程的创建东西，就不列举了，msdn上 一搜就出来了。呵呵。今天就讲到这里吧，希望是抛砖引玉，大家一起探讨，呵呵。部分内容我也是参考internet的，特此对原作者表示感谢！
③ 麻烦解释一下linux下进程和线程有什么区别和联系，linux下多线程和多进程通信的实现方法，请通俗解释
兄弟看到你这么高的分我就找了些资料：也算是对昨天学的知识总结一下吧
一、先说概念不管是windows还是linux下的进程和线程概念都是一样的，只是管理进程和线程的方式不一样，这个是前提，到时候你可别问我windows下进程和线程啊。这个涉及到操作系统原理。下面给你解答。
说道进程不得不提作业这个名词 ，我想兄弟你电脑里不会有一个程序吧对不？当你的系统启动完毕后你看看你的任务管理器里是不是有很多进程呢？那么多程序是怎么调如内存呢？能理解吗？这里要明白程序和进程的关系，程序是你磁盘上的一个文件，当你需要它时进入内存后才成为进程，好比QQ在磁盘上就是一个文件而已，只有进入了内存才成为进程，进程是活动的。QQ要扫描你文件啊，记录你聊天记录啊，偷偷上传个啥东西什么的你也不知道对不，他是活动的。这个能明白吗？
再看作业，这个作业可不是你写作业的那个作业啊。系统一看好家伙你个QQ那么大的家伙你想一下子进入内存啊？没门！慢慢来嘛，系统就把QQ程序分为好几块，这几块不能乱分的，要符合自然结构就是循环啦选择啦这样的结构，你把人家循环结构咔嚓截断了，怎么让人家QQ运行啊？这就是作业要一块一块的进入内存，同时要为作业产生JCB（JOB CONTROL BLOCK)作业控制块，你进入内存不能乱跑啊，要听系统的话，你要是进入系统自己的内存。框一下，内存不能读写 对话框就出来了，严重点直接蓝脸给你！你懂得。这是window下的，linux下直接给你报错！没事了就！所一系统通过jcb控制进程。JCB包含了进程号优先级好多内容，你打开你的windows任务管理器看看进程是不是有好多属性啊？那就是PCB（PRCESS，CONTROL BLOCK）同理作业也包含那些内容只是多少而已。下面写出进程特点：
1、进程是分配计算机资源最小的单位。你想啊人是要用程序干活的吧？你把程序调入内存成了就成了进程，所以说进程是分配资源的最小单位。你在linux下打开终端输入top命令看是不是有好多进程？
2、进程有操作系统为作业产生。有“父进程”产生“子进程”之间是父子关系，并可以继续向下产生“子进程”。还拿QQ来说，你双击QQ.exe。QQ启动了输入账号密码打开主界面了。这时候你要聊天，QQ进程赶紧产生个“儿子”说 “儿子你去陪主人聊天去吧。这样子进程产生了。突然你想看美女要传照片这时候那个”儿子“有”生“了一个”儿子“说”儿子“你去传照片。那个“儿子领到任务去传照片了。这时你想关了QQ，QQ提示你说”你还有个“儿子”和“孙子”还在干活呢你真要结束吗？你蒽了确定。QQ对他“儿子”（你聊天窗口）说：”儿子啊对不起了，主人要关闭我你也不能活啊“咔嚓一下”儿子“死了，儿子死之前对他儿子说：“儿子啊你爷爷不让我活了，你也别活了咔嚓孙子也死了。最后世界安静了。这就是进程的父子关系。能明白吗？记住：进程之活动在内存中。不能使用CPU，只管分配资源。
再说线程：线程也产生在内存中并且在内存中存在相当长的时间，但它的活动区域主要在CPU中，并且运行和灭亡都存在于CPU中，可以这么说，线程是程序中能被系统调度进入CPU中最小程序单位，它能直接使用进程分配的CPU的资源。
还拿QQ来说当你要传文件时QQ总要判断一下文件的扩展名吧，ok这时那个”儿子“赶紧对它爸爸说我需要一个线程判断扩展名QQ赶紧对一个管这个的线程说：”快点去CPU里计算下那个扩展名是什么然后向主人报告计算完了就“死了”消亡了，但是它的线程还在内存中！还等着你下一次传文件然后计算然后消亡！
线程之间是相互独立的。一个在CPU，一个在内存里还能有关系吗对不？CPU在每一个瞬间只能进入一个线程，当线程进入CPU时立即产生一个新的线程，新线程仍停留在内存中，就好比上面那个传文件还会等着你再传文件再计算扩展名。
线程相对线程是独立的，但它在内存中并不是独立的，这就好比你不开QQ能用QQ传输文件吗？它只存在与进程分配的资源中，也就是说计算扩展名这个线程只能停留在QQ这个进程中，不能跑到别的进程里！！相当于程序产生了新的进程和线程，进程向CPU申请资源，再有线程来使用，他们都是为程序服务的只是分工不同！
因为你没提问linux下是怎么管理进程和线程的所以我就不回答了，这个问题我建议你还是看看《笨兔兔的故事》里面讲到了linux是怎么管理进程和线程的。挺幽默的比我说得还好。
你第二个问题说实话我回答不了你！我想你现在连进程和线程还没理解第二个你更理解不了了你说对不？我猜的其实你用C/C++不管是在windows下编程还是在Linux下编程思想都是一样的对吧，如果你理解了在windows下线程间通信，在linux更没问题了！
参考资料：黑客手册2009合订本非安全第一二季244页，245页，328页，329页，398页，399页
浅谈操作系统原理 （一 二三）
ubuntu中文论坛 笨兔兔的故事
http://forum.ubuntu.org.cn/viewtopic.php?f=120&t=267518
希望我的回答你能理解
④ Linux下多线程和多进程程序的优缺点，各个适合什么样的业务场景
多进程比较安全，因为默认情况下不同进程之间的内存是独立的（如果需要共享内存则需要进行进程间通信）。而多线程下，内存是共享的，这时就比较危险了，你要自己使用锁、信号量等机制来解决内存块的同时读写和同步等等。如果两个功能没有数据需要共享，或只有前后递进关系，建议使用多进程。如果两个功能需要同时对一块数据进行处理（例如需要对资源进行创建和老化删除），则需要使用多线程，这时可能需要使用锁等机制来控制线程冲突。
⑤ Linux 多线程编程(二)2019-08-10
三种专门用于线程同步的机制:POSIX信号量,互斥量和条件变量.
在Linux上信号量API有两组,一组是System V IPC信号量,即PV操作,另外就是POSIX信号量,POSIX信号量的名字都是以sem_开头.
phshared参数指定信号量的类型,若其值为0,就表示这个信号量是当前进程的局部信号量,否则该信号量可以在多个进程之间共享.value值指定信号量的初始值,一般与下面的sem_wait函数相对应.
其中比较重要的函数sem_wait函数会以原子操作的方式将信号量的值减一,如果信号量的值为零,则sem_wait将会阻塞,信号量的值可以在sem_init函数中的value初始化;sem_trywait函数是sem_wait的非阻塞版本;sem_post函数将以原子的操作对信号量加一,当信号量的值大于0时,其他正在调用sem_wait等待信号量的线程将被唤醒.
这些函数成功时返回0,失败则返回-1并设置errno.
生产者消费者模型:
生产者对应一个信号量:sem_t procer;
消费者对应一个信号量:sem_t customer;
sem_init(&procer,2)----生产者拥有资源,可以工作;
sem_init(&customer,0)----消费者没有资源,阻塞;
在访问公共资源前对互斥量设置（加锁），确保同一时间只有一个线程访问数据，在访问完成后再释放（解锁）互斥量.
互斥锁的运行方式:串行访问共享资源;
信号量的运行方式:并行访问共享资源;
互斥量用pthread_mutex_t数据类型表示，在使用互斥量之前，必须使用pthread_mutex_init函数对它进行初始化，注意，使用完毕后需调用pthread_mutex_destroy.
pthread_mutex_init用于初始化互斥锁，mutexattr用于指定互斥锁的属性，若为NULL，则表示默认属性。除了用这个函数初始化互斥所外，还可以用如下方式初始化：pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER。
pthread_mutex_destroy用于销毁互斥锁，以释放占用的内核资源，销毁一个已经加锁的互斥锁将导致不可预期的后果。
pthread_mutex_lock以原子操作给一个互斥锁加锁。如果目标互斥锁已经被加锁，则pthread_mutex_lock则被阻塞，直到该互斥锁占有者把它给解锁.
pthread_mutex_trylock和pthread_mutex_lock类似，不过它始终立即返回，而不论被操作的互斥锁是否加锁，是pthread_mutex_lock的非阻塞版本.当目标互斥锁未被加锁时，pthread_mutex_trylock进行加锁操作；否则将返回EBUSY错误码。注意：这里讨论的pthread_mutex_lock和pthread_mutex_trylock是针对普通锁而言的，对于其他类型的锁，这两个加锁函数会有不同的行为.
pthread_mutex_unlock以原子操作方式给一个互斥锁进行解锁操作。如果此时有其他线程正在等待这个互斥锁，则这些线程中的一个将获得它.
三个打印机轮流打印:
输出结果:
如果说互斥锁是用于同步线程对共享数据的访问的话,那么条件变量就是用于在线程之间同步共享数据的值.条件变量提供了一种线程之间通信的机制:当某个共享数据达到某个值时,唤醒等待这个共享数据的线程.
条件变量会在条件不满足的情况下阻塞线程.且条件变量和互斥量一起使用，允许线程以无竞争的方式等待特定的条件发生.
其中pthread_cond_broadcast函数以广播的形式唤醒所有等待目标条件变量的线程,pthread_cond_signal函数用于唤醒一个等待目标条件变量线程.但有时候我们可能需要唤醒一个固定的线程,可以通过间接的方法实现:定义一个能够唯一标识目标线程的全局变量,在唤醒等待条件变量的线程前先设置该变量为目标线程,然后采用广播的方式唤醒所有等待的线程,这些线程被唤醒之后都检查该变量以判断是否是自己.
采用条件变量+互斥锁实现生产者消费者模型:
运行结果:
阻塞队列+生产者消费者
运行结果:
⑥ 在Linux环境下，对一个设备文件进行多线程读写（两个线程就行），求大神给一个简单的程序。
配置文件为 conf.txt
测试代码如下，注意链接的时候加上 -lpthread 这个参数
#include <stdio.h>
#include <errno.h> //perror()
#include <pthread.h>
#include <unistd.h> //sleep()
#include <time.h> // time()
#include <stdlib.h> //rand()
#define FD "conf.txt"
typedef void *(*fun)(void *);
struct my_struct
{
unsigned time_to_wait;
int n;
};
void *test_thread(struct my_struct *);
int main (int argc, char const *argv[])
{
FILE *fp = fopen(FD, "r");
if (fp == NULL)
{
perror(FD);
return -1;
}
srand((unsigned)time(NULL)); //初始化随机种子
int thread_count;
fscanf(fp, "%d", &thread_count);
fclose(fp);
if (thread_count <= 0)
{
printf("线程数<1,退出程序。\n");
return -1;
}
pthread_t *ptid = (pthread_t *)malloc(sizeof(pthread_t) * thread_count); //保存线程ID
int i;
for (i = 0; i < thread_count; i++)
{
int tw = rand() % thread_count + 1; //随机等待时间
struct my_struct * p = (struct my_struct *)malloc(sizeof(struct my_struct));
if (p == NULL)
{
perror("内存分配错误");
goto ERROR;
}
p->time_to_wait = tw;
p->n = i + 1;
int rval = pthread_create(ptid + i, NULL, (fun) test_thread, (void *)(p)); //注意这里的强制转换（两个）
if (rval != 0)
{
perror("Thread creation failed");
goto ERROR;
}
//sleep(1); //这句加也可以，不加也可以。最开始的时候加上这个是为了让两个线程启动的时候之间有一定的时间差
}
printf("主线程启动\n\n");
fflush(stdout);
for (i = 0; i < thread_count; i++)
{
pthread_join(*(ptid + i), NULL); //等待所有线程退出。
}
printf("\n主线程退出\n");
ERROR:
free(ptid);
return 0;
}
void *test_thread(struct my_struct * p) //线程启动的时候运行的函数
{
printf("第%d个线程启动，预计运行%d秒\n", p->n, p->time_to_wait);
fflush(stdout);
sleep(p->time_to_wait); //让线程等待一段时间
printf("第%d个线程结束\n", p->n);
fflush(stdout);
free(p);
return NULL;
}
你的第二个问题我在网络HI回你了～
⑦ Linux下如何实现shell多线程编程以提高应用程序的响应
Linux中多线程编程拥有提高应用程序的响应、使多cpu系统更加有效等优点，下面小编将通过Linux下shell多线程编程的例子给大家讲解下多线程编程的过程，一起来了解下吧。
#！/bin/bash
#———————————————————————————–
# 此例子说明了一种用wait、read命令模拟多线程的一种技巧
# 此技巧往往用于多主机检查，比如ssh登录、ping等等这种单进程比较慢而不耗费cpu的情况
# 还说明了多线程的控制
#———————————————————————————–
function a_sub
{
# 此处定义一个函数，作为一个线程（子进程）
sleep 3 # 线程的作用是sleep 3s
}
tmp_fifofile=“/tmp/$.fifo” mkfifo $tmp_fifofile # 新建一个fifo类型的文件
exec 6《》$tmp_fifofile # 将fd6指向fifo类型
rm $tmp_fifofile thread=15 # 此处定义线程数
for
（（i=0;i《$thread;i++））;do echo
done 》&6 # 事实上就是在fd6中放置了$thread个回车符
for
（（i=0;i《50;i++））;do # 50次循环，可以理解为50个主机，或其他
read -u6 # 一个read -u6命令执行一次，就从fd6中减去一个回车符，然后向下执行，
# fd6中没有回车符的时候，就停在这了，从而实现了线程数量控制
{ # 此处子进程开始执行，被放到后台
a_sub &&
{ # 此处可以用来判断子进程的逻辑
echo “a_sub is finished”
}
||
{ echo “sub error”
}
echo 》&6 # 当进程结束以后，再向fd6中加上一个回车符，即补上了read -u6减去的那个
}
& done wait # 等待所有的后台子进程结束
exec 6》&- # 关闭df6 exit 0
说明：
此程序中的命令
mkfifo tmpfile
和linux中的命令
mknod tmpfile p
效？果相同。区别是mkfifo为POSIX标准，因此推荐使用它。该命令创建了一个先入先出的管道文件，并为其分配文件标志符6。管道文件是进程之间通信的一种方式，注意这一句很重要
exec 6《》$tmp_fifofile # 将fd6指向fifo类型
如果没有这句，在向文件$tmp_fifofile或者&6写入数据时，程序会被阻塞，直到有read读出了管道文件中的数据为止。而执行了上面这一句后就可以在程序运行期间不断向fifo类型的文件写入数据而不会阻塞，并且数据会被保存下来以供read程序读出。
通过运行命令：
time 。/multithread.sh 》/dev/null
最终运算时间： 50/15 = 3组（每组15）+1组（5个《15 组成一个组）= 4组，每组花费时间：3秒，
则 3 * 4 = 12 秒。
传统非多线程的代码 运算时间： 50 * 3 = 150 秒。
上面就是Linux下shell多线程编程的实例介绍了，使用多线程编程还能够改善程序结构，有兴趣的朋友不妨试试看吧。
⑧ Linux多线程编程
编译时要用到pthread 库：gcc -lpthread
错误码位置：/usr/include/asm-generic/errno.h
gcc pthread_create.c -lpthread
思考：主子线程交替打印奇数偶数。
思考：证明线程可以自己取消自己。
思考：证明SIGKILL和SIGSTOP 是无法阻塞的。
/usr/include/bits/pthreadtypes.h中查看pthread_mutex_t
思考：用多线程将一个文件1.c拷贝3个副本，11.c,12.c,13.c
思考：多个生产者和消费者
思考：将互斥量等初始化使用pthread_once实现。
思考：设置线程的分离属性，然后在新县城中获取自己的分离属性。