Linux C/C++ 开发(学习笔记四):多线程并发锁:互斥锁、自旋锁、原子操作、CAS

简介: Linux C/C++ 开发(学习笔记四):多线程并发锁:互斥锁、自旋锁、原子操作、CAS

一、多线程计数

背景:

火车抢票,总共10个窗口,每个窗口都同时进行10w张抢票

可以采用多线程的方式,火车票计数是公共的任务

#include<pthread.h>//posix线程 
#include<stdio.h>
#include<unistd.h>
#define THREAD_COUNT 10  //定义线程数10
//线程入口函数
void* thread_callback(void* arg){ 
    int* pcount=(int*)arg;
    int i=0;
    while(i++<100000){
        (*pcount)++;
        usleep(1);//单位微秒
    }
}
//10个窗口,同时对count进行++操作
int main(){
    pthread_t threadid[THREAD_COUNT]={0};//初始化线程id
    int count=0;
    for(int i=0;i<THREAD_COUNT;i++){//创建10个线程
        //第一个参数:返回线程。 第二个参数:线程的属性(堆栈)。第三个:线程的入口函数。第四个:主线程往子线程传的参数
        pthread_create(&threadid[i],NULL,thread_callback,&count);//count是传入thread_callback内的
    }
    for(int i=0;i<100;i++){
        printf("count: %d\n",count);
        sleep(1);//单位秒
    }
}

虽然包含了线程的头文件,可是编译的时候却报错“对pthread_create未定义的引用“,原来时因为 pthread库不是Linux系统默认的库,连接时需要使用库libpthread.a,所以在使用pthread_create创建线程时,在编译中要加-lpthread参数

可以使用下面方法编译

g++ thread_count.cpp -o thread_count -lpthread

执行后,发现,按理说要执行到100w,可是停到99w多就结束了。

二、发现问题

理想状态,线程应该是这样的

但实际上存在,执行完线程1MOV操作后,线程1切换到线程2。导致两个线程的操作,本应该50->52,但是结果确实50->51

count是一个临界资源(两个线程共享一个变量),因此为了避免上述这种情况发生,要加锁

三、互斥锁

当一个线程在执行一个指令的时候,另一个线程进不来。

相当于把count++转化为汇编的3行命令给打包在一起。

定义互斥锁

pthread_mutex_t mutex;//定义互斥锁

初始化互斥锁

pthread_mutex_init(&mutex,NULL);//互斥锁初始化(第二个参数是 锁的属性)

加锁/解锁

//加了互斥锁
 pthread_mutex_lock(&mutex);
 (*pcount)++;
 pthread_mutex_unlock(&mutex);

完整代码

#include<pthread.h>
#include<stdio.h>
#include<unistd.h>
#define THREAD_COUNT 10
pthread_mutex_t mutex;//定义互斥锁
void* thread_callback(void* arg){
    int* pcount=(int*)arg;
    int i=0;
    while(i++<100000){
#if 0
        (*pcount)++;
#else   
        //加了互斥锁
        pthread_mutex_lock(&mutex);
        (*pcount)++;
        pthread_mutex_unlock(&mutex);
#endif
        usleep(1);//单位微秒
    }
}
//10个窗口,同时对count进行++操作
int main(){
    pthread_t threadid[THREAD_COUNT]={0};//初始化线程id
    pthread_mutex_init(&mutex,NULL);//互斥锁初始化(第二个参数是 锁的属性)
    int count=0;
    for(int i=0;i<THREAD_COUNT;i++){//创建10个线程
        //第一个参数:返回线程。 第二个参数:线程的属性(堆栈)。第三个:线程的入口函数。第四个:主线程往子线程传的参数
        pthread_create(&threadid[i],NULL,thread_callback,&count);//count是传入thread_callback内的
    }
    for(int i=0;i<100;i++){
        printf("count: %d\n",count);
        sleep(1);//单位秒
    }
}

四、自旋锁

在写法上和互斥锁基本上没有差别

定义自旋锁

pthread_spinlock_t spinlock;//定义自旋锁

初始化自旋锁

pthread_spin_init(&spinlock,PTHREAD_PROCESS_SHARED);//自旋锁初始化(第二个参数是 进程共享)

自旋锁(加锁/解锁)

//加了自旋锁
pthread_spin_lock(&spinlock);
(*pcount)++;
pthread_spin_unlock(&spinlock);

