2. 线程调用了pthread_exit函数；

3. 线程可以北同一进程中的其他线程取消。

**************************************************************

转载自： http://hi.baidu.com/ganss/blog/item/ff7799f97a87de58242df24c.html

1 线程取消的定义

一般情况下，线程在其主体函数退出的时候会自动终止，但同时也可以因为接收到另一个线程发来的终止（取消）请求而强制终止。

2 线程取消的语义

1. 线程取消的方法是向目标线程发Cancel信号，但如何处理Cancel信号则由目标线程自己决定，或者忽略（当禁止取消时）、或者立即终止（当在取消点或异步模式下）、或者继续运行至Cancelation-point（取消点，下面将描述），总之由不同的Cancelation状态决定。

2. 线程接收到CANCEL信号的缺省处理（即pthread_create()创建线程的缺省状态）是继续运行至取消点再处理（退出），或在异步方式下直接退出。一个线程处理cancel请求的退出操作相当于pthread_exit(PTHREAD_CANCELED)。当然线程可以通过设置为PTHREAD_CANCEL_DISABLE来拒绝处理cancel请求，稍后会提及。

3. 线程的取消与线程的工作方式（joinable或detached）无关。

3 取消点

根据POSIX标准，pthread_join()、pthread_testcancel()、pthread_cond_wait()、 pthread_cond_timedwait()、sem_wait()、sigwait()等函数以及read()、write()等会引起阻塞的系统调用都是Cancelation-point，而其他pthread函数都不会引起Cancelation动作。 但是pthread_cancel的手册页声称，由于LinuxThread库与C库结合得不好，因而目前C库函数都不是Cancelation-point； 但CANCEL信号会使线程从阻塞的系统调用中退出，并置EINTR错误码，因此可以在需要作为Cancelation-point的系统调用前后调用pthread_testcancel()，从而达到POSIX标准所要求的目标，即如下代码段：
pthread_testcancel();
retcode = read(fd, buffer,length);
pthread_testcancel();

使用前 须判断线程ID的有效性！即判断并保证：thrd != 0 否则有可能会出现“段错误”的异常！

但是pthread_cancel的手册页声称，由于LinuxThread库与C库结合得不好，因而 目前C库函数（比如read()）在linux中都不是Cancelation-point ；但CANCEL信号会使线程从阻塞的系统调用中退出，并置EINTR错误码，因此可以在需要作为Cancelation-point的系统调用前后调用 pthread_testcancel()，从而达到POSIX标准所要求的目标，即如下代码段：

4 程序设计方面的考虑

1. 如果线程处于无限循环中，且循环体内没有执行至取消点的必然路径，则线程无法由外部其他线程的取消请求而终止。因此 在这样的循环体的必经路径上应该加入pthread_testcancel()调用 。

2. 当pthread_cancel()返回时，线程未必已经取消，可能仅仅将请求发送给目标线程，而目标线程目前没有到达取消点，如果要知道线程在何时中止，就需要在取消它之后调用pthread_join()。有一个例外是当线程被detach后，不能这样处理：
a) 当join一个已经detached的线程时，返回 EINVAL ；
b) 如果join后该线程设置为detached，则detach将不起作用。
因此， 如果知道一个线程可能会以分离方式运行，就不需要在pthread_cancel()后调用pthread_join() 。

5 与线程取消相关的pthread函数

int pthread_cancel (pthread_t thread)
发送终止信号给thread线程，如果成功则返回0，否则为非0值。发送成功并不意味着thread会终止。

int pthread_setcancelstate (int state, int *oldstate)
设置本线程对Cancel信号的反应，state有两种值：PTHREAD_CANCEL_ENABLE（缺省）和 PTHREAD_CANCEL_DISABLE，分别表示收到信号后设为CANCLED状态和忽略CANCEL信号继续运行；old_state如果不为NULL则存入原来的Cancel状态以便恢复。

int pthread_setcanceltype (int type, int *oldtype)
设置本线程取消动作的执行时机，type有两种取值：PTHREAD_CANCEL_DEFFERED 和 PTHREAD_CANCEL_ASYCHRONOUS，仅当Cancel状态为Enable时有效，分别表示收到信号后继续运行至下一个取消点再退出和立即执行取消动作（退出）；oldtype如果不为NULL则存入运来的取消动作类型值。

void pthread_testcancel (void)
检查本线程是否处于Canceld状态，如果是，则进行取消动作，否则直接返回。

6 检测一个线程是否还活着的pthread函数

