A. 浅谈linux多线程编程和Windows多线程编程的异同
转载自fychit创意空间 很早以前就想写写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
B. 谁能推荐本讲linux多线程编程的书籍
感觉书上面提到的多线程编程都比较偏理论，都主要是讲线程的创建，退出，同步等一些情况，APUE讲解的也比较好理解，另外推荐看一下linux下的一些开源代码，比如pcsc-lite，它的主体构架就是多线程的，可以适当的参考一下它的框架。
C. Linux下如何实现shell多线程编程
程序代码test.c共两个线程，一个主线程，一个读缓存区的线程：
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
char globe_buffer[100];
void *read_buffer_thread(void *arg); //这里先声明一下读缓存的线程，具体实现写在后面了
int main()
{
int res,i;
pthread_t read_thread;
for(i=0;i<20;i++)
globe_buffer[i]=i;
printf("\nTest thread : write buffer finish\n");
sleep(3);\\这里的3秒是多余，可以不要。
res = pthread_create(&read_thread, NULL, read_buffer_thread, NULL);
if (res != 0)
{
printf("Read Thread creat Error!");
exit(0);
}
sleep(1);
printf("waiting for read thread to finish...\n");
res = pthread_join(read_thread, NULL);
if (res != 0)
{
printf("read thread join failed!\n");
exit(0);
}
printf("read thread test OK, have fun!! exit ByeBye\n");
return 0;
}
void *read_buffer_thread(void *arg)
{
int i,x;
printf("Read buffer thread read data : \n");
for(i=0;i<20;i++)
{
x=globe_buffer[i];
printf("%d ",x);
globe_buffer[i]=0;//清空
}
printf("\nread over\n");
}
---------------------------------------------------------------------------------
以上程序编译：
gcc -D_REENTRANT test.c -o test.o –lpthread
运行这个程序：
$ ./test.o：
D. Linux多线程编程时如何查看一个进程中的某
1。 使用top命令，具体用法是 top -H
加上这个选项，top的每一行就不是显示一个进程，而是一个线程。
2。 使用ps命令，具体用法是 ps -xH
这样可以查看所有存在的线程，也可以使用grep作进一步的过滤。
3。 使用ps命令，具体用法是 ps -mq PID
这样可以看到指定的进程产生的线程数目。
更进一步，其实一些系统监控工具，在本质上也是读取的系统产生的文件罢了。比如说进程这个事情，
看看这个目录吧，/proc/5000/ 这里面有你所有想要的。其实stat代表着当前的一些信息。
使用ps命令来查看进程的时候，进程状态分别对应的含义如下：
D 不可中断睡眠 (通常是在IO操作) 收到信号不唤醒和不可运行, 进程必须等待直到有中断发生
R 正在运行或可运行（在运行队列排队中）
S 可中断睡眠 (休眠中, 受阻, 在等待某个条件的形成或接受到信号)
T 已停止的 进程收到SIGSTOP, SIGSTP, SIGTIN, SIGTOU信号后停止运行
W 正在换页(2.6.内核之前有效)
X 死进程 (未开启)
Z 僵尸进程 进程已终止, 但进程描述符存在, 直到父进程调用wait4()系统调用后释放BSD风格的
< 高优先级(not nice to other users)
N 低优先级(nice to other users)
L 页面锁定在内存（实时和定制的IO）
s 一个信息头
l 多线程（使用 CLONE_THREAD，像NPTL的pthreads的那样）
+ 在前台进程组
E. Linux多线程编程
程序代码test.c共两个线程，一个主线程，一个读缓存区的线程：
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
char globe_buffer[100];
void *read_buffer_thread(void *arg); //这里先声明一下读缓存的线程，具体实现写在后面了
int main()
{
int res,i;
pthread_t read_thread;
for(i=0;i<20;i++)
globe_buffer[i]=i;
printf("\nTest thread : write buffer finish\n");
sleep(3);\\这里的3秒是多余，可以不要。
res = pthread_create(&read_thread, NULL, read_buffer_thread, NULL);
if (res != 0)
{
printf("Read Thread creat Error!");
exit(0);
}
sleep(1);
printf("waiting for read thread to finish...\n");
res = pthread_join(read_thread, NULL);
if (res != 0)
{
printf("read thread join failed!\n");
exit(0);
}
printf("read thread test OK, have fun!! exit ByeBye\n");
return 0;
}
void *read_buffer_thread(void *arg)
{
int i,x;
printf("Read buffer thread read data : \n");
for(i=0;i<20;i++)
{
x=globe_buffer[i];
printf("%d ",x);
globe_buffer[i]=0;//清空
}
printf("\nread over\n");
}
---------------------------------------------------------------------------------
以上程序编译：
gcc -D_REENTRANT test.c -o test.o –lpthread
运行这个程序：
$ ./test.o：
F. linux里面线程编译运行问题
#gcc a.c -o a #此句的-o a说明输出目标文件为“a”；
#gcc -Wall-lpthread threadcreatetest.c #此句未注明输出目标文件名，系统默认输出为a.out，所以编译之后执行./a.out文件。
如果上句也没有指明“ -o a ”的话，输出也是a.out，你可以试试
G. Linux 的多线程编程中，如何给线程发信号
不管是在进程还是线程，很多时候我们都会使用一些定时器之类的功能，这里就定时器在多线程的使用说一下。首先在linux编程中定时器函数有alarm()和setitimer(),alarm()可以提供一个基于秒的定时功能，而setitimer可以提供一个基于微妙的定时功能。
alarm()原型：
#include <unistd.h>
unsigned int alarm(unsigned int seconds);
这个函数在使用上很简单，第一次调用这个函数的时候是设置定时器的初值，下一次调用是重新设置这个值，并会返回上一次定时的剩余时间。
setitimer()原型：
#include <sys/time.h>
int setitimer(int which, const struct itimerval *value,struct itimerval *ovalue);
这个函数使用起来稍微有点说法，首先是第一个参数which的值，这个参数设置timer的计时策略，which有三种状态分别是：
ITIMER_REAL：使用系统时间来计数，时间为0时发出SIGALRM信号，这种定时能够得到一个精准的定时，当然这个定时是相对的，因为到了微秒级别我们的处理器本身就不够精确。
ITIMER_VIRTUAL：使用进程时间也就是进程分配到的时间片的时间来计数，时间为0是发出SIGVTALRM信号，这种定时显然不够准确，因为系统给进程分配时间片不由我们控制。
ITIMER_PROF：上面两种情况都能够触发
第二个参数参数value涉及到两个结构体：
struct itimerval {
struct timeval it_interval; /* next value */
struct timeval it_value; /* current value */
};
struct timeval {
long tv_sec; /* seconds */
long tv_usec; /* microseconds */
};
在结构体itimerval中it_value是定时器当前的值，it_interval是当it_value的为0后重新填充的值。而timeval结构体中的两个变量就简单了一个是秒一个是微秒。
上面是这两个定时函数的说明，这个函数使用本不是很难，可以说是很简单，但是碰到具体的应用的时候可能就遇到问题了，在多进程编程中使用一般不会碰到什么问题，这里说的这些问题主要体现在多线程编程中。比如下面这个程序：
#include <pthread.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/time.h>
void sig_handler(int signo)
{
alarm(2);
printf("alarm signal\n");
}
void *pthread_func()
{
alarm(2);
while(1)
{
pause();
}
}
int main(int argc, char **argv)
{
pthread_t tid;
int retval;
signal(SIGALRM, sig_handler);
if((retval = pthread_create(&tid, NULL, pthread_func, NULL)) < 0)
{
perror("pthread_create");
exit(-1);
}
while(1)
{
printf("main thread\n");
sleep(10);
}
return 0;
}
这个程序的理想结果是：
main thread
alarm signal
alarm signal
alarm signal
alarm signal
alarm signal
main thread
可事实上并不是这样的，它的结果是：
main pthread
alarm signal
main pthread
alarm signal
main pthread
H. linux系统下，c语言pthread多线程编程传参问题
3个线程使用的都是同一个info
代码 Info_t *info= (Info_t *)malloc(sizeof(Info_t));只创建了一个info
pthread_create(&threads[i],NULL,calMatrix,(void *)info); 三个线程使用的是同一个
我把你的代码改了下：
#include<stdio.h>
#include<stdlib.h>
#include<pthread.h>
intmtc[3]={0};//resultmatrix
typedefstruct
{
intprank;
int*mta;
int*mtb;
}Info_t;
void*calMatrix(void*arg)
{
inti;
Info_t*info=(Info_t*)arg;
intprank=info->prank;
fprintf(stdout,"calMatrix:prankis%d ",prank);
for(i=0;i<3;i++)
mtc[prank]+=info->mta[i]*info->mtb[i];
returnNULL;
}
intmain(intargc,char**argv)
{
inti,j,k=0;
intmta[3][3];
intmtb[3]={1};
Info_t*info=(Info_t*)malloc(sizeof(Info_t)*3);
for(i=0;i<3;i++)
for(j=0;j<3;j++)
mta[i][j]=k++;
/*3threads*/
pthread_t*threads=(pthread_t*)malloc(sizeof(pthread_t)*3);
fprintf(stdout," ");fflush(stdout);
for(i=0;i<3;i++)
{
info[i].prank=i;
info[i].mta=mta[i];
info[i].mtb=mtb;
pthread_create(&threads[i],NULL,calMatrix,(void*)(&info[i]));
}
for(i=0;i<3;i++)
pthread_join(threads[i],NULL);
fprintf(stdout," ====thematrixresult==== ");
fflush(stdout);
for(i=0;i<3;i++)
{
fprintf(stdout,"mtc[%d]=%d ",i,mtc[i]);
fflush(stdout);
}
return0;
}
矩阵的计算我忘记了，你运行看看结果对不对
I. Linux多线程编程问题
晕,没在 Linux下编过,尽管我的电脑有Linux系统