其实线程属性我看明白的很少，因为属性很多，很多都永不到，很多虽然看了却没法试验下，因此不知道对错。感觉关于多线程有句话说的很对，有很多多线程的程序，只有在多个机器，多个系统上都试验过，才知道对不对，错在哪里。

在/usr/include/pthread.h里可以看到一堆关于set or get attr的函数，大概全是这个样子的：pthread_attr_set*() 或者pthread_attr_get*();

想了下，先从一个普通例子开始说起：

#include <stdio.h>

#include <unistd.h>

int main()

{

const size_t asize = (8192*1024+1024*1024*2)/sizeof(int);

/*const size_t asize = 8388608/sizeof(int);*/

printf("heap:\n");

int *parray;

parray = malloc(asize*sizeof(int));

parray[asize-1] = 1;

printf("stack:\n");

int array[asize];

printf("%u\n",asize);

array[asize-1]=1;

return 0;

}

程序输出：

heap:

stack:

段错误

为什么会这样?因为每个进程的栈大小是有限制的，例如我的：

$ 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

通过ulimit –s可以修改进程栈的大小使这个程序运行OK（也可能不行，跟硬件有关）。

我们这里数组大小不止用到了8192k，因为linux下还有一个栈的缓冲区。

实际上进程在运行时并不一定会用到8192k大小的栈，这是一个最大值，可以写两个使用不同栈大小的例子，pause后，查看/proc/*/maps试验下。

但线程是不同的，线程的栈可以通过暴露栈指针的方式共享。无论线程使用多小的栈，进程都会分配一定数目（我的是8M，可以通过线程属性函数来查看）大小的栈给线程使用。如果线程不是以detach结束的，那么只有用join函数获得线程退出状态后才能回收该线程资源，这就是最开始我们说到join函数的作用。

用一个例子测试下线程数目：

#include <stdio.h>

#include <string.h>

#include <pthread.h>

void *test(void *arg)

{

/*pthread_detach(pthread_self());*/

}

int main()

{

int err;

int i = 0;

pthread_t tid;

pthread_attr_t attr;

pthread_attr_init(&attr);

pthread_attr_setstacksize(&attr,1024*1024*16);

while (1) {

err = pthread_create(&tid,NULL,test,NULL);

/*err = pthread_create(&tid,&attr,test,NULL);*/

if (err!=0) {

printf("create thread error: %s!\n",strerror(err));

exit(1);

}

++i;

printf("i=%d\n",i);

}

return 0;

}

我的机器上结果是381，有时382，注意此时这里返回值就是最开始提到的EAGAIN。如果注释放开的话，就可以一直运行下去，因为资源被回收。不过用有的机器试验时，数量虽然增大了，但并不能一直运行下去。没想清楚什么原因。

程序里有几个关于属性的函数，不过暂时没有用到，关于函数的作用，在pthread.h里可以直接看到。

从网上搜到的关于线程最大数目的解释：

这个值和理论完全相符，因为 32 位 linux 下的进程用户空间是 3G 的大小，也就是 3072M，用 3072M 除以 8M 得 384，但是实际上代码段和数据段等还要占用一些空间，这个值应该向下取整到 383，再减去主线程，得到 382。

那为什么 linuxthreads 上还要少一个线程呢？这可太对了，因为 linuxthreads 还需要一个管理线程

为了突破内存的限制，可以有两种方法

1) 用 ulimit -s 1024 减小默认的栈大小

2) 调用 pthread_create 的时候用 pthread_attr_getstacksize 设置一个较小的栈大小

要注意的是，即使这样的也无法突破 1024 个线程的硬限制，除非重新编译 C 库。

虽然结果不是确定的，不过这个解释感觉也还是很合理的。

可以通过程序里线程的attr（即在create的时候不采用NULL而采用这个attr）建立线程观察下线程最大数目再计算下验证下结果。

关于最开始那个程序的段错误，在线程里一样会有，相应的通过pthread_attr_setstacksize(&attr,stackSize)就可以解决了。

关于属性，很多一知半解的，就不拿上来贻笑大方了。

关于pthread多线程编程，用的多的话，其实需要学习的地方还有很多，感觉这些能够满足一些基本的使用了，其他的比如信号量等，等再有使用上的心得的时候再上来总结了。

直奔主题，如果signal的时候没有线程在条件等待队列里，那么本次signal就没有效果，后续的线程进入条件队列之后，无法被之前的signal唤醒。

似乎这与Windows上不一样？

考虑一个情形，旅客在出租车点排队（进入wait队列），当有出租车到来时，鸣笛或者干啥的（总之就是signal），旅客上车。

于是有了下面这个例子：

#include <stdio.h>

#include <pthread.h>

pthread_cond_t taxiCond;

pthread_mutex_t taxiMutex;

void *travelerArrive(void *name)

{

printf("Traveler: %s need a taxi now!\n",(char*)name);

pthread_mutex_lock(&taxiMutex);

pthread_cond_wait(&taxiCond, &taxiMutex);

pthread_mutex_unlock(&taxiMutex);

printf("Traveler: %s now got a taxi!\n",(char*)name);

pthread_exit((void*)0);

}

void *taxiArrive(void *name)

{

printf("Taxi %s arrives\n",(char*)name);

pthread_cond_signal(&taxiCond);

pthread_exit((void*)0);

}

int main()

