大部分情况，各线程使用的数据都是局部变量，变量的地址空间在线程栈空间内，这种情况，变量归属单个线程，其他线程无法获得这种变量。

但有时候，很多变量都需要在线程间共享，这样的变量称为共享变量，可以通过数据的共享，完成线程之间的交互。

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

2.1 初始化互斥量

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

参数：
    mutex：要初始化的互斥量
    attr：NULL

2.2 销毁互斥量

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

int pthread_mutex_destroy(pthread_mutex_t *mutex);

//加锁
int pthread_mutex_lock(pthread_mutex_t *mutex);

//解锁
int pthread_mutex_unlock(pthread_mutex_t *mutex);

返回值:
    成功返回0,失败返回错误号

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

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

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

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

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

死锁是指在一组进程中的各个进程均占有不会释放的资源，但因互相申请被其他进程所站用

不会释放的资源而处于的一种永久等待状态。

【互斥条件】：一个资源每次只能被一个执行流使用；

【请求与保持条件】：一个执行流因请求资源而阻塞时，对已获得的资源保持不放；

【不剥夺条件】 : 一个执行流已获得的资源，在末使用完之前，不能强行剥夺；

【循环等待条件】 : 若干执行流之间形成一种头尾相接的循环等待资源的关系；

• 破坏死锁的四个必要条件；
• 加锁顺序一致（如有多个锁，加锁和释放锁相对应）；
• 避免锁未释放的场景；
• 资源一次性分配；

• 死锁检测算法
• 银行家算法

银行家算法、死锁检测算法实践

#include <iostream>
#include <cstdio>
#include <string>
#include <ctime>
#include <mutex>
#include <cstdlib>
#include <unistd.h>
#include <pthread.h>

//票类
class Ticket
{
private:
    //票数
    int tickes;
    //互斥量
    pthread_mutex_t mtx;
public:
    //构造函数
    Ticket():tickes(1000)
    {
        pthread_mutex_init(&mtx,nullptr);
    }
    //抢票函数
    bool GetTicket()
    {
        bool res=true;
        //加锁
        pthread_mutex_lock(&mtx);
        //临界区
        if(tickes>0)
        {
            usleep(1000);
            std::cout<<"我是["<<pthread_self()<<"]我要抢的票是："<<tickes<<std::endl;
            tickes--;
        }
        else
        {
            std::cout<<"票已经抢空了"<<std::endl;
            res=false;
        }
        pthread_mutex_unlock(&mtx);
        return res;
    }
    //析构函数
    ~Ticket()
    {
        pthread_mutex_destroy(&mtx);
    }
};
//线程执行的函数
void* ThreadRoutine(void* 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++)
    {
        pthread_create(tid+i,nullptr,ThreadRoutine,(void*)t);
    }
    //等待线程
    for(int i=0;i<5;i++)
    {
        pthread_join(tid[i],nullptr);
    }
    return 0;
}

//票类
class Ticket 
{
private:
    int tickets;
    pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
    //pthread_mutex_t mtx;
public:
    //构造函数
    Ticket():tickets(1000)
    {
        //pthread_mutex_init(&mtx,nullptr);
    }
    //抢票
    bool GetTicket()
    {
        bool res=true;
        //加锁
        pthread_mutex_lock(&mtx);
        //临界区
        if(tickets>0)
        {
            usleep(1000);
            std::cout<<"我是线程["<<pthread_self()<<"]，我正在抢"<<tickets<<"号票"<<std::endl;
            tickets--;
        }
        else
        {
            std::cout<<"票抢完了"<<std::endl;
            res=false;
        }
        pthread_mutex_unlock(&mtx);
        return res;
    }
    //析构函数
    ~Ticket()
    {
        //pthread_mutex_destroy(&mtx);
    }
};