国内精品久久久久影院亚洲,久久精品亚洲中文字幕无码麻豆,国产精品无码久久综合

izualzhy — Mon, 14 Nov 2011 14:45:00 GMT

pthread多线�E�学习笔��C��条�g变量4使用之signal只能唤醒当前处于wait的线�E?

直奔主题�Q�如果signal的时候没有线�E�在条�g�{�待队列里，那么本次signal��没有效果，后箋的线�E�进入条仉��列之后，无法被之前的signal唤醒�?/strong>

��g��q�与Windows上不一��P��

考虑一个情形，旅客在出�U��R�Ҏ��队（�q�入wait队列�Q�，当有出租车到来时�Q�鸣�W�或者干啥的�Q��M��是signal�Q�，旅客上�R�?

于是有了下面�q�个例子�Q?/p>

#include 

#include 

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出租车到辑֐��Q�signal�Q�实际上没有效果�?
当Susan��C��后，�q�入wait队列�Q�是收不到哦啊Jack的signal的�?
只有当Mike出租车到了后�Q�signal�Q�Susan收到�?
�E�序输出�Q?
Taxi Jack arrives
Traveler: Susan need a taxi now!
Taxi Mike arrives
Traveler: Susan now got a taxi!
如果觉得�q�样不合理，其实�Ҏ��改变�Q�加一个关于旅客�h数的全局变量卛_��Q�修改后的程序如下：

#include

#include

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;

}

izualzhy 2011-11-14 22:45 发表评论

pthread多线�E�学习笔��C��条�g变量3使用之当wait遇到pthread_cancel

izualzhy — Mon, 14 Nov 2011 14:44:00 GMT

pthread多线�E�学习笔��C��条�g变量3使用之当wait遇到pthread_cancel
pthread_cond_wait,pthread_cond_timewait是被实现为取消点的，取消点的含义是如果该�U�程是可取消的，那么当到辑֏�消点的时候，该线�E�会取消掉�ƈ�q�回�?/strong>
先看一个例子：

#include

#include

#include

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);

}

如果注释掉的部分不放开的话�Q�线�E?会一直停在那里，即��ȝ��E�不断的去signal�?
原因是：
ß pthread_cond_wait ()和pthread_cond_timedwait()都被实现为取消点�Q�因此，在该处等待的�U�程��立即重新运行，在重新锁定mutex后离开 pthread_cond_wait()�Q�然后执行取消动作。也��是说如果pthread_cond_wait()被取消，mutex是保持锁定状态的�Q�因而需要定义退出回调函数来为其解锁�?
好了�Q�其实要说明的就是上面这句话�?

izualzhy 2011-11-14 22:44 发表评论

pthread多线�E�学习笔��C��条�g变量2使用

izualzhy — Mon, 14 Nov 2011 14:41:00 GMT

