当前位置： 首页 > news >正文

【Linux】多线程 -＞ 线程互斥与死锁

news 来源：原创 2025/5/15 18:28:12

【Linux】多线程 -＞ 从线程概念到线程控制-CSDN博客

基于对线程概念和线程控制的了解，我们来对线程做一下简单的封装。

线程封装

makefile：

mythread:mythread.cc
	g++ -o $@ $^ -std=c++11 -lpthread
.PHONY:clean
clean:
	rm -f mytherad

Thread.hpp:

#pragma once

#include <iostream>
#include <string>
#include <cstring>
#include <cassert>
#include <functional>
#include <pthread.h>
// header only 开源代码

class Thread;

// 上下文,当成一个大号的结构体
class Context
{
public:
    Thread *this_;
    void *args_;

public:
    Context() : this_(nullptr), args_(nullptr)
    {
    }
    ~Context()
    {
    }
};

class Thread
{
public:
    // using func_t = std::function<void*(void*)>;
    typedef std::function<void *(void *)> func_t;
    const int num = 1024;

public:
    Thread(func_t func, void *args = nullptr, int number = 0) : func_(func), args_(args)
    {
        // name_ = "thread-";
        // name_ += std::to_string(number);

        char buffer[num];
        snprintf(buffer, sizeof buffer, "thread-%d", number);
        name_ = buffer;

        // 异常 == if: 意料之外用异常或者if判断
        // assert: 意料之中用assert
        Context *ctx = new Context();
        ctx->this_ = this;
        ctx->args_ = args_;
        int n = pthread_create(&tid_, nullptr, start_routine, ctx); // TODO
        assert(n == 0);                                             // 编译debug的方式发布的时候存在，release方式发布，assert就不存在了，n就是一个定义了，但是没有被使用的变量,在有些编译器下会有warning
        (void)n;
    }
    // 在类内创建线程，想让线程执行对应的方法，需要将方法设置成为static
    static void *start_routine(void *args) // 类内成员，有缺省参数！
    {
        Context *ctx = static_cast<Context *>(args);
        void *ret = ctx->this_->run(ctx->args_);
        delete ctx;
        return ret;
        // 静态方法不能调用成员方法或者成员变量
        // return func_(_args);
    }
    // void start()
    // {
    //     // 异常 == if: 意料之外用异常或者if判断
    //     // assert: 意料之中用assert
    //     Context *ctx = new Context();
    //     ctx->this_ = this;
    //     ctx->args_ = args_;
    //     int n = pthread_create(&tid_, nullptr, start_routine, ctx); // TODO
    //     assert(n == 0);                                             // 编译debug的方式发布的时候存在，release方式发布，assert就不存在了，n就是一个定义了，但是没有被使用的变量,在有些编译器下会有warning
    //     (void)n;
    // }
    void join()
    {
        int n = pthread_join(tid_, nullptr);
        assert(n == 0);
        (void)n;
    }

    void *run(void *args)
    {
        return func_(args);
    }

    ~Thread()
    {
        // do nothing
    }

private:
    std::string name_;
    func_t func_;
    void *args_;

    pthread_t tid_;
};

mythread.cc:

#include <iostream>
#include <unistd.h>
#include <pthread.h>
#include <cstring>
#include <cstdio>
#include <memory>
#include <vector>
#include <string>

#include "Thread.hpp"

void *thread_run(void *args)
{
    std::string work_type = static_cast<const char *>(args);
    while (true)
    {
        std::cout << "我是一个新线程，我正在做：" << work_type << std::endl;
        sleep(1);
    }
}

int main()
{
    std::unique_ptr<Thread> thread1(new Thread(thread_run, (void *)"hellothread", 1));
    std::unique_ptr<Thread> thread2(new Thread(thread_run, (void *)"countthread", 2));
    std::unique_ptr<Thread> thread3(new Thread(thread_run, (void *)"logthread", 3));

    thread1->join();
    thread2->join();
    thread3->join();
}