int pthread_kill ( pthread_t thread , int sig )
向指定ID的 线程 发送sig信号，如果 线程 的代码内不做任何信号处理，则会按照信号默认的行为影响整个 进程 。也就是说，如果你给一个线程发送了SIGQUIT，但线程却没有实现signal处理函数，则整个进程退出。
pthread_kill(threadid, SIGKILL)也一样，他会杀死整个进程。
如果要获得正确的行为，就需要在线程内实现signal(SIGKILL,sig_handler)。
所以，如果int sig的参数不是0，那一定要清楚到底要干什么，而且一定要实现线程的信号处理函数，否则，就会影响整个进程。
那么，如果int sig的参数是0呢，这是一个保留信号，一个作用就是用来判断线程是不是还活着。
我们来看一下pthread_kill的返回值：
线程仍然活着：0
线程已不存在：ESRCH
信号不合法：EINVAL

***************************************************************************

先看下面一段程序：

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>
void* func(void *)
{
pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL); //允许退出线程
pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL); //设置立即取消
while (1)
{
//操作 ;
}
return NULL;
}
int main(int argc, char *argv[])
{
pthread_t thrd;
pthread_attr_t attr;
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
if( pthread_create(&thrd, &attr, func, NULL) )
{
perror( "pthread_create error ");
exit(EXIT_FAILURE);
}
if( !pthread_cancel(thrd) )
{
printf( "pthread_cancel OK\n " );
}
sleep( 10 );
return 0;
}
上面程序并不会将子线程取消 why?

-------

因为没有遇见或是设置引起Cancelation动作的取消点，

可以在调用了pthread_cancel函数后，调用pthread_join函数以获得取消点，使线程退出。

***************************************************************************

再看下面一段程序：

pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
pthread_testcancel();/*the thread can be killed only here*/
pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);

这个是代码里面摘录下来的代码，什么情况下 线程能被杀掉呢？
因为 这段代码 在 线程的循环里面，那每次执行到这段的时候，为什么都没有被杀掉呢？

-------

简单理解就是，两个线程T1和T2，如果T1发送cancel信号给T2，则T2默认会在取消点退出。取消点是固定的地方，只要thread_join()、pthread_testcancel()、pthread_cond_wait()、 pthread_cond_timedwait()、sem_wait()、sigwait()等函数以及read()、write()等会引起阻塞的系统调用都是Cancelation-point。

假设T2在一个循环中，这个循环中没有取消点，那么怎么办？收到cancel信号也没办法退出。这时就用pthread_testcancel()来创造一个取消点，如果有cancel信号就退出，没有就继续运行。

那么pthread_setcancelstate就比较好理解了，就是设置T2的状态，PTHREAD_CANCEL_ENABLE就是正常处理cancel信号，PTHREAD_CANCEL_DISABLE就是忽略cancel信号。

那么循环体中每次执行到这段的时候，为什么都没有被杀掉呢？
这里的被杀死指的是别的线程发送cancel信号给他，也许这里根本就没发送所以没被杀死。

====================================================================================

使用pthread_create创建大量线程时，创建线程失败，Resource temporarily unavailable的解决办法

转载自： http://blog.csdn.net/lifuxianoa/article/details/6796813 http://blog.csdn.net/lifuxianoa/article/details/6797104

今天在一个测试程序中使用pthread_create创建了大量线程，但是如果线程数量增加到400后，就会出现线程创建失败，perror打印出的错误原因是：Resource temporarily unavailable。

在网上查了下，原因如下，Linux系统中每个线程都拥有独立的栈空间，而我的系统上调用ulimit -a看到的结果如下：

ulimit -a
core file size (blocks, -c) 0
data seg size (kbytes, -d) unlimited
scheduling priority (-e) 20
file size (blocks, -f) unlimited
pending signals (-i) 16382
max locked memory (kbytes, -l) 64
max memory size (kbytes, -m) unlimited
open files (-n) 1024
pipe size (512 bytes, -p) 8
POSIX message queues (bytes, -q) 819200
real-time priority (-r) 0
stack size (kbytes, -s) 8192
cpu time (seconds, -t) unlimited
max user processes (-u) unlimited
virtual memory (kbytes, -v) unlimited
file locks (-x) unlimited

可以看到stack size是8M, 400个线程就需要8*400=3200M，虚拟内存不够用。

解决办法有两种：

1.使用ulimit -s 1024*1024命令，将线程栈大小临时设置成1M,经过试验能同时创建2000个线程了。

2.使用pthread_attr_setstacksize在程序中改变线程栈大小。

====================================================================================
进程与线程

转载自： http://blog.sina.com.cn/s/blog_68f262210100j61q.html

通俗的解释

一个系统运行着很多进程，可以比喻为一条马路上有很多马车

不同的进程可以理解为不同的马车

而同一辆马车可以有很多匹马来拉 ---- 这些马就是线程

假设道路的宽度恰好可以通过一辆马车

道路可以认为是临界资源

那么马车成为分配资源的最小单位（进程）

而同一个马车被很多匹马驱动（线程） ---- 即最小的运行单位

