关于线程中锁的使用以及死锁情况

简介

当多个线程同时访问共享数据时可能会冲突。比如两个线程都要把某个全局变量加一，而这个操作在底层实现的时候是需要三条指令完成，也就是说加一的操作不具有原子性。那么也就会造成不同的线程对其进行了加操作。
对于多线程的程序，这种冲突的问题是很常见的，解决的办法就是引入锁的概念。获得锁的线程可以完成对数据的读->修改->写的操作，而没有获取锁的线程就只能等待且不能访问共享数据。也可以说是锁把原本加一这种非原子性的操作变为了一个原子性的操作，这也就避免了冲突的发生。

这里我们写一段程序来验证一些数据冲突所出现的问题，我们给出一个全局变量，分别在两个线程中分别对其进行累加5000次。

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

static int val = 0;
void thread1()
{
    int i = 0;
    for(i = 0;i<5000;i++)
    {
        val++;
        printf("pid is %d and val is %d\n",getpid(),val);
    }
    pthread_exit(0);
}

void thread2()
{
    int i = 0;
    for(i = 0;i<5000;i++)
    {
        val++;
        printf("pid is %d and val is %d\n",getpid(),val);
    }
    pthread_exit(0);
}

int main()
{
    pthread_t tid1,tid2;
    pthread_create(&tid1,NULL,thread1,NULL);
    pthread_create(&tid2,NULL,thread2,NULL);
    pthread_join(tid1,NULL);
    pthread_join(tid2,NULL);
    printf("count:%d\n",val);
    return 0;
}

运行结果如下，累加结果明显比正确结果少了一次。如果累加次数更多，那么出现问题的几率也会更大。

锁的使用

#include<pthread.h>

pthread_mutex_t mymutex = PTHREAD_MUTEX_INITILALIZER;//互斥量的静态初始化

int pthread_mutex_init(pthread_mutex_t mymutex,const pthread_mutexattr_t attr);//动态初始化锁，成功返回0失败返回错误号。参数一为锁使用的互斥量，二为锁的状态

int pthread_mutex_destroy(pthread_mutex_t mymutex);//销毁锁，成功返回0，错误返回错误号，参数为锁使用的互斥量。

int pthread_mutex_lock(pthread_mutex_t *mutex);//一个线程调用这个函数获得mutex，代表该线程所访问资源已经上锁。

int pthread_mutex_unlock(pthread_mutex_t *mutex);//一个线程调用这个函数解除mutex锁

int pthread_mutex_trylock(pthread_mutex_T *mutex);//如果一个线程想获得锁又不想挂起等待，则调用这个函数

刚才的程序改为使用锁的形式则不会出现临界资源被同时访问的情况

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

pthread_mutex_t  mutex_lock;
pthread_mutex_init(mutex_lock);

static int val = 0;
void thread1()
{
    int i = 0;
    for(i = 0;i<5000;i++)
    {
        pthread_mutex_lock(&mutex_lock);
        val++;
        printf("pid is %d and val is %d\n",getpid(),val);
        pthread_mutex_unlock(&mutex_lock);
    }
    pthread_exit(0);
}

void thread2()
{
    int i = 0;
    for(i = 0;i<5000;i++)
    {
        pthread_mutex_lock(&mutex_lock);
        val++;
        printf("pid is %d and val is %d\n",getpid(),val);
        pthread_mutex_unlock(&mutex_lock);
    }
    pthread_exit(0);
}

int main()
{
    pthread_t tid1,tid2;
    pthread_create(&tid1,NULL,thread1,NULL);
    pthread_create(&tid2,NULL,thread2,NULL);
    pthread_join(tid1,NULL);
    pthread_join(tid2,NULL);
    printf("count:%d\n",val);
    return 0;
}

锁的种类

linux中用来实现线程同步常用的锁有互斥锁，读写锁以及自旋锁。
他们提供对临界资源的保护，当多线程试图访问临界资源时，都必须通过获取锁的方式来访问临界资源，在任何时刻只有一个单元能够获取锁。当读写线程获取锁的频率差别不大时，一般采用互斥锁，而当读进程访问临界资源的频率大于写线程，这个时候采用读写锁比较合适，读写锁允许多个读线程同时访问临界资源，写线程必须互斥访问临界资源。而读写锁在底层实现上其实是复用了互斥锁，所以当在读写次数差不多的情况下互斥锁的性能更为高效。
自旋锁在调度机制上不同于互斥锁，如果某个资源已经被某个互斥锁标示，那么其他线程想要调用该资源则会被暂时的挂起，直到这个锁被解开，刚才被挂起的线程才会被唤醒，此时它才可以访问资源。而自旋锁就不会引起线程的挂起等待，如果一个资源被自旋锁标示，那么其他调用这就会在资源处一直循环的观察自旋锁是否解锁。

死锁

在多线程编程中，我们可以利用各类锁来解决数据访问的同步与互斥，但是同时带来了新的问题，那就是死锁问题，死锁是指两个以上的进程在执行过程中，因为争夺资源而造成的一种互相等待的情况，此时若无外部处理，他们就会无限的等待下去。例如，在一个线程内忘记释放锁，再例如在两个以上的线程中申请锁产生了类似于环的形式，同样也会造成死锁。

产生死锁的条件

1.互斥条件：互斥即进程在某一时间内独占资源；
2.请求与保持条件：一个进程因为请求资源而阻塞时，对已获得的资源保持不放；
3.不剥夺条件：进程已获得的资源在未使用完之前不能强行剥夺；
4.循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系。
只要系统发生死锁，那么这些条件必然成立，而只要缺少上面任何一种条件，那么死锁也就不会发生。

死锁的预防

如上面所说的，只要不满足以上的任何一个条件也就不会出现死锁。所以预防死锁的方法也有四种。
1.打破互斥条件：允许线程同时访问某些资源，但是这样锁也就没有存在的意义了，一般不采用这种方法；
2.打破不剥夺条件：允许进程从占有者占有的资源中强行剥夺一些资源。这中方法实现起来有困难，并且会降低系统性能；
3.打破请求与保持条件：即实行资源预先分配策略，即进程在运行前一次性的向系统申请它所需的全部资源。如果某个进程所需的资源得不到满足，则不分配任何资源，进程也暂不运行。只有当系统能够满足当前进程的全部资源需要时，才一次性分配给它。
4.打破循环等待条件：实行资源的有序分配。把资源实现分类编号，按号分配，使进程在申请资源时不产生环路。

具体避免方式

1.编写正确的代码；
2.时刻记住上锁完要释放锁；
3.使用多个锁的时候要保证锁的获取顺序，避免出现循环等待；
4.使用带有死锁的测试用例，确保没有死锁。