Java中的锁

谁践踏了优雅 2022-12-28 07:37 96阅读 0赞

### 文章目录 ###

*   *  Lock锁
     *  生产者和消费者问题（synchronized和Condition）
     *  8锁现象
     *  Java中各种锁
     *   *  1、公平锁、非公平锁
         *  2、乐观锁、悲观锁
         *  2、读写锁（ReadWriteLock）
         *  3、可重入锁
         *  4、自旋锁
         *  5、死锁

## Lock锁 ##

> 传统 synchronized

public class SaleTickDemo01 { 
        public static void main(String[] args) { 
            // 并发：多线程操作同一个资源类，把资源类丢入线程
            Ticket ticket = new Ticket();
    
            // @RunctionalInterface 函数式接口，jdk1.8 lambda表达式 (参数)->{ 代码 }
            new Thread(() -> { 
                for (int i = 0; i < 100; i++) { 
                    ticket.sale();
                }
            }, "A").start();
            new Thread(() -> { 
                for (int i = 0; i < 100; i++) { 
                    ticket.sale();
                }
            }, "B").start();
            new Thread(() -> { 
                for (int i = 0; i < 100; i++) { 
                    ticket.sale();
                }
            }, "C").start();
        }
    }
    
    //资源类 OOP
    class Ticket { 
        //属性、方法
        private int number = 100;
    
        //卖票方式
        // synchronized 本质：队列，锁
        public synchronized void sale() { 
            if (number > 0) { 
                System.out.println(Thread.currentThread().getName() + "卖出了" + (number--) + "票，剩余" + number);
            }
        }
    }

> Lock接口  
> ![在这里插入图片描述][20201215144534693.png]

实现类

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tvbmdzYW5qaW4_size_16_color_FFFFFF_t_70]

**公平锁：** 十分公平，排队分先来后到

**非公平锁：十分不公平，可以插队（默认是使用非公平锁）**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tvbmdzYW5qaW4_size_16_color_FFFFFF_t_70 1]

public class SaleTickDemo02 { 
        public static void main(String[] args) { 
            // 并发：多线程操作同一个资源类，把资源类丢入线程
            Ticket2 ticket = new Ticket2();
    
            // @RunctionalInterface 函数式接口，jdk1.8 lambda表达式 (参数)->{ 代码 }
            new Thread(() -> { 
                for (int i = 0; i < 100; i++) { 
                    ticket.sale();
                }
            }, "A").start();
            new Thread(() -> { 
                for (int i = 0; i < 100; i++) { 
                    ticket.sale();
                }
            }, "B").start();
            new Thread(() -> { 
                for (int i = 0; i < 100; i++) { 
                    ticket.sale();
                }
            }, "C").start();
        }
    }
    
    //资源类 OOP
    class Ticket2 { 
        //属性、方法
        private int number = 100;
    
        Lock lock = new ReentrantLock();
    
        public  void sale() { 
    
            lock.lock();    // 加锁
    
            try { 
                if (number > 0) { 
                    System.out.println(Thread.currentThread().getName() + "卖出了" + (number--) + "票，剩余" + number);
                }
            }catch (Exception e){ 
                e.printStackTrace();
            }finally { 
                lock.unlock();  // 解锁
            }
        }
    }

> synchronized 和 Lock 区别

1、Synchronized 内置的Java关键字，Lock 是一个Java类

2、Synchronized 无法判断获取锁的状态，Lock 可以判断是否获取到了锁

3、Synchronized 会自动释放锁，Lock 必须要手动释放锁！如果不释放锁，会出现**死锁问题**

4、Synchronized 线程1（获得锁，阻塞）、线程2（等待、傻傻的等）；Lock锁就不一定会等待下去；

5、Synchronized 可重入锁，不可以中断的，非公平；Lock，可重入锁，可以判断锁，非公平（可以自己设置）；

6、Synchronized 适合锁少量的代码同步问题，Lock 适合锁大量的同步代码！

## 生产者和消费者问题（synchronized和Condition） ##

> 生产者和消费者问题 synchronized