// int main()
// {
//     std::unique_ptr<Thread> thread1(new Thread(thread_run,(void*)"hellothread",1));
//     std::unique_ptr<Thread> thread2(new Thread(thread_run,(void*)"countthread",2));
//     std::unique_ptr<Thread> thread3(new Thread(thread_run,(void*)"logthread",3));

//     thread1->start();
//     thread2->start();
//     thread3->start();

//     thread1->join();
//     thread2->join();
//     thread3->join();
// }

线程互斥

相关概念

临界资源：多线程执行流共享的资源就叫做临界资源。

临界区：每个线程内部，访问临界资源的代码，就叫做临界区。

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

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

互斥量mutex

大部分情况，线程使用的数据都是局部变量，变量的地址空间在线程栈空间内，这种情况，变量归属单个线程，其他线程无法获得这种变量。 但有时候，很多变量都需要在线程间共享，这样的变量称为共享变量，可以通过数据的共享，完成线程之间的交互。

多个线程并发的操作共享变量，会带来一些问题：

mythread.cc:

// 操作共享变量会有问题的售票系统代码
#include <iostream>
#include <string>
#include <unistd.h>
#include <pthread.h>

int tickets = 10000;

void *getTicket(void *args)
{
    std::string username = static_cast<const char *>(args);
    while (true)
    {

        if (tickets > 0)
        {
            usleep(1254); // 1秒 = 1000毫秒 = 1000 000 微妙 = 10^9纳秒
            // 值得抢
            std::cout << username << " 正在进行抢票: " << tickets << std::endl;
            // 用这段时间来模拟真实的抢票要花费的时间
            tickets--;
        }
        else
        {
            break;
        }
    }

    // other code

    return nullptr;
}

int main()
{

    pthread_t t1, t2, t3, t4;
    pthread_create(&t1, nullptr, getTicket, (void *)"thread 1");
    pthread_create(&t2, nullptr, getTicket, (void *)"thread 2");
    pthread_create(&t3, nullptr, getTicket, (void *)"thread 3");
    pthread_create(&t4, nullptr, getTicket, (void *)"thread 4");

    pthread_join(t1, nullptr);
    pthread_join(t2, nullptr);
    pthread_join(t3, nullptr);
    pthread_join(t4, nullptr);

    return 0;
}

  • 为什么抢票会出现负数？

  1. if 语句判断条件为真以后，代码可以并发的切换到其他线程。
  2. usleep这个模拟漫长业务的过程，在这个漫长的业务过程中，可能有很多个线程会进入该代码段。
  3. --ticket操作本身就不是一个原子操作。

-- 操作并不是原子操作，而是对应三条汇编指令：

  1. load ：将共享变量ticket从内存加载到寄存器中。
  2. update : 更新寄存器里面的值，执行-1操作。
  3. store ：将新值，从寄存器写回共享变量ticket的内存地址。

  • 仅仅对一个全局变量进行多线程更改就是安全的吗？

一：

二：

三：

我们定义的全局变量，在没有保护的时候，往往是不安全的，像上面多个线程在交替执行造成的数据安全问题，发生了数据不一致！

要解决以上问题，需要做到三点：

  1. 代码必须要有互斥行为：当代码进入临界区执行时，不允许其他线程进入该临界区。
  2. 如果多个线程同时要求执行临界区的代码，并且临界区没有线程在执行，那么只能允许一个线程进入该临界区。
  3. 如果线程不在临界区中执行，那么该线程不能阻止其他线程进入临界区。

要做到这三点，本质上就是需要一把锁。Linux上提供的这把锁叫互斥量。

互斥量接口

初始化互斥量

初始化互斥量有两种方法：

  • 静态分配
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER
  • 动态分配

int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict

attr);

参数：

mutex：要初始化的互斥量。

attr：NULL。

销毁互斥量

int pthread_mutex_destroy(pthread_mutex_t *mutex) ；

销毁互斥量需要注意：

  • 使用 PTHREAD_ MUTEX_ INITIALIZER 初始化的互斥量不需要销毁。
  • 不要销毁一个已经加锁的互斥量。
  • 已经销毁的互斥量，要确保后面不会有线程再尝试加锁。

互斥量加锁与解锁

