死锁的两种情况：

简单的说下单块cpu运行多线程的情况：

大家可能平时玩电脑，可以同时挂QQ啊，玩游戏啊，打开文本啊，等等。这里，我们假设是单块cpu。也就是俗称的单核cpu。

大家可能会觉得这些软件，这些线程是同时运行的，

其实不然，其实在任何一种情况下，电脑都只运行一个线程！

只是因为这个单块的cpu内部为我们划分了很多很多的时间块，

而这个时间的划分是以纳秒为单位的，也就是说，这个10纳秒我运行这个线程，下个10纳秒运行另外一个线程(或者又被上一个线程抢到了(只是被上一个线程抢到的概率小，这是cpu调度器的算法决定了的)，它会慢慢平衡的，不可能一直让某一个线程一直抢占cpu调度器资源)，所以说，它运行并不是连续的，只是间隔时间太短，我们感觉不出来而已！！！

第一种情况：

1)多个线程共用同一个对象锁，互相等待。

两个线程共用一个锁，一个线程拿着锁来调用另外一个线程，于是出现了死锁情况！package thread.deadLock.lock1;/** * 简单的类 *@author 陈浩翔 * * 2021年05月26日 */public class S { public int a = 0 ;}package thread.deadLock.lock1;/** * 含有main方法的类 *@author 陈浩翔 * * 2021年05月26日 */public class DeadLock1 { public static void main(String[] args) { S s = new S(); Thread b = new Thread(new ThreadB(s)); Thread a = new Thread(new ThreadA(s,b)); a.start(); b.start(); }}package thread.deadLock.lock1;/** * ThreadB类 *@author 陈浩翔 * * 2021年05月26日 */public class ThreadB implements Runnable{ private S s = null; public ThreadB(S s) { this.s = s; } @Override public void run() { System.out.println("线程B在等待锁s！"); synchronized (s) { System.out.println("线程B拿到锁s！"); s.a=100; System.out.println("线程B s.a = " + s.a); } }}package thread.deadLock.lock1;/** * ThreadA类 *@author 陈浩翔 * * 2021年05月26日 */public class ThreadA implements Runnable{ private S s = null; private Thread b = null; public ThreadA(S s,Thread b) { this.b = b; this.s = s; } @Override public void run() { System.out.println("线程A在等待锁s！"); synchronized (s) { System.out.println("线程A拿到锁s！"); try { //调用b线程的运行代码。 //但是此时的锁在a线程手里，b拿不到锁。 //所以出现了，b等待a给锁，a就拿着锁等待b运行，所以出现了死锁！ b.join(); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("s.a = " + s.a); } }}

运行结果只有一种情况，一定锁死！

第二种情况：

2)互相持有对方所需的资源(即每个线程都需要同时拿到多个资源才能继续执行，而多个线程都处于：各持有一部分，在等待另一部分。)package thread.deadLock.lock2;/** * 资源类1 *@author 陈浩翔 * * 2021年05月26日 */public class S1 { public int a =0;}package thread.deadLock.lock2;/** * 资源类2 *@author 陈浩翔 * * 2021年05月26日 */public class S2 { public int a =1;}package thread.deadLock.lock2;/** * *@author 陈浩翔 * * 2021年05月26日 */public class DeadLock2 { public static void main(String[] args) { //如果要解决这种多资源出现的死锁，可以把多个资源打包成一个综合资源， //把综合资源变成一个对象锁,哪个线程一拿到锁就有全部资源了 //在设计阶段就应该考虑到----把多线程中的每个线程所用的互斥资源图画出来 //--从图中看出哪些线程存在共享互斥资源，然后分析是否可能存在死锁 //这个死锁存在随机性！！！ S1 s1 = new S1(); S2 s2 = new S2(); Thread a = new Thread(new ThreadA(s1,s2)); Thread b = new Thread(new ThreadB(s1,s2)); a.start(); b.start(); }}package thread.deadLock.lock2;/** * ThreadA---a线程运行代码类 *@author 陈浩翔 * * 2021年05月26日 */public class ThreadA implements Runnable{ private S1 s1 = null; private S2 s2 = null; public ThreadA(S1 s1, S2 s2) { this.s1 = s1; this.s2 = s2; } @Override public void run() { System.out.println("线程a在等待锁s1!"); synchronized (s1) {//拿到了锁s1 System.out.println("s1.a=" + s1.a); System.out.println("线程a拿到了锁s1"); System.out.println("线程a在等待锁s2"); synchronized (s2) {//拿到锁s2 System.out.println("线程a拿到了锁s2"); System.out.println("s2.a=" + s2.a); }//释放锁s2 System.out.println("线程a释放了锁s2"); }//释放锁s1 }}package thread.deadLock.lock2;/** * ThreadB---b线程运行代码类 *@author 陈浩翔 * * 2021年05月26日 */public class ThreadB implements Runnable{ private S1 s1 = null; private S2 s2 = null; public ThreadB(S1 s1, S2 s2) { this.s1 = s1; this.s2 = s2; } @Override public void run() { System.out.println("线程b在等待锁s2!"); synchronized (s2) {//拿到了锁s2 System.out.println("s2.a=" + s2.a); System.out.println("线程b拿到了锁s2"); System.out.println("线程b在等待锁s1"); synchronized (s1) {//拿到锁s1 System.out.println("线程b拿到了锁s1"); System.out.println("s1.a=" + s1.a); }//释放锁s1 System.out.println("线程b释放了锁s1"); }//释放锁s2 }}

这个情况下的死锁会出现2中情况：：

第一种：没有死锁：

这种情况的出现是因为可能a线程或者b线程抢到了cpu资源，一次就全部运行完了，这样，就不会出现死锁！

第二种：出现了死锁：

假如a线程拿到了s1的锁，还没有拿到s2的锁，

这个时候s2的锁被b线程拿到了，b线程就开始等待s1锁，而s1锁在a线程手上，a线程就等s2锁啊，b线程就等s1锁，，，于是，出现了死锁！

大家可以看到，这个死锁的情况下，程序并没有停止运行的，那个程序运行的红方块标志还亮着呢！

前面那图没有出现死锁的情况下，程序运行一下就输出完了，红方块是暗的！

总结：

死锁的解决

(死锁并没有解决的方案，只能从源头上去避免！)

要从设计方面去解决避免，即在设计时就考虑不能出现死锁。

罗列出所有临界资源，画分布图，从图中观察其中的死锁情况，改变其中线程的(临界)资源的获取方式。

设计原则：尽量让程序中少出现临界资源。

wait/notify 和 sleep方法

wait和notify只能在它们被调用的实例的同步块内使用，而sleep()到处都可以用。

wait()和sleep()最大的区别：sleep()不释放对象锁，而wait()会释放，因此从效率方面考虑wait()方法更好。

同步设计的基本原则

◎ 同步块中(synchronized修饰)的代码越小越好！

◎ 同步块中不要写阻塞性代码(如，InputStream.read() )！

◎ 在持有锁的时候，不要对其它对象调用方法。(如果做到，可以消除最常见的死锁源头。)

同步概述

◎同步的原理：将需要同步的代码进行封装，并在该代码上加了一个锁。

◎同步的好处：解决多线程的安全问题。

◎同步的弊端：会降低性能。

◎同步的前提：必须要保证有多个线程且它们在同步中使用的是同一个锁。