pthread多线�E�学习笔��C��条�g变量2使用
上篇�W�记的例子运行效果没有问题，但有些疑问还没搞清楚�?
wait函数�q�不是单使该�U�程�q�入休眠�?/strong>
ß wait函数做以下三步的操作�Q?
ß 1.释放Mutex 2.��d��{�待�Q�不耗费cpu周期�Q?3.当被唤醒�Ӟ��重新锁定互斥锁�ƈ重新��试条�g是否满�� ?
ß 需要重新测试条件的原因是因为可能存在多个consumer的情况，卛_��果线�E�不止两个而是多个�Q�即使线�E�被唤醒了，如果一个consumer取走了列表里的��品，那么另外一个consumer需要重新进入休眠等待。这也是��Z��么用while不用if��d��断的原因。条件变量只是�v��d��和唤醒线�E�的作用�Q�具体的判断条�g�q�需用户�l�出。从wait或者timewait调用成功�q�回�Ӟ��U�程需要重新计��条�Ӟ��因�ؓ其他的线�E�可能已�l�在�q�行�q�改变了条�g�?
wait函数会在休眠�{�待之前释放锁，因此producer是不用担心一直获取不到锁的�?
传递给wait的互斥量�Ҏ��件进行保护，调用者把锁住的互斥量传给函数。函数把调用�U�程攑ֈ��{�待条�g的线�E�列表上�Q�然后对互斥量解锁，�q�两个操作是原子操作。这样就关闭了条件检查和�U�程�q�入休眠状态等待条件改变这两个操作之间的时间通道�Q�这��L��E�就不会错过条�g的�Q何变化。这��是互斥量和条�g一起��用的原因�Q�如果consumer判断到列表�ؓ�I�，正准备进入休眠，而此时producer产生节点攑ֈ�了列表里�Q�consumer却接着�q�入休眠很明显不是我们想要的�Q�如果producer在其休眠前发��Z��信号�Q�又会造成没有接受者的情�Ş�Q�一会会讲到�q�个�Q�。wait�q�回�Ӟ��互斥量再�ơ被锁住�?
要注意，一定要在改变条件之后再�l�线�E�发信号。否则无意义的唤醒休眠线�E�就�q�反我们最初引入条件变量的目的�?
关于signal与mutex的相对位�|?/b>�Q�《UNIX高��环境�~�程》里是说都可以的�Q�只要在cond_signal之后能从列表里取��炏V��因为是while循环��查条�Ӟ��所以不会存在问题：�U�程醒来�Q�发现队列�ؓ�I�，然后�q�回�l�箋�{�待。如果代码不能容忍这�U�竞争，��需要在向线�E�发送信��L��时候占有互斥量�?
关于�q�个�Q�从�|�上找了下资料，也是各执一词，主要是跟当前�pȝ��环境有关�p�，因此�q�无定论。下面的�q�个感觉是比较合理的�Q?
pthread_cond_signal卛_��以放在pthread_mutex_lock和pthread_mutex_unlock之间�Q�也可以攑֜� pthread_mutex_lock和pthread_mutex_unlock之后�Q�但是各有有�~�点�?
之间�Q?
pthread_mutex_lock
xxxxxxx
pthread_cond_signal
pthread_mutex_unlock
�~�点�Q�在某下�U�程的实��C��Q�会造成�{�待�U�程从内�怸�唤醒�Q�由于cond_signal)然后又回到内核空��_��因�ؓcond_wait�q�回后会有原子加锁的行�ؓ�Q�，所以一来一回会有性能的问题。但是在LinuxThreads或者NPTL里面�Q�就不会有这个问题，因�ؓ在Linux �U�程中，有两个队列，分别是cond_wait队列和mutex_lock队列�Q?cond_signal只是让线�E�从cond_wait队列�U�d��mutex_lock队列�Q�而不用返回到用户�I�间�Q�不会有性能的损耗�?
所以在Linux中推荐��用这�U�模式�?
之后�Q?
pthread_mutex_lock
xxxxxxx
pthread_mutex_unlock
pthread_cond_signal
优点�Q�不会出��C��前说的那个潜在的性能损耗，因�ؓ在signal之前��已�l�释��N��?
�~�点�Q�如果unlock和signal之前�Q�有个低优先�U�的�U�程正在mutex上等待的话，那么�q�个低优先��的线�E�就会抢占高优先�U�的�U�程 �Q�cond_wait的线�E?�Q�而这在上面的放中间的模式下是不会出现的�?
所以，在Linux下最好pthread_cond_signal放中��_��但从�~�程规则上说�Q�其他两�U�都可以�?
我理解�ؓsignal后唤醒的�U�程会具有较高的加锁优先�U�，如果有多个线�E�在�{�待�l�该互斥量加锁的话，唤醒�U�程会获取得到锁�Q�而这在大部分情况下都是我们所希望看到的。当然如文章中所�a��Q�可能会有性能的问题�?
关于signal与broadcast的区别，扑ֈ�一个解释很有意思（如果我的��看明白了的话）�Q?
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。可能关于一些问题，更多的还需要具体情况具体分析�?/p>

izualzhy 2011-11-14 22:41 发表评论

pthread多线�E�学习笔��C��条�g变量1介绍

izualzhy — Mon, 14 Nov 2011 14:40:00 GMT

pthread多线�E�学习笔��C��条�g变量1介绍
互斥量是用来上锁的。有时候我们需要这样一�U�情形：
�U�程A需要等某个条�g成立才能�l�箋往下执行，现在�q�个条�g不成立，�U�程A��阻塞等待，而线�E�B在执行过�E�中使这个条件成立了�Q�就唤醒A�l�箋执行�?
使用互斥量固然可以，�U�程A不断的去��试加锁�Q�但却造成cpu周期的浪费，�U�程A的阻塞等待能是不耗费cpu周期的？
�q�就是引入条件变量的作用�?
ß 条�g变量是用来等待而不是用来上锁的。条件变量用来自动阻塞一个线�E�，直到某特�D�情况发生�ؓ止。通常条�g变量和互斥锁同时使用�?
ß 条�g变量使我们可以睡眠等待某�U�条件出现。条件变量是利用�U�程间共享的全局变量�q�行同步的一�U�机�Ӟ��主要包括两个动作�Q�一个线�E�等�?条�g变量的条件成�?而挂��P��另一个线�E��"条�g成立"�Q�给出条件成立信��P��?
针对条�g变量的这两个动作�Q�就定义了条件变量响应的两个函数�?
�{�待�Q?
ß 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)
�W�二个函��C��比第一个多了时间变量，如果�l�定旉��内还未被唤醒�Q�则�q�回ETIMEDOUT。注意时间是一个绝对��D��不是一个相对��|��具体使用可以先��用gettimeofday函数获得旉��?
唤醒�Q?
ß int pthread_cond_signal(pthread_cond_t *cond)
ß int pthread_cond_broadcast(pthread_cond_t *cond)
POSIX��Z��化实玎ͼ�允许pthread_cond_signal在实现的时候可以唤醒不止一个线�E?
条�g变量的类型标识符是pthread_cond_t,与互斥量一��P��需要初始化�Q�用完后需要销毁�?
ß 初始�?
int pthread_cond_init(pthread_cond_t *cond, pthread_condattr_t*attr);
PTHREAD_COND_INITIALIZER
ß 销毁：int pthread_cond_destroy(pthread_cond_t *cond)
看一个例子，有点长，是生产�?消费者模型的例子。从一��教�E�里扑ֈ�的，��量的完善了下，修改了其中可能引起问题的地方�?
生��者和消费者都是单独的一个线�E�，生��者生产��品，消费者从中取��Z�品，产品是一个队列，生��者new一个节�Ҏ��加进来，消费者取��Z��个节点�ƈfree掉，当消费者取的速度很快�Q�而生产者生产的很慢�Ӟ��消费者就�q�入休眠�{�等�Q�wait�Q�，而当生��者生产��品后�Q�就唤醒�Q�signal�Q�消费者队列。程序节点定义�ؓ一个结构体msg�?/p>
#include

#include

#include

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) {*/

//条�g受互斥锁保护?

//用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;

}

�q�个例子是多�U�程�~�程里比较经典的例子�Q�刚开始学习条件变量时其实很多问题没弄明白。没关系�Q�其实很多条件变量的例子形式都差不多是这个样子。关于我的疑问，先提出来�Q�下��笔记里一个一个记录下扑ֈ�的和惛_��的答案。。�?
1. consumer里�ؓ什么是while而不是if�Q�要知道producer是改变了条�g了才signal的�?/strong>
2. wait一定要在lock之后�Q��ؓ什么用mutex��M��护cond?
3. signal的位�|�和mutex有关�?
4. wait函数做了什么，如果只是休眠�{�待的话。producer会阻塞在lock函数上（consumer先lock了mutex�Q��?/strong>

izualzhy 2011-11-14 22:40 发表评论

pthread多线�E�学习笔记四互斥�?使用

izualzhy — Sun, 13 Nov 2011 14:58:00 GMT

pthread多线�E�学习笔记四互斥�?使用
上篇�W�记介绍了互斥量的基本定义，�q�篇主要介绍其��用方法�?
对应其作用，关于互斥量的函数有这么几个：
1. 初始化：int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr);或者Pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;//静态分�?
2. 加锁�Q�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 环境高��~�程》上抄的�Q?/p>
/*mutex.c*/

#include

#include

#include

#include

#include

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);

/** 创徏两个�U�程*/

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函数不会��d��{�待�Q�如果互斥量当前被锁�Q�则�q�回EBUSY倹{�?
�Ҏ��出错的情形：
A
ß pthread_mutex_lock (theMutex);
ß pthread_mutex_lock (theMutex);
ß pthread_mutex_unlock (theMutex);
ß pthread_mutex_unlock (theMutex);
表面上看�E�序加锁两次�Q�然后解锁两�ơ没有错�Q�实际上加锁�W�二�ơ的时候就出错了�?
B�Q?

卛_��在多个互斥量时的问题�Q�两个线�E�都在等在另一个线�E�解锁才能��l�往下执行�?
��到�q�种情况�Q�我们一般约定一�?-2-3…的加锁��序�Q�所有线�E�都遵守�q�一�U�定才行�?
但即使这��P��有时候应用程序的�l�构使得对互斥量加锁�q�行排序是很困难的，如果涉及了太多的锁和数据�l�构�Q�可用的函数�q�不能把它�{换成��单的层次�Q�那么就需要采用另外的办法。可以先释放所有的锁，然后�q�一�D�|��间再试。这�U�情况可以��用pthread_mutex_trylock接口避免死锁�?
ß 互斥锁一个明昄��~�点是它只有两种状态：锁定和非锁定。设想一�U�简单情景：多个�U�程讉K��同一个共享资源时�Q��ƈ不知道何时应该��用共享资源，如果在��界区里加入判断语句，或者可以有效，但一来效率不高，二来复杂环境下就难以�~�写了，�q�是我们需要一个结构，能在条�g成立时触发相应线�E�，�q�行变量修改和访问�?
针对此问题，下一��开始学习条件变量�?

izualzhy 2011-11-13 22:58 发表评论

pthread多线�E�学习笔记四互斥�?介绍

izualzhy — Sun, 13 Nov 2011 14:56:00 GMT

pthread多线�E�学习笔记四互斥�?介绍
多线�E�资源共享可以说有利有弊�Q�这点从�W�记一可以清楚的看刎ͼ�子线�E�修改内存后�Q�主�U�程可以看到�Q�但子线�E�free后，�ȝ��E�再�ơfree��有问题了）�?
更直接一点的错误�Q�如果子�U�程修改那块内存的时候，�ȝ��E�同时在修改会发生什么状��c��答案是�Q�不��定。因此，�U�程同步变得很重要。解��x��法就是不允许多个�U�程同时��M��改一个变量�?
ß 当一个线�E�修改变量时�Q�其他线�E�在��d��q�个变量的值时��可能看��C��一��L��数倹{�?
ß 在变量修�Ҏ��间多于一个存储器讉K��周期的处理器�l�构中，当存储器��M��存储器写�q�两个周期交叉时�Q�这�U�潜在的不一致性就会出现�?
因此引入了互斥量�?
看个例子可能�Ҏ��理解一些：
void *threadA(void *) { i++; }
void *threadB(void *) { i++; }
对应于自增的操作�Q?

从左到右依次为A�U�程�Q�B�U�程和我们看到的i的倹{��横向的表示同一旉��。我们把�q�种一个时间点上cpu能完成的动作�U�Cؓ原子操作�Q�那么如果操作不是原子操作时�Q�不一致性就出现了�?
合理的办法是当A�U�程修改i的时候，B�U�程应当��d��{�待�Q�直到A�U�程修改完毕�Q�B�U�程再开始修攏V��或者A�ȝ��待B完成�?
��像是锁�Q�A�Q�B��M��改i的时候都��试去锁住i�Q�如果i处于没被锁住�Q�解锁）状态，则可以锁上，若i处于锁住状态，则阻塞等待直到i被别的线�E�开锁后可以锁住i为止�?
我刚开始理解�ؓ互斥量就是用来保护一个变量的�Q�后来发现是错误的�?
��像如果B��试��M��改i的时候没有先��试�ȝ��互斥量加锁，一样可以修改i�Q�一样会产生问题。。�?
因此互斥量加锁，解锁的位�|�都是由我们自己来确定的�?
我的理解是，互斥量可以锁住一块区域，因此抛开变量来解释，最直观的就是，当线�E�A执行某段代码�Ӟ��不希望别的线�E�同时来修改其要��d��或者修改的变量�Q�可能有多个�Q�，因此对互斥量加锁�Q�直到这�D�代码结束，再对其解锁。这样就一定管用吗�Q�如果线�E�B执行的某�D�代码可能会修改�U�程A所不希望别的线�E�所修改的那些变量，而线�E�B又没有先��试加锁�Q�看下有没有�U�程已锁住互斥量�Q�若有，则需要阻塞等待）的话�Q�结果�ƈ不确定，互斥量是不会起作用的。因此，�q�更像是个“君子协定”（从一��教�E�里看到的，�q�挺贴切。。。。。。）�Q�如何确保程序正��，在哪个线�E�哪里加锁与解锁都需要写�E�序的�h来保证。互斥量的作用仅仅是加锁与解锁�?
真啰嗦。。。不�q�我��实看了几个例子后才明白。。�?
使用互斥量先看个例子�Q?
单实例模式（在看一本设计模式书的时候看到的�Q?/p>
#include

#include

#include

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;

}

�l�果会��生两个实例，昄��不是我们惌��的�?
if (NULL == m_instance) {
sleep(1);
printf("m_instance is NULL\n");
�q�里当发现m_instance为空后，休眠1s�Q�然后new��Z��个新的出来�?
当两个线�E�运行到�q�里�Q�sleep(1)是特意加的）。无论哪个线�E�先调用该函敎ͼ��ȝ��E�开了子�U�程后，接着调用�Q�两个的旉��不会��过1s......�Q�会发现m_instance的确为空�Q�于是休�?s�Q�然后new一个新的出来。该�U�程休眠的时候，后调用的�U�程同样调用到这里，跟之前的一��P��发现为空�Q�休�?s�Q�然后醒来new一个。于是两个线�E�休眠醒来的时候都会取new一个实例出来。即产生两个单实例的原因。当然可能跟sleep�Q?�Q�有着关系�Q�但在许多实际项目里�Q�这�U�情况很明显是要避免的�?
产生的原因其实跟之前i++相同�Q�判断的和调用�ƈ不是一个原子操作�?
如果我们��试��d��下互斥量加锁和解锁两个操作的伪代码：

lock:

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

mutex = 0;

return 0;

} else

挂�v�{�待;

goto lock;

unlock:

mutex = 1;

唤醒�{�待Mutex的线�E?

return 0;

可以看到跟这个例子一��P��if判断和调用�ƈ不是一个原子操作。因此互斥量具体实现是这��L��Q?
ß ��Z��实现互斥锁操作，大多��C��pȝ��构都提供了swap或exchange指��o�Q�该指��o的作用是把寄存器和内存单元的数据�怺�换，�׃��只有一条指令，保证了原子性，即��是多处理器��^収ͼ�讉K��内存的�ȝ��周期也有先后�Q�一个处理器上的交换指��o执行时另一个处理器的交换指令只能等待�ȝ��周期
实际上上面这句话我几乎没看懂�Q�不�q�没关系�Q�我惌��明的�q�是那句话，互斥量的作用在这里（使之成�ؓ了原子操作）�Q�而对变量的保护需要写代码的�h�Q�遵循所谓的“君子协议”）来完成�?

izualzhy 2011-11-13 22:56 发表评论

pthread多线�E�学习笔��C��U�程清理处理�E�序

izualzhy — Sun, 13 Nov 2011 14:53:00 GMT

pthread多线�E�学习笔��C��U�程清理处理�E�序
�U�程可以安排自己退出时(某些情况下的退�?的回调函数�?
Void pthread_cleanup_push(void (*rtn)(void*),void *arg);
Void pthread_pop(int execute);
�q�与�q�程可以用atexit函数安排�q�程退出时需要调用的函数是类似的。这��L��函数�U�Cؓ�U�程清理处理�E�序(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里给照搬�q�来了，主要是想说明�q�两个函数实��Cؓ宏，要成对��用，英文解释里很明确了呵��c�?
注意�Q?
1. �U�程可以建立多个清理处理�E�序�Q�处理程序记录在栈中�Q�也��是说它们的执行��序与它们的注册��序相反�?

当线�E�执行以下动作时调用

1调用pthread_exit�?
2响应取消��h��?
3用非零execute参数调用pthread_cleanup_pop时�?
可以看到return时�ƈ不会调用�?
3. 如果execute参数�|?�Q�清理函��C��被调用。无论哪�U�情况，pthread_cleanup_pop都将删除上次pthread_cleanup_push调用建立的清理处理程序�?
直接看个例子,:

#include

#include

#include

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);

}

Technorati 标签: c/c++,多线�E?/a>

��x��多线�E�基本的创徏�Q�结束，清理的方法就都有了，接下来开始进入互斥量,Mutex,锁（其实是一个东东）�?

izualzhy 2011-11-13 22:53 发表评论

izualzhy — Sun, 13 Nov 2011 07:05:00 GMT

pthread多线�E�学习笔��C��U�程�l�止、取消与获得�q�回状�?/p>

上篇�W�记里可以看到线�E�函数的开始和�l�束意味着�U�程的开始和�l�止�Q�那么就有一个问题，同其他普通函��C��P��如何获得�U�程�q�回时的状态？

如果子线�E�运行过�E�中�Q�主�U�程需要取消子�U�程�Q�该如何做？

子线�E�退出方式有哪些�Q?/p>

ß 如果需要只�l�止某个�U�程而不�l�止整个�q�程�Q�可以有三种�Ҏ��Q?/p>
1.从线�E�函数return。这�U�方法对�ȝ��E�不适用�Q�从main函数return相当于调用exit�?如果�q�程中�Q一�U�程调用了exit,_Exit或者_exit,那么整个�q�程��׃��l�止�?

2.一个线�E�可以调用pthread_cancel�l�止同一�q�程中的另一个线�E��?/p>
3.�U�程可以调用pthread_exit�l�止自己

可以用pthread_join�{�待�U�程�l�束�q�获得其�q�回��|��

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

�q�回��|��成功�q�回0�Q�失败返回错误号(ESRCH,EINVAL�{?

ß 通过pthread_join得到的终止状态是不同的，�ȝ��如下�Q?/p>
1.如果thread�U�程通过return�q�回�Q�rval_ptr所指向的单元里存放的是thread�U�程函数的返回倹{�?/p>
2. 如果thread�U�程被别的线�E�调用pthread_cancel异常�l�止掉，rval_ptr所指向的单元里存放的是常数PTHREAD_CANCELED�?/p>
3.如果thread�U�程是自��p��用pthread_exit�l�止的，rval_ptr所指向的单元存攄��是传�l�pthread_exit的参数�?/p>
ß 如果对thread�U�程的终止状态不感兴��，可以传NULL�l�rval_ptr参数�?/p>
同之前一��P��每个函数具体的解释就不记录在�q�里了，很多教程上有�Q?usr/include/pthread.h文�g里也可以看到��单的注解�?/p>
注意�q�个函数和进�E�里的waitpid很像�?/p>
调用�q�个函数其实有两个原因：

1. 获得�U�程�q�回��|��存在�W�二个参数里�Q�指向指针的指针�Q��?/p>
2. 如果不想获得函数退出状态，只是单纯的想�{�待�U�程�l�束�Q�可以传NULL�l�它。要说明的是�Q�一个线�E�不能被多个�U�程�{�待�Q�否则第一个接收到信号的线�E�成功返回，其余调用pthread_join的线�E�则�q�回错误代码ESRCH�?/p>
一般情况下�Q�线�E�终止后�Q�其�l�止状态一直保留到其它�U�程调用pthread_join获取它的状态�ؓ止。因此用�q�个函数取等待线�E�结束是必要的，具体�pȝ��回收的是那部分资源线�E�属性里可以体现的很明显�Q�当然肯定就是线�E�独有的那部分资�?#8230;…但是�U�程也可以被�|��ؓdetach状态，�q�样的线�E�一旦终止就立刻回收它占用的所有资源，而不保留�l�止状态。不能对一个已�l�处于detach状态的�U�程调用pthread_join�Q�这��L��调用��返回EINVAL。对一个尚未detach的线�E�调用pthread_join或pthread_detach都可以把该线�E�置为detach状态，也就是说�Q�不能对同一�U�程调用两次pthread_join�Q�或者如果已�l�对一个线�E�调用了pthread_detach��׃��能再调用pthread_join了。有兴趣的同学可以做个试验，看下在对每个�U�程讄��为detach状态前后系�l�可以开的最大线�E�数目对比，看下是否�U�程资源回收是必要的�?/p>
�W�二点好像太啰嗦了（学的一知半解。。）�Q�不�q�感觉最主要的是也就是说�q�里。。。�?/p>

取消�U�程�Q?/p>
int pthread_cancel(pthread_t tid);

ß �U�程可以通过调用该函数来��h��取消同一�q�程中的其他�U�程�?/p>
ß 在默认情况下�Q�pthread_cancel函数会��得由tid标识的线�E�的行�ؓ表现为如同调用了参数为PTHREAD_CANCELED的pthread_exit函数�Q�但是线�E�可以选择忽略取消方式或是控制取消方式。注意pthread_cancel�q�不�{�待�U�程�l�止�Q�它仅仅提出��h��?/p>
注意�Q?/p>
1. #define PTHREAD_CANCELED ((void *) -1)�Q�因此此旉��过join获得�q�回值其实就�?1.

2. 该函��C��仅是提出��h��。具体被取消�U�程的动作跟其线�E�属性相兟�?/p>
例子�Q?/p>
#include

#include

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;

}

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

izualzhy 2011-11-13 15:05 发表评论

izualzhy — Sun, 13 Nov 2011 06:59:00 GMT

pthread多线�E�学习笔��C��U�程创徏��?/span>

最�q�在学习Linux多线�E�编�E�部分，�W�记之一�Q?/span>

�U�程库函数是�?/span>POSIX标准定义的，�U�CؓPOSIX thread或�?/span>pthread。在Linux上线�E�函��C��?/span>libpthread�׃�n库中�Q�因此在�~�译时要加上-lpthread选项�?/span>

与进�E�相比：

每个�q�程都拥有自��q��数据�D�c��代码段和堆栈段,�q�就造成了进�E�在�q�行切换�{�操作时都需要有比较负责的上下文切换�{�动作。运行于一个进�E�中的多个线�E�，它们彼此之间使用相同的地址�I�间�Q�共享大部分数据�Q�启动一个线�E�所��p��的空间远�q�小于启动一个进�E�所��p��的空��_��而且�Q�线�E�间彼此切换所需的时间也�q�远��于�q�程间切换所需要的旉��?/span>

先看一个简单的多线�E�的例子�Q?/span>

注意该例子会引�vdouble free的问题，是�ؓ了说明下�U�程�׃�n堆的性质�?/span>

//(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);//�{�待�U�程�l�束

         free(p);

         exit(0);

}

感觉多线�E�编�E�可以和�q�程函数一��h��看：

最基本的几个函数是如下几个�Q?/span>

ß �U�程标识: pthread_t pthread_self         pthread_equal

ß �U�程创徏:pthrea_create

ß �U�程�l�止:pthread_exit pthread_join

ß �U�程取消:pthread_cancel

ß �U�程清理:pthread_cleanup_push pthread_cleanup_pop

ß �U�程分离属�?/span>:pthread_detach

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

�q�里只记录下我学习过�E�中觉得要注意的几个地方�Q?/span>

1.       pthread_create的参��C��l�：
int pthread_create(pthread_t *tidp, const pthread_attr_t *attr, void *(*start_rtn)(void *),void *arg)

一个线�E�中调用pthread_create()创徏新的�U�程后，当前�U�程�?/span>pthread_create()�q�回�l�箋往下执行，而新的线�E�所执行的代码由我们传给pthread_create的函数指�?/span>start_rtn军_��?/span>start_rtn函数接收一个参敎ͼ�是通过pthread_create�?/span>arg参数传递给它的�Q�该参数的类型�ؓvoid *�Q�这个指针按什么类型解释由调用者自己定义�?/span>start_routine的返回值类型也�?/span>void *�Q�这个指针的含义同样��p��用者自己定义�?/span>start_routine�q�回�Ӟ��q�个�U�程��退��Z�� ?/span>

注意如果tidp是全局的变量，不要在子�U�程里��用它�Q�因为可能子�U�程�q�行的时候，�ȝ��E�还没有来得及给他赋倹{��这也是�E�序里我们打印子�U�程ID用了pthread_self而没有用ntid的原因�?/span>

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

3.       �U�程id的类型是pthread_t�Q�它只在当前�q�程中保证是唯一的，在不同的�pȝ��?/span>pthread_t�q�个�c�d��有不同的实现�Q�它可能是一个整数��|��也可能是个结构体�Q�地址�{�。不�q�查�?/span>/usr/include/bits/pthreadtypes.h可以看到我的�pȝ��(ubuntu 10.04)�q�里定义�?/span>: typedef unsigned long int pthread_t.因此�E�序里我们直接用%x打印其倹{�?/span>

ok了。接下来在写个关于线�E�终止，取消以及获得�q�回状态的例子�?/span>

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

国内精品久久久久影院亚洲,久久精品亚洲中文字幕无码麻豆,国产精品无码久久综合

pthread多线�E�学习笔��C��条�g变量3使用之当wait遇到pthread_cancel

pthread多线�E�学习笔��C��条�g变量2使用

pthread多线�E�学习笔��C��条�g变量1介绍

pthread多线�E�学习笔记四互斥�?使用

pthread多线�E�学习笔记四互斥�?介绍

pthread多线�E�学习笔��C���U�程清理处理�E�序

pthread多线�E�学习笔��C��U�程清理处理�E�序