【Linux】线程封装_互斥

cefler

已于 2024-03-14 17:39:12 修改

阅读量1.2k

点赞数 24

分类专栏： Linux 文章标签： linux 线程互斥

于 2024-03-06 23:08:04 首次发布

本文链接：https://blog.csdn.net/cefler/article/details/136519455

版权

Linux 专栏收录该内容

42 篇文章 0 订阅

订阅专栏

在这里插入图片描述

欢迎来到Cefler的博客😁
🕌博客主页：折纸花满衣
🏠个人专栏：题目解析
🌎推荐文章：【LeetCode】winter vacation training

在这里插入图片描述

👉🏻线程封装

Thread.cpp

#pragma once

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

// 设计方的视角
//typedef std::function<void()> func_t;
template<class T>
using func_t = std::function<void(T)>;

template<class T>
class Thread
{
public:
    Thread(const std::string &threadname, func_t<T> func, T data)
    :_tid(0), _threadname(threadname), _isrunning(false), _func(func), _data(data)
    {}

    static void *ThreadRoutine(void *args) // 类内方法，
    {
        // (void)args; // 仅仅是为了防止编译器有告警
        Thread *ts = static_cast<Thread *>(args);

        ts->_func(ts->_data);

        return nullptr;
    }

    bool Start()//线程创建
    {
        int n = pthread_create(&_tid, nullptr, ThreadRoutine, this/*?*/);
        if(n == 0) 
        {
            _isrunning = true;
            return true;
        }
        else return false;
    }
    bool Join()//线程等待
    {
        if(!_isrunning) return true;
        int n = pthread_join(_tid, nullptr);
        if(n == 0)
        {
            _isrunning = false;
            return true;
        }
        return false;
    }
    std::string ThreadName()
    {
        return _threadname;
    }
    bool IsRunning()
    {
        return _isrunning;
    }
    ~Thread()
    {}
private:
    pthread_t _tid;
    std::string _threadname;
    bool _isrunning;
    func_t<T> _func;
    T _data;
};

👉🏻线程互斥

🌈线程互斥基本概念
线程互斥是指在多线程编程中，为了避免多个线程同时访问共享资源而导致数据不一致的情况，需要采取措施来保证同一时间只有一个线程可以访问共享资源。这种机制可以通过使用互（mutex）来实现。

当一个线程要访问共享资源时，它首先尝试获取互斥量的锁。如果这个锁已经被其他线程占用，那么当前线程就会被阻塞，直到锁被释放为止。一旦线程成功获取了锁，它就可以安全地访问共享资源，并在完成操作后释放锁，以便其他线程可以继续访问这个资源。

通过使用线程互斥机制，可以有效地避免多个线程之间发生竞争条件（race condition），从而确保数据的一致性和程序的正确性。

🌈以下是一些关于线程互斥相关的名词介绍：
1.临界资源：多线程执行流共享的资源就叫做临界资源
2.临界区：每个线程内部，访问临界资源的代码，就叫做临界区
3.互斥：任何时刻，互斥保证有且只有一个执行流进入临界区，访问临界资源，通常对临界资源起保护作用
4.原子性：不会被任何调度机制打断的操作，该操作只有两态，要么完成，要么未完成

多个线程操作共享变量带来的问题

示例代码：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
int ticket = 100;
void *route(void *arg)
{
char *id = (char*)arg;
while ( 1 ) {
if ( ticket > 0 ) {
usleep(1000);
printf("%s sells ticket:%d\n", id, ticket);
ticket--;
} else {
break;
}
}
}
int main( void )
{
pthread_t t1, t2, t3, t4;
pthread_create(&t1, NULL, route, "thread 1");
pthread_create(&t2, NULL, route, "thread 2");
pthread_create(&t3, NULL, route, "thread 3");
pthread_create(&t4, NULL, route, "thread 4");
pthread_join(t1, NULL);
pthread_join(t2, NULL);
pthread_join(t3, NULL);
pthread_join(t4, NULL);
}
//一次执行结果：
thread 4 sells ticket:100
...
thread 4 sells ticket:1
thread 2 sells ticket:0
thread 1 sells ticket:-1
thread 3 sells ticket:-2

这里对共享变量ticket进行减减的操作属于非原子操作，而非原子操作的指令与只有一条指令的原子操作不同的是，非原子操作的指令有三条：

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

这里的ticket减到-1，主要问题是多个线程同时进行了if ( ticket > 0 ) 的判断，并进入了语句中，而数据在内存中，本质是被线程共享的，数据被读取到寄存器中，本质变成了线程的上下文，属于线程私有数据！。
所以为什么可以减减到-1，按理来说只有ticket>0的情况下才可以进入语句执行减减操作，但是因为每个线程的上下文数据都是独立的，而进行判断的数据是从CPU的寄存器中读取的，此时每个同时进来的线程在进来前存储在CPU上寄存器上的数据，也即是自己的上下文中的ticket值都是为1，也就是＞0，所以才会判断合法。