int pthread_mutex_lock(pthread_mutex_t *mutex);

int pthread_mutex_unlock(pthread_mutex_t *mutex);

成功，返回0；失败，返回错误号。

调用 pthread_ lock 时，可能会遇到以下情况:

  • 互斥量处于未锁状态，该函数会将互斥量锁定，同时返回成功
  • 发起函数调用时，如果其他线程已经锁定互斥量，或者存在其他线程同时申请互斥量，导致没有竞争到互斥量。那么pthread_ lock调用会陷入阻塞(执行流被挂起)，等待互斥量解锁。

改进上面的售票系统：

mythread.cc:

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

int tickets = 10000;

class ThreadData
{
public:
    ThreadData(const std::string &threadname,pthread_mutex_t *mutex_p)
        : threadname_(threadname),
          mutex_p_(mutex_p)
    {
    }
    ~ThreadData()
    {
    }

public:
    std::string threadname_;
    pthread_mutex_t *mutex_p_;
};

void *getTicket(void *args)
{
    ThreadData *td = static_cast<ThreadData *>(args);
    while (true)
    {
        //加锁
        pthread_mutex_lock(td->mutex_p_);
        if (tickets > 0)
        {
            usleep(1254);
            std::cout << td->threadname_ << " 正在进行抢票: " << tickets << std::endl;
            // 用这段时间来模拟真实的抢票要花费的时间
            tickets--;
            //解锁
            pthread_mutex_unlock(td->mutex_p_);
        }
        else
        {
            pthread_mutex_unlock(td->mutex_p_);

            break;
        }
    }
    return nullptr;
}

int main()
{
#define NUM 4
    pthread_mutex_t lock;
    pthread_mutex_init(&lock, nullptr);
    std::vector<pthread_t> tids(NUM);
    for (int i = 0; i < NUM; i++)
    {
        char buffer[64];
        snprintf(buffer, sizeof(buffer), "thread: %d", i + 1);
        ThreadData *td = new ThreadData(buffer,&lock);
        pthread_create(&tids[i], nullptr, getTicket, td);
    }

    for (const auto &tid : tids)
    {
        pthread_join(tid, nullptr);
    }

    pthread_mutex_destroy(&lock);

    return 0;
}

加锁和解锁的过程是串行执行的，程序变慢了。

  • 为什么一段时间某一个线程一直抢票呢？

因为这段时间某个线程比其他线程竞争锁的能力强。

锁只规定互斥访问，没有规定必须让哪个线程先执行，当某一个线程申请锁的时候，其他线程就在休眠，直到释放锁，申请锁的过程很快，谁的竞争力强，谁就申请到锁。锁就是真正的让多个执行流竞争的结果。

一个线程抢完票之后，它应该在做其他事情，在这个时间段，才可能让其他线程持有锁的可能性。

mythread.cc:


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

int tickets = 10000;

// 全局的锁使用PTHREAD_ MUTEX_ INITIALIZER初始化，不需要再销毁
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;

class ThreadData
{
public:
    ThreadData(const std::string &threadname, pthread_mutex_t *mutex_p)
        : threadname_(threadname),
          mutex_p_(mutex_p)
    {
    }
    ~ThreadData()
    {
    }

public:
    std::string threadname_;
    pthread_mutex_t *mutex_p_;
};

void *getTicket(void *args)
{
    ThreadData *td = static_cast<ThreadData *>(args);
    while (true)
    {
        // 加锁
        pthread_mutex_lock(td->mutex_p_);
        if (tickets > 0)
        {
            usleep(1254);
            std::cout << td->threadname_ << " 正在进行抢票: " << tickets << std::endl;
            // 用这段时间来模拟真实的抢票要花费的时间
            tickets--;
            // 解锁
            pthread_mutex_unlock(td->mutex_p_);
        }
        else
        {
            pthread_mutex_unlock(td->mutex_p_);
            break;
        }
        // 当抢完票就完了吗？当然不是，要做其他事情。
        usleep(1000); // 模拟形成一个订单给用户
    }
    return nullptr;
}

