信号量概念

Linux 内核的信号量在概念和原理上与用户态的 System V 的 IPC 机制信号量是一样的，但是它绝不可能在内核之外使用，因此它与 System V 的 IPC 机制信号量毫不相干。
信号量在创建时需要设置一个初始值，表示同时可以有几个任务可以访问该信号量保护的共享资源，初始值为 1 就变成互斥锁（Mutex），即同时只能有一个任务可以访问信号量保护的共享资源。
一个任务要想访问共享资源，首先必须得到信号量，获取信号量的操作将把信号量的值减 1，若当前信号量的值为负数，表明无法获得信号量，该任务必须挂起在该信号量的等待队列等待该信号量可用；若当前信号量的值为非负数，表示可以获得信号量，因而可以立刻访问被该信号量保护的共享资源。
当任务访问完被信号量保护的共享资源后，必须释放信号量，释放信号量通过把信号量的值加 1 实现，如果信号量的值为非正数，表明有任务等待当前信号量，因此它也唤醒所有等待该信号量的任务。

内核信号量核心结构

内核中使用 struct semaphore 结构来描述一个信号量，结构定义如下：

struct semaphore {
raw_spinlock_t lock;
unsigned int count; //信号值，只要这个值为正数，则信号可用， 一般情况设置 0 或 1。
struct list_head wait_list;
};

信号量相关 API

DEFINE_SEMAPHORE (name)

void sema_init(struct semaphore *sem, int val)

void sema_init (struct semaphore *sem, int val);

定义、初始化信号量相关 API:这是一个静态定义方式。 定义一个名字为 name,信号量值为 1 的信号量结构变量。
示例：
struct semaphore sem;
sema_init(&sem, 1);
以上两行等效：
DEFINE_SEMAPHORE(sem);
 

void down(struct semaphore *sem)

int down_timeout(struct semaphore *sem, long jiffies);
sem： 信号量结构指针
jiffies： 要设置超时时间，单位是时钟节拍。
阻塞地请求一个信号量,如果信号量大于 0， 则可以马上返回， 否则休眠，直到有其他进程释放信号量
（把信号量的 count 修改为大于 0 的值） 或超时时间到。
这个函数效果和 down 函数很像，它也是不可中断的休眠。
 

int down_interruptible(struct semaphore * sem);

int down_trylock(struct semaphore * sem);

void up(struct semaphore * sem);

虽然信号量可以设置为大于 1 的值，但是信号量在绝大部分情况下作为互斥锁使用。

简单信号量使用例子实现设备只能被一个进程打开：

#include <linux/module.h> /* Needed by all modules */
#include <linux/init.h> /* Needed for the module-macros */
#include <linux/fs.h>
#include <linux/miscdevice.h>
#include <asm/atomic.h>
#define LEDS_MAJOR 255
#define DEVICE_NAME "miscdev_semaphore"

DECLARE_MUTEX(lock); //定义一个互斥信号量，并初始化 1;

static int first_miscdev_open(struct inode *pinode, struct file *pfile)
{
printk (KERN_EMERG "Linux miscdevice:%s is call\r\n",__FUNCTION__);

/* 获取信号量 */
if (!down_trylock(&lock))
return 0;
else
return -EBUSY;
}

int first_miscdev_release (struct inode *inode, struct file *file)
{
printk (KERN_EMERG "Linux miscdevice:%s is call\r\n",__FUNCTION__);

up(&lock); //释放信号量
return 0;
}
static struct file_operations dev_fops =
{
.owner = THIS_MODULE,
.open = first_miscdev_open,
.release= first_miscdev_release,
};
static struct miscdevice misc =
{
.minor = LEDS_MAJOR,
.name = DEVICE_NAME,
.fops = &dev_fops,
};
/* 模块装载执行函数 */
static int __init first_miscdev_init(void)
{
int ret;
ret = misc_register(&misc); //注册混杂设备
if(ret <0)
printk (KERN_EMERG DEVICE_NAME"\t err\r\n");
printk (KERN_EMERG DEVICE_NAME"\tinitialized\n");
return ret;
}

