linux 线程同步 互斥锁、条件变量、读写锁、自旋锁、信号量

本文详细介绍了Linux多线程环境下的同步技术,包括互斥锁(mutex)、条件变量、读写锁、自旋锁和信号量的原理、特点、操作流程及使用示例。互斥锁确保了对资源的独占访问,条件变量用于等待特定条件,读写锁允许多个读线程并发,自旋锁适用于短时间锁,信号量则可用于同步和互斥。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

以下内容转载自 https://www.toutiao.com/i6850002300325347843/

linux技术栈2020-07-16 17:07:24

一、互斥锁(同步)

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

  在线程里也有这么一把锁——互斥锁(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]; //字符指针数组  全局变量
int pos; //用于指定上面数组的下标
 
//1.定义互斥量
pthread_mutex_t mutex;
 
void *task(void *p)
{
    //3.使用互斥量进行加锁
    pthread_mutex_lock(&mutex);
 
    buf[pos] = (char *)p;
    sleep(1);
    pos++;
 
    //4.使用互斥量进行解锁
    pthread_mutex_unlock(&mutex);
}
 
int main(void)
{
    //2.初始化互斥量, 默认属性
    pthread_mutex_init(&mutex, NULL);
 
    //1.启动一个线程 向数组中存储内容
    pthread_t tid, 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);
 
    int i = 0;
    printf("字符指针数组中的内容是:");
    for(i = 0; i < pos; ++i)
    {
        printf("%s ", buf[i]);
    }
    printf("\n");
    return 0;
}

【Demo】(非阻塞模式):

#include <stdio.h>
#include <pthread.h>
#include <time.h>
#include <string.h>
 
int main (void)
{
    int err;
    struct timespec tout;
    struct tm *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));
    return 0;
}

需要C/C++ Linux服务器架构师学习资料私信“资料”(资料包括C/C++,Linux,golang技术,Nginx,ZeroMQ,MySQL,Redis,fastdfs,MongoDB,ZK,流媒体,CDN,P2P,K8S,Docker,TCP/IP,协程,DPDK,ffmpeg等),免费分享

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

 

二、条件变量(同步)

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

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

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

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

【原理】:

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

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

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的车走了。如图所示:

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

 

#include <stdio.h>  
#include <stdlib.h>  
#include <unistd.h>  
#include <pthread.h>  
  
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);  
  
    return 0;  
}

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

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

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

 

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
 
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);
 
    return 0;
}

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 <stdio.h>  
#include <unistd.h>  
#include <pthread.h>  
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);//销毁读写锁  
      
    return 0;  
}  

五、自旋锁(同步)

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

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

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

六、信号量(同步与互斥)

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

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

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

【信号量用于同步】:

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

 

// 信号量用于同步实例
#include <stdio.h>
#include <unistd.h>
#include <pthread.h>
#include <semaphore.h>
 
sem_t sem_g,sem_p;   //定义两个信号量
char ch = '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);
    }
}
 
int main(int argc, char *argv[])
{
    pthread_t tid1,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);
    
    return 0;
}

【信号量用于互斥】:

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

 

// 信号量用于互斥实例
#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
#include <semaphore.h>
 
sem_t sem; //信号量
 
void printer(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);
}
 