int main()
{
#define NUM 4

    // 静态的锁使用PTHREAD_ MUTEX_ INITIALIZER初始化，不需要再销毁
    // static pthread_mutex_t lock=PTHREAD_MUTEX_INITIALIZER;

    std::vector<pthread_t> tids(NUM);
    for (int i = 0; i < NUM; i++)
    {
        char buffer[64];
        snprintf(buffer, sizeof(buffer), "thread: %d", i + 1);
        ThreadData *td = new ThreadData(buffer, &lock);
        pthread_create(&tids[i], nullptr, getTicket, td);
    }
    for (const auto &tid : tids)
    {
        pthread_join(tid, nullptr);
    }
    return 0;
}

usleep模拟抢完票之后，形成一个订单给用户的过程。在这个时间段，其他线程就有可能持有锁的可能性了。

  • 如何看待锁？

线程在访问临界资源时，也一定要先访问这把锁。要保护全局数据，要进行加锁 ，对它进行加锁的前提条件，也就是每个线程都能看到并访问这把锁。

  1. 锁本身就是共享资源！全局的变量是要被保护的，锁是用来保护全局资源的，锁本身也是全局资源，锁的安全谁来保护呢？
  2. pthread_mutex_lock、pthread_mutex_unlock加锁的过程必须是安全的！加锁的过程其实是原子性的， 要么申请成功，要么申请不成功。
  3. 如果申请成功，就继续向后执行，如果申请暂时没有成功，执行流会阻塞挂起。直到
  4. 谁持有锁，谁进入临界区。

互斥量原理探究

  • 如何理解加锁和解锁的本质：

加锁的过程是原子的。

  • 锁是如何实现原子性的？

经过上面的例子，大家已经意识到单纯的 i++ 或者 ++i 都不是原子的，有可能会有数据一致性问题 为了实现互斥锁操作，大多数体系结构都提供了swap或exchange指令，该指令的作用是把寄存器和内存单元的数据相交换，由于只有一条指令，保证了原子性，即使是多处理器平台，访问内存的 总线周期也有先后，一个处理器上的交换指令执行时另一个处理器的交换指令只能等待总线周期。 现在我们把lock和unlock的伪代码改一下：

1、CPU内寄存器只有一套，被所有执行流共享！

2、CPU内寄存器内容，是当前执行流运行时的上下文，属于当前执行流，是每个执行流私有的！

我们来理解一下上面的伪代码。

一：

二： 

三： 

锁，全局数据，通过一条汇编exchange，就交换到了执行流的上下文，就属于这个执行流私有了，直到它主动归还这把锁，否则其他线程就用不了。

锁的封装

如果我们想简单的使用锁，该如何进行封装设计。下面我们将锁的封装和上面线程的封装放在一起，后续将会用到。

makefile:

mythread:mythread.cc
	g++ -o $@ $^ -std=c++11 -lpthread
.PHONY:clean
clean:
	rm -f mythread

 Mutex.hpp:

#pragma once

#include <iostream>
#include <pthread.h>

class Mutex
{
public:
    Mutex(pthread_mutex_t *lock_p = nullptr)
        : lock_p_(lock_p)
    {
    }
    void lock()
    {
        if (lock_p_)
            pthread_mutex_lock(lock_p_);
    }
    void unlock()
    {
        if (lock_p_)
            pthread_mutex_unlock(lock_p_);
    }
    ~Mutex()
    {
    }

private:
    pthread_mutex_t *lock_p_;
};

class LockGuard
{
public:
    LockGuard(pthread_mutex_t *mutex)
        : mutex_(mutex)
    {
        mutex_.lock(); // 在构造函数中进行加锁
    }
    ~LockGuard()
    {
        mutex_.unlock(); // 在析构函数中进行解锁
    }

private:
    Mutex mutex_;
};

mytherad.cc:

#include <iostream>
#include <string>
#include <vector>
#include <unistd.h>
#include <pthread.h>
#include "Mutex.hpp"

int tickets = 10000;

// 全局的锁使用PTHREAD_ MUTEX_ INITIALIZER初始化，不需要再销毁
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;

