Linux线程互斥之线程加锁的使用详解

#include <pthread.h>
int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr);

#include <pthread.h>
int pthread_mutex_destroy(pthread_mutex_t *mutex);

#include <pthread.h>
int pthread_mutex_lock(pthread_mutex_t *mutex);

#include <pthread.h>
int pthread_mutex_unlock(pthread_mutex_t *mutex);

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

using namespace std;

//定义一个全局锁就可以不需要初始化和销毁锁的函数了
//pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;

#define NUM 4
//共500张票
int tickets = 500;

class ThreadInfo
{
public:
    ThreadInfo(const string &threadname, pthread_mutex_t *lock)
    :threadname_(threadname)
    ,lock_(lock)
    {}

public:
    string threadname_;
    pthread_mutex_t *lock_;
};

void *GrabTickets(void *args)
{
    ThreadInfo *ti = static_cast<ThreadInfo*>(args);
    string name(ti->threadname_);
    while(true)
    {
        pthread_mutex_lock(ti->lock_); // 加锁
        if(tickets > 0)
        {
            usleep(10000);
            printf("%s get a ticket: %d\n", name.c_str(), tickets);
            tickets--;
            pthread_mutex_unlock(ti->lock_); // 解锁
        }
        else 
        {
            pthread_mutex_unlock(ti->lock_); // 解锁
            break;
        }
        //这里上面的代码
        usleep(13); // 用休眠来模拟抢到票的后续动作
    }
    printf("%s quit...\n", name.c_str());
}

int main()
{
    pthread_mutex_t lock; // 定义互斥锁
    pthread_mutex_init(&lock, nullptr); // 初始化互斥锁
    vector<pthread_t> tids;
    vector<ThreadInfo*> tis;
    for(int i = 1; i <= NUM; i++)
    {
        pthread_t tid;
        ThreadInfo *ti = new ThreadInfo("Thread-"+to_string(i), &lock);
        pthread_create(&tid, nullptr, GrabTickets, ti);
        tids.push_back(tid);
        tis.push_back(ti);
    }

    // 等待所有线程
    for(auto tid : tids)
    {
        pthread_join(tid, nullptr);
    }
    // 释放资源
    for(auto ti : tis)
    {
        delete ti;
    }
	// 销毁互斥锁
    pthread_mutex_destroy(&lock); 
    
    return 0;
}

#pragma once
#include <pthread.h>
//简单的封装了一下函数，用的时候方便一些
class Mutex
{
public:
    Mutex(pthread_mutex_t *lock)
    :lock_(lock)
    {}

    void Lock()
    {
        pthread_mutex_lock(lock_);
    }

    void Unlock()
    {
        pthread_mutex_unlock(lock_);
    }
private:
    pthread_mutex_t *lock_;
};

class LockGuard
{
public:
    LockGuard(pthread_mutex_t *lock)
    :mutex_(lock)
    {
        mutex_.Lock(); // 对象创建的时候加锁
    }

    ~LockGuard()
    {
        mutex_.Unlock(); // 对象销毁的时候解锁
    }
private:
    Mutex mutex_;
};

#include <iostream>
#include <pthread.h>
#include <vector>
#include <cstdio>
#include <unistd.h>
#include "LockGuard.hpp"

using namespace std;

#define NUM 4

int tickets = 500; 
//全局变量定义锁
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;

class ThreadInfo
{
public:
    ThreadInfo(const string &threadname)
        : threadname_(threadname)

public:
    string threadname_;
};

void *GrabTickets(void *args)
{
    ThreadInfo *ti = static_cast<ThreadInfo *>(args);
    string name(ti->threadname_);
    while (true)
    {
        {
            LockGuard lockguard(&lock); // RAII 风格的锁
            if (tickets > 0)
            {
                usleep(10000);
                printf("%s get a ticket: %d\n", name.c_str(), tickets);
                tickets--;
            }
            else
            {
                break;
            }
        }
        usleep(13); // 用休眠来模拟抢到票的后续动作
    }

    printf("%s quit...\n", name.c_str());
}

int main()
{
    vector<pthread_t> tids;
    vector<ThreadInfo *> tis;
    for (int i = 1; i <= NUM; i++)
    {
        pthread_t tid;
        ThreadInfo *ti = new ThreadInfo("Thread-" + to_string(i));
        pthread_create(&tid, nullptr, GrabTickets, ti);
        tids.push_back(tid);
        tis.push_back(ti);
    }

    // 等待所有线程
    for (auto tid : tids)
    {
        pthread_join(tid, nullptr);
    }

    // 释放资源
    for (auto ti : tis)
    {
        delete ti;
    }

    pthread_mutex_destroy(&lock);
    return 0;
}