public class A { 
        public static void main(String[] args) { 
            Data data = new Data();
    
            new Thread(()->{ 
                for (int i = 0; i < 10; i++) { 
                    try { 
                        data.increment();
                    } catch (InterruptedException e) { 
                        e.printStackTrace();
                    }
                }
            },"A").start();
            new Thread(()->{ 
                for (int i = 0; i < 10; i++) { 
                    try { 
                        data.decrment();
                    } catch (InterruptedException e) { 
                        e.printStackTrace();
                    }
                }
            },"B").start();
        }
    }
    
    //判断等待，业务，通知
    class Data{  // 数字 资源类
    
        private int number = 0;
    
        // +1
        public synchronized void increment() throws InterruptedException { 
            if (number!=0){ 
                //等待
                this.wait();
            }
            number++;
            System.out.println(Thread.currentThread().getName()+"=>"+number);
            //通知其他线程，我+1完毕了
            this.notifyAll();
        }
    
        // -1
        public synchronized void decrment() throws InterruptedException { 
            if (number==0){ 
                //等待
                this.wait();
            }
            number--;
            System.out.println(Thread.currentThread().getName()+"=>"+number);
            // 通知其他线程，我-1完毕了
            this.notifyAll();
        }
    }

> 问题存在，若A B C D 4个线程！虚假唤醒

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tvbmdzYW5qaW4_size_16_color_FFFFFF_t_70 2]

**解决，防止虚假唤醒：**

**if 改为 while 判断**

> JUC版的生产者和消费者问题

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tvbmdzYW5qaW4_size_16_color_FFFFFF_t_70 3]  
通过Lock找的Condition  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tvbmdzYW5qaW4_size_16_color_FFFFFF_t_70 4]

代码实现：

public class B { 
        public static void main(String[] args) { 
            Data2 data = new Data2();
    
            new Thread(()->{ 
                for (int i = 0; i < 10; i++) { 
                    try { 
                        data.increment();
                    } catch (Exception e) { 
                        e.printStackTrace();
                    }
                }
            },"A").start();
            new Thread(()->{ 
                for (int i = 0; i < 10; i++) { 
                    try { 
                        data.decrment();
                    } catch (Exception e) { 
                        e.printStackTrace();
                    }
                }
            },"B").start();
            new Thread(()->{ 
                for (int i = 0; i < 10; i++) { 
                    try { 
                        data.increment();
                    } catch (Exception e) { 
                        e.printStackTrace();
                    }
                }
            },"C").start();
            new Thread(()->{ 
                for (int i = 0; i < 10; i++) { 
                    try { 
                        data.decrment();
                    } catch (Exception e) { 
                        e.printStackTrace();
                    }
                }
            },"D").start();
        }
    }
    
    //判断等待，业务，通知
    class Data2{  // 数字 资源类
    
        private int number = 0;
    
        Lock lock = new ReentrantLock();
        Condition condition = lock.newCondition();
    // condition.await(); // 等待
    // condition.signalAll(); // 唤醒全部
        // +1
        public  void increment() { 
            lock.lock();
            try { 
                while (number!=0){ 
                    //等待
                    condition.await();
                }
                number++;
                System.out.println(Thread.currentThread().getName()+"=>"+number);
                //通知其他线程，我+1完毕了
                condition.signalAll();
            } catch (Exception e) { 
                e.printStackTrace();
            } finally { 
                lock.unlock();
            }
        }
    
        // -1
        public synchronized void decrment() { 
            lock.lock();
            try { 
                while (number==0){ 
                    //等待
                    condition.await();
                }
                number--;
                System.out.println(Thread.currentThread().getName()+"=>"+number);
                // 通知其他线程，我-1完毕了
                condition.signalAll();
            } catch (Exception e) { 
                e.printStackTrace();
            } finally { 
                lock.unlock();
            }
        }
    }

**问题：随机的状态，想要有序的执行 A B C D**

> Condition 精准的通知和唤醒线程