class ThreadData
{
public:
    ThreadData(const std::string &threadname, pthread_mutex_t *mutex_p)
        : threadname_(threadname),
          mutex_p_(mutex_p)
    {
    }
    ~ThreadData()
    {
    }

public:
    std::string threadname_;
    pthread_mutex_t *mutex_p_;
};

void *getTicket(void *args)
{
    ThreadData *td = static_cast<ThreadData *>(args);
    while (true)
    {
        {
            // RAII风格的加锁
            LockGuard lockguard(&lock); // 局部变量的生命周期是代码块，在下次while循环之前，会被析构，重新定义。
            // 加锁
            // pthread_mutex_lock(td->mutex_p_);
            if (tickets > 0)
            {
                usleep(1254);
                std::cout << td->threadname_ << " 正在进行抢票: " << tickets << std::endl;
                // 用这段时间来模拟真实的抢票要花费的时间
                tickets--;
                // 解锁
                // pthread_mutex_unlock(td->mutex_p_);
            }
            else
            {
                // pthread_mutex_unlock(td->mutex_p_);
                break;
            }
            // 当抢完票就完了吗？当然不是，要做其他事情。
            usleep(1000); // 模拟形成一个订单给用户
        }
    }
    return nullptr;
}

int main()
{
#define NUM 4

    // 静态的锁使用PTHREAD_ MUTEX_ INITIALIZER初始化，不需要再销毁
    // static pthread_mutex_t lock=PTHREAD_MUTEX_INITIALIZER;

    std::vector<pthread_t> tids(NUM);
    for (int i = 0; i < NUM; i++)
    {
        char buffer[64];
        snprintf(buffer, sizeof(buffer), "thread: %d", i + 1);
        ThreadData *td = new ThreadData(buffer, &lock);
        pthread_create(&tids[i], nullptr, getTicket, td);
    }
    for (const auto &tid : tids)
    {
        pthread_join(tid, nullptr);
    }
    return 0;
}

票全部被一个线程抢了，让线程2、3、4一直等待，这就造成了线程饥饿问题。没有错，但不合理。一个线程频繁的申请锁资源，导致其他线程长时间得不到资源，这就叫做饥饿问题。

可重入VS线程安全

概念

线程安全：多个线程并发同一段代码时，不会出现不同的结果。常见对全局变量或者静态变量进行操作，并且没有锁保护的情况下，会出现该问题。

重入：同一个函数被不同的执行流调用，当前一个流程还没有执行完，就有其他的执行流再次进入，我们称之为重入。一个函数在重入的情况下，运行结果不会出现任何不同或者任何问题，则该函数被称为可重入函数，否则，是不可重入函数。

常见的线程不安全的情况

  • 不保护共享变量的函数
  • 函数状态随着被调用，状态发生变化的函数
  • 返回指向静态变量指针的函数
  • 调用线程不安全函数的函数

常见的线程安全的情况

  • 每个线程对全局变量或者静态变量只有读取的权限，而没有写入的权限，一般来说这些线程是安全的。
  • 类或者接口对于线程来说都是原子操作。
  • 多个线程之间的切换不会导致该接口的执行结果存在二义性。

常见不可重入的情况

  • 调用了malloc/free函数，因为malloc函数是用全局链表来管理堆的。
  • 调用了标准I/O库函数，标准I/O库的很多实现都以不可重入的方式使用全局数据结构。
  • 可重入函数体内使用了静态的数据结构

常见可重入的情况

  • 不使用全局变量或静态变量
  • 不使用用malloc或者new开辟出的空间
  • 不调用不可重入函数
  • 不返回静态或全局数据，所有数据都有函数的调用者提供
  • 使用本地数据，或者通过制作全局数据的本地拷贝来保护全局数据

可重入与线程安全联系

  • 函数是可重入的，那就是线程安全的。
  • 函数是不可重入的，那就不能由多个线程使用，有可能引发线程安全问题。
  • 如果一个函数中有全局变量，那么这个函数既不是线程安全也不是可重入的。