{

pthread_t thread;

pthread_attr_t threadAttr;

pthread_attr_init(&threadAttr);

pthread_cond_init(&taxiCond,NULL);

/*pthread_create(&thread, &threadAttr, travelerArrive, (void*)("Liona"));*/

/*sleep(1);*/

pthread_create(&thread, &threadAttr, taxiArrive, (void*)("Jack"));

sleep(1);

pthread_create(&thread, &threadAttr, travelerArrive, (void*)("Susan"));

sleep(1);

pthread_create(&thread, &threadAttr, taxiArrive, (void*)("Mike"));

sleep(1);

return 0;

}

当Jack出租车到达后，signal，实际上没有效果。

当Susan到了后，进入wait队列，是收不到哦啊Jack的signal的。

只有当Mike出租车到了后，signal，Susan收到。

程序输出：

Taxi Jack arrives

Traveler: Susan need a taxi now!

Taxi Mike arrives

Traveler: Susan now got a taxi!

如果觉得这样不合理，其实容易改变，加一个关于旅客人数的全局变量即可，修改后的程序如下：

#include <stdio.h>

#include <pthread.h>

pthread_cond_t taxiCond;

pthread_mutex_t taxiMutex;

int travelerCount = 0;

void *travelerArrive(void *name)

{

printf("Traveler: %s need a taxi now!\n",(char*)name);

pthread_mutex_lock(&taxiMutex);

travelerCount++;

pthread_cond_wait(&taxiCond, &taxiMutex);

travelerCount--;

pthread_mutex_unlock(&taxiMutex);

printf("Traveler: %s now got a taxi!\n",(char*)name);

pthread_exit((void*)0);

}

void *taxiArrive(void *name)

{

printf("Taxi %s arrives\n",(char*)name);

while (1) {

pthread_mutex_lock(&taxiMutex);

if (travelerCount>0) {

pthread_cond_signal(&taxiCond);

pthread_mutex_unlock(&taxiMutex);

break;

}

pthread_mutex_unlock(&taxiMutex);

}

pthread_exit((void*)0);

}

int main()

{

pthread_t thread;

pthread_attr_t threadAttr;

pthread_attr_init(&threadAttr);

pthread_cond_init(&taxiCond,NULL);

/*pthread_create(&thread, &threadAttr, travelerArrive, (void*)("Liona"));*/

/*sleep(1);*/

pthread_create(&thread, &threadAttr, taxiArrive, (void*)("Jack"));

sleep(1);

pthread_create(&thread, &threadAttr, taxiArrive, (void*)("Join"));

sleep(1);

pthread_create(&thread, &threadAttr, travelerArrive, (void*)("Susan"));

sleep(1);

pthread_create(&thread, &threadAttr, taxiArrive, (void*)("Mike"));

sleep(1);

pthread_create(&thread, &threadAttr, travelerArrive, (void*)("Lyn"));

sleep(1);

return 0;

}

pthread_cond_wait,pthread_cond_timewait是被实现为取消点的，取消点的含义是如果该线程是可取消的，那么当到达取消点的时候，该线程会取消掉并返回。

先看一个例子：

#include <stdio.h>

#include <pthread.h>

#include <unistd.h>

pthread_mutex_t mutex;

pthread_cond_t cond;

void *child1(void *arg)

{

/*pthread_cleanup_push(pthread_mutex_unlock, &mutex);*/

while (1) {

printf("thread 1 get running\n");

printf("thread 1 pthread_mutex_lock returns %d\n",pthread_mutex_lock(&mutex));

pthread_cond_wait(&cond,&mutex);

printf("thread 1 conditional applied\n");

pthread_mutex_unlock(&mutex);

sleep(5);

}

/*pthread_cleanup_pop(0);//comment 2*/

}

void *child2(void *arg)

{

while (1) {

sleep(3); //comment 3

printf("thread 2 get running.\n");

printf("thread 2 pthread_mutex_lock returns %d\n",pthread_mutex_lock(&mutex));

pthread_cond_wait(&cond,&mutex);

printf("thread 2 conditional applied\n");

pthread_mutex_unlock(&mutex);

sleep(1);

}

}

int main(void)

{

int tid1,tid2;

printf("conditional variable test\n");

pthread_mutex_init(&mutex,NULL);

pthread_cond_init(&cond,NULL);

pthread_create(&tid1, NULL, child1, NULL);

pthread_create(&tid2, NULL, child2, NULL);

do {

sleep(2);//comment 4

pthread_cancel(tid1);//comment 5

sleep(2);//comment 6

pthread_cond_signal(&cond);

}while(1);

sleep(100);

pthread_exit(0);

}

如果注释掉的部分不放开的话，线程2会一直停在那里，即使主线程不断的去signal。

原因是：

ß pthread_cond_wait ()和pthread_cond_timedwait()都被实现为取消点，因此，在该处等待的线程将立即重新运行，在重新锁定mutex后离开 pthread_cond_wait()，然后执行取消动作。也就是说如果pthread_cond_wait()被取消，mutex是保持锁定状态的，因而需要定义退出回调函数来为其解锁。

好了，其实要说明的就是上面这句话。

上篇笔记的例子运行效果没有问题，但有些疑问还没搞清楚。

wait函数并不是单使该线程进入休眠。

ß wait函数做以下三步的操作：

ß 1.释放Mutex 2.阻塞等待（不耗费cpu周期） 3.当被唤醒时，重新锁定互斥锁并重新测试条件是否满足 。

