线程安全与互斥锁(访问控制)

最新推荐文章于 2024-11-16 21:09:36 发布

布逆呲没来

最新推荐文章于 2024-11-16 21:09:36 发布

阅读量541

点赞数 1

分类专栏： Linux 文章标签： linux 安全

本文链接：https://blog.csdn.net/qq_54549527/article/details/130979134

版权

Linux 专栏收录该内容

23 篇文章 0 订阅

订阅专栏

文章探讨了线程安全问题，由于多个线程共享资源可能导致的不一致性。通过抢票的示例说明了临界区的概念，并展示了如何通过互斥锁解决线程安全问题。同时，文章提到了死锁现象，介绍了死锁的四个必要条件，并提出了避免死锁的方法。

摘要由CSDN通过智能技术生成

线程安全问题

因为多个线程是共享地址空间的，也就是很多资源都是共享的。

优点:通信方便
缺点:缺乏访问控制

因为一个线程的操作问题，给其他线程造成了不可控，或者引起崩溃，异常，逻辑不正确等这种现象:线程安全。

创建一个函数没有线程安全问题的话，尽量不要使用全局，stl，malloc，new等会在全局内有效的数据。

使用的话，需要访问控制。

线程有自己的独立栈结构。
线程崩溃的影响一定是有限的，因为线程在进程内部，而进程具有独立性。

访问控制之一 —— 互斥

由于线程安全问题，需要引入访问控制：互斥、同步。

几个概念。临界资源、临界区、互斥、原子性、同步

通过下面这个抢票的例子，发现线程安全问题

#include <iostream>
#include <string>
#include <pthread.h>
#include <unistd.h>
using namespace std;

//抢票逻辑，1000张票，5线程同时抢

int tickes = 1000;

void *ThreadRoutine(void *args){
    // string tname = (char*)args;
    int id = *(int*)args;
    delete (int*)args;

    while(true){
        //临界区
        if(tickes > 0){
            //抢票
            usleep(10000); //usleep 微秒  1s = 1000ms 1ms = 1000us
            cout << "我是[" << id << "]我要抢的票是：" << tickes << endl;
            tickes--;
        }
        else{
            //没有票
            break;
        }
        // cout << tname << "is running ... " << endl;
        // sleep(1);
    }

}
int main(){
    pthread_t tid[5];
    for(int i = 0; i < 5; i++){
        int *id = new int(i); 
        pthread_create(tid+i, nullptr, ThreadRoutine, id); //i值可能会被主线程修改,所以此处用在堆区新建的id
        // pthread_create(tid+i, nullptr, ThreadRun, (void *)"thread 1");
    }

    for(int i = 0; i < 5; i++)
        pthread_join(tid[i], nullptr); //等待

    return 0;
}

tickets--在此处并不安全

因此，需要对临界区进行加锁。

mutex 互斥锁

#include <iostream>
#include <string>
#include <pthread.h>
#include <unistd.h>
using namespace std;

//抢票逻辑，1000张票，5线程同时抢
//对临界区进行加锁
class Ticket{
private:
    int tickets;
    pthread_mutex_t mtx;
public:
    Ticket():tickets(1000){
        pthread_mutex_init(&mtx, nullptr);
    }

    bool GetTicket(){
        pthread_mutex_lock(&mtx);
        //执行这部分代码的执行流就是互斥的，串行执行的
        if(tickets > 0){
            //抢票
            usleep(1000); //usleep 微秒  1s = 1000ms 1ms = 1000us
            cout << "我是[" << pthread_self() << "]我要抢的票是：" << tickets << endl;
            tickets--; 
        }
        else{
            cout << "票已经被抢空了" << endl;
            return false;
        }
        pthread_mutex_unlock(&mtx);
        return true;
    }
    ~Ticket(){
        pthread_mutex_destroy(&mtx);
    }
};