int main(void)
{
    pthread_t tid1, 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); //销毁信号量
    
    return 0;
}
<think>好的,用户想了解不同类型的锁机制及其应用场景,包括互斥锁条件变量自旋锁读写锁。首先我需要回忆这些锁的基本概念和工作原理,然后比较它们的区别和使用场景。 首先,互斥锁互斥锁用于保护共享资源,确保同一时间只有一个线程可以访问。当线程尝试获取已被锁定的互斥锁时,会进入阻塞状态,释放CPU资源。这在多线程环境中很常见,比如修改全局变量时。记得用户提供的引用中提到,互斥锁要么是锁住状态,要么是不加锁,一次只能一个线程加锁[^2]。另外,条件变量需要和互斥锁一起使用,因为条件变量在等待时会释放互斥锁,被唤醒后再重新加锁[^4]。 然后是条件变量条件变量通常与互斥锁配合使用,用于线程间的等待和通知机制。当某个条件不满足时,线程会等待在条件变量上,同时释放互斥锁,让其他线程有机会修改条件。当条件满足时,其他线程发送信号唤醒等待的线程。比如引用中的例子,线程在等待i等于20时,会调用pthread_cond_wait,此时会释放互斥锁,直到被唤醒后重新获得锁。 接下来是自旋锁自旋锁互斥锁不同,当获取锁失败时,线程不会阻塞,而是循环检查锁是否可用。这样会占用CPU资源,但避免了上下文切换的开销。适用于锁持有时间短的场景,比如内核中的短临界区。引用中提到自旋锁在无法确定锁持有时间是否短的情况下应避免使用,否则会导致CPU资源浪费。 读写锁,允许更高的并行性。读写锁有三种状态:读模式加锁、写模式加锁、不加锁。多个读线程可以同时持有读锁,而写锁是独占的。适用于读多写少的场景,比如配置文件的读取和偶尔的更新。引用[2]提到读写锁与互斥量类似,但允许更高的并行性,适合读操作频繁的情况[^2]。 现在需要将这些整理成结构清晰的回答,比较它们的工作原理、区别和应用场景。需要注意用户提到的引用内容,比如互斥锁的释放和条件变量的使用[^1][^4],以及读写锁互斥锁的区别[^2]。同时,用户提供的引用中有关于trylock的使用,但用户的问题没有直接提到,可能需要暂时忽略,除非在比较时有必要提及。 在区别部分,可以从阻塞行为、适用场景、性能影响等方面展开。比如互斥锁在阻塞时线程休眠,自旋锁则忙等待;读写锁区分读写,提高并发性;条件变量用于等待特定条件,必须与互斥锁配合。 应用场景方面,互斥锁适合一般的共享资源保护;读写锁适合读多写少;自旋锁适合锁持有时间极短且不想有上下文切换的情况;条件变量用于线程间协调,比如生产者-消费者问题。 最后生成相关问题,可能需要根据常见的问题类型,比如比较不同锁的优缺点,如何选择锁机制,或者实际应用中的例子。 需要确保回答中引用正确的文献,比如条件变量必须和互斥锁一起使用,以及读写锁的三种状态[^2]。</think>### 不同类型的锁机制详解 #### 1. **互斥锁(Mutex)** - **工作原理**: 通过原子操作保证共享资源的独占访问。线程尝试加锁时,若锁已被占用,则进入阻塞状态(释放CPU),直到锁被释放后被唤醒[^1]。 - **应用场景**: 适用于对共享资源的简单互斥操作,如全局变量修改、链表更新等。例如: ```c pthread_mutex_lock(&mutex); // 加锁 counter++; // 修改共享变量 pthread_mutex_unlock(&mutex); // 解锁 ``` #### 2. **条件变量(Condition Variable)** - **工作原理**: 与互斥锁配合使用,用于线程间的条件等待和通知。调用 `pthread_cond_wait()` 时会自动释放互斥锁并进入阻塞;当条件满足时,其他线程通过 `pthread_cond_signal()` 唤醒等待线程,后者重新获取锁[^3]。 - **应用场景**: 生产者-消费者模型、任务队列调度。例如: ```c pthread_mutex_lock(&mutex); while (queue_empty) pthread_cond_wait(&cond, &mutex); // 等待队列非空 // 消费数据 pthread_mutex_unlock(&mutex); ``` #### 3. **自旋锁(Spinlock)** - **工作原理**: 通过忙等待(循环检查锁状态)实现同步线程在获取锁失败时不阻塞,持续占用CPU直到锁可用。 - **应用场景**: 锁持有时间极短的场景(如内核中断处理),避免上下文切换开销。例如: ```c spin_lock(&lock); // 快速修改共享状态 spin_unlock(&lock); ``` #### 4. **读写锁(Read-Write Lock)** - **工作原理**: 允许多个读线程共享访问,但写线程独占访问。读模式下可并行,写模式下互斥[^2]。 - **应用场景**: 读多写少的数据结构(如缓存、配置文件)。例如: ```c pthread_rwlock_rdlock(&rwlock); // 读锁 // 读取数据 pthread_rwlock_unlock(&rwlock); pthread_rwlock_wrlock(&rwlock); // 写锁 // 修改数据 pthread_rwlock_unlock(&rwlock); ``` --- ### **锁机制对比** | 锁类型 | 阻塞行为 | 适用场景 | 性能特点 | |--------------|----------------------|------------------------------|------------------------------| | **互斥锁** | 线程休眠,释放CPU | 通用共享资源保护 | 上下文切换开销 | | **条件变量** | 依赖互斥锁的休眠/唤醒 | 线程间条件协作 | 需结合互斥锁使用 | | **自旋锁** | 忙等待,不释放CPU | 短临界区、低延迟场景 | 无上下文切换,但占用CPU | | **读写锁** | 读共享,写独占 | 读多写少(如缓存、配置文件) | 提高读并发性,写操作仍串行 | --- ### **典型应用场景** 1. **互斥锁**:数据库事务的原子性保证。 2. **条件变量**:多线程任务池中的任务调度。 3. **自旋锁**:内核中中断处理程序的资源保护。 4. **读写锁**:Web服务器中频繁读取静态资源的场景。 ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值