Linux锁的使用

news2024/11/24 2:30:28

一、临界资源与临界区

多线程会共享例如全局变量等资源，我们把会被多个执行流访问的资源称为临界资源，我们是通过代码访问临界资源的，而我们访问临界资源的那部分代码称为临界区。

实现一个抢票系统

只有一个线程抢票时

#include <iostream>
#include <vector>
#include <unistd.h>

#include "Thread.hpp"


int num = 10000; 

std::string GetThreadName()
{
    static int num = 1;
    char name[64];
    snprintf(name, sizeof(name), "thread-%d", num++);
    return name;
}

void Ticket(std::string name)
{
    while(true)
    {
        if(num > 0)
        {
            usleep(1000);
            printf("%s get ticket: %d\n", name.c_str(), num);
            num--;
        }
        else
        {
            break;
        }
    }
}

int main()
{
    std::string name1 = GetThreadName();
    Thread<std::string> t1(name1, Ticket, name1);
    
    t1.Start();
    t1.Join();
    
    return 0;
}

正常输出，最终票数为0时退出。

但是当我们启动多个线程同时抢票时，num就是临界资源，使用num的那部分代码就是临界区

#include <iostream>
#include <vector>
#include <unistd.h>

#include "Thread.hpp"


int num = 10000; 

std::string GetThreadName()
{
    static int num = 1;
    char name[64];
    snprintf(name, sizeof(name), "thread-%d", num++);
    return name;
}

void Ticket(std::string name)
{
    while(true)
    {
        if(num > 0)
        {
            usleep(1000);
            printf("%s get ticket: %d\n", name.c_str(), num);
            num--;
        }
        else
        {
            break;
        }
    }
}

int main()
{
    std::string name1 = GetThreadName();
    Thread<std::string> t1(name1, Ticket, name1);
    std::string name2 = GetThreadName();
    Thread<std::string> t2(name2, Ticket, name2);
    std::string name3 = GetThreadName();
    Thread<std::string> t3(name3, Ticket, name3);
    std::string name4 = GetThreadName();
    Thread<std::string> t4(name4, Ticket, name4);

    t1.Start();
    t2.Start();
    t3.Start();
    t4.Start();

    t1.Join();
    t2.Join();
    t3.Join();
    t4.Join();
    
    return 0;
}

可以看到出现了0和负数的票数，这是因为当票数只剩1时，有多个执行流在同一时间通过了if判断，使得能继续进行减票操作。

vs下自减操作的反汇编，分为三步：先从内存拿数据，再把数据减1，最后把数据拷贝到内存

多个执行流同时访问临界资源例如自减操作，由于--操作不是原子性的（我们认为一条汇编指令是原子性的，是不会被中断的。但--操作转为汇编指令后，需要多条指令才能完成），当--操作执行到一半切换到其他线程会导致数据不一致的问题。这种情况下需要通过锁把临界区保护起来，每次只让一个执行流访问临界资源，避免数据不一致问题。

互斥：任何时刻，互斥保证有且只有一个执行流进入临界区，访问临界资源，通常对临界资源起保护作用。

原子性：不会被任何调度机制打断的操作，该操作只有两态，要么完成，要么未完成。

二、使用锁的方法

1.创建锁

如果定义一个全局的锁，直接使用pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER用宏初始化。

如果定义一个局部锁，要使用pthread_mutex_init方法创建，参数attr设为nullptr

2.加锁解锁

使用pthread_mutex_lock加锁，传递锁的地址，

解锁用pthread_mutex_unlock

当我们使用锁后，就能保证每次只有一个执行流能访问临界资源。

#include <iostream>
#include <vector>
#include <unistd.h>

#include "Thread.hpp"


int num = 10000;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; //定义一个全局锁

std::string GetThreadName()
{
    static int num = 1;
    char name[64];
    snprintf(name, sizeof(name), "thread-%d", num++);
    return name;
}

void Ticket(std::string name)
{
    while(true)
    {
        pthread_mutex_lock(&mutex); //加锁
        if(num > 0)
        {
            usleep(1000);
            printf("%s get ticket: %d\n", name.c_str(), num);
            num--;
            pthread_mutex_unlock(&mutex); //解锁
        }
        else
        {
            pthread_mutex_unlock(&mutex); //解锁
            break;
        }
    }
}

int main()
{
    std::string name1 = GetThreadName();
    Thread<std::string> t1(name1, Ticket, name1);
    std::string name2 = GetThreadName();
    Thread<std::string> t2(name2, Ticket, name2);
    std::string name3 = GetThreadName();
    Thread<std::string> t3(name3, Ticket, name3);
    std::string name4 = GetThreadName();
    Thread<std::string> t4(name4, Ticket, name4);

    t1.Start();
    t2.Start();
    t3.Start();
    t4.Start();

    t1.Join();
    t2.Join();
    t3.Join();
    t4.Join();

    return 0;
}

结果正常，但是速度慢了很多，因为要不断申请锁和释放锁