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);//单位秒
    }
}


相关文章
|
18天前
|
开发框架 Linux C语言
C、C++、boost、Qt在嵌入式系统开发中的使用
C、C++、boost、Qt在嵌入式系统开发中的使用
29 1
|
29天前
|
存储 前端开发 Java
【C++ 多线程 】C++并发编程:精细控制数据打印顺序的策略
【C++ 多线程 】C++并发编程:精细控制数据打印顺序的策略
43 1
|
26天前
|
算法 C++ 开发者
【C++ 20 并发工具 std::barrier】掌握并发编程:深入理解C++的std::barrier
【C++ 20 并发工具 std::barrier】掌握并发编程:深入理解C++的std::barrier
40 0
|
26天前
|
存储 监控 API
【C/C++ 文件操作】深入浸润:C++多线程文件操作的艺术与策略
【C/C++ 文件操作】深入浸润:C++多线程文件操作的艺术与策略
50 0
|
26天前
|
算法 安全 Unix
【C++ 20 信号量 】C++ 线程同步新特性 C++ 20 std::counting_semaphore 信号量的用法 控制对共享资源的并发访问
【C++ 20 信号量 】C++ 线程同步新特性 C++ 20 std::counting_semaphore 信号量的用法 控制对共享资源的并发访问
28 0
|
29天前
|
存储 设计模式 算法
【C++ 并发 线程池设计】深入理解C++线程池:设计、实现与应用
【C++ 并发 线程池设计】深入理解C++线程池:设计、实现与应用
44 0
|
29天前
|
消息中间件 Java 数据库连接
【C++ 多线程】C++ 多线程环境下的资源管理:深入理解与应用
【C++ 多线程】C++ 多线程环境下的资源管理:深入理解与应用
37 1
|
29天前
|
监控 C++
C++ Qt开发:QProcess进程管理模块
Qt是一个跨平台的C++图形库,简化了窗体应用开发,支持通过拖放组件提升效率。本章节关注`QProcess`组件,它用于控制和管理进程,例如执行命令、运行可执行文件及与外部进程通信。`QProcess`提供多种方法如`start`、`waitForStarted`和`waitForFinished`等,实现启动、监控和交互。示例展示了如何使用`QProcess`获取系统进程和信息,通过`tasklist`和`systeminfo`命令,并将结果展示在`QTreeWidget`中。
28 0
C++ Qt开发:QProcess进程管理模块
|
30天前
|
存储 安全 算法
【C++ 包装器类 std::atomic 】全面入门指南:深入理解并掌握C++ std::atomic 原子操作 的实用技巧与应用
【C++ 包装器类 std::atomic 】全面入门指南:深入理解并掌握C++ std::atomic 原子操作 的实用技巧与应用
30 1
|
30天前
|
消息中间件 存储 算法
【C/C++ 泡沫精选面试题04】在实际项目中,多进程和多线程如何选择?
【C/C++ 泡沫精选面试题04】在实际项目中,多进程和多线程如何选择?
43 1