详解linux多线程——互斥锁、条件变量、读写锁、自旋锁、信号量

一、互斥锁（同步）

  在多任务操作系统中，同时运行的多个任务可能都需要使用同一种资源。这个过程有点类似于，公司部门里，我在使用着打印机打印东西的同时（还没有打印完），别人刚好也在此刻使用打印机打印东西，如果不做任何处理的话，打印出来的东西肯定是错乱的。

  在线程里也有这么一把锁——互斥锁（mutex），互斥锁是一种简单的加锁的方法来控制对共享资源的访问，互斥锁只有两种状态,即上锁( lock )和解锁( unlock )。

【互斥锁的特点】：

1. 原子性：把一个互斥量锁定为一个原子操作，这意味着操作系统（或pthread函数库）保证了如果一个线程锁定了一个互斥量，没有其他线程在同一时间可以成功锁定这个互斥量；

2. 唯一性：如果一个线程锁定了一个互斥量，在它解除锁定之前，没有其他线程可以锁定这个互斥量；

3. 非繁忙等待：如果一个线程已经锁定了一个互斥量，第二个线程又试图去锁定这个互斥量，则第二个线程将被挂起（不占用任何cpu资源），直到第一个线程解除对这个互斥量的锁定为止，第二个线程则被唤醒并继续执行，同时锁定这个互斥量。

【互斥锁的操作流程如下】：

1. 在访问共享资源后临界区域前，对互斥锁进行加锁；

2. 在访问完成后释放互斥锁导上的锁。在访问完成后释放互斥锁导上的锁；

3. 对互斥锁进行加锁后，任何其他试图再次对互斥锁加锁的线程将会被阻塞，直到锁被释放。对互斥锁进行加锁后，任何其他试图再次对互斥锁加锁的线程将会被阻塞，直到锁被释放。

#include<pthread.h>

#include <time.h>

// 初始化一个互斥锁。

int pthread_mutex_init(pthread_mutex_t *mutex,

const pthread_mutexattr_t *attr);

// 对互斥锁上锁，若互斥锁已经上锁，则调用者一直阻塞，

// 直到互斥锁解锁后再上锁。

int pthread_mutex_lock(pthread_mutex_t *mutex);

// 调用该函数时，若互斥锁未加锁，则上锁，返回 0；

// 若互斥锁已加锁，则函数直接返回失败，即 EBUSY。

int pthread_mutex_trylock(pthread_mutex_t *mutex);

// 当线程试图获取一个已加锁的互斥量时，pthread_mutex_timedlock 互斥量

// 原语允许绑定线程阻塞时间。即非阻塞加锁互斥量。

int pthread_mutex_timedlock(pthread_mutex_t *restrict mutex,

const struct timespec *restrict abs_timeout);

// 对指定的互斥锁解锁。

int pthread_mutex_unlock(pthread_mutex_t *mutex);

// 销毁指定的一个互斥锁。互斥锁在使用完毕后，

// 必须要对互斥锁进行销毁，以释放资源。

int pthread_mutex_destroy(pthread_mutex_t *mutex);

【Demo】（阻塞模式）：

//使用互斥量解决多线程抢占资源的问题

#include<stdio.h>

#include<stdlib.h>

#include<unistd.h>

#include<pthread.h>

#include<string.h>

char*buf[5];//字符指针数组全局变量

intpos;//用于指定上面数组的下标

//1.定义互斥量

pthread_mutex_tmutex;

void*task(void*p)

{

//3.使用互斥量进行加锁

pthread_mutex_lock(&mutex);

buf[pos]=(char*)p;

sleep(1);

pos++;

//4.使用互斥量进行解锁

pthread_mutex_unlock(&mutex);

}

intmain(void)

