典型的顺序死锁

package com.thread.deadlock;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
 * 死锁的出现分2中情况：
 * 1.锁顺序死锁
 * 2.资源死锁
 * 资源死锁的典型例子是：线程饥饿死锁和数据库连接池的饥饿死锁
 * 
 * 本例演示的是锁顺序死锁
 * 当一个线程永远占用一个锁，而其他线程尝试去获得这个锁，那么它们将永远被阻塞。
 * 当线程A占用锁L时，想要获得锁M，但是同时，线程B持有锁M，并尝试获得L，两个线程将永远等待下去。
 * 这种情况是死锁最简单的形式（或称致命的拥抱）。
 * 发生在多个线程因为环路的锁依赖关系而永远等待的情况下。
 * 
 * 
 * 怎么避免出现锁顺序死锁？
 * 如果所有线程以通用的固定秩序获得锁，程序就不会出现锁顺序死锁的问题了。
 * 
 * @author hadoop
 *
 */
public class LeftRightDeadlock {
   private final Object left = new Object();
   private final Object right = new Object();
   public void leftToRight(){
       synchronized(left){
            synchronized(right){
              try {
              Thread.currentThread().sleep(20);//延迟执行时间，提高死锁概率
            } catch (InterruptedException e) {
              // TODO Auto-generated catch block
              e.printStackTrace();
            }
               System.out.println(Thread.currentThread().getName() + "执行从左到右顺序的操作");
            }
       }
   }
   public void  RightToLeft(){
     synchronized(right){
        synchronized(left){
          try {
        Thread.currentThread().sleep(30);
      } catch (InterruptedException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
      }
           System.out.println(Thread.currentThread().getName() +"执行从右到左顺序的操作");
        }
    }
   }
   public static void main(String[] args) {
         ExecutorService mExecutor = Executors.newCachedThreadPool();
         final LeftRightDeadlock lrlock = new LeftRightDeadlock();
         for (int i = 0; i < 1000; i++) {
           mExecutor.execute(new Runnable() {
          @Override
          public void run() {
            lrlock.RightToLeft();
          }
        });
      }
         for (int i = 0; i < 1000; i++) {
           mExecutor.execute(new Runnable() {
          @Override
          public void run() {
            lrlock.leftToRight();
          }
        });
      } 
   }
}