public class C { 
        public static void main(String[] args) { 
            Data3 data = new Data3();
            new Thread(() -> { 
                for (int i = 0; i < 10; i++) { 
                    data.printA();
                }
            }, "A").start();
            new Thread(() -> { 
                for (int i = 0; i < 10; i++) { 
                    data.printB();
                }
            }, "B").start();
            new Thread(() -> { 
                for (int i = 0; i < 10; i++) { 
                    data.printC();
                }
            }, "C").start();
    
        }
    }
    
    //判断等待，业务，通知
    class Data3 {  // 数字 资源类
    
        private int number = 1; // 1 A 2 B 3C
        private Lock lock = new ReentrantLock();
        private Condition condition1 = lock.newCondition();
        private Condition condition2 = lock.newCondition();
        private Condition condition3 = lock.newCondition();
    
        public void printA() { 
            lock.lock();
            try { 
                while (number != 1) { 
                    condition1.await();
                }
                System.out.println(Thread.currentThread().getName() + "=>AAAAA");
                // 唤醒，唤醒指定唤醒的人 B
                number = 2;
                condition2.signal();
            } catch (Exception e) { 
                e.printStackTrace();
            } finally { 
                lock.unlock();
            }
        }
    
        public void printB() { 
            lock.lock();
            try { 
                while (number != 2) { 
                    condition2.await();
                }
                System.out.println(Thread.currentThread().getName() + "=>BBBBBBB");
                number = 3;
                condition3.signal();
            } catch (Exception e) { 
                e.printStackTrace();
            } finally { 
                lock.unlock();
            }
        }
    
        public void printC() { 
            lock.lock();
            try { 
                while (number != 3) { 
                    condition3.await();
                }
                System.out.println(Thread.currentThread().getName() + "=>CCCCCCCCC");
                number = 1;
                condition1.signal();
            } catch (Exception e) { 
                e.printStackTrace();
            } finally { 
                lock.unlock();
            }
        }
    }

## 8锁现象 ##

**关于锁的八个问题**

线程睡眠使用`TimeUnit.SECONDS.sleep(1);`JUC包下工具类

一个Phone类两个方法发短信和打电话，线程A调用发短信方法；主线程中睡眠1秒，启动线程B调用打电话方法。

1、标准情况下两个同步方法，一个对象去调用，两个线程先打印发短信还是打电话？

public class Test1 { 
        public static void main(String[] args) { 
            Phone1 phone1 = new Phone1();
            new Thread(()->{ 
                phone1.sendSms();
    
            },"A").start();
    
            try { 
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
    
            new Thread(()->{ 
                phone1.call();
            },"B").start();
        }
    }
    
    class Phone1{ 
        public synchronized void sendSms(){ 
            System.out.println("发短信");
        }
    
        public synchronized void call(){ 
            System.out.println("打电话");
        }
    }

结果：先输出发短信，再输出打电话。

2、两个同步方法，一个对象去调用，发短信先睡眠4秒，先输出发短信还是打电话？

public class Test2 { 
        public static void main(String[] args) { 
            Phone2 phone2 = new Phone2();
            new Thread(()->{ 
                phone2.sendSms();
    
            },"A").start();
    
            try { 
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
    
            new Thread(()->{ 
                phone2.call();
            },"B").start();
        }
    }
    
    class Phone2{ 
        public synchronized void sendSms(){ 
            try { 
                TimeUnit.SECONDS.sleep(4);
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
            System.out.println("发短信");
        }
    
        public synchronized void call(){ 
            System.out.println("打电话");
        }
    }

结果：控制台等待4秒，先输出发短信，再输出打电话。

**synchronized，锁的对象是方法的调用者，两个方法用的是同一个锁，谁先拿到谁执行。**

3、发短信睡眠4秒，增加了一个普通方法，一个对象，先输出发短信还是普通方法hello？

public class Test3 { 
        public static void main(String[] args) { 
            Phone3 phone3 = new Phone3();
            new Thread(()->{ 
                phone3.sendSms();
    
            },"A").start();
    
            try { 
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
    
            new Thread(()->{ 
                phone3.hello();
            },"B").start();
        }
    }
    
    class Phone3{ 
        public synchronized void sendSms(){ 
            try { 
                TimeUnit.SECONDS.sleep(4);
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
            System.out.println("发短信");
        }
    
        public synchronized void call(){ 
            System.out.println("打电话");
        }
    
        public void hello(){ 
            System.out.println("hello");
        }
    }

结果：先输出hello，再输出发短信。

4、两个对象调用两个同步方法，先发短信还是打电话？

public class Test4 { 
        public static void main(String[] args) { 
            Phone4 phone4 = new Phone4();
            Phone4 phone41 = new Phone4();
            new Thread(()->{ 
                phone4.sendSms();
    
            },"A").start();
    
            try { 
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
    
            new Thread(()->{ 
                phone41.call();
            },"B").start();
        }
    }
    
    class Phone4{ 
        public synchronized void sendSms(){ 
            try { 
                TimeUnit.SECONDS.sleep(4);
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
            System.out.println("发短信");
        }
    
        public synchronized void call(){ 
            System.out.println("打电话");
        }
    }

结果：先输出打电话，再输出发短信。

两个对象，调用两个方法，两个方法不是同一把锁，所以先输出打电话。

5、一个对象，调用连个静态同步方法，先发短信还是打电话？

public class Test5 { 
        public static void main(String[] args) { 
            Phone5 phone5 = new Phone5();
            new Thread(()->{ 
                phone5.sendSms();
    
            },"A").start();
    
            try { 
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
    
            new Thread(()->{ 
                phone5.call();
            },"B").start();
        }
    }
    