{

//2.初始化互斥量,默认属性

pthread_mutex_init(&mutex,NULL);

//1.启动一个线程向数组中存储内容

pthread_ttid,tid2;

pthread_create(&tid,NULL,task,(void*)"zhangfei");

pthread_create(&tid2,NULL,task,(void*)"guanyu");

//2.主线程进程等待,并且打印最终的结果

pthread_join(tid,NULL);

pthread_join(tid2,NULL);

//5.销毁互斥量

pthread_mutex_destroy(&mutex);

inti=0;

printf("字符指针数组中的内容是：");

for(i=0;i<pos;++i)

{

printf("%s", buf[i]);

    }

    printf("\n");

return0;

}

【Demo】（非阻塞模式）：

#include

#include #include #include

intmain (void)

{interr;

structtimespec tout;

structtm *tmp;

char buf[64];

pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;        pthread_mutex_lock (&lock);    printf ("mutex is locked\n");

clock_gettime (CLOCK_REALTIME, &tout);    tmp = localtime (&tout.tv_sec);    strftime (buf, sizeof (buf),"%r", tmp);

printf ("current time is %s\n", buf);

tout.tv_sec +=10;

err = pthread_mutex_timedlock (&lock, &tout);    clock_gettime (CLOCK_REALTIME, &tout);    tmp = localtime (&tout.tv_sec);    strftime (buf, sizeof (buf),"%r", tmp);

printf ("the time is now %s\n", buf);

if(err ==0)

printf ("mutex locked again\n");

else

printf ("can`t lock mutex again:%s\n", strerror (err));

return0;

}

需要C/C++ Linux服务器架构师学习资料加qun（563998835）（资料包括C/C++，Linux，golang技术，Nginx，ZeroMQ，MySQL，Redis，fastdfs，MongoDB，ZK，流媒体，CDN，P2P，K8S，Docker，TCP/IP，协程，DPDK，ffmpeg等），免费分享

二、条件变量（同步）

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

  条件变量使我们可以睡眠等待某种条件出现。条件变量是利用线程间共享的全局变量进行同步 的一种机制，主要包括两个动作：

一个线程等待"条件变量的条件成立"而挂起；

另一个线程使 “条件成立”（给出条件成立信号）。

【原理】：

  条件的检测是在互斥锁的保护下进行的。线程在改变条件状态之前必须首先锁住互斥量。如果一个条件为假，一个线程自动阻塞，并释放等待状态改变的互斥锁。如果另一个线程改变了条件，它发信号给关联的条件变量，唤醒一个或多个等待它的线程，重新获得互斥锁，重新评价条件。如果两进程共享可读写的内存，条件变量 可以被用来实现这两进程间的线程同步。

【条件变量的操作流程如下】：

1. 初始化：init()或者pthread_cond_tcond=PTHREAD_COND_INITIALIER；属性置为NULL；

2. 等待条件成立：pthread_wait，pthread_timewait.wait()释放锁,并阻塞等待条件变量为真 timewait()设置等待时间,仍未signal,返回ETIMEOUT(加锁保证只有一个线程wait)；

3. 激活条件变量：pthread_cond_signal,pthread_cond_broadcast(激活所有等待线程)

4. 清除条件变量：destroy;无线程等待,否则返回EBUSY清除条件变量:destroy;无线程等待,否则返回EBUSY

#include<pthread.h>

// 初始化条件变量

int pthread_cond_init(pthread_cond_t *cond,

pthread_condattr_t *cond_attr);

// 阻塞等待

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

// 超时等待

int pthread_cond_timewait(pthread_cond_t *cond,pthread_mutex *mutex,

const timespec *abstime);

// 解除所有线程的阻塞

int pthread_cond_destroy(pthread_cond_t *cond);

// 至少唤醒一个等待该条件的线程

int pthread_cond_signal(pthread_cond_t *cond);

// 唤醒等待该条件的所有线程

int pthread_cond_broadcast(pthread_cond_t *cond); 

1、线程的条件变量实例1

  Jack开着一辆出租车来到一个站点停车，看见没人就走了。过段时间，Susan来到站点准备乘车，但是没有来，于是就等着。过了一会Mike开着车来到了这个站点，Sunsan就上了Mike的车走了。如图所示：

