多线程程序设计 for Linux
声明：本文是网上整理的资料，版权属其作者本人所
有。
第一章线程基础知识
一．什么是线程在一个程序里的多个执行路线就叫做线程。更准确的定义是：线程是“一个
进程内部的一个控制序列”。
典型的unix进程可以看成只有一个控制线程：一个进程在同一时刻只做一件事情。有了多个控制线程以后，在程序设计时可以把进程设计成在同一时刻能够做不止一件事，每个线程处理各只独立的任务。
二．线程的优点
（1）通过为每种事件类型的处理分配单独的线程，能够简化处理异步时间的代码。
（2）多个线程可以自动共享相同的存储地址空间和文件描述符。
（3）有些问题可以通过将其分解从而改善整个程序的吞吐量。
（4）交互的程序可以通过使用多线程实现相应时间的改善，多线程可以把程序中处理用户输入输出的部分与其它部分分开。
三．线程的缺点线程也有不足之处。编写多线程程序需要更全面更深入的思考。
在一个多线
程程序里，因时间分配上的细微偏差或者因共享了不该共享的变量而造成不良影响的可能性是很大的。调试一个多线程程序也比调试一个单线程程序困难得多四．线程的结构线程包含了表示进程内执行环境必需的信息，其中包括进程中标识线程的
线程ID，一组寄存器值、栈、调度优先级和策略、信号屏蔽子，errno变量以及线程私有数据。进程的所有信息对该进程的所有线程都是共享的，包括可执行的程序文本，程序的全局内存和堆内存、栈以及文件描述符。
五．线程标识
就像每个进程有一个进程ID一样，每个线程也有一个线程ID，进程ID在
整个系统中是唯一的，但线程不同，线程ID只在它所属的进程环境中有效。线程ID用pthread_t数据类型来表示，实现的时候可以用一个结构来代表pthread_t 数据类型，所以可以移植的操作系统不能把它作为整数处理。因此必须使用函数来对来对两个线程ID进行比较。
1．
2．
六．线程的创建
3．
当pthread_creat成功返回时，tidp指向的内存单元被设置为新创建线程的线程ID。attr参数用于定制各种不同的线程属性。可以把它设置为NULL，创建默认的线程属性。
新创建的线程从start_rtn函数的地址开始运行，该函数只有一个无类型指针
参数arg,如果需要向start_rtn函数传递的参数不止一个，那么需要把这些参数放
到一个结构中，然后把这个结构的地址作为arg参数传入。
#include
void printids(constchar*s)
{
printf(“%s p id:%u tid:%u\n“, s,ge tpid(),pthread_self());
}
void *thr_fn(void*arg)
{
printi ds(“new thread:“);
}
intmain()
{
interr; pthread_ttid;
err=pthread_create(&tid,NULL,thr_fn,NULL);
if(err=0)
printf(“can’tcreatethread:%s\n”,s trerror(err));
printi ds(“main thread:“);
sleep(1);
exit(0);
}
关于进程的编译我们都要加上参数–lpthread否则提示找不到函数的错误。
具体编译方法是cc –lpthread –o gettidgettid.c
运行结果为
mainthread:pid 14954 tid134529024
new thread:pid 14954 tid134530048
七．.线程的终止线程是依进程而存在的，当进程终止时，线程也就终止了。当然也有在不
终止整个进程的情况下停止它的控制流。
（1）线程只是从启动例程中返回，返回值是线程的退出码。
（2）县城可以被同一进程中的其他线程取消。
（3）线程调用pthread_exit.
4．
rval_prt是一个无类型指针，与传给启动例程的单个参数类似。进程中的其他线程可以调用pthread_join函数访问到这个指针。
5．
当一个线程通过调用pthread_exit退出或者简单地从启动历程中返回时，进程中的其他线程可以通过调用pthread_join函数获得进程的退出状态。调用pthread_join进程将一直阻塞，直到指定的线程调用pthread_exit,从启动例程中或者被取消。
如果线程只是从它的启动历程返回，rval_ptr将包含返回码。
#include
#include
void *thr_fn1(void*arg)
{
printf(“thread 1 returning\n”);
return((void *)1);
}
void *thr_fn2(void*arg)
{
printf(“thread 2 exiting\n”);
return((void *)2);
}
intmain()
{
pthread_ttid1,tid2;
void*tret;
pthread_create(&tid1,NULL,thr_fn1,NULL);
pthread_create(&tid2,NULL,thr_fn2,NULL);
pthread_join(tid1,&tret);
printf(“thread 1 exitcode %d\n”,(int)tret);
pthread_join(tid2,&tret);
printf(“thread 2 exitcode %d\n”,(int)tret);
exit(0);
}
运行结果是：
thread1 returning
thread2 exiting
thread1 exitcode 1
thread2 exitcode 2
6．
在默认情况下，线程的终止状态会保存到对该线程调用pthr ea d_j o i n,如果线程已经处于分离状态，线程的底层存储资源可以在线程终止时立即被收回。当线程被分离时，并不能用pthr ea d_j o i n函数等待它的终止状态。对分离状态的线程
进行pthr ea d_j o i n的调用会产生失败，返回E I N VA L.p thr ea d_d eta ch调用可以用于使线程进入分离状态。
7．
在默认的情况下，pthread_cancel函数会使由tid标识的线程的行为表现为如同调用了参数为PTHEAD_CANCELED的pthread_exit函数，但是，线程可以选择忽略取消方式和控制取消方式。pthr ea d_c a nce l并不等待线程终止，它仅仅提出请求。
8．
线程可以安排它退出时需要调用的函数，这样的函数称为线程清理处理程序，线程可以建立多个清理处理程序。处理程序记录在栈中，也就是说它们的执行顺序与它们注册时的顺序相反。
要注意的是如果线程是通过从他的启动例程中返回而终止的，它的处理程序就不会调用。还要注意清理处理程序是按照与它们安装时相反的顺序调用的。#i nclud e
#i nclud e
void cl ea nup(vo i d*a rg)
{
pr i nt f(“c l ea nup:%s\n”,(char*)a rg);
}
void*thr_fn(void*arg)/*线程入口地址*/
{
pr i ntf(“thr ea ds ta rt\n”);
pthread_cleanup_push(cleanup,”t hreadfirsthand l e r”);/*设置第一
个线程处理程序*/
pthread_cleanup_push(cleanup,”t hreadsecondhand l e r”);/*设置
第二个线程处理程序*/
pr i ntf(“thr ea dpushcomp l ete\n”);
pthread_cleanup_pop(0);/*取消第一个线程处理程序*/
pthread_cleanup_pop(0);/*取消第二个线程处理程序*/
}
i ntma i n()
{
pthread_ttid;
void*t r e t;
pthread_creat(&tid,NULL,thr_fn,(void*)1); /*创建一个线程*/
pthr ea d_j o i n(t i d,&tr e t);/*获得线程终止状态*/
ptinr f(“t hreadexitcode%d\n”,(i nt)t r e t);
}
八、一次性初始化
有时候我们需要对一些pos i x变量只进行一次初始化，如线程键（我下面
会讲到）。如果我们进行多次初始化程序就会出现错误。
在传统的顺序编程中，一次性初始化经常通过使用布尔变量来管理。控制变量被静态初始化为0，而任何依赖于初始化的代码都能测试该变量。如果变量值仍然为0，则它能实行初始化，然后将变量置为1。以后检查的代码将跳过初始化。
但是在多线程程序设计中，事情就变的复杂的多。如果多个线程并发地执行初始化序列代码，2个线程可能发现控制变量为0，并且都实行初始化，而
该过程本该仅仅执行一次。初始化的状态必须由互斥量保护。
如果我们需要对一个pos i x变量静态的初始化，可使用的方法是用一个互
斥量对该变量的初始话进行控制。但有时候我们需要对该变量进行动态初始化，pthread_once就会方便的多。
9.
类型为pthread_once_t的变量是一个控制变量。控制变量必须使用PTHREAD_ONCE_INIT宏静态地初始化。
pthread_once函数首先检查控制变量，判断是否已经完成初始化，如果完成就简单地返回；否则，pthr ea d_o nce调用初始化函数，并且记录下初始
化被完成。如果在一个线程初始时，另外的线程调用pthr ea d_o nce，则调用线程等待，直到那个现成完成初始话返回。
下面就是该函数的程序例子：
#i nclud e
pthread_once_tonce=PTHRE A D_ONCE_I N I T;
pthread_mutex_tmutex;/*互斥量，我们后面会讲到*/
voidonce_i nit_routine(vo i d)/*一次初始化函数*/
{
i nts ta tus;
s ta tus=pthr ea d_mute x_i nit(&mute x,NU L L);/*初始化互斥量*/
if(s ta tus==0)
pr i ntf(“I ni t success!,Myidi s%u”,pthr ea d_s e lf());
}
void*child_thread(void*arg)
{
pr i nt f(“I’m child,Myid is%u”,p t hr ea d_s e lf());
pthr ea d_o nce(&once,once_i ni t_rout i ne);/*子线程调用一次性初始化函数*/
}
i ntma i n(i ntargc,char *argv[])
{
pthread_tchi l d_thr ea d_i d;
pthr ea d_cr eate(&chi l d_thr ea d_i d,NULL,chil d_thr ea d,NU LL);/*创建
子线程*/
pr i ntf(“I’m father,myidis%u”,pthr ea d_s e lf());
pthr ea d_o nce(&once,once_i n i t_routine);/*父线程调用一次性初始化函数*/
pthr ea d_j o i n(ch il d_thr ea d_i d,NU LL);
}
程序运行结果如下：
./once
I’m father,Myidis3086874304
I ni t success!,Myidis3086874304
I’m child,My idis3086871472
从上面的结果可以看到当主函数初始化成功后，子函数初始化失败。
九、线程的私有数据在进程内的所有线程共享相同的地址空间，任何声明为静态
或外部的变量，
或在进程堆声明的变量，都可以被进程所有的线程读写。那怎样才能使线程序拥有自己的私有数据呢。
pos i x提供了一种方法，创建线程键。
10.
第一个参数为指向一个键值的指针，第二个参数指明了一个destructor函数（清理函数），如果这个参数不为空，那么当每个线程结束时，系统将调用这个函数来释放绑定在这个键上的内存块。这个函数常和函数pthread_once一起使用，为了让这个键只被创建一次。函数pthread_once声明一个初始化函数，第一次调用pthread_once时它执行这个函数，以后的调用将被它忽略。下面是程序例子：
#i nclud e
pthread_key_t t sd_k e y;
pthread_once_t k e y_o nce=PTHRE A D_ONCE_I N I T;
voidonce_r outine(vo i d)
{
i nts ta tus;
s ta tus=pthr ea d_k e y_cr eate(&t sd_k e y,NU LL);/*初始化线程私有数据键*/
if(s ta tus=0)
pr i ntf(“K e ycreatesuccess!My idis%u\n”,pthr ea d_s e lf());
}
void*child_thread(void*arg)
{
pr i ntf(“I’mch ild,Myid is%u\n”,pthr ea d_s e lf());
pthr ea d_o nce(&k e y_o nce,once_rout i ne);/*调用一次性初始化函数*/ }
i ntma i n(i ntargc,char *argv[])
{
pthread_tchi l d_thr ea d_i d;
pthr ea d_cr eate(&chi l d_thr ea d_i d,NULL,chil d_thr ea d,NU LL);
pr i ntf(“I’m father,myidis%u\n”,pthr ea d_s e lf());
pthr ea d_o nce(&k e y_o nce,once_rout i ne);
}
程序运行结果如下：
I’m father,Myidis3086231232
K e ycreatesuccess!My idis3086231232
I’m child,Myid is2086228400
第二章线程高级知识
一．线程属性
线程具有属性，用pthread_attr_t表示，在对该结构进行处理之前必须进行
初始化，在使用后需要对其去除初始化。我们用pthread_attr_init函数对其初始化，用pthread_attr_destroy对其去除初始化。
1．
调用pthread_attr_init之后，pthread_t结构所包含的内容就是操作系统实现支持
的线程所有属性的默认值。
如果要去除对pthread_attr_t结构的初始化，可以调用pthread_attr_destroy
函数。如果pthread_attr_init实现时为属性对象分配了动态内存空间，
pthread_attr_destroy还会用无效的值初始化属性对象，因此如果经
pthread_attr_destroy去除初始化之后的pthread_attr_t结构被pthread_create函数
调用，将会导致其返回错误。
线程属性结构如下：
typedefstruct
{
int detachstate; 线程的分离状态
int schedpolicy; 线程调度策略
structsched_param schedparam; 线程的调度参数
int inheritsched; 线程的继承性
int scope; 线程的作用域
size_t guardsize; 线程栈末尾的警戒缓冲区大小
int stackaddr_set;
void * stackaddr; 线程栈的位置
size_t stacksize; 线程栈的大小
}pthread_attr_t;
每个个属性都对应一些函数对其查看或修改。下面我们分别介绍。
二、线程的分离状态
线程的分离状态决定一个线程以什么样的方式来终止自己。在默认情况下线程是非分离状态的，这种情况下，原有的线程等待创建的线程结束。只有当pthr ea d_j o i n（）函数返回时，创建的线程才算终止，才能释放自己占用的系统资源。
而分离线程不是这样子的，它没有被其他的线程所等待，自己运行结束了，线程也就终止了，马上释放系统资源。程序员应该根据自己的需要，选择适当的分离状态。所以如果我们在创建线程时就知道不需要了解线程的终止状态，则可以pthread_attr_t结构中的detachstate线程属性，让线程以分离状态启动。
2．
可以使用pthread_attr_setdetachstate函数把线程属性detachstate设置为下面
的两个合法值之一：设置为PTHREAD_CREA TE_DETACHED,以分离状态启动线程；或者设置为PTHREAD_CREA TE_JOINABLE,正常启动线程。可以使用pthread_attr_getdetachstate函数获取当前的datachstate线程属性。
以分离状态创建线程
#iinclude
void *child_thread(void *arg)
{
printf(“ch ild threadrun!\n”);
}
intmain(intargc,char*argv[ ])
{
pthread_ttid;
pthread_attr_tattr;
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_DETACHED);
pthread_create(&tid,&attr,fn,arg);
pthread_attr_destroy(&attr);
sleep(1);
}
三、线程的继承性
函数pthread_attr_setinheritsched和pthread_attr_getinheritsched分别用来设
置和得到线程的继承性，这两个函数的定义如下：
3.
这两个函数具有两个参数，第1个是指向属性对象的指针，第2个是继承性或指向继承性的指针。继承性决定调度的参数是从创建的进程中继承还是使用在schedpolicy和schedparam属性中显式设置的调度信息。Pthreads不为inheritsched 指定默认值，因此如果你关心线程的调度策略和参数，必须先设置该属性。
继承性的可能值是PTHREAD_INHERIT_SCHED（表示新线程将继承创建线程的调度策略和参数）和PTHREAD_EXPLICIT_SCHED（表示使用在schedpolicy和schedparam属性中显式设置的调度策略和参数）。
如果你需要显式的设置一个线程的调度策略或参数，那么你必须在设置之前将inheritsched属性设置为PTHREAD_EXPLICIT_SCHED.
下面我来讲进程的调度策略和调度参数。我会结合下面的函数给出本函数的程序例子。
四、线程的调度策略
函数pthread_attr_setschedpolicy和pthread_attr_getschedpolicy分别用来设置和得到线程的调度策略。
4.
这两个函数具有两个参数，第1个参数是指向属性对象的指针，第2个参数是
调度策略或指向调度策略的指针。调度策略可能的值是先进先出
（SCHED_FIFO）、轮转法（SCHED_RR）,或其它（SCHED_OTHER）。
SCHED_FIFO策略允许一个线程运行直到有更高优先级的线程准备好，或者直到它自愿阻塞自己。在SCHED_FIFO调度策略下，当有一个线程准备好时，除非有平等或更高优先级的线程已经在运行，否则它会很快开始执行。
SCHED_RR(轮循)策略是基本相同的，不同之处在于：如果有一个
SCHED_RR 策略的线程执行了超过一个固定的时期(时间片间隔)没有阻塞，
而另外的SCHED_RR或SCHBD_FIPO策略的相同优先级的线程准备好时，运
行的线程将被抢占以便准备好的线程可以执行。
当有SCHED_FIFO或SCHED_RR策赂的线程在一个条件变量上等持或等持加锁同一个互斥量时，它们将以优先级顺序被唤醒。即，如果一个低优先级的SCHED_FIFO线程和一个高优先织的SCHED_FIFO线程都在等待锁相同的互斥且，则当互斥量被解锁时，高优先级线程将总是被首先解除阻塞。
五、线程的调度参数
函数pthread_attr_getschedparam和pthread_attr_setschedparam分别用来设
置和得到线程的调度参数。
5.
这两个函数具有两个参数，第1个参数是指向属性对象的指针，第2个参数是sched_param结构或指向该结构的指针。结构sched_param在文件/usr/include
/bits/sched.h中定义如下：
structsched_param
{
intsched_priority;
};
结构sched_param的子成员sched_priority控制一个优先权值，大的优先权值对应高的优先权。系统支持的最大和最小优先权值可以用sched_get_priority_max 函数和sched_get_priority_min函数分别得到。
注意：如果不是编写实时程序，不建议修改线程的优先级。因为，调度策略是一件非常复杂的事情，如果不正确使用会导致程序错误，从而导致死锁等问题。如：在多线程应用程序中为线程设置不同的优先级别，有可能因为共享资源而导致优先级倒置。
6.
下面是上面几个函数的程序例子：
#include
#include
void *child_thread(void *arg)
{
intpolicy;
intmax_priority,min_priority;
structsched_paramparam;
pthread_attr_tattr;
pthread_attr_init(&attr);/*初始化线程属性变量*/
pthread_attr_setinheritsched(&attr,PTHREAD_EXPLICIT_SCHED);/*设置线程继承性*/
pthread_attr_getinheritsched(&attr,&policy); /*获得线程的继承性*/
if(policy==PTHREAD_EXPLICIT_SCHED)
printf(“Inher itsched:PTHREAD_EXPLICIT_SCHED\n”);
if(policy==PTHREAD_INHERIT_SCHED)
printf(“Inher itsched:PTHREAD_INHERIT_SCHED\n”);
pthread_attr_setschedpolicy(&attr,SCHED_RR);/*设置线程调度策略*/
pthread_attr_getschedpolicy(&attr,&policy);/*取得线程的调度策略*/
if(policy==SCHED_FIFO)
printf(“Schedpo licy:SCHED_FIFO\n”);
if(policy==SCHED_RR)
printf(“Schedpo licy:SCHED_RR\n”);
if(policy==SCHED_OTHER)
printf(“Schedpo licy:SCHED_OTHER\n”);
sched_get_priority_max(max_priority);/*获得系统支持的线程优先权的最大值*/
sched_get_priority_min(min_priority);/*获得系统支持的线程优先权的最小值*/
printf(“Max pr iority:%u\n”,max_priority);
printf(“M in priority:%u\n”,min_priority);
param.sched_priority=max_priority;
pthread_attr_setschedparam(&attr,¶m);/*设置线程的调度参数*/
printf(“sched_pr iority:%u\n”,par am.sched_priority);/*获得线程的调度参数*/ pthread_attr_destroy(&attr);
}
intmain(intargc,char*argv[ ])
{
pthread_tchild_thread_id;
pthread_create(&child_thread_id,NULL,child_thread,NULL);
pthread_join(child_thread_id,NULL);
}
六、线程的作用域
函数pthread_attr_setscope和pthread_attr_getscope分别用来设置和得到线程的作用域，这两个函数的定义如下：
7．
这两个函数具有两个参数，第1个是指向属性对象的指针，第2个是作用域或指向作用域的指针，作用域控制线程是否在进程内或在系统级上竞争资源，可能的值是PTHREAD_SCOPE_PROCESS（进程内竞争资源）
PTHREAD_SCOPE_SYSTEM.（系统级上竞争资源）。
七、线程堆栈的大小
函数pthread_attr_setstacksize和pthread_attr_getstacksize分别用来设置和得
到线程堆栈的大小，这两个函数的定义如下所示：
8．
这两个参数具有两个参数，第1个是指向属性对象的指针，第2个是堆栈大小或指向堆栈大小的指针
如果希望改变栈的默认大小，但又不想自己处理线程栈的分配问题，这时使用pthread_attr_setstacksize函数就非常用用。
八、线程堆栈的地址
函数pthread_attr_setstackaddr和pthread_attr_getstackaddr分别用来设置和得到线程堆栈的位置，这两个函数的定义如下：
9.
这两个函数具有两个参数，第1个是指向属性对象的指针，第2个是堆栈地址或指向堆栈地址的指针。
九、线程栈末尾的警戒缓冲区大小
函数pthread_attr_getguardsize和pthread_attr_setguardsize分别用来设置和得到线程栈末尾的警戒缓冲区大小，这两个函数的定义如下：
10.
线程属性guardsize控制着线程栈末尾之后以避免栈溢出的扩展内存大小。这个属性默认设置为PAGESIZE个字节。可以把guardsize线程属性设为0，从而不允许属性的这种特征行为发生：在这种情况下不会提供警戒缓存区。同样地，如果对线程属性stackaddr作了修改，系统就会假设我们会自己管理栈，并使警戒栈缓冲区机制无效，等同于把guardsize线程属性设为0。
第三章Posix有名信号
灯
函数sem_open创建一个新的有名信号灯或打开一个已存在的有名信号灯。有名信号灯总是既可用于线程间的同步，又可以用于进程间的同步。
一、posix有名信号灯函数
1.
oflag参数可以是0、O_CREAT（创建一个信号灯）或O_CREA T|O_EXCL（如果没有指定的信号灯就创建），如果指定了O_CREAT，那么第三个和第四个参数是需要的；其中mode参数指定权限位，value参数指定信号灯的初始值，通
常用来指定共享资源的书面。该初始不能超过SEM_V ALUE_MAX，这个常值必须低于为32767。二值信号灯的初始值通常为1，计数信号灯的初始值则往往大于1。
如果指定了O_CREAT（而没有指定O_EXCL），那么只有所需的信号灯尚未存在时才初始化它。所需信号灯已存在条件下指定O_CREAT不是一个错误该标志的意思仅仅是“如果所需信号灯尚未存在，那就创建并初始化它”。但是所需信号灯等已存在条件下指定O_CREA T|O_EXCL却是一个错误。
sem_open返回指向sem_t信号灯的指针，该结构里记录着当前共享资源的数目。
/*semopen.c*/
#include
#include
#include
#include
#include
intmain(intargc,char**argv)
{
sem_t*sem;
if(argc!=2)
{
print f(“please inputa file name!\n”);
exit(1);
}
sem=sem_open(argv[1],O_CREAT,0644,1);
exit(0);
}
#gcc –lpthread –o semopensemopen.c
#./semopen
2.
一个进程终止时，内核还对其上仍然打开着的所有有名信号灯自动执行这样的信号灯关闭操作。不论该进程是自愿终止的还是非自愿终止的，这种自动关闭都会发生。
但应注意的是关闭一个信号灯并没有将它从系统中删除。这就是说，Posix 有名信号灯至少是随内核持续的：即使当前没有进程打开着某个信号灯，它的值仍然保持。
3.
有名信号灯使用sem_unlink从系统中删除。每个信号灯有一个引用计数器记录当前的打开次数，sem_unlink必须等待
这个数为0时才能把name所指的信号灯从文件系统中删除。也就是要等待最后一个sem_close发生。
/*semunlink.c*/
#include
#include
#include
#include
#include
intmain(intargc,char**argv)
实验七：Linux多线程编程(实验分析报告)
实验七：Linux多线程编程(实验报告)
————————————————————————————————作者：————————————————————————————————日期：
实验七：Linux多线程编程（4课时） 实验目的：掌握线程的概念；熟悉Linux下线程程序编译的过程；掌握多线程程序编写方法。 实验原理：为什么有了进程的概念后，还要再引入线程呢？使用多线程到底有哪些好处？什么的系统应该选用多线程？我们首先必须回答这些问题。 1 多线程概念 使用多线程的理由之一是和进程相比，它是一种非常"节俭"的多任务操作方式。运行于一个进程中的多个线程，它们彼此之间使用相同的地址空间，共享大部分数据，启动一个线程所花费的空间远远小于启动一个进程所花费的空间。 使用多线程的理由之二是线程间方便的通信机制。同一进程下的线程之间共享数据空间，所以一个线程的数据可以直接为其它线程所用，这不仅快捷，而且方便。2多线程编程函数 Linux系统下的多线程遵循POSIX线程接口，称为pthread。编写Linux下的多线程程序，需要使用头文件pthread.h，连接时需要使用库libpthread.a。pthread_t在头文件/usr/include/bits/pthreadtypes.h中定义： typedef unsigned long int pthread_t; 它是一个线程的标识符。 函数pthread_create用来创建一个线程，它的原型为： extern int pthread_create((pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine) (void *), void *arg)); 第一个参数为指向线程标识符的指针，第二个参数用来设置线程属性，第三个参数是线程运行函数的起始地址，最后一个参数是运行函数的参数。 函数pthread_join用来等待一个线程的结束。函数原型为： extern int pthread_join(pthread_t th, void **thread_return); 第一个参数为被等待的线程标识符，第二个参数为一个用户定义的指针，它可以用来存储被等待线程的返回值。 函数pthread_exit的函数原型为： extern void pthread_exit(void *retval); 唯一的参数是函数的返回代码，只要pthread_join中的第二个参数thread_return不是NULL，这个值将被传递给thread_return。 3 修改线程的属性 线程属性结构为pthread_attr_t，它在头文件/usr/include/pthread.h中定义。属性值不能直接设置，须使用相关函数进行操作，初始化的函数为pthread_attr_init，这个函数必须在pthread_create函数之前调用。 设置线程绑定状态的函数为pthread_attr_setscope，它有两个参数，第一个是指向属性结构的指针，第二个是绑定类型，它有两个取值：PTHREAD_SCOPE_SYSTEM（绑定的）和PTHREAD_SCOPE_PROCESS（非绑定的）。 另外一个可能常用的属性是线程的优先级，它存放在结构sched_param中。用函数pthread_attr_getschedparam和函数pthread_attr_setschedparam进行存放，一般说来，我们总是先取优先级，对取得的值修改后再存放回去。 4 线程的数据处理
Linux多线程编程的基本的函数
Posix线程编程指南（一） 线程创建与取消 这是一个关于Posix线程编程的专栏。作者在阐明概念的基础上，将向您详细讲述Posix线程库API。本文是第一篇将向您讲述线程的创建与取消。 线程创建 1．1 线程与进程 相对进程而言，线程是一个更加接近于执行体的概念，它可以与同进程中的其他线程共享数据，但拥有自己的栈空间，拥有独立的执行序列。在串行程序基础上引入线程和进程是为了提高程序的并发度，从而提高程序运行效率和响应时间。 线程和进程在使用上各有优缺点：线程执行开销小，但不利于资源的管理和保护；而进程正相反。同时，线程适合于在SMP机器上运行，而进程则可以跨机器迁移。 1．2 创建线程 POSIX通过pthread_create()函数创建线程，API定义如下： 与fork()调用创建一个进程的方法不同，pthread_create()创建的线程并不具备与主线程（即调用pthread_create()的线程）同样的执行序列，而是使其运行 start_routine(arg)函数。thread返回创建的线程ID，而attr是创建线程时设置的线程属性（见下）。pthread_create()的返回值表示线程创建是否成功。尽管arg是void *类型的变量，但它同样可以作为任意类型的参数传给start_routine()函数；同时，start_routine()可以返回一个void *类型的返回值，而这个返回值也可以是其他类型，并由pthread_join()获取。 1．3 线程创建属性 pthread_create()中的attr参数是一个结构指针，结构中的元素分别对应着新线程的运行属性，主要包括以下几项： __detachstate，表示新线程是否与进程中其他线程脱离同步，如果置位则新线程不能用pthread_join()来同步，且在退出时自行释放所占用的资源。缺省为 PTHREAD_CREATE_JOINABLE状态。这个属性也可以在线程创建并运行以后用pthread_detach()来设置，而一旦设置为PTHREAD_CREATE_DETACH状态（不论是创建时设置还是运行时设置）则不能再恢复到PTHREAD_CREATE_JOINABLE状态。
linux下的多线程编程常用函数
Linux下pthread的实现是通过系统调用clone（）来实现的。clone（）是Linux所特 有的系统调用，他的使用方式类似fork. int pthread_create(pthread_t *restrict tidp,const pthread_attr_t *restrict attr, void *(*start_rtn)(void),void *restrict arg); 返回值：若是成功建立线程返回0,否则返回错误的编号 形式参数： pthread_t *restrict tidp 要创建的线程的线程id指针 const pthread_attr_t *restrict attr 创建线程时的线程属性 void* (start_rtn)(void) 返回值是void类型的指针函数 void *restrict arg start_rtn的行参 进行编译的时候要加上-lpthread 向线程传递参数。 例程2： 功能：向新的线程传递整形值 #include
Step by Step：Linux C多线程编程入门(基本API及多线程的同步与互斥)
介绍：什么是线程，线程的优点是什么 线程在Unix系统下，通常被称为轻量级的进程，线程虽然不是进程，但却可以看作是Unix进程的表亲，同一进程中的多条线程将共享该进程中的全部系统资源，如虚拟地址空间，文件描述符和信号处理等等。但同一进程中的多个线程有各自的调用栈(call stack)，自己的寄存器环境（register context)，自己的线程本地存储(thread-local storage)。 一个进程可以有很多线程，每条线程并行执行不同的任务。 线程可以提高应用程序在多核环境下处理诸如文件I/O或者socket I/O等会产生堵塞的情况的表现性能。在Unix系统中，一个进程包含很多东西，包括可执行程序以及一大堆的诸如文件描述符地址空间等资源。在很多情况下，完成相关任务的不同代码间需要交换数据。如果采用多进程的方式，那么通信就需要在用户空间和内核空间进行频繁的切换，开销很大。但是如果使用多线程的方式，因为可以使用共享的全局变量，所以线程间的通信（数据交换）变得非常高效。 Hello World(线程创建、结束、等待） 创建线程 pthread_create 线程创建函数包含四个变量，分别为： 1. 一个线程变量名，被创建线程的标识 2. 线程的属性指针，缺省为NULL即可 3. 被创建线程的程序代码 4. 程序代码的参数 For example： - pthread_t thrd1? - pthread_attr_t attr? - void thread_function(void argument)? - char *some_argument? pthread_create(&thrd1, NULL, (void *)&thread_function, (void *) &some_argument); 结束线程 pthread_exit 线程结束调用实例：pthread_exit(void *retval); //retval用于存放线程结束的退出状态 线程等待 pthread_join pthread_create调用成功以后，新线程和老线程谁先执行，谁后执行用户是不知道的，这一块取决与操作系统对线程的调度，如果我们需要等待指定线程结束，需要使用pthread_join函数，这个函数实际上类似与多进程编程中的waitpid。 举个例子，以下假设 A 线程调用 pthread_join 试图去操作B线程，该函数将A线程阻塞，直到B线程退出，当B线程退出以后，A线程会收集B线程的返回码。 该函数包含两个参数：pthread_t th //th是要等待结束的线程的标识 void **thread_return //指针thread_return指向的位置存放的是终止线程的返回状态。 调用实例：pthread_join(thrd1, NULL); example1： 1 /************************************************************************* 2 > F i l e N a m e: t h r e a d_h e l l o_w o r l d.c 3 > A u t h o r: c o u l d t t(f y b y) 4 > M a i l: f u y u n b i y i@g m a i l.c o m 5 > C r e a t e d T i m e: 2013年12月14日 星期六 11时48分50秒 6 ************************************************************************/ 7 8 #i n c l u d e 9 #i n c l u d e 10 #i n c l u d e
11 12 v o i d p r i n t_m e s s a g e_f u n c t i o n (v o i d *p t r)? 13 14 i n t m a i n() 15 { 16 i n t t m p1, t m p2?
跟我学Linux编程-13-多线程编程-性能
多线程编程-性能 在上一章节中，我们介绍了线程互斥锁的使用。通过互斥锁，使得每个线程只能串行地运行临界区代码，从而有效地避免了多线程冲突。串行的代码运行方式削弱了多线程并发运行的特性，因此线程锁也潜在地降低了程序性能，如何杜绝线程冲突，又尽可能不影响程序效率，是我们每一个线程从员需要认真考虑的事情。 减少线程性能下降的方法有如下几点: 1 尽可能减小互斥锁的颗粒，使串行代码的比例减小从而提高效率，这在上一章节末已提过。 2 加锁解锁之间的代码，运行时间尽可能减少，避免有sleep或死循环一类的超时等待。 3 对不同的冲突资源使用不同的线程锁，避免不相关的线线之间因锁反而产生关联。 4 使用pthread_mutex_trylock代替pthread_lock在检测和处理锁冲突，实现单线程对多个对像的非阻塞处理。 今天我们重点介绍pthread_mutex_trylock的使用，并通过实例的来展现其用法，探究其提高程序效果的原理。 首先，我们来看pthread_lock与pthread_mutex_trylock的函数原型： int pthread_mutex_lock(pthread_mutex_t *mutex); int pthread_mutex_trylock( pthread_mutex_t *mutex); 可以看到，这两个函数的原型非常想像，功能也比较类似，都是尝试对给定的锁对像进行加锁，如果成功，则线程获得该锁，并返回0；不同点在于当锁已被其他线程占有的情况下，pthread_mutex_lock会阻塞，直至锁被其它线程释放并且本线程获得锁；如pthread_mutex_trylock则不然，如果锁当前已被其他线程占有，则立刻返回失败(非0值)，我们的程序可判读返回值并进行下一步的处理（如处理另一个任务），避免线程被阻塞，从而提高了线程并发度，提升程序性能。我们接下来看例子： #include
跟我学Linux编程-12-多线程编程-同步
多线程编程-同步 在上一章节中，我们通过程序示例，见证了单线程世界中不可能发生的事件（一个数既是奇数又是偶数）在多线程环境中是怎样分分钟发生的，我通过细分程序执行步骤，分析了奇异事件发生的过程，并探明了其原因：一个线程在对全局变量gcnt进行两次判读的过程中，另一个线刚好改变了这个变量的值。在多线程编程术语中，称这两个线程同时进入了临界区域。 所谓临界区域，是指多线程环境下两个及以上线程同时执行可能会导致冲突的一段代码。在上一章节的示例中，这几行代码就是一个临界区域： gcnt++; if (gcnt % 2) { if (!(gcnt % 2)) printf("[%d] : %d\n", id, gcnt); } 冲突之所以会发生，是因为临界区域的代码，通常需要很多个CPU指令周期才能完成，其运行过程随时可能被打断(进行了线程调试)，CPU去运行另外的线程，如果这个线程刚好也进入了临界区域，则异常的程序状态极可能会发生。 如果当某个线程进入临界区域，在其退出区域之前，其他的线程无论如何也不能进入该区域，那么冲突就不会发生。Linux提供了这种保证多线程进入临界区域互斥的机制，这正是本章节所要介绍的内容：线程锁。 我们今天的示例程序还是在上一章节的示例上改进而来的，我们的任务就是使用线程锁，保证“一个数既是奇数又是偶数”的奇异事件在多线程环境下也不发生，代码如下： #include
linux多线程编程
2.终止线程 (2) 3. 等待线程终止 (2) pthread_exit和pthread_join进一步说明： (3) 4.分离线程 (7) 5.获取线程标识符 (8) 6.比较线程ID (8) 7.一次性初始化 (8) 8. 设置线程的调度策略和优先级 (9) 9. 获取线程的优先级 (11) 10.取消线程 (12) 取消线程，是否会释放线程的所有资源？例子： (14) 设置取消类型 (16) 11.初始化属性 (17) 12.设置分离状态 (18) 13.设置范围 (18) 14. 设置继承的调度策略 (18) 16. 设置调度参数 (19) 17.初始化互斥锁 (21) 18.销毁互斥锁 (21) 19.锁定互斥锁 (22) 20.解除锁定互斥锁 (23) 21. 互斥锁的类型： (23) 22. 初始化互斥锁属性对象 (23) 23. 销毁互斥锁属性对象 (23) 24.设置互斥锁类型的属性 (24) 互斥锁动态初始化和静态初始化区别： (26) 销毁互斥锁：事实上没做任何销毁操作，如下： (27) 非递归类型的互斥锁解锁和加锁操作： (27) 29.初始化条件变量 (27) 30.基于条件变量阻塞 (27) 31.解除阻塞一个线程 (28) 31.解除阻塞所有线程 (29) 33. 在指定的时间之前阻塞 (30) 32.唤醒丢失问题 (31) 33. 计数信号量概述 (31) 34. 初始化信号 (31) 35. 增加信号 (31) 36. 基于信号计数进行阻塞 (32) 37.多线程链表添加删除例子（使用条件变量实现互斥）： (32) 38.为线程特定数据创建键 (34) 39. 删除线程特定数据键 (35) 40.设置线程特定数据 (35) 41. 获取线程特定数据 (35)
Linux多线程编程问题
Linux 多线程编程问题 1重入问题 传统的UNIX没有太多考虑线程问题，库函数里过多使用了全局和静态数据，导致严重的线程重入问题。 1.1–D_REENTRANT /-pthread和errno的重入问题。 所先UNIX的系统调用被设计为出错返回-1，把错误码放在errno中（更简单而直 接的方法应该是程序直接返回错误码，或者通过几个参数指针来返回）。由于线程 共享所有的数据区，而errno是一个全局的变量，这里产生了最糟糕的线程重入问 题。比如： do { bytes = recv(netfd, recvbuf, buflen, 0); } while (bytes != -1 && errno != EINTR); 在上面的处理recv被信号打断的程序里。如果这时连接被关闭，此时errno应该不 等于EINTR，如果别的线程正好设置errno为EINTR，这时程序就可能进入死循环。 其它的错误码处理也可能进入不可预测的分支。 在线程需求刚开始时，很多方面技术和标准（TLS）还不够成熟，所以在为了 解决这个重入问题引入了一个解决方案，把errno定义为一个宏： extern int *__errno_location (void); #define errno (*__errno_location()) 在上面的方案里，访问errno之前先调用__errno_location()函数，线程库提供这个 函数，不同线程返回各自errno的地址，从而解决这个重入问题。在编译时加 -D_REENTRANT就是启用上面的宏，避免errno重入。另外-D_REENTRANT 还影响一些stdio的函数。在较高版本的gcc里，有很多嵌入函数的优化，比如把printf(“Hello\n”); 优化为 puts(“hello\n”); 之类的，有些优化在多线程下有问题。所以gcc引入了–pthread 参数，这个 参数出了-D_REENTRANT外，还校正一些针对多线程的优化。 因为宏是编译时确定的，所以没有加-D_REENTRANT编译的程序和库都有errno 重入问题，原则上都不能在线程环境下使用。不过在一般实现上主线程是直接使用 全局errno变量的，也就是__errno_location()返回值为全局&errno，所以那些没加 -D_REENTRANT编译的库可以在主线程里使用。这里仅限于主线程，有其它且只 有一个固定子线程使用也不行，因为子线程使用的errno地址不是全局errno变量 地址。 对于一个纯算法的库，不涉及到errno和stdio等等，有时不加_REENTRANT也是 安全的，比如一个纯粹的加密/解谜函数库。比较简单的判断一个库是否有errno问 题是看看这个库是使用了errno还是__errno_location()：
实验七：Linux多线程编程(实验报告)
实验七：Linux多线程编程（4课时） 实验目的：掌握线程的概念；熟悉Linux下线程程序编译的过程；掌握多线程程序编写方法。 实验原理：为什么有了进程的概念后，还要再引入线程呢？使用多线程到底有哪些好处？什么的系统应该选用多线程？我们首先必须回答这些问题。 1 多线程概念 使用多线程的理由之一是和进程相比，它是一种非常"节俭"的多任务操作方式。运行于一个进程中的多个线程，它们彼此之间使用相同的地址空间，共享大部分数据，启动一个线程所花费的空间远远小于启动一个进程所花费的空间。 使用多线程的理由之二是线程间方便的通信机制。同一进程下的线程之间共享数据空间，所以一个线程的数据可以直接为其它线程所用，这不仅快捷，而且方便。2多线程编程函数 Linux系统下的多线程遵循POSIX线程接口，称为pthread。编写Linux下的多线程程序，需要使用头文件pthread.h，连接时需要使用库libpthread.a。pthread_t在头文件/usr/include/bits/pthreadtypes.h中定义： typedef unsigned long int pthread_t; 它是一个线程的标识符。 函数pthread_create用来创建一个线程，它的原型为： extern int pthread_create((pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine) (void *), void *arg)); 第一个参数为指向线程标识符的指针，第二个参数用来设置线程属性，第三个参数是线程运行函数的起始地址，最后一个参数是运行函数的参数。 函数pthread_join用来等待一个线程的结束。函数原型为： extern int pthread_join(pthread_t th, void **thread_return); 第一个参数为被等待的线程标识符，第二个参数为一个用户定义的指针，它可以用来存储被等待线程的返回值。 函数pthread_exit的函数原型为： extern void pthread_exit(void *retval); 唯一的参数是函数的返回代码，只要pthread_join中的第二个参数thread_return不是NULL，这个值将被传递给thread_return。 3 修改线程的属性 线程属性结构为pthread_attr_t，它在头文件/usr/include/pthread.h中定义。属性值不能直接设置，须使用相关函数进行操作，初始化的函数为pthread_attr_init，这个函数必须在pthread_create函数之前调用。 设置线程绑定状态的函数为pthread_attr_setscope，它有两个参数，第一个是指向属性结构的指针，第二个是绑定类型，它有两个取值：PTHREAD_SCOPE_SYSTEM（绑定的）和PTHREAD_SCOPE_PROCESS （非绑定的）。 另外一个可能常用的属性是线程的优先级，它存放在结构sched_param中。用函数pthread_attr_getschedparam和函数pthread_attr_setschedparam进行存放，一般说来，我们总是先取优先级，对取得的值修改后再存放回去。 4 线程的数据处理
linux操作系统-实验-Linux-多线程编程
《操作系统》实验报告
用gcc编译的时候需要加-lpthread,否则会出现以下错误： 五、思考题 多进程编程与多线程编程有何区别？ 相同点：Linux下不管是多线程编程还是多进程编程，最终都是用do_fork 实现 不同点：父子进程变量是互不影响的，由于父子进程地址空间是完全隔开的，变量的地址可以是完全相同的。Linux下编程多用多进程编程少用多线程编程。多线程比多进程成本低，但性能更低：多进程是立体交通系统，虽然造价高，上坡下坡多耗点油，但是不；多线程是平面交通系统，造价低，但红绿灯太多，老堵车。 1、多进程：子进程是父进程的复制品。子进程获得父进程数据空间、堆和栈的复制品。 2、多线程：相对与进程而言，线程是一个更加接近与执行体的概念，它可以与同进程的其他线程共享数据，但拥有自己的栈空间，拥有独立的执行序列。两者都可以提高程序的并发度，提高程序运行效率和响应时间。 3、线程和进程在使用上各有优缺点：线程执行开销小，但不利于资源管理和保护；而进程正相反。同时，线程适合于在5MP机器上运行，而进程则可以跨机器迁移。
代码： #include
Linux多线程编程小结
Linux多线程编程小结 愤怒的小狐狸----博客专栏 前一段时间因为开题的事情一直耽搁了我搞Linux的进度，搞的我之前学的东西都遗忘了，很烦躁的说，现在抽个时间把之前所学的做个小节。文章内容主要总结于《Linux程序设计第3版》。 1.Linux进程与线程 Linux进程创建一个新线程时，线程将拥有自己的栈（因为线程有自己的局部变量），但与它的创建者共享全局变量、文件描述符、信号句柄和当前目录状态。 Linux通过fork创建子进程与创建线程之间是有区别的：fork创建出该进程的一份拷贝，这个新进程拥有自己的变量和自己的PID，它的时间调度是独立的，它的执行几乎完全独立于父进程。 进程可以看成一个资源的基本单位，而线程是程序调度的基本单位，一个进程内部的线程之间共享进程获得的时间片。 2._REENTRANT宏 在一个多线程程序里，默认情况下，只有一个errno变量供所有的线程共享。在一个线程准备获取刚才的错误代码时，该变量很容易被另一个线程中的函数调用所改变。类似的问题还存在于fputs之类的函数中，这些函数通常用一个单独的全局性区域来缓存输出数据。 为解决这个问题，需要使用可重入的例程。可重入代码可以被多次调用而仍然工作正常。编写的多线程程序，通过定义宏_REENTRANT来告诉编译器我们需要可重入功能，这个宏的定义必须出现于程序中的任何#include语句之前。 _REENTRANT为我们做三件事情，并且做的非常优雅： （1）它会对部分函数重新定义它们的可安全重入的版本，这些函数名字一般不会发生改变，只是会在函数名后面添加_r字符串，如函数名gethostbyname 变成gethostbyname_r。 （2）stdio.h中原来以宏的形式实现的一些函数将变成可安全重入函数。 （3）在error.h中定义的变量error现在将成为一个函数调用，它能够以一种安全的多线程方式来获取真正的errno的值。
Linux下多线程编程-Pthread与Semaphore的使用
简单的多线程编程 Linux系统下的多线程遵循POSIX线程接口，称为pthread。编写Linux下的多线程程序，需要使用头文件pthread.h，连接时需要使用库libpthread.a。顺便说一下，Linux下pthread的实现是通过系统调用clone（）来实现的。clone （）是Linux所特有的系统调用，它的使用方式类似fork，关于clone（）的详细情况，有兴趣的读者可以去查看有关文档说明。下面我们展示一个最简单的多线程程序 example1.c。 /* example.c*/ #include
Linux多线程编程和Linux 2.6下的NPTL
Linux多线程编程和Linux 2.6下的NPTL 这几天由于工作需要，琢磨了一下Linux下的多线程的相关资料。Linux下最常用的多线程支持库为Pthread库，它是glibc库的组成部分。但是关于Pthread的说明文档非常缺乏，特别是对POSIX多线程规范的介绍以及pthread库中多线程实现方式的介绍实在是少之又少。而多线程编程对于系统程序员而言是必须掌握的技术，因此总是让学习中的程序员觉得头痛不以。我自己也没有太多多线程编程的经验，在这里只是把自己收集到的一些关于Linux上多线程还算新的资料进行汇总来抛砖引玉，以便相互学习交流。 这里顺便提一下市面上有的一本介绍多线程的书《Posix 多线程编程》，它是英文版《Programming with POSIX Muiltthread》中译本，这也是半年前我所能找到的唯一专题介绍多线程编程的书。我个人感觉这本书的前面1/3之一的内容写的还是不错的，但是后面的东西就非常晦涩并且有很多明显的文字错误。看看这本书的翻译者是好几个人，估计每个人的翻译能力不同造成了这本书的虎头蛇尾。因此我不建议大家去买这本书作为圣经收藏。这本书前半步的内容主要围绕Posix的多线程，介绍的比较精彩的就是几个多线程编程模型，把多线程的互斥和同步机制介绍的挺酣畅的，推荐一看。这些内容并非这本书首创，早在《UNIX网络编程》第二卷进程间通信就有了这些经典的介绍，但是能系统的把这些机制结合到多线程编程中来还是有可圈可点之处的。此外毕竟《UNIX网络编程》两卷内容太老，书也太厚了，并不是大多数程序员所能坐下来细细看的。这里我还想表达一下对微软在技术上的不足斥责。在msdn中platform sdk部分中的windows多线程编程的内容真是简陋的可笑，只有傻兮兮的建立和退出线程的函数，关于互斥，条件的介绍一概全无。只能在它的sample代码中自己去找，sample 代码里面的线程同步方式居然是做一个死循环来死等，也不知道它把windows卖这么多钱是干什么吃的。MFC中多线程的封装倒是看上去像那么一回事情了，但是我想象不出在如此简陋的系统api上微软到底是如何实现出MFC上线程功能的。拥护windows的人不要在这里砸鸡蛋，最好也能写一篇windows上的多线程介绍除了。这比砸鸡蛋来得有意义多了。好了，书归正传继续说Linux上的多线程。 在Linux上，从内核角度而言，基本没有什么线程和进程的区别－－大家都是进程。一个进程的多个线程只是多个特殊的进程他们虽然有各自的进程描述结构，却共享了同一个代码上下文。在Linux上，这样的进程称为轻量级进程Light weight process。致此，就是关于线程的总体概念了，我们往往就在了解这个概念的情况下开始我们的多线程编程之旅。这对于多线程编程入门已经足够了，然而事实上线程却要复杂的多。首先多线程间的优先级调度，内存资源（栈）分配和信号投递就不是简单的共享同一个进程代码上下文所能所能解决的。其次，效率的问题：如何有效的使用多cpu资源（2.4内核的多线程就无法使用多个cpu，一个进程的线程都被限制在同一个cpu上运行）。因此多线程库Pthread的实现并不是一件简单的事情，它建立在特有的线程模型之上。 在Linux 2.4内核中，Linux内核中使用了一个内核线程来处理用户态进程中的多个线程的上下文切换（线程切换）。由于内核中并没有什么线程组的概念，即一个进程的多个线程，因此必须依靠在pthread库中实现一个额外的线程来管理其他用户线程（即用户程序生成的线程）的建立，退出，资源分配和回收以及线程的切换。由于当时硬件并没有线程寄存器之类的冬冬来支持多线程，因此线程的切换性能和低下，并且需要引入复杂的机制在进程的栈中为各个线程划分出各自的栈数据所在位置，并且在切换时进行栈数据拷贝。而最大的问题是内核中缺乏对线程间的同步机制的支持，因此pthread库不得不在底层依靠信号方式来实现同步，因此线程互斥中
多线程程序设计 for Linux
声明：本文是网上整理的资料，版权属其作者本人所 有。 第一章线程基础知识 一．什么是线程在一个程序里的多个执行路线就叫做线程。更准确的定义是：线程是“一个 进程内部的一个控制序列”。 典型的unix进程可以看成只有一个控制线程：一个进程在同一时刻只做一件事情。有了多个控制线程以后，在程序设计时可以把进程设计成在同一时刻能够做不止一件事，每个线程处理各只独立的任务。 二．线程的优点 （1）通过为每种事件类型的处理分配单独的线程，能够简化处理异步时间的代码。 （2）多个线程可以自动共享相同的存储地址空间和文件描述符。 （3）有些问题可以通过将其分解从而改善整个程序的吞吐量。 （4）交互的程序可以通过使用多线程实现相应时间的改善，多线程可以把程序中处理用户输入输出的部分与其它部分分开。 三．线程的缺点线程也有不足之处。编写多线程程序需要更全面更深入的思考。 在一个多线 程程序里，因时间分配上的细微偏差或者因共享了不该共享的变量而造成不良影响的可能性是很大的。调试一个多线程程序也比调试一个单线程程序困难得多四．线程的结构线程包含了表示进程内执行环境必需的信息，其中包括进程中标识线程的 线程ID，一组寄存器值、栈、调度优先级和策略、信号屏蔽子，errno变量以及线程私有数据。进程的所有信息对该进程的所有线程都是共享的，包括可执行的程序文本，程序的全局内存和堆内存、栈以及文件描述符。 五．线程标识 就像每个进程有一个进程ID一样，每个线程也有一个线程ID，进程ID在 整个系统中是唯一的，但线程不同，线程ID只在它所属的进程环境中有效。线程ID用pthread_t数据类型来表示，实现的时候可以用一个结构来代表pthread_t 数据类型，所以可以移植的操作系统不能把它作为整数处理。因此必须使用函数来对来对两个线程ID进行比较。 1．
Linux下C多线程编程
Linux下C多线程编程 2007-08-24 10:07:56 Linux系统下的多线程遵循POSIX线程接口，称为pthread。编写Linux 下的多线程程序，需要使用头文件pthread.h，连接时需要使用库 libpthread.a。顺便说一下，Linux下pthread的实现是通过系统调用 clone（）来实现的。clone（）是Linux所特有的系统调用，它的使用方式类似fork，关于clone（）的详细情况，有兴趣的读者可以去查看有关文档说明。下面我们展示一个最简单的多线程程序example1.c。 我们编译此程序： 运行example1，我们得到如下结果：
再次运行，我们可能得到如下结果： 前后两次结果不一样，这是两个线程争夺CPU资源的结果。上面的示例中，我们使用到了两个函数，pthread_create和pthread_join，并声明了一个pthread_t型的变量。 pthread_t在头文件/usr/include/bits/pthreadtypes.h中定义： typedef unsigned long int pthread_t; 它是一个线程的标识符。函数pthread_create用来创建一个线程，它的原型为： 第一个参数为指向线程标识符的指针，第二个参数用来设置线程属性，第三个参数是线程运行函数的起始地址，最后一个参数是运行函数的参数。这里，我们的函数thread不需要参数，所以最后一个参数设为空指针。第二个参数我们也设为空指针，这样将生成默认属性的线程。对线程属性的设定和修改我们将在下一节阐述。当创建线程成功时，函数返回0，若不为0则说明创建线程失败，常见的错误返回代码为EAGAIN和EINVAL。前者表示系统限制创建新的线程，例如线程数目过多了；后者表示第二个参数代表的线程属性值非法。创建线程成功后，新创建的线程则运行参数三和参数四确定的函数，原来的线程则继续运行下一行代码。 函数pthread_join用来等待一个线程的结束。函数原型为： extern int pthread_join __P ((pthread_t __th, void **__thread_return));
跟我学Linux编程-11-多线程编程-竞争
多线程编程-变量 在上几个章节关于Linux多线程示例程序的运行结果描述过程中，细心的同志可能已经发现，我几乎每次的措辞都是“运行结果大致为”。在单线程的编程环境上，如果输入条件一样，程序中又没有随机处理逻辑，那么程序的运行结果是非常精确的，每次都会一样。在多线程中，“程序每次运行，结果精确相同”的结论不再成立，因为各个线程中存在竞争，导致程序进入不可完全预测的分支或执行顺序，从而每次运行的结果可能(注意不是一定)会有变化。今天，我将通过一个简单的示例，要向大家展示，“竞争”是怎么一回事。 示例程序还是和上前边的章节相同，只做了一些简单的改动。代码如下： #include
实验一 Linux多线程编程一
实验一 Linux多线程编程I 一、实验目的 熟悉GNU GCC编译器，能够用Pthreads线程库熟练编写多线程程序。 二、实验内容 1、设一个double型的一维数组，数组长度是1,000,000，计算全数组部元素的和。 要求： 1) 编制一个串行程序，仅有一个主线程完成上述计算。 2）编制一个多线程程序，除主线程外，派生四个子线程完成上述计算。 分别获得以上两个程序的计算时间，对比分析。 2、定义以下三个数组： #define LEN 100000; Double A[LEN], B[LEN], C[LEN]; for (i=0; i++;i
#include