完整代码

#include<pthread.h>
#include<stdio.h>
#include<unistd.h>
#define THREAD_COUNT 10
// pthread_mutex_t mutex;
pthread_spinlock_t spinlock;//定义自旋锁
void* thread_callback(void* arg){
    int* pcount=(int*)arg;
    int i=0;
    while(i++<100000){
#if 0
        (*pcount)++;
#elif 0 
        //加了互斥锁
        pthread_mutex_lock(&mutex);
        (*pcount)++;
        pthread_mutex_unlock(&mutex);
#else 
        //加了自旋锁
        pthread_spin_lock(&spinlock);
        (*pcount)++;
        pthread_spin_unlock(&spinlock);
#endif
        usleep(1);
    }
}
int main(){
    pthread_t threadid[THREAD_COUNT]={0};
    // pthread_mutex_init(&mutex,NULL);
    pthread_spin_init(&spinlock,PTHREAD_PROCESS_SHARED);//自旋锁初始化(第二个参数是 进程共享)
    int count=0;
    for(int i=0;i<THREAD_COUNT;i++){
        pthread_create(&threadid[i],NULL,thread_callback,&count);
    }
    for(int i=0;i<100;i++){
        printf("count: %d\n",count);
        sleep(1);//单位秒
    }
}

五、互斥锁和自旋锁的对比

自选锁的介绍

使用场景:

当锁的内容很少的时候,继续等待的时间代价比 线程切换的时间代价更小的 时候,选择使用自旋锁(因为互斥锁会切换线程,等待重新调度请求,判断锁是否被占用,如果占用,继续阻塞,并切换到其他线程。如果切换线程的代价比 等待的代价大,可以使用自旋锁。否则使用互斥锁)。

锁的内容比较多的时候,使用互斥锁。(比如,线程安全的红黑树,可以使用mutex)

也就是说:

锁的内容少/没有系统调用,等待的时间代价少-》用自旋锁

锁的内容多,等待时间代价大-》用互斥锁

六、原子操作

如果把这三条指令变成一条,那么就不会出现,这种问题了。

原子操作:单条cpu指令实现(因此使用范围有限,必须要是cpu指令中有的指令)

完整代码

#include<pthread.h>
#include<stdio.h>
#include<unistd.h>
#define THREAD_COUNT 10
// pthread_mutex_t mutex;
// pthread_spinlock_t spinlock;
//用一个函数去实现
int increase(int *value,int add){
    int old;
    __asm__ volatile(
        "lock;xaddl %2,%1;"
        :"=a"(old)
        :"m"(*value),"a"(add)
        :"cc","memory"
    );
    return old;
}
void* thread_callback(void* arg){
    int* pcount=(int*)arg;
    int i=0;
    while(i++<100000000){
#if 0
        (*pcount)++;
#elif 0 
        //加了互斥锁
        pthread_mutex_lock(&mutex);
        (*pcount)++;
        pthread_mutex_unlock(&mutex);
#elif 0 
        //加了自旋锁
        pthread_spin_lock(&spinlock);
        (*pcount)++;
        pthread_spin_unlock(&spinlock);
#else
    //原子操作
        increase(pcount,1);
#endif
        usleep(1);
    }
}
int main(){
    pthread_t threadid[THREAD_COUNT]={0};
    // pthread_mutex_init(&mutex,NULL);
    // pthread_spin_init(&spinlock,PTHREAD_PROCESS_SHARED);//自旋锁初始化(第二个参数是 进程共享)
    int count=0;
    for(int i=0;i<THREAD_COUNT;i++){
        pthread_create(&threadid[i],NULL,thread_callback,&count);
    }
    for(int i=0;i<100;i++){
        printf("count: %d\n",count);
        sleep(1);//单位秒
    }
}

七、其他:CAS

CAS:compare and swap

cpu有这样一条指令cmpxchg(a,b,c),(其实就是原子操作的原理)。

它的意思是

if(a==b){
  a=c;
}

下面例子中,instance就是a,NULL是b,c是malloc(sizeof(object))

if(instance==NULL){
  instance=malloc(sizeof(object));
}