void *ThreadRoutine(void *args){
    // string tname = (char*)args;
    // int id = *(int*)args;
    // delete (int*)args;

    Ticket *t = (Ticket*)args;

    while(true){
        if(!t->GetTicket()) break; //抢票失败，退出
    }

}
int main(){
    Ticket *t = new Ticket();

    pthread_t tid[5];
    for(int i = 0; i < 5; i++){
        // int *id = new int(i); 
        pthread_create(tid+i, nullptr, ThreadRoutine, (void*)t); 
        // pthread_create(tid+i, nullptr, ThreadRun, (void *)"thread 1");
    }

    for(int i = 0; i < 5; i++)
        pthread_join(tid[i], nullptr); //等待

    return 0;
}

运行结果：

因为使用了互斥锁，线程之间不会造成访问干扰和重入问题。

除了使用原生线程库里的锁，也可使用C++提供的库内的锁，包含在头文件#include <mutex>内，修改代码如下

#include <iostream>
#include <string>
#include <pthread.h>
#include <unistd.h>
#include <mutex>
using namespace std;

//抢票逻辑，1000张票，5线程同时抢
//对临界区进行加锁
class Ticket{
private:
    int tickets;
    pthread_mutex_t mtx;  //原生线程库，系统级别
    mutex mytex;  //C++语言级别
public:
    Ticket():tickets(1000){
        pthread_mutex_init(&mtx, nullptr);
    }

    bool GetTicket(){
        // pthread_mutex_lock(&mtx);
        mytex.lock();
        //执行这部分代码的执行流就是互斥的，串行执行的
        if(tickets > 0){
            //抢票
            usleep(1000); //usleep 微秒  1s = 1000ms 1ms = 1000us
            cout << "我是[" << pthread_self() << "]我要抢的票是：" << tickets << endl;
            tickets--; 
        }
        else{
            cout << "票已经被抢空了" << endl;
            return false;
        }
        // pthread_mutex_unlock(&mtx);
        mytex.unlock();
        return true;
    }
    ~Ticket(){
        pthread_mutex_destroy(&mtx);
    }
};


void *ThreadRoutine(void *args){
    // string tname = (char*)args;
    // int id = *(int*)args;
    // delete (int*)args;

    Ticket *t = (Ticket*)args;

    while(true){
        if(!t->GetTicket()) break; //抢票失败，退出
    }

}
int main(){
    Ticket *t = new Ticket();

    pthread_t tid[5];
    for(int i = 0; i < 5; i++){
        // int *id = new int(i); 
        pthread_create(tid+i, nullptr, ThreadRoutine, (void*)t); //i值可能会被主线程修改,所以此处用在堆区新建的id
        // pthread_create(tid+i, nullptr, ThreadRun, (void *)"thread 1");
    }

    for(int i = 0; i < 5; i++)
        pthread_join(tid[i], nullptr); //等待

    return 0;
}

运行效果与上述相同。

也可定义静态锁，如下，静态锁的使用。

class Ticket{
private:
    int tickets;
    // pthread_mutex_t mtx;  //原生线程库
    // mutex mytex;  //C++语言级别
public:
    Ticket():tickets(1000){
        // pthread_mutex_init(&mtx, nullptr);
    }

    bool GetTicket(){
        static pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER; //定义一把静态锁
        //锁本身也是临界资源，如何保证其是安全的?
        //lock、unlock是原子性的
        //一行汇编，即为原子
        pthread_mutex_lock(&mtx);
        // mytex.lock();
        //执行这部分代码的执行流就是互斥的，串行执行的
        if(tickets > 0){
            //抢票
            usleep(1000); //usleep 微秒  1s = 1000ms 1ms = 1000us
            cout << "我是[" << pthread_self() << "]我要抢的票是：" << tickets << endl;
            tickets--; 
        }
        else{
            cout << "票已经被抢空了" << endl;
            return false;
        }
        pthread_mutex_unlock(&mtx);
        // mytex.unlock();
        return true;
    }
    ~Ticket(){
        // pthread_mutex_destroy(&mtx);
    }
};