#include

#include   #include   #include     pthread_cond_t taxicond = PTHREAD_COND_INITIALIZER;  pthread_mutex_t taximutex = PTHREAD_MUTEX_INITIALIZER;    void *traveler_arrive(void *name)  {char*p = (char*)name;

printf ("Travelr: %s need a taxi now!\n", p);

// 加锁，把信号量加入队列，释放信号量    pthread_mutex_lock(&taximutex);      pthread_cond_wait(&taxicond, &taximutex);      pthread_mutex_unlock(&taximutex);      printf ("traveler: %s now got a taxi!\n", p);

pthread_exit(NULL);  }    void *taxi_arrive(void *name)  {char*p = (char*)name;

printf ("Taxi: %s arrives.\n", p);

// 给线程或者条件发信号，一定要在改变条件状态后再给线程发信号    pthread_cond_signal(&taxicond);      pthread_exit(NULL);  }    int main (int argc,char**argv)

{char*name;

pthread_t thread;      pthread_attr_t threadattr; // 线程属性    pthread_attr_init(&threadattr);  // 线程属性初始化      // 创建三个线程    name ="Jack";

pthread_create(&thread, &threadattr, taxi_arrive, (void *)name);      sleep(1);

name ="Susan";

pthread_create(&thread, &threadattr, traveler_arrive, (void *)name);      sleep(1);

name ="Mike";

pthread_create(&thread, &threadattr, taxi_arrive, (void *)name);      sleep(1);

return0;

}

2、线程的条件变量实例2

  Jack开着一辆出租车来到一个站点停车，看见没人就等着。过段时间，Susan来到站点准备乘车看见了Jack的出租车，于是就上去了。过了一会Mike开着车来到了这个站点，看见没人救等着。如图所示：

#include

#include #include #include int travelercount =0;

pthread_cond_t taxicond = PTHREAD_COND_INITIALIZER;pthread_mutex_t taximutex = PTHREAD_MUTEX_INITIALIZER; void *traveler_arrive(void *name){char*p = (char*)name;

pthread_mutex_lock(&taximutex);    printf ("traveler: %s need a taxi now!\n", p);

travelercount++;    pthread_cond_wait(&taxicond, &taximutex);                pthread_mutex_unlock(&taximutex);    printf ("traveler: %s now got a taxi!\n", p);

pthread_exit(NULL);} void *taxi_arrive(void *name){char*p = (char*)name;

printf ("Taxi: %s arrives.\n", p);

for(;;)

{if(travelercount)

{            pthread_cond_signal(&taxicond);            travelercount--;break;

}    }    pthread_exit(NULL);} int main (int argc,char**argv)

{char*name;

pthread_t thread;    pthread_attr_t threadattr;    pthread_attr_init(&threadattr);    name ="Jack";

pthread_create(&thread, &threadattr, taxi_arrive, name);    sleep(1);

name ="Susan";

pthread_create(&thread, &threadattr, traveler_arrive, name);    sleep(3);

name ="Mike";

pthread_create(&thread, &threadattr, taxi_arrive, name);    sleep(4);

return0;

}

3、虚假唤醒(spurious wakeup)

  虚假唤醒(spurious wakeup)在采用条件等待时：

while(条件不满足)

{condition_wait(cond, mutex);

}// 而不是: 

If( 条件不满足 )

{ 

  Condition_wait(cond,mutex); 

} 

这是因为可能会存在虚假唤醒”spurious wakeup”的情况。

  也就是说，即使没有线程调用condition_signal, 原先调用condition_wait的函数也可能会返回。此时线程被唤醒了，但是条件并不满足，这个时候如果不对条件进行检查而往下执行，就可能会导致后续的处理出现错误。

  虚假唤醒在linux的多处理器系统中/在程序接收到信号时可能回发生。在Windows系统和JAVA虚拟机上也存在。在系统设计时应该可以避免虚假唤醒，但是这会影响条件变量的执行效率，而既然通过while循环就能避免虚假唤醒造成的错误，因此程序的逻辑就变成了while循环的情况。

四、读写锁（同步）

  读写锁与互斥量类似，不过读写锁允许更改的并行性，也叫共享互斥锁。互斥量要么是锁住状态，要么就是不加锁状态，而且一次只有一个线程可以对其加锁。读写锁可以有3种状态：读模式下加锁状态、写模式加锁状态、不加锁状态。

  一次只有一个线程可以占有写模式的读写锁，但是多个线程可以同时占有读模式的读写锁（允许多个线程读但只允许一个线程写）。

【读写锁的特点】：

如果有其它线程读数据，则允许其它线程执行读操作，但不允许写操作；

如果有其它线程写数据，则其它线程都不允许读、写操作。

【读写锁的规则】：

如果某线程申请了读锁，其它线程可以再申请读锁，但不能申请写锁；

如果某线程申请了写锁，其它线程不能申请读锁，也不能申请写锁。

读写锁适合于对数据结构的读次数比写次数多得多的情况。

#include<pthread.h>

// 初始化读写锁

int pthread_rwlock_init(pthread_rwlock_t *rwlock,

const pthread_rwlockattr_t *attr);

// 申请读锁

int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock );

