死锁

• 多个线程各自占有一些共享资源，并且互相等到其他线程占有的资源才能运行，而导致两个或者多个线程都在等待对方释放资源，都停止执行的情形称之为死锁

• 某一个同步块同时拥有两个以上对象的锁时，就可能会发生死锁的问题

• 产生死锁的四个必要条件：

  1. 互斥条件：一个资源每次只能被一个进程使用
  2. 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放
  3. 不剥夺条件：进程已获得的资源，在未使用完之前，不能强行剥夺
  4. 循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系

  //死锁：多个线程互相抱着对方需要的资源，然后形成僵持
  public class DeadLock{
      public static void main(String[] args){
          Makeup makeup1 = new Makeup(0,"灰姑娘");
          Makeup makeup2 = new Makeup(1,"白雪公主");
          
          makeup1.start();
          makeup2.start();
      }
  }
  
  //口红
  class Lipstick{
      
  }
  
  //镜子
  class Mirror{
      
  }
  
  //化妆
  class Makeup extends Thread{
      
      //需要的资源只有一份资源，用static来保证只有一份
      static Lipstick lipstick = new Lipstick();
      static Mirror mirror = new Mirror();
      
      int choice; //选择
      String name; //使用化妆品的人
      
      public Makeup (int choice, String name){
          this.choice = choice;
          this.name = name;
      }
      
      @Override
      public void run(){
          //化妆
          try{
          	 makeup();
          }catch(InterruptedException e){
               e.printStackTrace();
          }
  
      }
      
      //化妆，互相持有对方的锁
      private void makeup() throws InterruptedException{
          if(choice == 0){
              synchronized(lipstick){ //获得口红的锁
                  System.out.println(this.name + "获得口红的锁");
               	Thread.sleep(1000);
               
               	synchronized(mirror){ //一秒钟后获得镜子的锁
                   	System.out.println(this.name + "获得镜子的锁");
               	}
           	}
       	}else{
              synchronized(mirror){ //获得镜子的锁
                  System.out.println(this.name + "获得镜子的锁");
               	Thread.sleep(2000);
               
               	synchronized(lipstick){ //一秒钟后获得口红的锁
                   	System.out.println(this.name + "获得口红的锁");
               	}
           	}
          }   
      }
  }
  

  解决死锁

  ...
  private void makeup() throws InterruptedException{
      if(choice == 0){
          synchronized(lipstick){ //获得口红的锁
              System.out.println(this.name + "获得口红的锁");
              Thread.sleep(1000);
          }
          synchronized(mirror){ //一秒钟后获得镜子的锁
              System.out.println(this.name + "获得镜子的锁");
          }
      }else{
          synchronized(mirror){ //获得镜子的锁
              System.out.println(this.name + "获得镜子的锁");
              Thread.sleep(2000);
          }
          synchronized(lipstick){ //一秒钟后获得口红的锁
              System.out.println(this.name + "获得口红的锁");
          }
      }   
  }
  ...
  

• Lock（锁）

  • 从jdk5.0开始，java提供了更强大的线程同步机制——通过显示定义对同步锁对象来实现同步。同步锁使用Lock对象充当
  • java.util.concurrent.locks.Lock接口是控制多个线程对公共资源进行访问的工具。锁提供了对公共资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象
  • ReentrantLock（可重入锁）类实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是RenntrantLock，可以显式加锁、释放锁

  //测试Lock锁
  public class TestLock{
      public static void main(String[] args){
          TestLock testLock = new TestLock();
          
          new Thread(testLock).start();
          new Thread(testLock).start();
          new Thread(testLock).start();
      }
  }
  
  class TestLock implements Runnable{
      int ticketNums = 10;
      
      //定义lock锁
      private final ReentrantLock lock = new ReentrantLock();
      
      @Override
      public void run(){
          while(true){
              try{
                  lock.lock(); //加锁
              	if(ticketNums > 0){
                      try{
                          Thread.sleep(1000);
                      }catch(InterruptedException e){
                          e.printStackTrace();
                      }
                  	System.out.println(ticketNums--);
              	}else{
                  	break;
              	}
              }finally{
                  lock.unlock(); //解锁
              }
              
          }
      }
  }
  

• synchronized和Lock对比

  • Lock是显式锁（手动开启和关闭锁）；synchronized是隐式锁，除了作用域自动释放
  • Lock只有代码块锁，synchronized有代码块和方法锁
  • 使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的拓展性（提供更多的子类）
  • 优先使用顺序：Lock > 同步代码块（已经进入了方法体，分配了相应资源） > 同步方法（在方法体之外）