每辆马车马匹数 >=1

所以马匹数 =1 的时候进程和线程没有严格界限，只存在一个概念上的区分度

马匹数 >1 的时候才可以严格区分进程和线程

专业的解释：

简而言之 , 一个程序至少有一个进程 , 一个进程至少有一个线程 .

线程的划分尺度小于进程，使得多线程程序的并发性高。另外，进程在执行过程中拥有独立的内存单元，而多个线程共享内存，从而极大地提高了程序的运行效率。

线程在执行过程中与进程还是有区别的。每个独立的线程有一个程序运行的入口、顺序执行序列和程序的出口。但是线程不能够独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制。

从逻辑角度来看，多线程的意义在于一个应用程序中，有多个执行部分可以同时执行。但操作系统并没有将多个线程看做多个独立的应用，来实现进程的调度和管理以及资源分配。这就是进程和线程的重要区别。

进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动 , 进程是系统进行资源分配和调度的一个独立单位 .

线程是进程的一个实体 , 是 CPU 调度和分派的基本单位 , 它是比进程更小的能独立运行的基本单位 . 线程自己基本上不拥有系统资源 , 只拥有一点在运行中必不可少的资源 ( 如程序计数器 , 一组寄存器和栈 ), 但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源 .

一个线程可以创建和撤销另一个线程 ; 同一个进程中的多个线程之间可以并发执行

进程和线程的主要差别在于它们是不同的操作系统资源管理方式。进程有独立的地址空间，一个进程崩溃后，在保护模式下不会对其它进程产生影响，而线程只是一个进程中的不同执行路径。线程有自己的堆栈和局部变量，但线程之间没有单独的地址空间，一个线程死掉就等于整个进程死掉，所以多进程的程序要比多线程的程序健壮，但在进程切换时，耗费资源较大，效率要差一些。但对于一些要求同时进行并且又要共享某些变量的并发操作，只能用线程，不能用进程。如果有兴趣深入的话，我建议你们看看《现代操作系统》或者《操作系统的设计与实现》。对就个问题说得比较清楚。

+++++++++++++++++++++++++++++++++++++++++++++++

进程是表示资源分配的基本单位，又是调度运行的基本单位。例如，用户运行自己的程序，系统就创建一个进程，并为它分配资源，包括各种表格、内存空间、磁盘空间、 I ／ O 设备等。然后，把该进程放人进程的就绪队列。进程调度程序选中它，为它分配 CPU 以及其它有关资源，该进程才真正运行。所以，进程是系统中的并发执行的单位。

在 Mac 、 Windows NT 等采用微内核结构的操作系统中，进程的功能发生了变化：它只是资源分配的单位，而不再是调度运行的单位。在微内核系统中，真正调度运行的基本单位是线程。因此，实现并发功能的单位是线程。

线程是进程中执行运算的最小单位，亦即执行处理机调度的基本单位。如果把进程理解为在逻辑上操作系统所完成的任务，那么线程表示完成该任务的许多可能的子任务之一。例如，假设用户启动了一个窗口中的数据库应用程序，操作系统就将对数据库的调用表示为一个进程。假设用户要从数据库中产生一份工资单报表，并传到一个文件中，这是一个子任务；在产生工资单报表的过程中，用户又可以输人数据库查询请求，这又是一个子任务。这样，操作系统则把每一个请求――工资单报表和新输人的数据查询表示为数据库进程中的独立的线程。线程可以在处理器上独立调度执行，这样，在多处理器环境下就允许几个线程各自在单独处理器上进行。操作系统提供线程就是为了方便而有效地实现这种并发性

引入线程的好处

（ 1 ）易于调度。

（ 2 ）提高并发性。通过线程可方便有效地实现并发性。进程可创建多个线程来执行同一程序的不同部分。

（ 3 ）开销少。创建线程比创建进程要快，所需开销很少。。

（ 4 ）利于充分发挥多处理器的功能。通过创建多线程进程（即一个进程可具有两个或更多个线程），每个线程在一个处理器上运行，从而实现应用程序的并发性，使每个处理器都得到充分运行。

++++++++++++++++++++++++++++++++++++++++++++++++

进程和线程的关系：

（ 1 ）一个线程只能属于一个进程，而一个进程可以有多个线程，但至少有一个线程。

（ 2 ）资源分配给进程，同一进程的所有线程共享该进程的所有资源。

（ 3 ）处理机分给线程，即真正在处理机上运行的是线程。

（ 4 ）线程在执行过程中，需要协作同步。不同进程的线程间要利用消息通信的办法实现同步。

线程是指进程内的一个执行单元 , 也是进程内的可调度实体 .

与进程的区别 :

(1) 调度：线程作为调度和分配的基本单位，进程作为拥有资源的基本单位