ß 需要重新测试条件的原因是因为可能存在多个consumer的情况，即如果线程不止两个而是多个，即使线程被唤醒了，如果一个consumer取走了列表里的产品，那么另外一个consumer需要重新进入休眠等待。这也是为什么用while不用if去判断的原因。条件变量只是起阻塞和唤醒线程的作用，具体的判断条件还需用户给出。从wait或者timewait调用成功返回时，线程需要重新计算条件，因为其他的线程可能已经在运行并改变了条件。

wait函数会在 休眠等待之前释放锁，因此producer是不用担心一直获取不到锁的。

传递给wait的互斥量对条件进行保护，调用者把锁住的互斥量传给函数。函数把调用线程放到等待条件的线程列表上，然后对互斥量解锁，这两个操作是原子操作。这样就关闭了条件检查和线程进入休眠状态等待条件改变这两个操作之间的时间通道，这样线程就不会错过条件的任何变化。这就是互斥量和条件一起使用的原因，如果consumer判断到列表为空，正准备进入休眠，而此时producer产生节点放到了列表里，consumer却接着进入休眠很明显不是我们想要的，如果producer在其休眠前发出了信号，又会造成没有接受者的情形（一会会讲到这个）。wait返回时，互斥量再次被锁住。

要注意，一定要在改变条件之后再给线程发信号。否则无意义的唤醒休眠线程就违反我们最初引入条件变量的目的了

关于signal与mutex的相对位置，《UNIX高级环境编程》里是说都可以的，只要在cond_signal之后能从列表里取出节点。因为是while循环检查条件，所以不会存在问题：线程醒来，发现队列为空，然后返回继续等待。如果代码不能容忍这种竞争，就需要在向线程发送信号的时候占有互斥量。

关于这个，从网上找了下资料，也是各执一词，主要是跟当前系统环境有关系，因此并无定论。下面的这个感觉是比较合理的：

pthread_cond_signal即可以放在pthread_mutex_lock和pthread_mutex_unlock之间，也可以放在 pthread_mutex_lock和pthread_mutex_unlock之后，但是各有有缺点。

之间：

pthread_mutex_lock

xxxxxxx

pthread_cond_signal

pthread_mutex_unlock

缺点：在某下线程的实现中，会造成等待线程从内核中唤醒（由于cond_signal)然后又回到内核空间（因为cond_wait返回后会有原子加锁的 行为），所以一来一回会有性能的问题。但是在LinuxThreads或者NPTL里面，就不会有这个问题，因为在Linux 线程中，有两个队列，分别是cond_wait队列和mutex_lock队列， cond_signal只是让线程从cond_wait队列移到mutex_lock队列，而不用返回到用户空间，不会有性能的损耗。

所以在Linux中推荐使用这种模式。

之后：

pthread_mutex_lock

xxxxxxx

pthread_mutex_unlock

pthread_cond_signal

优点：不会出现之前说的那个潜在的性能损耗，因为在signal之前就已经释放锁了

缺点：如果unlock和signal之前，有个低优先级的线程正在mutex上等待的话，那么这个低优先级的线程就会抢占高优先级的线程 （cond_wait的线程)，而这在上面的放中间的模式下是不会出现的。

所以，在Linux下最好pthread_cond_signal放中间，但从编程规则上说，其他两种都可以。

我理解为signal后唤醒的线程会具有较高的加锁优先级，如果有多个线程在等待给该互斥量加锁的话，唤醒线程会获取得到锁，而这在大部分情况下都是我们所希望看到的。当然如文章中所言，可能会有性能的问题。

关于signal与broadcast的区别，找到一个解释很有意思（如果我的确看明白了的话）：

FiLH wrote On 03/29/06 08:47,:

Hello,

I wonder what is the effective usage difference between

pthread_cond_signal and pthread_cond_broadcast.

I understand that the first awake one waiting thread, and the second

all the waiting threads (on that condition),

That is the difference.

but be seen that the

awkaed thread should enter a mutex, it seems to me in the second case

that only one thread will run while the other one will go back

waiting. But than, I see no big differences, so I must miss something,

but.. what ?

All the threads wake up, and all try to lock the

mutex. Only one at a time can succeed, and the others

must wait for a later opportunity. Yes, they "go back

waiting" -- but they are not waiting for the condition

any more, they are waiting to lock the mutex.

The bugler sounds Reveille, all the soldiers in the

barracks awaken, and they all rush for the lone shower

stall. One soldier gets there first and showers, while

the others stand around fidgeting. When the first is

done, there's a brief struggle among the others until

a second soldier hits the shower, and so on until all

the soldiers have made themselves nice and clean and

ready to go crawl in the mud all day. The soldiers who

don't happen to be first into the shower don't all go

back to bed and await another bugle call (they might

wish to, but the Drill Sergeant has other ideas).

ok。可能关于一些问题，更多的还需要具体情况具体分析。

互斥量是用来上锁的。有时候我们需要这样一种情形：

线程A需要等某个条件成立才能继续往下执行，现在这个条件不成立，线程A就阻塞等待，而线程B在执行过程中使这个条件成立了，就唤醒A继续执行。

使用互斥量固然可以，线程A不断的去尝试加锁，但却造成cpu周期的浪费，线程A的阻塞等待能是不耗费cpu周期的？

这就是引入条件变量的作用。