// 申请写锁

int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock );

// 尝试以非阻塞的方式来在读写锁上获取写锁，

// 如果有任何的读者或写者持有该锁，则立即失败返回。

int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock);

// 解锁

int pthread_rwlock_unlock (pthread_rwlock_t *rwlock);

// 销毁读写锁

int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);

【Demo】：

// 一个使用读写锁来实现4个线程读写一段数据是实例。

// 在此示例程序中，共创建了4个线程，

// 其中两个线程用来写入数据，两个线程用来读取数据#include   #include   #include   pthread_rwlock_t rwlock; //读写锁  int num =1;

//读操作，其他线程允许读操作，却不允许写操作  void *fun1(void *arg)

{while(1)

{          pthread_rwlock_rdlock(&rwlock);        printf("read num first == %d\n", num);

pthread_rwlock_unlock(&rwlock);        sleep(1);

}}  //读操作，其他线程允许读操作，却不允许写操作  void *fun2(void *arg)

{while(1)

{        pthread_rwlock_rdlock(&rwlock);        printf("read num second == %d\n", num);

pthread_rwlock_unlock(&rwlock);        sleep(2);

}} //写操作，其它线程都不允许读或写操作  void *fun3(void *arg)

{while(1)

{        pthread_rwlock_wrlock(&rwlock);        num++;        printf("write thread first\n");

pthread_rwlock_unlock(&rwlock);        sleep(2);

}} //写操作，其它线程都不允许读或写操作  void *fun4(void *arg)

{while(1)

{          pthread_rwlock_wrlock(&rwlock);          num++;          printf("write thread second\n");

pthread_rwlock_unlock(&rwlock);          sleep(1);

}  }    int main()  {      pthread_t ptd1, ptd2, ptd3, ptd4;            pthread_rwlock_init(&rwlock, NULL);//初始化一个读写锁            //创建线程      pthread_create(&ptd1, NULL, fun1, NULL);      pthread_create(&ptd2, NULL, fun2, NULL);      pthread_create(&ptd3, NULL, fun3, NULL);      pthread_create(&ptd4, NULL, fun4, NULL);            //等待线程结束，回收其资源      pthread_join(ptd1, NULL);      pthread_join(ptd2, NULL);      pthread_join(ptd3, NULL);      pthread_join(ptd4, NULL);            pthread_rwlock_destroy(&rwlock);//销毁读写锁return0;

}