可重入与线程安全区别

  • 可重入函数是线程安全函数的一种。
  • 线程安全不一定是可重入的，而可重入函数则一定是线程安全的。
  • 如果将对临界资源的访问加上锁，则这个函数是线程安全的，但如果这个重入函数若锁还未释放则会产生。
  • 死锁，因此是不可重入的。

死锁

  • 死锁是指在一组进程中的各个进程均占有不会释放的资源，但因互相申请被其他进程所占用且不会释放的资源而处于的一种永久等待状态。

举个例子：小明和小黑去超市买一块钱的棒棒糖，他们各自有五毛钱，小明说“你把你的五毛钱给我”，小黑说“你把你的五毛钱给我”，这就是互相拿着自己的五毛钱，还要对方的五毛钱，最后谁也没有给，也没有买到棒棒糖。这两个小朋友所处的状态就是死锁。

在多个锁的场景下，我们持有自己的锁不释放，还要对方的锁，对方也是如此，此时就容易造成死锁。

  • 一把锁，有可能出现死锁吗？

可能，你自己持有一把锁，但是你忘了，你又申请了一把锁。

  • 为什么会有死锁？

逻辑链条：

  1. 资源竞争：系统中存在多个进程或线程，它们都需要使用一些资源，如打印机、内存、数据库记录等。当这些资源在某一时刻只能被一个进程或线程使用时，如果多个进程或线程同时请求这些资源，就可能导致资源竞争。
  2. 进程推进顺序不当：进程在运行过程中，对资源的请求和释放顺序是有一定要求的。如果进程的推进顺序不恰当，就可能导致死锁。例如，进程 A 先占用了资源 R1，然后请求资源 R2；而进程 B 先占用了资源 R2，然后请求资源 R1，这样两个进程就会相互等待对方释放资源，从而产生死锁。

任何技术都有自己的边界，是解决问题的，但有可能在解决问题的同时，一定会引入新的问题！   

死锁四个必要条件

  1. 互斥条件：一个资源每次只能被一个执行流使用。
  2. 请求与保持条件：一个执行流因请求资源而阻塞时，对已获得的资源保持不放。
  3. 不剥夺条件：一个执行流已获得的资源，在末使用完之前，不能强行剥夺。
  4. 循环等待条件：若干执行流之间形成一种头尾相接的循环等待资源的关系。

避免死锁

  • 破坏死锁的四个必要条件之一
  • 加锁顺序一致
  • 避免锁未释放的场景
  • 资源一次性分配

避免死锁算法

  • 死锁检测算法(了解)
  • 银行家算法（了解）

线程互斥可能会导致饥饿问题，如何解决这个问题呢？同步。

关于线程同步请看下篇......

相关文章：

  • java.2.19
  • [STM32 - 野火] - - - 固件库学习笔记 - - - 十六.在SRAM中调试代码
  • GITHUB的若干操作
  • C# 背景 透明 抗锯齿 （效果完美）
  • 蓝桥杯备赛1-2合法日期
  • 深入浅出Spring Security：从入门到实战
  • 2.19学习记录
  • 1258：【例9.2】数字金字塔
  • LED灯闪烁实验：实验介绍
  • 基于Python的Django+Hadoop民族服饰数据分析系统+毕业论文+指导搭建视频
  • Git是什么
  • DHCP详解，网络安全零基础入门到精通实战教程！
  • 常用网络工具分析（ping，tcpdump等）
  • 算法的解题模式Ⅲ
  • Python数据结构进阶：栈与队列的实现与应用
  • ollama使用教程
  • 我的2025年计划
  • 前OpenAI CTO Mira Murati创办AI新公司
  • 迪威模型网：免费畅享 3D 打印盛宴，科技魅力与趣味创意并存
  • golang panic信息捕获
  • 商务部：中方敦促美方尽快停止232关税措施
  • 俄方代表团抵达土耳其，俄乌直接谈判有望于当地时间上午重启
  • 观察｜本轮印巴冲突或促使印度空军寻求更先进战机
  • 陕西旱情实探：大型灌区农业供水有保障，大旱之年无旱象
  • 书法需从字外看，书法家、学者吴本清辞世
  • 7月打卡乐高乐园，还可以去千年古镇枫泾参加这个漫画艺术季