ß 条件变量是用来等待而不是用来上锁的。条件变量用来自动阻塞一个线程，直到某特殊情况发生为止。通常条件变量和互斥锁同时使用。

ß 条件变量使我们可以睡眠等待某种条件出现。条件变量是利用线程间共享的全局变量进行同步的一种机制，主要包括两个动作：一个线程等待"条件变量的条件成立"而挂起；另一个线程使"条件成立"（给出条件成立信号）。

针对条件变量的这两个动作，就定义了条件变量响应的两个函数。

等待：

ß int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);

ß int pthread_cond_timewait(pthread_cond_t *cond,pthread_mutex_t *mutex, const struct timespec *timeout)

第二个函数仅比第一个多了时间变量，如果给定时间内还未被唤醒，则返回ETIMEDOUT。注意时间是一个绝对值而不是一个相对值，具体使用可以先使用gettimeofday函数获得时间。

唤醒：

ß int pthread_cond_signal(pthread_cond_t *cond)

ß int pthread_cond_broadcast(pthread_cond_t *cond)

POSIX为了简化实现，允许pthread_cond_signal在实现的时候可以唤醒不止一个线程

条件变量的类型标识符是pthread_cond_t,与互斥量一样，需要初始化，用完后需要销毁。

ß 初始化:

int pthread_cond_init(pthread_cond_t *cond, pthread_condattr_t*attr);

PTHREAD_COND_INITIALIZER

ß 销毁：int pthread_cond_destroy(pthread_cond_t *cond)

看一个例子，有点长，是生产者-消费者模型的例子。从一篇教程里找到的，尽量的完善了下，修改了其中可能引起问题的地方。

生产者和消费者都是单独的一个线程，生产者生产产品，消费者从中取出产品，产品是一个队列，生产者new一个节点添加进来，消费者取出一个节点并free掉，当消费者取的速度很快，而生产者生产的很慢时，消费者就进入休眠等等（wait），而当生产者生产产品后，就唤醒（signal）消费者队列。程序节点定义为一个结构体msg。

#include <stdlib.h>

#include <pthread.h>

#include <stdio.h>

struct msg {

struct msg *next;

int num;

};

volatile struct msg *head;

pthread_cond_t hasProduct = PTHREAD_COND_INITIALIZER;

pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;

void *consumer(void *p)

{

struct msg *mp;

for(;;) {

pthread_mutex_lock(&lock);

while (head==NULL) {

/*if (head==NULL) {*/

//条件受互斥锁保护?

//用while不用if?

printf("consumer entering wait......\n");

pthread_cond_wait(&hasProduct,&lock);

printf("consumer leaveing wait : %d......\n",head->num);

}

mp = head;

head = mp->next;

printf("Consume %d\n",mp->num);

pthread_mutex_unlock(&lock);

free(mp);

sleep(rand()%5);

}

}

void *producer(void *p)

{

struct msg *mp;

for(;;) {

mp = malloc(sizeof(struct msg));

mp->num = rand()%1000 + 1;

pthread_mutex_lock(&lock);

mp->next = head;

head = mp;

printf("Produce %d\n",mp->num);

pthread_mutex_unlock(&lock);

pthread_cond_signal(&hasProduct);

//signal与lock位置无关

sleep(rand()%5);

}

}

int main(int argc, char *argv[])

{

pthread_t pid,cid;

srand(time(NULL));

pthread_create(&pid,NULL, producer, NULL);

pthread_create(&cid,NULL, consumer, NULL);

pthread_join(pid,NULL);

pthread_join(cid,NULL);

struct msg* mp = head;

while (head!=NULL) {

mp = head;

head = head->next;

printf("main thread: %d\n",mp->num);

free(mp);

}

return 0;

}

这个例子是多线程编程里比较经典的例子，刚开始学习条件变量时其实很多问题没弄明白。没关系，其实很多条件变量的例子形式都差不多是这个样子。关于我的疑问，先提出来，下篇笔记里一个一个记录下找到的和想到的答案。。。

1. consumer里为什么是while而不是if，要知道producer是改变了条件了才signal的。

2. wait一定要在lock之后，为什么用mutex去保护cond?

3. signal的位置和mutex有关么?

4. wait函数做了什么，如果只是休眠等待的话。producer会阻塞在lock函数上（consumer先lock了mutex）。

上篇笔记介绍了互斥量的基本定义，这篇主要介绍其使用方法。

对应其作用，关于互斥量的函数有这么几个：

1. 初始化：int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr);或者Pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;//静态分配

2. 加锁：Int pthread_mutex_lock(pthread_mutex_t* mutex); Int pthread_mutex_trylock(pthread_mutex_t* mutex);

3. 解锁Int pthread_mutex_unlock(pthread_mutex_t* mutex)

4. 销毁：Int pthread_mutex_destroy(pthread_mutex_t *mutex);

具体的使用直接看个例子，从《UNIX 环境高级编程》上抄的：

/*mutex.c*/

#include <stdio.h>

#include <stdlib.h>

#include <unistd.h>

#include <pthread.h>

#include <errno.h>

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

int lock_var;

time_t end_time;

void pthread1(void *arg);

void pthread2(void *arg);

int main(int argc, char *argv[])