五、自旋锁（同步）

  自旋锁与互斥量功能一样，唯一一点不同的就是互斥量阻塞后休眠让出cpu，而自旋锁阻塞后不会让出cpu，会一直忙等待，直到得到锁。

  自旋锁在用户态使用的比较少，在内核使用的比较多！自旋锁的使用场景：锁的持有时间比较短，或者说小于2次上下文切换的时间。

  自旋锁在用户态的函数接口和互斥量一样，把pthread_mutex_xxx()中mutex换成spin，如：pthread_spin_init()。

六、信号量（同步与互斥）

  信号量广泛用于进程或线程间的同步和互斥，信号量本质上是一个非负的整数计数器，它被用来控制对公共资源的访问。

  编程时可根据操作信号量值的结果判断是否对公共资源具有访问的权限，当信号量值大于 0 时，则可以访问，否则将阻塞。PV 原语是对信号量的操作，一次 P 操作使信号量减１，一次 V 操作使信号量加１。

#include<semaphore.h>

// 初始化信号量

int sem_init(sem_t *sem, int pshared, unsigned int value);

// 信号量 P 操作（减 1）

int sem_wait(sem_t *sem);

// 以非阻塞的方式来对信号量进行减 1 操作

int sem_trywait(sem_t *sem);

// 信号量 V 操作（加 1）

int sem_post(sem_t *sem);

// 获取信号量的值

int sem_getvalue(sem_t *sem, int *sval);

// 销毁信号量

int sem_destroy(sem_t *sem);

【信号量用于同步】：

//信号量用于同步实例

#include<stdio.h>

#include<unistd.h>

#include<pthread.h>

#include<semaphore.h>

sem_tsem_g,sem_p;//定义两个信号量

charch='a';

void*pthread_g(void*arg)//此线程改变字符ch的值

{

while(1)

{

sem_wait(&sem_g);

ch++;

sleep(1);

sem_post(&sem_p);

}

}

void*pthread_p(void*arg)//此线程打印ch的值

{

while(1)

{

sem_wait(&sem_p);

printf("%c",ch);

fflush(stdout);

sem_post(&sem_g);

}

}

intmain(intargc,char*argv[])

{

pthread_ttid1,tid2;

sem_init(&sem_g,0,0);//初始化信号量为0

sem_init(&sem_p,0,1);//初始化信号量为1

//创建两个线程

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

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

//回收线程

pthread_join(tid1,NULL);

pthread_join(tid2,NULL);

return0;

}

【信号量用于互斥】：

//信号量用于互斥实例

#include<stdio.h>

#include<pthread.h>

#include<unistd.h>

#include<semaphore.h>

sem_tsem;//信号量

voidprinter(char*str)

{

sem_wait(&sem);//减一，p操作

while(*str)//输出字符串（如果不用互斥，此处可能会被其他线程入侵）

{

putchar(*str);

fflush(stdout);

str++;

sleep(1);

}

printf("\n");

sem_post(&sem);//加一，v操作

}

void*thread_fun1(void*arg)

{

char*str1="hello";

printer(str1);

}

void*thread_fun2(void*arg)

{

char*str2="world";

printer(str2);

}

intmain(void)

{

pthread_ttid1,tid2;

sem_init(&sem,0,1);//初始化信号量，初始值为1

//创建2个线程

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

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

//等待线程结束，回收其资源

pthread_join(tid1,NULL);

pthread_join(tid2,NULL);

sem_destroy(&sem);//销毁信号量

return0;

}

©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 204,530评论 6赞 478
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 86,403评论 2赞 381
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 151,120评论 0赞 337
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 54,770评论 1赞 277
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 63,758评论 5赞 367
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 48,649评论 1赞 281
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 38,021评论 3赞 398
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 36,675评论 0赞 258
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 40,931评论 1赞 299
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 35,659评论 2赞 321
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 37,751评论 1赞 330
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 33,410评论 4赞 321
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 39,004评论 3赞 307
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 29,969评论 0赞 19
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 31,203评论 1赞 260
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 45,042评论 2赞 350
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 42,493评论 2赞 343