    class Phone5{ 
        public static synchronized void sendSms(){ 
            try { 
                TimeUnit.SECONDS.sleep(4);
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
            System.out.println("发短信");
        }
    
        public static synchronized void call(){ 
            System.out.println("打电话");
        }
    }

结果：先执行发短信，再执行打电话。

static修饰的方法为静态方法，类一加载就有的，并且只加载一次。

synchronized锁静态方法，锁的是类的模板即Class。

6、两个对象，调用两个静态方法，先输出发短信还是打电话？

public class Test6 { 
        public static void main(String[] args) { 
            Phone6 phone6 = new Phone6();
            Phone6 phone61 = new Phone6();
            new Thread(()->{ 
                phone6.sendSms();
    
            },"A").start();
    
            try { 
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
    
            new Thread(()->{ 
                phone61.call();
            },"B").start();
        }
    }
    
    class Phone6{ 
        public static synchronized void sendSms(){ 
            try { 
                TimeUnit.SECONDS.sleep(4);
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
            System.out.println("发短信");
        }
    
        public static synchronized void call(){ 
            System.out.println("打电话");
        }
    }

结果：先输出发短信，再输出打电话。

phone6和phon61，两个对象是通过个Class模板。

7、一个普通同步方法，一个静态同步方法，一个对象调用，先输出发短信还是打电话？

public class Test7 { 
        public static void main(String[] args) { 
            Phone7 phone7 = new Phone7();
            new Thread(()->{ 
                phone7.sendSms();
    
            },"A").start();
    
            try { 
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
    
            new Thread(()->{ 
                phone7.call();
            },"B").start();
        }
    }
    
    class Phone7{ 
        public static synchronized void sendSms(){ 
            try { 
                TimeUnit.SECONDS.sleep(4);
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
            System.out.println("发短信");
        }
    
        public synchronized void call(){ 
            System.out.println("打电话");
        }
    }

结果：先输出打电话，再输出发短信。

发短信锁的是类的模板，而打电话锁的是对象，不是同一把锁。

8、一个静态同步方法，一个普通同步方法，两个对象调用，先输出发短信还是打电话？

public class Test8 { 
        public static void main(String[] args) { 
            Phone8 phone8 = new Phone8();
            Phone8 phone81 = new Phone8();
            new Thread(()->{ 
                phone8.sendSms();
    
            },"A").start();
    
            try { 
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
    
            new Thread(()->{ 
                phone81.call();
            },"B").start();
        }
    }
    
    class Phone8{ 
        public static synchronized void sendSms(){ 
            try { 
                TimeUnit.SECONDS.sleep(4);
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
            System.out.println("发短信");
        }
    
        public synchronized void call(){ 
            System.out.println("打电话");
        }
    }

结果：先输出打电话，再输出发短信。

同一个模板但对象不同，而且两个方法的锁也不同。

## Java中各种锁 ##

### 1、公平锁、非公平锁 ###

公平锁：非常公平，不能够插队，必须先来后到！

非公平锁：非常不公平，可以插队（默认都是非公平锁）

public ReentrantLock() { 
        sync = new NonfairSync();
    }
    
    public ReentrantLock(boolean fair) { 
        sync = fair ? new FairSync() : new NonfairSync();
    }

### 2、乐观锁、悲观锁 ###

> **悲观锁**  
> 对于同一个数据的并发操作，悲观锁认为自己在使用数据的时候一定有别的线程来修改数据，因此在获取数据的时候会先加锁，确保数据不会被别的线程修改。Java中，synchronized关键字和Lock的实现类都是悲观锁。

> **乐观锁**  
> 乐观锁认为自己在使用数据时不会有别的线程修改数据，所以不会添加锁，只是在更新数据的时候去判断之前有没有别的线程更新了这个数据（一般通过版本号去进行判断）。如果这个数据没有被更新，当前线程将自己修改的数据成功写入。如果数据已经被其他线程更新，则根据不同的实现方式执行不同的操作（例如报错或者自动重试）。

*  悲观锁适合写操作多的场景，先加锁可以保证写操作时数据正确。
 *  乐观锁适合读操作多的场景，不加锁的特点能够使其读操作的性能大幅提升。

### 2、读写锁（ReadWriteLock） ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tvbmdzYW5qaW4_size_16_color_FFFFFF_t_70 5]

// 独占锁（写锁） 一次只能被一个线程占有
    // 共享锁（读锁） 多个线程可以同时占有 ReadWriteLock
    // 读-读 可以共存！
    // 读-写 不能共存！
    // 写-写 不能共存！
    public class ReadWriteLockDemo { 
        public static void main(String[] args) { 
            MyCacheLock myCache = new MyCacheLock();
            // 写入
            for (int i = 1; i <= 30; i++) { 
                final int temp = i;
                new Thread(() -> { 
                    myCache.put(temp + "", temp + "");
                }, String.valueOf(i)).start();
            }
            // 读取
            for (int i = 1; i <= 30; i++) { 
                final int temp = i;
                new Thread(() -> { 
                    myCache.get(temp + "");
                }, String.valueOf(i)).start();
            }
        }
    }
    