{

pthread_t id1,id2;

pthread_t mon_th_id;

int ret;

end_time = time(NULL) + 10;

/** 互斥锁初始化*/

pthread_mutex_init(&mutex,NULL);

/** 创建两个线程*/

ret = pthread_create(&id1,NULL,(void *)pthread1,NULL);

if (ret!=0) {

perror("pthread create error.\n");

exit(-1);

}

ret = pthread_create(&id2,NULL,(void *)pthread2,NULL);

if (ret!=0) {

perror("pthread create error.\n");

}

pthread_join(id1,NULL);

pthread_join(id2,NULL);

pthread_mutex_destroy(&mutex);

exit(0);

}

void pthread1(void *arg)

{

int i;

while (time(NULL) < end_time) {

/** 互斥锁上锁*/

if (pthread_mutex_lock(&mutex)!=0) {

perror("pthread_mutex_lock");

} else {

printf("pthread1:pthread1 lock the variable %d\n",lock_var);

}

for (i=0; i<2; i++) {

sleep(1);

lock_var++;

}

/** 互斥锁解锁*/

if (pthread_mutex_unlock(&mutex)!=0) {

perror("pthread_mutex_unlock.");

} else {

printf("pthread1:pthread1 unlock the variable %d\n",lock_var);

}

sleep(1);

}

}

void pthread2(void *arg)

{

int ret;

while (time(NULL) < end_time) {

/** 测试互斥锁*/

ret = pthread_mutex_trylock(&mutex);

if (ret == EBUSY) {

printf("pthread2:the variable is locked by pthread1\n");

} else {

if (ret!=0) {

perror("pthread_mutex_trylock");

exit(1);

} else {

printf("pthread2:pthread2 got lock. The variable is %d\n",lock_var);

}

if (pthread_mutex_unlock(&mutex)!=0) {

perror("pthread_mutex_unlock");

} else {

printf("pthread2:pthread2 unlock the variable\n");

}

}

sleep(3);

}

}

需要说明的有两点：

1. lock函数会阻塞等待，直到获得锁

2. trylock函数不会阻塞等待，如果互斥量当前被锁，则返回EBUSY值。

容易出错的情形：

A

ß pthread_mutex_lock (theMutex);

ß pthread_mutex_lock (theMutex);

ß pthread_mutex_unlock (theMutex);

ß pthread_mutex_unlock (theMutex);

表面上看程序加锁两次，然后解锁两次没有错，实际上加锁第二次的时候就出错了。

B．

即存在多个互斥量时的问题，两个线程都在等在另一个线程解锁才能继续往下执行。

碰到这种情况，我们一般约定一个1-2-3…的加锁顺序，所有线程都遵守这一约定才行。

但即使这样，有时候应用程序的结构使得对互斥量加锁进行排序是很困难的，如果涉及了太多的锁和数据结构，可用的函数并不能把它转换成简单的层次，那么就需要采用另外的办法。可以先释放所有的锁，然后过一段时间再试。这种情况可以使用pthread_mutex_trylock接口避免死锁。

ß 互斥锁一个明显的缺点是它只有两种状态：锁定和非锁定。设想一种简单情景：多个线程访问同一个共享资源时，并不知道何时应该使用共享资源，如果在临界区里加入判断语句，或者可以有效，但一来效率不高，二来复杂环境下就难以编写了，这是我们需要一个结构，能在条件成立时触发相应线程，进行变量修改和访问。

针对此问题，下一篇开始学习条件变量。

多线程资源共享可以说有利有弊，这点从笔记一可以清楚的看到（子线程修改内存后，主线程可以看到，但子线程free后，主线程再次free就有问题了）。

更直接一点的错误，如果子线程修改那块内存的时候，主线程同时在修改会发生什么状况。答案是：不确定。因此，线程同步变得很重要。解决方法就是不允许多个线程同时去修改一个变量。

ß 当一个线程修改变量时，其他线程在读取这个变量的值时就可能看到不一样的数值。

ß 在变量修改时间多于一个存储器访问周期的处理器结构中，当存储器读与存储器写这两个周期交叉时，这种潜在的不一致性就会出现。

因此引入了互斥量。

看个例子可能容易理解一些：

void *threadA(void *) { i++; }

void *threadB(void *) { i++; }

对应于自增的操作：

从左到右依次为A线程，B线程和我们看到的i的值。横向的表示同一时间。我们把这种一个时间点上cpu能完成的动作称为原子操作，那么如果操作不是原子操作时，不一致性就出现了。

合理的办法是当A线程修改i的时候，B线程应当阻塞等待，直到A线程修改完毕，B线程再开始修改。或者A去等待B完成。

就像是锁，A，B去修改i的时候都尝试去锁住i，如果i处于没被锁住（解锁）状态，则可以锁上，若i处于锁住状态，则阻塞等待直到i被别的线程开锁后可以锁住i为止。

我刚开始理解为互斥量就是用来保护一个变量的，后来发现是错误的。

就像如果B尝试去修改i的时候没有先尝试去给互斥量加锁，一样可以修改i，一样会产生问题。。。

因此互斥量加锁，解锁的位置都是由我们自己来确定的。

我的理解是，互斥量可以锁住一块区域，因此抛开变量来解释，最直观的就是，当线程A执行某段代码时，不希望别的线程同时来修改其要读取或者修改的变量（可能有多个），因此对互斥量加锁，直到这段代码结束，再对其解锁。这样就一定管用吗？如果线程B执行的某段代码可能会修改线程A所不希望别的线程所修改的那些变量，而线程B又没有先尝试加锁（看下有没有线程已锁住互斥量，若有，则需要阻塞等待）的话，结果并不确定，互斥量是不会起作用的。因此，这更像是个“君子协定”（从一篇教程里看到的，还挺贴切。。。。。。），如何确保程序正确，在哪个线程哪里加锁与解锁都需要写程序的人来保证。互斥量的作用仅仅是加锁与解锁。