(2) 并发性：不仅进程之间可以并发执行，同一个进程的多个线程之间也可并发执行

(3) 拥有资源：进程是拥有资源的一个独立单位，线程不拥有系统资源，但可以访问隶属于进程的资源 .

(4) 系统开销：在创建或撤消进程时，由于系统都要为之分配和回收资源，导致系统的开销明显大于创建或撤消线程时的开销。

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

进程间的通信方式：

1. 管道（ pipe ）及有名管道（ named pipe ）：

管道可用于具有亲缘关系的父子进程间的通信，有名管道除了具有管道所具有的功能外，它还允许无亲缘关系进程间的通信。

2. 信号（ signal ）：

信号是在软件层次上对中断机制的一种模拟，它是比较复杂的通信方式，用于通知进程有某事件发生，一个进程收到一个信号与处理器收到一个中断请求效果上可以说是一致的。

3. 消息队列（ message queue ）：

消息队列是消息的链接表，它克服了上两种通信方式中信号量有限的缺点，具有写权限得进程可以按照一定得规则向消息队列中添加新信息；对消息队列有读权限得进程则可以从消息队列中读取信息。

4. 共享内存（ shared memory ）：

可以说这是最有用的进程间通信方式。它使得多个进程可以访问同一块内存空间，不同进程可以及时看到对方进程中对共享内存中数据得更新。这种方式需要依靠某种同步操作，如互斥锁和信号量等。

5. 信号量（ semaphore ）：

主要作为进程之间及同一种进程的不同线程之间得同步和互斥手段。

6. 套接字（ socket ）；

这是一种更为一般得进程间通信机制，它可用于网络中不同机器之间的进程间通信，应用非常广泛。

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

线程之间的同步通信：

1. 信号量 二进制信号量 互斥信号量 整数型信号量记录型信号量

2. 消息 消息队列 消息邮箱

3. 事件 event

互斥型信号量： 必须是同一个任务申请，同一个任务释放，其他任务释放无效。同一个任务可以递归申请。（ 互斥信号量是二进制信号量的一个子集 ）

二进制信号量： 一个任务申请成功后，可以由另一个任务释放。（ 与互斥信号量的区别 ）

整数型信号量：取值不局限于 0 和 1, 可以一个任务申请，另一个任务释放。（ 包含二进制信号量，二进制信号量是整数型信号量的子集 ）

二进制信号量实现任务互斥：

打印机资源只有一个， a b c 三个任务共享，当 a 取得使用权后，为了防止其他任务错误地释放了信号量（二进制信号量允许其他任务释放），必须将打印机房的门关起来 ( 进入临界段 ) ，用完后，释放信号量，再把门打开 ( 出临界段 ) ，其他任务再进去打印。 ( 而互斥型信号量由于必须由取得信号量的那个任务释放，故不会出现其他任务错误地释放了信号量的情况出现，故不需要有临界段。互斥型信号量是二进制信号量的子集。 )

二进制信号量实现任务同步：

a 任务一直等待信号量， b 任务定时释放信号量，完成同步功能

记录型信号量（ record semaphore) ：
每个信号量 s 除一个整数值 value （计数）外，还有一个等待队列 List ，其中是阻塞在该信号量的各个线程的标识。当信号量被释放一个，值被加一后，系统自动从等待队列中唤醒一个等待中的线程，让其获得信号量，同时信号量再减一。

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

同步和互斥的区别：

当有多个线程的时候，经常需要去同步这些线程以访问同一个数据或资源。例如，假设有一个程序，其中一个线程用于把文件读到内存，而另一个线程用于统计文件中的字符数。当然，在把整个文件调入内存之前，统计它的计数是没有意义的。但是，由于每个操作都有自己的线程，操作系统会把两个线程当作是互不相干的任务分别执行，这样就可能在没有把整个文件装入内存时统计字数。为解决此问题，你必须使两个线程同步工作。

所谓互斥，是指散布在不同进程之间的若干程序片断，当某个进程运行其中一个程序片段时，其它进程就不能运行它们之中的任一程序片段，只能等到该进程运行完这个程序片段后才可以运行。如果用对资源的访问来定义的话，互斥某一资源同时只允许一个访问者对其进行访问，具有唯一性和排它性。但互斥无法限制访问者对资源的访问顺序，即访问是无序的

所谓同步，是指散步在不同进程之间的若干程序片断，它们的运行必须严格按照规定的某种先后次序来运行，这种先后次序依赖于要完成的特定的任务。如果用对资源的访问来定义的话，同步是指在互斥的基础上（大多数情况），通过其它机制实现访问者对资源的有序访问。在大多数情况下，同步已经实现了互斥，特别是所有写入资源的情况必定是互斥的。少数情况是指可以允许多个访问者同时访问资源。