    // 加锁的自定义缓存
    class MyCacheLock { 
        private volatile Map<String, Object> map = new HashMap<>();
        // 读写锁： 更加细粒度的控制
        private ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    
        // 存，写入的时候，只希望同时只有一个线程写
        public void put(String key, Object value) { 
            readWriteLock.writeLock().lock();
            try { 
                System.out.println(Thread.currentThread().getName() + "写入" + key);
                map.put(key, value);
                System.out.println(Thread.currentThread().getName() + "写入OK");
            } catch (Exception e) { 
                e.printStackTrace();
            } finally { 
                readWriteLock.writeLock().unlock();
            }
        }
    
        // 取，读，所有人都可以读！
        public void get(String key) { 
            readWriteLock.readLock().lock();
            try { 
                System.out.println(Thread.currentThread().getName() + "读取" + key);
                Object o = map.get(key);
                System.out.println(Thread.currentThread().getName() + "读取OK");
            } catch (Exception e) { 
                e.printStackTrace();
            } finally { 
                readWriteLock.readLock().unlock();
            }
        }
    }

> private ReadWriteLock readWriteLock = new ReentrantReadWriteLock(); // 定义读写锁
> 
> readWriteLock.writeLock().lock(); //加写锁
> 
> readWriteLock.writeLock().unlock(); //释放写锁
> 
> readWriteLock.readLock().lock(); //加读锁
> 
> readWriteLock.readLock().unlock(); //释放读锁

### 3、可重入锁 ###

（递归锁）![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tvbmdzYW5qaW4_size_16_color_FFFFFF_t_70 6]

> **Synchronized**

public class Demo01 { 
        public static void main(String[] args) { 
            Phone phone = new Phone();
    
            new Thread(() -> { 
                phone.sms();
            }, "A").start();
    
            new Thread(() -> { 
                phone.sms();
            }, "B").start();
    
        }
    }
    
    class Phone { 
        public synchronized void sms() { 
            System.out.println(Thread.currentThread().getName() + "发短信");
            call(); //这里也有锁
        }
    
        public synchronized void call() { 
            System.out.println(Thread.currentThread().getName() + "打电话");
        }
    }

> **Lock**

public class Demo02 { 
        public static void main(String[] args) { 
            Phone2 phone = new Phone2();
    
            new Thread(() -> { 
                phone.sms();
            }, "A").start();
    
            new Thread(() -> { 
                phone.sms();
            }, "B").start();
    
        }
    }
    
    class Phone2 { 
        Lock lock = new ReentrantLock();
    
        public synchronized void sms() { 
            lock.lock();    // 细节问题：lock.lock(); lock.unlock(); // lock 锁必须配对，否则就会死在里面。
    
            try { 
                System.out.println(Thread.currentThread().getName() + "发短信");
                call(); //这里也有锁
            } catch (Exception e) { 
                e.printStackTrace();
            } finally { 
                lock.unlock();
            }
        }
    
        public synchronized void call() { 
    
            lock.lock();
            try { 
                System.out.println(Thread.currentThread().getName() + "打电话");
            } catch (Exception e) { 
                e.printStackTrace();
            } finally { 
                lock.unlock();
            }
        }
    }

### 4、自旋锁 ###

CAS自旋  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tvbmdzYW5qaW4_size_16_color_FFFFFF_t_70 7]

自定义一个自旋锁

public class SpinlockDemo { 
        AtomicReference<Thread> atomicReference = new AtomicReference<>();
    