使用cas实现求和

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>
#include<pthread.h>
#define CAS(a_ptr, a_oldVal, a_newVal) __sync_bool_compare_and_swap(a_ptr, a_oldVal, a_newVal)
// #define AtomicAdd(a_ptr,a_count) __sync_fetch_and_add (a_ptr, a_count)
#define THREAD_COUNT 10
void* callback(void* arg){
    int* pcount=(int*)arg;
    for(int i=0;i<100000;i++){
        while(true){
            int current=(*pcount);
            if(CAS(pcount,current,current+1)) break;
        }
        usleep(1);
    }
    return (void*)nullptr;
}
int main(int argc,char** argv){
    pthread_t threadid[THREAD_COUNT]={0};
    int count=0;
    for(int i=0;i<THREAD_COUNT;i++){//创建10个线程
        pthread_create(&threadid[i],NULL,callback,&count);
    }
    for(int i=0;i<100;i++){
        printf("count: %d\n",count);
        sleep(1);//单位秒
    }
}


相关文章
|
1月前
|
Linux C语言
Linux读写锁源码分析
本文分析了读写锁的实现原理与应用场景,基于glibc 2.17源码。读写锁通过读引用计数、写线程ID、条件变量等实现,支持读优先(默认)和写优先模式。读优先时,写锁可能饥饿;写优先时,读线程需等待写锁释放。详细解析了`pthread_rwlock_t`数据结构及加解锁流程,并通过实验验证:2000个读线程与1个写线程测试下,读优先导致写锁饥饿,写优先则正常抢占锁。
54 19
|
8月前
|
Shell Linux
Linux shell编程学习笔记30:打造彩色的选项菜单
Linux shell编程学习笔记30:打造彩色的选项菜单
|
5月前
|
监控 算法 Linux
Linux内核锁机制深度剖析与实践优化####
本文作为一篇技术性文章,深入探讨了Linux操作系统内核中锁机制的工作原理、类型及其在并发控制中的应用,旨在为开发者提供关于如何有效利用这些工具来提升系统性能和稳定性的见解。不同于常规摘要的概述性质,本文将直接通过具体案例分析,展示在不同场景下选择合适的锁策略对于解决竞争条件、死锁问题的重要性,以及如何根据实际需求调整锁的粒度以达到最佳效果,为读者呈现一份实用性强的实践指南。 ####
|
6月前
|
算法 Linux 开发者
Linux内核中的锁机制:保障并发控制的艺术####
本文深入探讨了Linux操作系统内核中实现的多种锁机制,包括自旋锁、互斥锁、读写锁等,旨在揭示这些同步原语如何高效地解决资源竞争问题,保证系统的稳定性和性能。通过分析不同锁机制的工作原理及应用场景,本文为开发者提供了在高并发环境下进行有效并发控制的实用指南。 ####
|
6月前
|
缓存 Linux 开发者
Linux内核中的并发控制机制:深入理解与应用####
【10月更文挑战第21天】 本文旨在为读者提供一个全面的指南,探讨Linux操作系统中用于实现多线程和进程间同步的关键技术——并发控制机制。通过剖析互斥锁、自旋锁、读写锁等核心概念及其在实际场景中的应用,本文将帮助开发者更好地理解和运用这些工具来构建高效且稳定的应用程序。 ####
98 5
|
6月前
|
Linux 数据库
Linux内核中的锁机制:保障并发操作的数据一致性####
【10月更文挑战第29天】 在多线程编程中,确保数据一致性和防止竞争条件是至关重要的。本文将深入探讨Linux操作系统中实现的几种关键锁机制,包括自旋锁、互斥锁和读写锁等。通过分析这些锁的设计原理和使用场景,帮助读者理解如何在实际应用中选择合适的锁机制以优化系统性能和稳定性。 ####
128 6
|
7月前
|
并行计算 Ubuntu Linux
Ubuntu学习笔记(三):Linux下操作指令大全
Ubuntu学习笔记,介绍了Linux操作系统中常用的命令和操作,如文件管理、系统信息查看、软件安装等。
93 3
|
8月前
|
Shell Linux
Linux shell编程学习笔记82:w命令——一览无余
Linux shell编程学习笔记82:w命令——一览无余
|
7月前
|
安全
【多线程】CAS、ABA问题详解
【多线程】CAS、ABA问题详解
84 0
|
7月前
|
安全 Linux
Linux线程(十一)线程互斥锁-条件变量详解
Linux线程(十一)线程互斥锁-条件变量详解