请教请教多线程死锁怎么用，还是不太明白怎么用，有多大用？

死锁没什么用，但是你如果了解了发生死锁的前提，就会更好的的去避免发生死锁

多线程出现死锁，程序会一直等待执行不会终止。编程序时是要避免出现死锁的。之所以要学死锁就是要避免在程序中出现死锁。

多线程中，a线程在等待b线程持有的锁，b线程等待c线程持有的锁，…… 最后的线程在等待a线程持有的锁，这样死循环的相互等待而使线程都处于阻塞状态，无法使程序继续执行也无法 停止
出现死锁的原因是同步语句块使用了嵌套同步，不同层使用不同的锁
死锁不一定能看到现象，所以要了解死锁产生的原因，避免出现死锁

多线程死锁，是因为两个持有相同锁的线程同时互相访问，都需要对方的资源,但是双方又都是加有锁独占访问的，导致双方都一直等待对方资源，造成死锁。

lass Tick implements Runnable {       
        private int tick=1888;
        boolean flag =true;              
         Object obj = new Object();        
                   
          
        public void run()
        {   
                  
                if(flag )
                        {  
                                while(true)
                                {
                                        synchronized(obj)   //锁是obj
                                        {       
                                                        show();                                                               
                                                               
                                        }       
                        }
                }
                        else
                                while(true)
                                show();
               
        }
public synchronized void show()
        {   
                        synchronized(obj)  //锁是this
                        {       
                                if(tick>0)
                                        {
                                        try {
                                                        Thread.sleep(10);
                                                        }
                                        catch (Exception e) {}               
                                                               
                                                        System.out.println(Thread.currentThread().getName()+"----"+tick--);                                                                               
                                                }                       
                                        }       
                }
}               
                       
       


class DeadLock
{

public static void main(String[] args) {       
                Tick t = new Tick();               
        Thread t1 = new Thread(t);               
        Thread t2 = new Thread(t);       
        t1.start();
        try {
                Thread.sleep(10);
                }
        catch (Exception e) {}               

        t.flag = false;       
        t2.start();
        }
}
在这样的多线程嵌套中就会容易出现死锁，一个进程因请求资源而阻塞时，对已获得的资源保持不放。所以造成死锁，在编写程序时应避免。

对资源采用同步，还有银行家算法
银行家算法是一种最有代表性的避免死锁的算法。在避免死锁方法中允许进程动态地申请资源，但系  银行家算法
统在进行资源分配之前，应先计算此次分配资源的安全性，若分配不会导致系统进入不安全状态，则分配，否则等待。为实现银行家算法，系统必须设置若干数据结构。 　　要解释银行家算法，必须先解释操作系统安全状态和不安全状态。 　　安全序列是指一个进程序列{P1，…，Pn}是安全的，如果对于每一个进程Pi(1≤i≤n），它以后尚需要的资源量不超过系统当前剩余资源量与所有进程Pj (j < i )当前占有资源量之和。
安全状态
　　如果存在一个由系统中所有进程构成的安全序列P1，…，Pn，则系统处于安全状态。安全状态一定是没有死锁发生。
不安全状态
　　不存在一个安全序列。不安全状态不一定导致死锁。

所谓死锁: 是指两个或两个以上的进程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。   
那么为什么会产生死锁呢？
1.因为系统资源不足。
2.进程运行推进的顺序不合适。   
3.资源分配不当。            
学过操作系统的朋友都知道：产生死锁的条件有四个：
1.互斥条件：所谓互斥就是进程在某一时间内独占资源。
2.请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。
3.不剥夺条件:进程已获得资源，在末使用完之前，不能强行剥夺。
4.循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。

例如：      
死锁是因为多线程访问共享资源，由于访问的顺序不当所造成的，通常是一个线程锁定了一个资源A，而又想去锁定资源B；在另一个线程中，锁定了资源B，而又想去锁定资源A以完成自身的操作，两个线程都想得到对方的资源，而不愿释放自己的资源，造成两个线程都在等待，而无法执行的情况。
分析死锁产生的原因不难看出是由访问共享资源顺序不当所造成的，下面写一个造成线程死锁的例子，希望能对大家理解多线程死锁问题有进一步的理解！如果有人需要编写多线程的系统，当操作共享资源时一定要特别的小心，以防出现死锁的情况！

1. package com.oyqh;
   
2. 
   
3. public class RunnableTest implements Runnable {
   
4.         private int flag = 1;
   
5.         private Object obj1 = new Object(), obj2 = new Object();
   
6. 
   
7.         public void run() {
   
8.                 System.out.println("flag=" + flag);
   
9.                 if (flag == 1) {
   
10.                         synchronized (obj1) {
    
11.                                 System.out.println("我已经锁定obj1，休息0.5秒后锁定obj2去！");
    
12.                                 try {
    
13.                                         Thread.sleep(500);
    
14.                                 } catch (InterruptedException e) {
    
15.                                         e.printStackTrace();
    
16.                                 }
    
17.                                 synchronized (obj2) {
    
18.                                         System.out.println("1");
    
19.                                 }
    
20.                         }
    
21.                 }
    
22.                 if (flag == 0) {
    
23.                         synchronized (obj2) {
    
24.                                 System.out.println("我已经锁定obj2，休息0.5秒后锁定obj1去！");
    
25.                                 try {
    
26.                                         Thread.sleep(500);
    
27.                                 } catch (InterruptedException e) {
    
28.                                         e.printStackTrace();
    
29.                                 }
    
30.                                 synchronized (obj1) {
    
31.                                         System.out.println("0");
    
32.                                 }
    
33.                         }
    
34.                 }
    
35.         }
    
36. 
    
37.         public static void main(String[] args) {
    
38.                 RunnableTest run01 = new RunnableTest();
    
39.                 RunnableTest run02 = new RunnableTest();
    
40.                 run01.flag = 1;
    
41.                 run02.flag = 0;
    
42.                 Thread thread01 = new Thread(run01);
    
43.                 Thread thread02 = new Thread(run02);
    
44.                 System.out.println("线程开始喽！");
    
45.                 thread01.start();
    
46.                 thread02.start();
    
47.         }
    
48. }

复制代码

这样就产生了死锁，这是我们过多的使用同步而产生的。我们在java中使用synchonized的时候要考虑这个问题，如何解决死锁，大家可以从死锁的四个条件去解决，只要破坏了一个必要条件，那么我们的死锁就解决了。