        // 加锁
        public void myLock() { 
            Thread thread = Thread.currentThread();
            // 自旋锁
            while (!atomicReference.compareAndSet(null, thread)) { 
    
            }
            System.out.println(Thread.currentThread().getName() + "===> mylock");
        }
    
        // 解锁
        public void myUnLock() { 
            Thread thread = Thread.currentThread();
            atomicReference.compareAndSet(thread, null);
            System.out.println(Thread.currentThread().getName() + "===> myUnLock");
        }
    }

> 测试

public class TestSpinLock { 
        public static void main(String[] args) throws InterruptedException { 
            // 底层使用的自旋锁CAS
            SpinlockDemo lock = new SpinlockDemo();
    
            new Thread(() -> { 
                lock.myLock();
    
                try { 
                    TimeUnit.SECONDS.sleep(5);
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                } finally { 
                    lock.myUnLock();
                }
            }, "T1").start();
    
            TimeUnit.SECONDS.sleep(1);
    
            new Thread(() -> { 
                lock.myLock();
    
                try { 
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                } finally { 
                    lock.myUnLock();
                }
            }, "T2").start();
        }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tvbmdzYW5qaW4_size_16_color_FFFFFF_t_70 8]

### 5、死锁 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tvbmdzYW5qaW4_size_16_color_FFFFFF_t_70 9]

死锁测试，怎么排除死锁：

public class DeadLockDemo { 
        public static void main(String[] args) { 
            String lockA = "lockA";
            String lockB = "lockB";
    
            new Thread(new MyThread(lockA, lockB), "T1").start();
            new Thread(new MyThread(lockB, lockA), "T2").start();
    
        }
    }
    
    class MyThread implements Runnable { 
        private String lockA;
        private String lockB;
    
        public MyThread(String lockA, String lockB) { 
            this.lockA = lockA;
            this.lockB = lockB;
        }
    
        @Override
        public void run() { 
            synchronized (lockA) { 
                System.out.println(Thread.currentThread().getName() + "lock:" + lockA + "=>get" + lockB);
    
                try { 
                    TimeUnit.SECONDS.sleep(2);
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
                synchronized (lockB) { 
                    System.out.println(Thread.currentThread().getName() + "lock:" + lockB + "=>get" + lockA);
                }
            }
        }
    }

1、使用`jps -l`定位进程号

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7vTfW2e0-1608014611062)(F:\\aaaa笔记\\JUC并发编程.assets\\image-20201215142812361.png)\]

2、使用`jstack 进程号`找到死锁问题  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tvbmdzYW5qaW4_size_16_color_FFFFFF_t_70 10]

[20201215144534693.png]: /images/20221120/392b1b1823244cb4a67079fe49c375eb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tvbmdzYW5qaW4_size_16_color_FFFFFF_t_70]: /images/20221120/e224ae7f7e5c4c9992879815edcd88f2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tvbmdzYW5qaW4_size_16_color_FFFFFF_t_70 1]: /images/20221120/1300a3287dcb4bb19cc89589686ffde1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tvbmdzYW5qaW4_size_16_color_FFFFFF_t_70 2]: /images/20221120/e6767027dacd48179b51ba4fd5926590.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tvbmdzYW5qaW4_size_16_color_FFFFFF_t_70 3]: /images/20221120/c701f39598d24910b34e0cef76fd76a2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tvbmdzYW5qaW4_size_16_color_FFFFFF_t_70 4]: /images/20221120/f70e0e678ac34c8ea08c0d712347defb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tvbmdzYW5qaW4_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/20201215145239622.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tvbmdzYW5qaW4=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tvbmdzYW5qaW4_size_16_color_FFFFFF_t_70 6]: https://img-blog.csdnimg.cn/20201215150159599.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tvbmdzYW5qaW4=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tvbmdzYW5qaW4_size_16_color_FFFFFF_t_70 7]: https://img-blog.csdnimg.cn/2020121515021533.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tvbmdzYW5qaW4=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tvbmdzYW5qaW4_size_16_color_FFFFFF_t_70 8]: https://img-blog.csdnimg.cn/20201215150234491.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tvbmdzYW5qaW4=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tvbmdzYW5qaW4_size_16_color_FFFFFF_t_70 9]: https://img-blog.csdnimg.cn/20201215150247947.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tvbmdzYW5qaW4=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tvbmdzYW5qaW4_size_16_color_FFFFFF_t_70 10]: https://img-blog.csdnimg.cn/20201215150308252.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tvbmdzYW5qaW4=,size_16,color_FFFFFF,t_70