真啰嗦。。。不过我确实看了几个例子后才明白。。。

使用互斥量先看个例子：

单实例模式（在看一本设计模式书的时候看到的）

#include <pthread.h>

#include <stdio.h>

#include <unistd.h>

class Test {

public:

static Test* instance() {

if (NULL == m_instance) {

sleep(1);

printf("m_instance is NULL\n");

m_instance = new Test;

}

return m_instance;

}

static Test* m_instance;

void print(char* tip) 

{ 

printf("In: %s,Test print %x\n",tip,m_instance); 

printf("tid: %x\n",pthread_self());

}

private:

Test() {}

Test(const Test& ) {}

};

Test* Test::m_instance = NULL;

void *thr_fn(void* arg)

{

Test::instance()->print("thread");

return ((void*)0);

}

int main()

{

int err;

pthread_t tid;

err = pthread_create(&tid, NULL, thr_fn, NULL);

Test::instance()->print("main thread1");

Test::instance()->print("main thread2");

sleep(2);

return 0;

}

结果会产生两个实例，显然不是我们想要的。

if (NULL == m_instance) {

sleep(1);

printf("m_instance is NULL\n");

这里当发现m_instance为空后，休眠1s，然后new出一个新的出来。

当两个线程运行到这里（sleep(1)是特意加的）。无论哪个线程先调用该函数（主线程开了子线程后，接着调用，两个的时间不会超过1s......）会发现m_instance的确为空，于是休眠1s，然后new一个新的出来。该线程休眠的时候，后调用的线程同样调用到这里，跟之前的一样，发现为空，休眠1s，然后醒来new一个。于是两个线程休眠醒来的时候都会取new一个实例出来。即产生两个单实例的原因。当然可能跟sleep（1）有着关系，但在许多实际项目里，这种情况很明显是要避免的。

产生的原因其实跟之前i++相同，判断的和调用并不是一个原子操作。

如果我们尝试去写下互斥量加锁和解锁两个操作的伪代码：

lock:

if (mutex > 0) {//mutex = 1表示空闲

mutex = 0;

return 0;

} else

挂起等待;

goto lock;

unlock:

mutex = 1;

唤醒等待Mutex的线程;

return 0;

可以看到跟这个例子一样，if判断和调用并不是一个原子操作。因此互斥量具体实现是这样的：

ß 为了实现互斥锁操作，大多数体系结构都提供了swap或exchange指令，该指令的作用是把寄存器和内存单元的数据相交换，由于只有一条指令，保证了原子性，即使是多处理器平台，访问内存的总线周期也有先后，一个处理器上的交换指令执行时另一个处理器的交换指令只能等待总线周期

实际上上面这句话我几乎没看懂，不过没关系，我想说明的还是那句话，互斥量的作用在这里（使之成为了原子操作），而对变量的保护需要写代码的人（遵循所谓的“君子协议”）来完成。

线程可以安排自己退出时(某些情况下的退出)的回调函数。

Void pthread_cleanup_push(void (*rtn)(void*),void *arg);

Void pthread_pop(int execute);

这与进程可以用atexit函数安排进程退出时需要调用的函数是类似的。这样的函数称为线程清理处理程序(thread cleanup handler)。

先看下这两个函数的实现：

/* Install a cleanup handler: ROUTINE will be called with arguments ARG

when the thread is canceled or calls pthread_exit. ROUTINE will also

be called with arguments ARG when the matching pthread_cleanup_pop

is executed with non-zero EXECUTE argument.

pthread_cleanup_push and pthread_cleanup_pop are macros and must always

be used in matching pairs at the same nesting level of braces. */

# define pthread_cleanup_push(routine, arg) \

do { \

__pthread_cleanup_class __clframe (routine, arg)

/* Remove a cleanup handler installed by the matching pthread_cleanup_push.

If EXECUTE is non-zero, the handler function is called. */

# define pthread_cleanup_pop(execute) \

__clframe.__setdoit (execute); \

} while (0)

我从pthread.h里给照搬过来了，主要是想说明这两个函数实现为宏，要成对使用，英文解释里很明确了呵呵。

注意：

1. 线程可以建立多个清理处理程序，处理程序记录在栈中，也就是说它们的执行顺序与它们的注册顺序相反。

2. 当线程执行以下动作时调用

1调用pthread_exit时

2响应取消请求时.

3用非零execute参数调用pthread_cleanup_pop时。

可以看到return时并不会调用。

3. 如果execute参数置0，清理函数不被调用。无论哪种情况，pthread_cleanup_pop都将删除上次pthread_cleanup_push调用建立的清理处理程序。

直接看个例子,<UNIX 环境高级编程上的>:

#include <stdio.h>

#include <stdlib.h>

#include <pthread.h>

void cleanup(void *arg)

{

printf("cleanup: %s\n",(char *)arg);

}

void *thr_fn1(void *arg)

{

printf("thread 1 start\n");

pthread_cleanup_push(cleanup, "thread 1 first handler");

pthread_cleanup_push(cleanup, "thread 1 second handler");

printf("thread 1 push complete\n");

if (arg)

return((void *)1);

pthread_cleanup_pop(0);

pthread_cleanup_pop(0);

return((void *)1);

}

void *thr_fn2(void *arg)

{

printf("thread 2 start\n");

pthread_cleanup_push(cleanup, "thread 2 first handler");

pthread_cleanup_push(cleanup, "thread 2 second handler");

printf("thread 2 push complete\n");

if (arg)

pthread_exit((void *)2);

pthread_cleanup_pop(0);

pthread_cleanup_pop(0);

pthread_exit((void *)2);

}

int main(void)

{

int err;

pthread_t tid1,tid2;

void *tret;

err = pthread_create(&tid1, NULL, thr_fn1, (void *)1);

if (err != 0) {

printf("can't create thread 1: %s\n",strerror(err));

exit(-1);

}

err = pthread_create(&tid2, NULL, thr_fn2, (void *)1);

if (err != 0) {

printf("can't create thread 2: %s\n",strerror(err));

exit(-1);

}

err = pthread_join(tid1, &tret);

if (err != 0) {

printf("can't join with thread 1: %s\n",strerror(err));

exit(-1);

}

printf("thread 1 exit code %d\n",(int)tret);

err = pthread_join(tid2, &tret);

if (err != 0) {

printf("can't join with thread 2: %s\n",strerror(err));

exit(-1);

}

printf("thread 2 exit code %d\n",(int)tret);

}

至此多线程基本的创建，结束，清理的方法就都有了，接下来开始进入互斥量,Mutex,锁（其实是一个东东）…

上篇笔记里可以看到线程函数的开始和结束意味着线程的开始和终止，那么就有一个问题，同其他普通函数一样，如何获得线程返回时的状态？

如果子线程运行过程中，主线程需要取消子线程，该如何做？

子线程退出方式有哪些？

ß 如果需要只终止某个线程而不终止整个进程，可以有三种方法：

1.从线程函数return。这种方法对主线程不适用，从main函数return相当于调用exit。(如果进程中任一线程调用了exit,_Exit或者_exit,那么整个进程就会终止。)

2.一个线程可以调用pthread_cancel终止同一进程中的另一个线程。

3.线程可以调用pthread_exit终止自己

可以用pthread_join等待线程结束并获得其返回值：

ß int pthread_join(pthread_t thread, void **rval_ptr)

返回值：成功返回0，失败返回错误号(ESRCH,EINVAL等)

ß 通过pthread_join得到的终止状态是不同的，总结如下：

1.如果thread线程通过return返回，rval_ptr所指向的单元里存放的是thread线程函数的返回值。

2. 如果thread线程被别的线程调用pthread_cancel异常终止掉，rval_ptr所指向的单元里存放的是常数PTHREAD_CANCELED。

3.如果thread线程是自己调用pthread_exit终止的，rval_ptr所指向的单元存放的是传给pthread_exit的参数。

ß 如果对thread线程的终止状态不感兴趣，可以传NULL给rval_ptr参数。

同之前一样，每个函数具体的解释就不记录在这里了，很多教程上有，/usr/include/pthread.h文件里也可以看到简单的注解。

注意这个函数和进程里的waitpid很像。

调用这个函数其实有两个原因：

1. 获得线程返回值，存在第二个参数里（指向指针的指针）。

2. 如果不想获得函数退出状态，只是单纯的想等待线程结束，可以传NULL给它。要说明的是，一个线程不能被多个线程等待，否则第一个接收到信号的线程成功返回，其余调用pthread_join的线程则返回错误代码ESRCH。

一般情况下，线程终止后，其终止状态一直保留到其它线程调用pthread_join获取它的状态为止。因此用这个函数取等待线程结束是必要的，具体系统回收的是那部分资源线程属性里可以体现的很明显，当然肯定就是线程独有的那部分资源……但是线程也可以被置为detach状态，这样的线程一旦终止就立刻回收它占用的所有资源，而不保留终止状态。不能对一个已经处于detach状态的线程调用pthread_join，这样的调用将返回EINVAL。对一个尚未detach的线程调用pthread_join或pthread_detach都可以把该线程置为detach状态，也就是说，不能对同一线程调用两次pthread_join，或者如果已经对一个线程调用了pthread_detach就不能再调用pthread_join了。有兴趣的同学可以做个试验，看下在对每个线程设置为detach状态前后系统可以开的最大线程数目对比，看下是否线程资源回收是必要的。

第二点好像太啰嗦了（学的一知半解。。），不过感觉最主要的是也就是说这里。。。。

取消线程：

int pthread_cancel(pthread_t tid);

ß 线程可以通过调用该函数来请求取消同一进程中的其他线程。

ß 在默认情况下，pthread_cancel函数会使得由tid标识的线程的行为表现为如同调用了参数为PTHREAD_CANCELED的pthread_exit函数，但是线程可以选择忽略取消方式或是控制取消方式。注意pthread_cancel并不等待线程终止，它仅仅提出请求。

注意：

1. #define PTHREAD_CANCELED ((void *) -1)，因此此时通过join获得返回值其实就是-1.

2. 该函数仅仅是提出请求。具体被取消线程的动作跟其线程属性相关。

例子：

#include <pthread.h>

#include <stdio.h>




void cleanup(void *arg)

{

printf("clean up \n");

}

char c = 'a';




void *print(void *arg)

{

int i;

pthread_cleanup_push(cleanup,NULL);

for ( i=0; i<10; ++i) {

printf("%s\n",(char *)arg);

sleep(2);

}




pthread_exit((void *)c);

pthread_cleanup_pop(0);

/*exit(NULL);*/

}




int main()

{

pthread_t pid;

pthread_create(&pid,NULL,print,"hello world.");

/*pthread_detach(pid);*/

int i;

for( i=0; i<10; i++) {

printf("I'm main thread\n");

sleep(1);

}

void *ret;

/*pthread_cancel(pid);*/

int r = pthread_join(pid,&ret);

if (r != 0) {

printf("join error: %s\n",strerror(r));

}

/*r = pthread_join(pid,&ret);*/

/*if (r != 0) {*/

/*printf("join error: %s\n",strerror(r));*/

/*}*/

printf("%d\n",(int*)ret);




return 0;

}

这个例子里注释掉的部分是我用来测试这篇笔记里大部分感觉要注意的地方的

pthread多线程学习笔记一线程创建篇

最近在学习Linux多线程编程部分，笔记之一：

线程库函数是由POSIX标准定义的，称为POSIX thread或者pthread。在Linux上线程函数位于libpthread共享库中，因此在编译时要加上-lpthread选项。

与进程相比：

每个进程都拥有自己的数据段、代码段和堆栈段,这就造成了进程在进行切换等操作时都需要有比较负责的上下文切换等动作。运行于一个进程中的多个线程，它们彼此之间使用相同的地址空间，共享大部分数据，启动一个线程所花费的空间远远小于启动一个进程所花费的空间，而且，线程间彼此切换所需的时间也远远小于进程间切换所需要的时间。

先看一个简单的多线程的例子：

注意该例子会引起double free的问题，是为了说明下线程共享堆的性质。

//(gcc –o example example.c –lpthread)

#include <pthread.h>

#include <string.h>

#include <stdio.h>

#include <unistd.h>

 

pthread_t ntid;

 

void* thr_fn(void* arg)

{

         char* c = (char*)arg;

         memset(c,'a',9);

         c[9]=0;

         /**//*printf("ntid: %x\n",ntid);*/

         printf("thread,pid: %d, tid: %x, %x:%s\n",getpid(),pthread_self(),(unsigned int)arg,(unsigned int)c);

         sleep(2);

         free(c);

}

 

int main()

{

         int err;

         char* p = (char*)malloc(10);

         printf("main thread,pid: %d, tid: %x, %x\n",getpid(),pthread_self(),(unsigned int)p);

         err = pthread_create(&ntid, NULL, thr_fn,(void*)p);//pthread.h

         if (err!=0) {

                   printf("exit\n");

                   exit(1);

         }

         sleep(1);

         printf("main thread,pid: %d, tid: %x, %x:%s\n",getpid(),pthread_self(),(unsigned int)p,(unsigned int)p);

         sleep(10);//等待线程结束

         free(p);

         exit(0);

}

感觉多线程编程可以和进程函数一起来看：

最基本的几个函数是如下几个：

ß  线程标识: pthread_t pthread_self         pthread_equal

ß  线程创建:pthrea_create

ß  线程终止:pthread_exit pthread_join

ß  线程取消:pthread_cancel

ß  线程清理:pthread_cleanup_push pthread_cleanup_pop

ß  线程分离属性:pthread_detach

很多书里都会讲到其用法。在/usr/include/pthread.h下也可以直接看到其函数声明和基本的介绍。

这里只记录下我学习过程中觉得要注意的几个地方：

1.       pthread_create的参数介绍：
int pthread_create(pthread_t *tidp, const pthread_attr_t *attr, void *(*start_rtn)(void *),void *arg)

一个线程中调用pthread_create()创建新的线程后，当前线程从pthread_create()返回继续往下执行，而新的线程所执行的代码由我们传给pthread_create的函数指针start_rtn决定。start_rtn函数接收一个参数，是通过pthread_create的arg参数传递给它的，该参数的类型为void *，这个指针按什么类型解释由调用者自己定义。start_routine的返回值类型也是void *，这个指针的含义同样由调用者自己定义。start_routine返回时，这个线程就退出了 。

注意如果tidp是全局的变量，不要在子线程里使用它，因为可能子线程运行的时候，主线程还没有来得及给他赋值。这也是程序里我们打印子线程ID用了pthread_self而没有用ntid的原因。

2.       如果 函数有返回值，注意对返回值的判断，例如create时可能返回EAGAIN(表示线程数目过多了)，EINVAL(表示属性值非法)，join时返回ESRCH(表示没有那个线程，例如已经join过一次了，线程资源被收回，这个线程id也一起被回收，就会返回这个错误)等等其他。感觉对以后学习线程属性是比较有用的，因为很多错误从线程属性上可以了解原因，同时加深对线程属性的理解。这些错误都可以通过man errno来查看。

3.       线程id的类型是pthread_t，它只在当前进程中保证是唯一的，在不同的系统中pthread_t这个类型有不同的实现，它可能是一个整数值，也可能是个结构体，地址等。不过查看/usr/include/bits/pthreadtypes.h可以看到我的系统(ubuntu 10.04)这里定义为: typedef unsigned long int pthread_t.因此程序里我们直接用%x打印其值。

ok了。接下来在写个关于线程终止，取消以及获得返回状态的例子。

 

izualzhy 2011-11-13 14:59 发表评论

]]>