今日看老毕视频讲多线程的时候提到了这么一个问题，就是关于同步的，同步有两种表现形式，1同步代码块。2同步函数。
说道同步函数就想到这么个问题，同步函数的死锁是什么呢？怎么用代码来验证呢？

  死锁就是共享资源被占用，线程会一直等待，或者是两个线程相互想使用对方的资源，在没有得到对方资源情况下，又不释放自己的资源，这时两个线程都不往下走，也会造成死锁。

1. public class Test {
   
2.         public static void main(String[] args) {
   
3.                 A a1 = new A();
   
4.                 A a2 = new A();
   
5.                 Thread t1 = new Thread1(a1, a2);
   
6.                 Thread t2 = new Thread1(a2, a1);
   
7.                 t1.start();
   
8.                 t2.start();
   
9.         }
   
10. }
    
11. class Thread1 extends Thread {
    
12.         private A from;
    
13.         private A to;
    
14.        
    
15.         public Thread1(A from, A to) {
    
16.                 this.from = from;
    
17.                 this.to = to;
    
18.         }
    
19.         public void run() {
    
20.                 from.fun1(to);
    
21.         }
    
22. }
    
23. class A {
    
24.         public synchronized void fun1(A a) {
    
25.                 System.out.println(Thread.currentThread().getName() + ": fun1()...");
    
26.                 try {
    
27.                         Thread.sleep(1000);
    
28.                 } catch(InterruptedException e) {}
    
29.         a.fun2();
    
30.         }
    
31.         public synchronized void fun2() {}
    
32. }
    

复制代码

1、死锁和所有进程都在等待而不能执行是两回事
2、死锁是，你等我释放资源，我也在等你释放资源，这就是死锁
3、所有进程都在等待不是死锁，你可以认为的调用所有进程的wait()方法，可以使他们都在等待，而都不执行。
4、代码实现我的水平，还写不出来

死锁分析：
        现在有两个线程，都能读写相同的共享数据。这样就带来了新的麻烦：由于数据共享会带来同步问题，进而会导致死锁的产生。
        众所周知，多线程带来的好处是显而易见的，特别是性能的改善；但这个是以牺牲可靠性为代价的，主要是因为多线程共享数据有可能会产生线程死锁。举个简单的例子：第一个线程等待第二个线程释放资源，而同时第二个线程又在等待第 一个线程释放资源。双方互不相让，死锁发生，程序不能正常运行。人的现实生活又何尝不是这样，很多时候都出现对峙的状态。要是每个人都这样想就好了：只要不是涉及原则问题和自己的核心利益，退一步海阔天空。当然了，说起来容易做起来难，这是理想情况，只能往这方面努力了。
        导致死锁的根源在于不适当地运用“synchronized”同步关键词来管理线程对特定对象的访问而引起的。“synchronized”关键词的作用是，确保在某 个时刻只有一个线程被允许执行特定的同步代码块，因此，被允许执行的线程首先必须拥有对该变量或对象的排他性访问权。Java中每个对象都有一把锁与之对应。当线程访问对象时，线程会给对象加锁（监视器），而这 个锁导致其它也想访问同一对象的线程被阻塞，直至第一个线程释放它加在对象上的锁。

死锁的经典案例：
有一群科学家应邀来我家吃饭，但是我只给每个人一根筷子，当他们坐在餐桌上时，
谁也没有动筷子，他们就处于等待状态。只有当某个人给他一根筷子时，他才会执行吃的动作。

死锁实例代码

1. public class Demo {
   
2.         public static void main(String[] args) {
   
3.                 Thread t1 = new Thread1();
   
4.                 Thread t2 = new Thread2();
   
5.                 t1.start();
   
6.                 t2.start();
   
7. }
   
8. class Thread1 extends Thread{
   
9.         public void run(){
   
10.                 synchronized(Thread1.class){
    
11.                         try{
    
12.                                 System.out.println("Thread1");
    
13.                                 Thread.sleep(100);
    
14.                         }catch(InterruptedException e){}
    
15.                         synchronized(Thread2.class){
    
16.                               
    
17.                         }
    
18.                 }
    
19.         }
    
20. }
    
21. class Thread2 extends Thread{
    
22.         public void run(){
    
23.                 synchronized(Thread2.class){
    
24.                         try{
    
25.                                 System.out.println("Thread2");
    
26.                                 Thread.sleep(100);
    
27.                         }catch(InterruptedException e){}
    
28.                         synchronized(Thread1.class){}
    
29.                 }
    
30.         }
    
31. }

复制代码

简言之 同步中嵌套同步，而且不同锁。