JAVA最直观的死锁代码

package com.sunle.thread;

import java.util.ArrayList;

import com.sunle.object;
/**
 * 死锁：
 * 就是两个同时在运行的线程，他们在拥有自己的对象同时，又要互相访问资源。
 * 这时同步机制就发挥了作用，导致它们都开始等待对方先执行完，而双方都要做的
 * 却是访问对方锁定的资源，这样就进入了线程死胡同。
 *
 *
 * 1.利用多线程在同步关键字synchronized()锁定容器ArrayList对象，
 * 在进行增加和移除时出现的死锁问题。
 *
 * 2.针对问题1，用代码将它问题结果最直观的展现出来。
 *
 * 3.通过结果显示得出结论：当多个同步锁同时锁住一个对象的情况下，
 * 会出现
 * @author 孙乐
 *
 */
public class SynDeadLockT {
 public static void main(String[] args){
 ArrayList arr1;
 ArrayList arr2;
 arr1=new ArrayList<>();
 arr2=new ArrayList<>();

 Test t=new Test();
 t.setArrA(arr1);
 t.setArrB(arr2);
 
 Thread th1=new Thread(t,"--th1--");
 Thread th2=new Thread(t,"--th2--");
 th1.start();
 th2.start();
 
 }

}
class Test implements Runnable{
 private ArrayList arrA;
 private ArrayList arrB;
 private String str1="--th1--";
 private String str2="--th2--";
 int j=0;
 public ArrayList getArrA() {
  return arrA;
 }

 public void setArrA(ArrayList arrA) {
  this.arrA = arrA;
 }

 public ArrayList getArrB() {
  return arrB;
 }

 public void setArrB(ArrayList arrB) {
  this.arrB = arrB;
 }

 
 public void run(){
  arrAdd();
 
  arrDel();
  
 }
 
 //ArrayList增加数据方法，利用同步锁，锁住了操作对象的代码块
 private void arrAdd(){
  synchronized (arrA) {
  //1t,2t
   System.out.println(str1.equals(Thread.currentThread().getName()));
   System.out.println(str2.equals(Thread.currentThread().getName()));
   
   //arrB添加数据代码块，根据先后进入的线程，对容器对象进行添加数据的控制。
   for(int i=0;i<5;i++){
    if(j==5&&j<6){
     /*如果打印的是1表示已经new了一个新的容器对象，并且容器里面没有数据。
      *  并且CPU已经执行完了前面的线程，释放了之前地址，JVM回收了之前的收对象*/
     
     /*1.若打印的是地址，并且和下面del方法出现的是同一个地址，
      *  那么证明CPU尚未执行完前线程一，只是cpu分配给线程一的
      *  时间片段已经用完,线程一的状态是等待cpu再次运行时间片，
      *  这时线程二开始了它的执行。
      * 
      * 2.这时线程一和线程二都拥有调度arrA和arrB的权限，只是
      * 这时的线程一已经执行到删除方法在等CPU，线程一锁住的对象arrB里还含有
      * 另一个同步对象arrA的锁，正好线程二正在调度的是arrA的同步锁，
      * 而线程二里也有arrB的同步锁
      *
      * 3.接下来当线程二执行将要调度arrB时，发现线程一还未执行完arrB，那么
      * 线程二就开始等待线程一执行完，
      * 接着线程一便开始执行，但是当它执行到arrA时，又发现线程二还未
      * 执行完arrA，这时线程一也开始了等待，两个线程就开始了漫长的互相等待*/
     
     System.out.println("add方法监听A的地址1："+arrA.hashCode()+Thread.currentThread().getName());
    }
    arrA.add(Thread.currentThread().getName());
    if(str1.equals(Thread.currentThread().getName())&&arrA.size()>5){
     
    System.out.println(arrA.get(arrA.size()-i-1)+"添加方法A");
    }else if(str2.equals(Thread.currentThread().getName())&&arrA.size()>5){
     System.out.println(arrA.get(arrA.size()-i-1)+"添加方法A");
    }else{
     if(j==5){
      //如果不是同一个对象，这里将打印新对象的地址，程序就不会死锁。
      System.out.println("Add方法监听A的地址2："+arrA.hashCode()+Thread.currentThread().getName());
     }
     System.out.println(arrA.get(i)+"添加方法A");
     
    }
    j++;
   }
   System.out.println(arrA.size()+"容器长度---J="+j);
   
   
   synchronized (arrB) {
    //arrB添加数据，和arrA添加数据是一个模型
    for(int i=0;i<5;i++){
     arrB.add(Thread.currentThread().getName());
     if(str1.equals(Thread.currentThread().getName())&&arrB.size()>5){
      
     System.out.println(arrB.get(arrB.size()-i-1)+"添加方法B");
     }else if(str2.equals(Thread.currentThread().getName())&&arrB.size()>5){
      System.out.println(arrB.get(arrB.size()-i-1)+"添加方法B");
     }else{
      System.out.println(arrB.get(i)+"添加方法B");
     }
    } 
    
    
   }

   }

 

 }
 //ArrayList移除数据方法，利用同步锁，锁住了操作对象的代码块
 public void arrDel(){

   synchronized(arrB){
    /*监听容器arrA在上一个方法增加完数据之后，在本移除方法里即将执行synchronied代码块
     * 之前打印的容器arrA的地址，它打印的是按CPU先后顺序执行的线程。-----下面注释提示----*/
    System.out.println("Del方法监听A的地址："+arrA.hashCode()+Thread.currentThread().getName());
    
    for(int i=0;arrB.size()>0;i++){
     
     System.out.println(arrB.get(arrB.size()-1)+Thread.currentThread().getName()+"删除B");
     arrB.remove(arrB.size()-1);
     try {
      Thread.sleep(500);
     } catch (InterruptedException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
     }
     
     
    }
    /*-------------上一个注释，指的是这里-----------为直观展示---------*/
    synchronized(arrA){
     for(int i=0;arrA.size()>0;i++){
      System.out.println(arrA.get(arrA.size()-1)+Thread.currentThread().getName()+"删除A");
      arrA.remove(arrA.size()-1);
      

     }
    
   }
  }
 }
 
 
}