/* 模块卸载执行函数 */
static void __exit first_miscdev_exit(void)
{
misc_deregister(&misc);
printk(KERN_EMERG "Goodbye,cruel world!, priority = 0\n");
}
module_init(first_miscdev_init);
module_exit(first_miscdev_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("XYD");
MODULE_DESCRIPTION("This the samlpe drv_test");

互斥信号量

互斥信号量概念：

互斥锁主要用于实现内核中的互斥访问功能。内核互斥锁是在原子 API 之上实现的，但这对于内核用户是不可见的。 在大部分场合中，对共享资源的访问，都是使用独占方式， 在这种情况下， 提供专门的互斥接口给编程者使用。 对它的访问必须遵循一些规则：同一时间只能有一个任务持有互斥锁，而且只有这个任务可以对互斥锁进行解锁。互斥锁不能进行递归锁定或解锁。一个互斥锁对象必须通过其 API 初始化，而不能使用 memset 或复制初始化。一个任务在持有互斥锁的时候是不能结束的。互斥锁所使用的内存区域是不能被释放的。使用中的互斥锁是不能被重新初始化的。并且互斥锁不能用于中断上下文。但是互斥锁比当前的内核信号量选项更快，并且更加紧凑，因此如果它们满足您的需求，那么它们将是您明智的选择。

内核信号量核心结构

内核中使用 struct mutex 结构来描述一个信号量，结构定义如下：
 

struct mutex {
/* 1: unlocked, 0: locked, negative: locked, possible waiters */
atomic_t count;
spinlock_t wait_lock;
struct list_head wait_list;
#if defined(CONFIG_DEBUG_MUTEXES) || defined(CONFIG_SMP)
struct task_struct *owner;
#endif
#ifdef CONFIG_DEBUG_MUTEXES
const char *name;
void *magic;
#endif
#ifdef CONFIG_DEBUG_LOCK_ALLOC
struct lockdep_map dep_map;
#endif
};

关键成员说明：
atomic_t count：
指示互斥锁的状态：
1--没有上锁，可以获得
0--被锁定，不能获得
负数--被锁定，且可能在该锁上有等待进程
初始化时为没有上锁状态。

spinlock_t wait_lock：
等待获取互斥锁中使用的自旋锁。在获取互斥锁的过程中，操作会在自旋锁的保护中进行。初始化为为
锁定， 用户一般无需关心。

struct list_head wait_list：
等待互斥锁的进程队列， 用户无需关心。

互斥信号量相关 API

DEFINE_MUTEX(mutexname)

mutex_init(mutex)

int mutex_is_locked(struct mutex *lock)

mutex_lock(lock) 或 void mutex_lock(struct mutex *lock);

mutex_lock_interruptible(lock) 或 int mutex_lock_interruptible(struct mutex *lock);

int mutex_trylock(struct mutex *lock);

void mutex_unlock(struct mutex *lock);

互斥锁应用例子：

/* chardev.c */
#include <linux/module.h>       /* Needed by all modules */
#include <linux/init.h>              /* Needed for the module-macros */
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/device.h>       /* 自动创建设备文件 */
#include <linux/miscdevice.h>
#include <asm/io.h>                /*ioremap*/
#include <asm/uaccess.h>       /*copy_from_user ,copy_to_user*/
#include <linux/atomic.h>
#include <linux/mutex.h>

#include <linux/gpio.h>
#include <mach/gpio.h>
#include <plat/gpio-cfg.h>  /* s3c_gpio_cfgpin  S3C_GPIO_OUTPUT */
static struct cdev *pcdev;
static struct device *this_device = NULL;
static struct class *leds_class = NULL;

/* 是否开启 gpio_request 函数功能 */
#define GPIO_REQUEST          1     //0 :关,非0 :开 

static int led_gpios[] = {
  EXYNOS4X12_GPM4(0),
  EXYNOS4X12_GPM4(1),
  EXYNOS4X12_GPM4(2),
  EXYNOS4X12_GPM4(3),
};

#define LED_NUM     ARRAY_SIZE(led_gpios)
#define   DEV_NAME   "myleds"
unsigned int major  = 0;                    //主设备号
unsigned int minor = 0;                   //次设备号

unsigned int devnr = 0;                    //设备号
char *chrdev_name = DEV_NAME;  //设备名
module_param(major, int, S_IRUGO | S_IWUSR);
module_param(minor, int, S_IRUGO | S_IWUSR);
module_param(chrdev_name, charp, S_IRUGO | S_IWUSR);


struct mutex lock;

//打开设备时候执行的程序
static int  chrdev_open(struct inode *pinode, struct file *pfile)
{
   mutex_lock(&lock);

  printk(KERN_EMERG "line:%d,%s is call\n", __LINE__, __FUNCTION__);
  return 0;
}

//关闭设备时执行的程序
static int chrdev_release(struct inode *pinode, struct file *pfile)
{
   mutex_unlock(&lock);
  printk(KERN_EMERG "line:%d,%s is call\n", __LINE__, __FUNCTION__);
  return 0;
}



//读接口函数
static ssize_t chrdev_read ( struct file *file,
                             char __user *buf,
                             size_t count,
                             loff_t * f_pos )
{
  char led_buffer[4] = {2, 2, 2, 2};
  int i = 0;
  //  printk ( KERN_EMERG "line:%d,%s is call\n", __LINE__, __FUNCTION__ );

  /* count ==0 ,则返回0，不是错误 */
  if ( !count ) {
    return 0;
  }

  /* 当前已经到文件末尾，不能再写，返回0,*/
  if ( count > LED_NUM ) {
    count =  LED_NUM;
  }


  /* 准备数据，0表示灭，1表示亮 */
  for (i = 0; i < LED_NUM; i++) {
    led_buffer[i] = !gpio_get_value(led_gpios[i]);
  }

  if ( copy_to_user ( buf, &led_buffer[0], count ) ) {
    return -EFAULT;
  }

  return count;
}



//写接口函数
static ssize_t chrdev_write(struct file *pfile,
                            const char __user *user_buf,
                            size_t count,
                            loff_t *off)
{
  int ret = 0;
  char buf[LED_NUM] = {0};
  int i = 0;
  // printk(KERN_EMERG "line:%d,%s is call\n", __LINE__, __FUNCTION__);
  //应用程序传递count=0下来，并不是错误，应该返回0
  if(count == 0) {
    return 0;
  }

  //因为板子只有4个灯，所以防止用户程序恶意破坏系统。
  if(count > LED_NUM) {
    count = LED_NUM;
  }

  //把用户空间传递下来的数据复制到内核空间的buf数组中
  ret = copy_from_user(buf, user_buf, count); //返回，成功是0，其他是失败
  if(ret) { //如果复制失败返回-1;
    return -EFAULT;
  }

  for(i = 0; i < count; i++) {
    if(buf[i] == 1)
      //                  GPM4DAT &= ~(1 << (0 + i));/* 亮 */

    {
      gpio_set_value(led_gpios[i], 0);
    }

    else if(buf[i] == 0)
      //                  rGPM4DAT |=  (1 << (0 + i));/* 灭 */
    {
      gpio_set_value(led_gpios[i], 1);
    }

  }

  count  = 1;


  return count;
}



//文件操作方法：
static const  struct file_operations chrdev_fops = {
  .read      = chrdev_read,
  .write     = chrdev_write,
  .release  = chrdev_release,
  .open     = chrdev_open,
};



static int __init chrdev_init(void)
{

  int ret = 0;
  int i;

  /* IO口配置代码 */
  for (i = 0; i < LED_NUM; i++) {
#if GPIO_REQUEST
    ret = gpio_request(led_gpios[i], "LED");
    if (ret) {
      printk("%s: request GPIO %d for LED failed, ret = %d\n",
             chrdev_name, led_gpios[i], ret);
      goto gpio_request_err;
    }
#endif

    //s3c_gpio_cfgpin(led_gpios[i], S3C_GPIO_OUTPUT);
    //gpio_set_value(led_gpios[i], 1);
    //gpio_direction_output等效于上面两条语句,
    gpio_direction_output(led_gpios[i], 1);

  }

  //分配cdev核心结构;
  pcdev = cdev_alloc();
  if (pcdev == NULL) {
    ret = -ENOMEM;
    printk(KERN_EMERG"cdev_alloc_err error\n");
    goto cdev_alloc_err;
  }

  //如果主设备号是0,则动态分配设备号
  if(!major) {
    ret  = alloc_chrdev_region(&devnr, minor, 1, chrdev_name);
    if(ret < 0) {
      printk(KERN_EMERG"alloc_chrdev_region error\n");
      goto devnr_requst_err;
    }

  } else {

    //合成设备号
    devnr =  MKDEV(major, minor);

    //静态注册设备号
    ret = register_chrdev_region(devnr, 1, chrdev_name);
    if(ret != 0) {
      printk(KERN_EMERG"register_chrdev_region error\n");
      goto devnr_requst_err;
    }
  }

  //cdev结构体初始化
  cdev_init(pcdev, &chrdev_fops);

  //注册字符设备
  ret = cdev_add(pcdev, devnr, 1);
  if ( ret < 0) {
    printk(KERN_EMERG"cdev_add error\n");
    goto cdev_add_err;
  }

  //输出字符设备主设备号和次设备号
  printk(KERN_EMERG "name:%s,major:%d,minor:%d\n",
         chrdev_name, MAJOR(devnr), MINOR(devnr));

  //创建一个类
  leds_class =   class_create(THIS_MODULE, "leds_class");
  if ( IS_ERR(leds_class) ) {
    ret = PTR_ERR(leds_class);
    printk(KERN_EMERG"class_create error\n");
    goto class_create_err;
  }

  //创建一个设备
  this_device = device_create(leds_class, NULL, devnr, NULL, "%s", chrdev_name);
  if ( IS_ERR(this_device) ) {
    ret = PTR_ERR(this_device);
    printk(KERN_EMERG"this_device error\n");
    goto device_create_err;
  }

  mutex_init(&lock);
  return 0;

device_create_err:
  class_destroy(leds_class);
class_create_err:
  unregister_chrdev(major, chrdev_name);
cdev_add_err:
devnr_requst_err:
  if (pcdev) {
    cdev_del(pcdev);
  }
  unregister_chrdev_region(devnr, 1);
cdev_alloc_err:

#if GPIO_REQUEST
gpio_request_err:
  /* gpio 反向释放 */
  for ( --i ; i >= 0 ; i-- ) {
    gpio_free(led_gpios[i]);
  }
#endif

  return ret;
}

static void  __exit chrdev_exit(void)
{
  int i = 0;
  device_destroy(leds_class, devnr);
  class_destroy(leds_class);

  /* gpio 反向释放 */
  for (   ; i < 4 ; i++) {
    gpio_free(led_gpios[i]);
  }

  cdev_del(pcdev);
  unregister_chrdev_region(devnr, 1);
  printk(KERN_EMERG "Goodbye,chrdev\n");
}
module_init(chrdev_init);
module_exit(chrdev_exit);

MODULE_LICENSE("Dual BSD/GPL");
MODULE_AUTHOR("learn");                //optional
MODULE_DESCRIPTION("STUDY_MODULE"); //optional

1、初始化互斥锁

mutex用pthread_mutex_t数据类型表示，在使用互斥锁前，必须先对它进行初始化。

静态分配的互斥锁：
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

动态分配互斥锁：
pthread_mutex_t mutex;
pthread_mutex_init(&mutex,NULL);

销毁互斥锁：
在所有使用过互斥锁的线程都不再需要使用时候，应调用pthread_mutex_destroy销毁互斥锁。

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

功能：初始化一个互斥锁。

参数：
mutex：互斥锁地址。
attr：互斥锁的属性，NULL为默认的属性。

返回值：
成功：返回 0
失败：返回非 0

2、互斥锁上锁：

互斥锁上锁1

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

功能：对互斥锁上锁，若已经上锁，则调用者一直阻塞到互斥锁解锁  

参数：
mutex：互斥锁地址。

返回值：
成功：返回 0
失败：返回非 0

互斥锁上锁2

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

功能：对互斥锁上锁，若已经上锁，则上锁失败，函数立即返回。

参数：
mutex：互斥锁地址。

返回值：
成功：返回 0
失败：返回非 0

一般情况下在互斥锁上锁的时候用的是pthread_mutex_lock这个函数。

3、互斥锁解锁：

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

功能：对指定的互斥锁解锁。

参数: 
mutex：互斥锁地址。

返回值：
成功：返回 0
失败：返回非 0

4、销毁互斥锁：

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

功能：销毁指定的一个互斥锁。

参数：
mutex：互斥锁地址。

返回值：
成功：返回 0
失败：返回非 0 

5、案例代码：

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

//通过互斥锁解决线程间互斥问题

int money = 10000;

//第一步：创建互斥锁（由于两个线程操作同一个互斥锁，所以定义在全局更加方便一点）
pthread_mutex_t mymutex;

void *pthread_fun1(void *arg)
{
        int get,yu,shiji;
        get = 10000;

        //第三步：对共享资源的操作进行上锁
        pthread_mutex_lock(&mymutex);

        printf("张三正在查询余额……\n");
        sleep(1);
        yu =money;

        printf("张三正在取钱……\n");
        sleep(1);
        if(get > yu)
        {
                shiji = 0;
        }

        else
        {
                shiji = get;
                yu = yu - get;
                money = yu;
        }

        printf("张三想取%d元，实际取了%d元，余额为%d元\n",get,shiji,yu);

        //第四步：当共享资源的操作执行完毕后，对互斥锁执行解锁操作
        pthread_mutex_unlock(&mymutex);

        pthread_exit(NULL);

}
void *pthread_fun2(void *arg)
{
        int get,yu,shiji;
        get = 10000;

        //第三步：对共享资源的操作进行上锁
        pthread_mutex_lock(&mymutex);

        printf("李四正在查询余额……\n");
        sleep(1);
        yu =money;

        printf("李四正在取钱……\n");
        sleep(1);
        if(get > yu)
        {
                shiji = 0;
        }

        else
        {
                shiji = get;
                yu = yu - get;
                money = yu;
        }

        printf("李四想取%d元，实际取了%d元，余额为%d元\n",get,shiji,yu);

        //第四步：当共享资源的操作执行完毕后，对互斥锁执行解锁操作
        pthread_mutex_unlock(&mymutex);

        pthread_exit(NULL);

}

int main(int argc,char const *argv[])

{

        //第二步：初始化操作
        pthread_mutex_init(&mymutex,NULL);

        pthread_t thread1,thread2;

        if(pthread_create(&thread1,NULL,pthread_fun1,NULL) != 0)
        {
                perror("fail to pthread_create");
                exit(1);
        }

        if(pthread_create(&thread2,NULL,pthread_fun2,NULL) != 0)
        {
                perror("fail to pthread_create");
                exit(1);
        }

        pthread_join(thread1,NULL);
        pthread_join(thread2,NULL);

        //第五步：当互斥锁使用完毕后，要销毁
        pthread_mutex_destroy(&mymutex);

        return 0;
}

运行结果：

目录

1. 互斥锁原理

2. 互斥锁相关函数

3. 互斥锁使用过程

4. 互斥锁使用示例

5. 死锁

1. 互斥锁原理

如上图所示：如果多个线程要访问一段共享资源的内存区域时，其中一个线程（如图中线程1）首先读取共享区域时，会在共享区域外设置一把互斥锁，其它线程阻塞在互斥锁处，线程1结束共享资源的访问后，会解锁该内存区域，此时其它的线程才可以继续访问共享资源的内存区域。本来多线程访问数据时是并行访问内存区域的，加上互斥锁后变为串行处理。

多线程编程是建议使用互斥锁，这样可以对公共区域的数据进行保护。互斥锁的缺点就是串行，数据访问的效率会有一定的降低。

2. 互斥锁相关函数

1.创建互斥锁函数
pthread_mutex_t mutex;

2.初始化互斥锁函数：
int pthread_mutex_init(pthread_mutex_t *restrict mutex, 
                       const pthread_mutexattr_t *restrict attr
                        ); 
    参数1：传出参数，调用是创建的互斥锁变量。
    参数2：传入参数，互斥锁属性，一般为NULL表示为默认属性
    这里的restrict关键字，表示指针指向的内容只能通过这个指针进行修改
    restrict关键字作用可以理解为：
	    用来限定指针变量。被该关键字限定的指针变量所指向的内存操作，必须由本指针完成。
    
    初始化可以使用静态初始化和动态初始化，示例：
    pthread_mutex_t mutex;
		1. pthread_mutex_init(&mutex, NULL);   			动态初始化。
		2. pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;	静态初始化。

3.加锁
int pthread_mutex_lock(pthread_mutex_t *mutex);
     参数：mutex
     没有上锁，当前线程会将这把锁上锁
     已经上锁，当前线程会阻塞在此
              锁被打开之后，线程会解除阻塞

4.尝试加锁
int pthread_mutex_trylock(pthread_mutex_t *mutex);
      参数：mutex
      没有上锁：同上
      已经上锁，不阻塞返回

5.解锁
int pthread_mutex_unlock(pthread_mutex_t *mutex);

6.销毁一个互斥锁
int pthread_mutex_destroy(pthread_mutex_t *mutex);

3. 互斥锁使用过程

（1）创建互斥锁：pthread_mutex_t mutex;

（2）初始化互斥锁： pthread_mutex_init(&mutex, NULL);

（3）找到线程共同操作的共享资源

           加锁：prhread_mutex_lock(&mutex);     //如果共享区域已经上锁，会阻塞线程

                      pthread_mutex_trylock(&mutex);   //如果共享区域已经上锁，直接返回，不会阻塞。

（4）访问内存区域

（5）解锁：pthread_mutex_unlock(&mutex);

（6）销毁：pthread_mutex_destory(&mutex);

 使用注意：

尽量保证锁的粒度，越小越好，一般访问共享数据前加锁，访问结束立即解锁。

        互斥锁，本质是结构体。 我们可以看成整数。 初值为 1。（pthread_mutex_init() 函数调用成功。）

        加锁： --操作， 阻塞线程。

        解锁： ++操作， 唤醒阻塞在锁上的线程。

        try锁：尝试加锁，成功--。失败，返回。同时设置错误号 EBUSY

4. 互斥锁使用示例

pthread_mutex.c：主线程建立两个子线程对全局变量进行++操作。

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <string.h>
#include <pthread.h>


#define MAX 10000
// 全局变量
int number;
//创建一把互斥锁
pthread_mutex_t mutex;


// 线程A处理函数
void* funcA_num(void* arg)
{
    for(int i=0; i<MAX; ++i)
    {
        //访问全局变量之前加锁
        //如果mutex被锁上了，代码阻塞在当前位置
        pthread_mutex_lock(&mutex);
        int cur = number;
        cur++;
        number = cur;
        printf("Thread A, id = %lu, number = %d\n", pthread_self(), number);
        //解锁
        pthread_mutex_unlock(&mutex);
        usleep(10);
    }
 
    return NULL;
}
// 线程B处理函数 
void* funcB_num(void* arg)
{
    for(int i=0; i<MAX; ++i)
    {
        pthread_mutex_lock(&mutex);
        int cur = number;
        cur++;
        number = cur;
        printf("Thread B, id = %lu, number = %d\n", pthread_self(), number);
                pthread_mutex_unlock(&mutex);
        usleep(10);
    }
 
    return NULL;
}

/*主函数创建两个线程，分别操作共享区域内存：全局变量number*/
int main(int argc, const char* argv[])
{
    pthread_t p1, p2;
        //初始化互斥锁
    pthread_mutex_init(&mutex,NULL);
 
    // 创建两个子线程
    pthread_create(&p1, NULL, funcA_num, NULL);
    pthread_create(&p2, NULL, funcB_num, NULL);
 
    // 阻塞，资源回收
    pthread_join(p1, NULL);
    pthread_join(p2, NULL);
 
        //释放互斥锁资源
    pthread_mutex_destroy(&mutex);
 
    return 0;
}

运行结果：AB两个线程逐个访问共享内存区域。

5. 死锁

程序运行是要避免死锁的情况。通常出现死锁的情况有两种：
       1.  对一个锁反复lock：对一个地方使用了两次锁，没有及时解锁

2. 两个线程，各自持有一把锁，请求另一把锁，如下图所示:A，B两个线程访问AB两个共享数据区域时。

解决方法：

        1. 让线程按照一定的顺序去访问共享资源

        2. 在访问的其他锁的时候，需要先将字节的锁解开

        3.trylock方式定义锁