那么如何解决这种线程挤占共享资源的情况呢，这里我们就要引入互斥的一些接口函数了。

👉🏻 互斥量(mutex)的接口函数

pthread_mutex_init

pthread_mutex_init 函数是 POSIX 线程库中用于初始化互斥锁（mutex）的函数。互斥锁是一种线程同步机制，用于保护临界区（critical section）代码，防止多个线程同时访问共享资源而导致的竞争条件（race condition）。调用 pthread_mutex_init 函数可以对互斥锁进行初始化，设置其属性等。

这个函数的原型如下：

int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr);

mutex 参数是指向要初始化的互斥锁的指针。
attr 参数是一个指向互斥锁属性的指针，通常可以设置为 NULL，表示使用默认的属性。

成功初始化互斥锁后，可以使用 pthread_mutex_lock 和 pthread_mutex_unlock 来分别加锁和解锁互斥锁。

需要注意的是，在使用完互斥锁后，应该使用 pthread_mutex_destroy 函数来销毁互斥锁以释放资源。

pthread_mutex_lock函数

函数原型：

int pthread_mutex_lock(pthread_mutex_t *mutex);

参数解释：

mutex：指向要获取锁的互斥量的指针。互斥量是一种用于线程同步的对象，通过对互斥量加锁和解锁来控制线程对共享资源的访问。

使用方法总结：

首先，定义并初始化一个互斥量变量 pthread_mutex_t mutex;。
在需要对共享资源进行保护的临界区内，使用 pthread_mutex_lock(&mutex); 来获取互斥量的锁。
在临界区内执行对共享资源的操作。
最后，使用 pthread_mutex_unlock(&mutex); 来释放互斥量的锁，允许其他线程访问共享资源。

pthread_mutex_unlock函数

函数原型：

int pthread_mutex_unlock(pthread_mutex_t *mutex);

参数解释：

mutex：指向要释放锁的互斥量的指针。该参数是一个 pthread_mutex_t 类型的指针，表示需要释放锁的互斥量。

使用方法：

在临界区内使用 pthread_mutex_unlock(&mutex); 来释放互斥量的锁。这样做可以让其他线程获取该互斥量的锁，继续访问共享资源。
通常情况下，pthread_mutex_unlock 应该与 pthread_mutex_lock 配对使用，以确保正确的互斥访问共享资源。

pthread_mutex_destory函数

函数原型：

int pthread_mutex_destroy(pthread_mutex_t *mutex);

参数解释：

mutex：指向要销毁的互斥量的指针。该参数是一个 pthread_mutex_t 类型的指针，表示需要销毁的互斥量。

使用方法：

在不再需要使用互斥量时，可以调用 pthread_mutex_destroy(&mutex); 来销毁互斥量。
在销毁互斥量之前，确保所有线程已经停止使用该互斥量。

pthread_mutex_trylock函数

函数原型：

int pthread_mutex_trylock(pthread_mutex_t *mutex);

参数解释：

mutex：指向要尝试获取锁的互斥量的指针。互斥量是一种用于线程同步的对象，通过对互斥量加锁和解锁来控制线程对共享资源的访问。

使用方法：

pthread_mutex_trylock 函数尝试获取互斥量的锁，如果互斥量当前未被其他线程占用，则获取锁成功并返回 0；如果互斥量已经被其他线程占用，则立即返回一个非零值。
通过检查 pthread_mutex_trylock 的返回值来确定是否成功获取了互斥量的锁。
相较于 pthread_mutex_lock 函数，pthread_mutex_trylock 是非阻塞的，不会使线程进入等待状态，而是立即返回结果。

线程互斥访问共享变量代码示例

下面是一个简单的示例代码，演示了如何使用 pthread_mutex_init、pthread_mutex_lock、pthread_mutex_unlock 和 pthread_mutex_destroy 来实现线程互斥访问共享变量的情况：

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>

#define NUM_THREADS 2
#define MAX_COUNT 10000

int shared_variable = 0;
pthread_mutex_t mutex;

void* thread_function(void* arg) {
    for (int i = 0; i < MAX_COUNT; i++) {
        pthread_mutex_lock(&mutex);
        shared_variable++;
        pthread_mutex_unlock(&mutex);
    }

    return NULL;
}

int main() {
    pthread_t threads[NUM_THREADS];

    pthread_mutex_init(&mutex, NULL);

    for (int i = 0; i < NUM_THREADS; i++) {
        pthread_create(&threads[i], NULL, thread_function, NULL);
    }

    for (int i = 0; i < NUM_THREADS; i++) {
        pthread_join(threads[i], NULL);
    }

    pthread_mutex_destroy(&mutex);

    printf("Final value of shared_variable: %d\n", shared_variable);

    return 0;
}