线程安全的懒汉式_死锁_ReentrantLock的使用

解决单例模式中的懒汉式的线程安全问题

• 饿汉式：不存在线程安全问题。

• 懒汉式：存在线程安全问题。（需要使用同步机制来处理）

  public class BankTest {
  
      static Bank b1 = null;
      static Bank b2 = null;
  
      public static void main(String[] args) {
  
          new Thread(new Runnable() {
              @Override
              public void run() {
                  b1 = Bank.getInstance();
              }
          }).start();
          new Thread(new Runnable() {
              @Override
              public void run() {
                  b2 = Bank.getInstance();
              }
          }).start();
          try {
              Thread.sleep(1000);
          } catch (InterruptedException e) {
              e.printStackTrace();
          }
          System.out.println(b1);
          System.out.println(b2);
          System.out.println(b1 == b2);
      }
  }
  
  class Bank {
  
      private Bank() {
      }
  
      private static Bank instance = null;
  
      public static Bank getInstance() {
          synchronized (Bank.class) {
              if (instance == null) {
                  try {
                      Thread.sleep(10);
                  } catch (InterruptedException e) {
                      e.printStackTrace();
                  }
                  instance = new Bank();
              }
          }
          return instance;
      }
  }
  

线程的同步机制带来的问题：死锁

public class DeadLock {

    public static void main(String[] args) {
        StringBuilder s1 = new StringBuilder();
        StringBuilder s2 = new StringBuilder();

        new Thread() {
            @Override
            public void run() {
                synchronized (s1) {
                    s1.append("a");
                    s2.append("1");

                    try {
                        Thread.sleep(0);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    synchronized (s2) {
                        s1.append("b");
                        s2.append("2");

                        System.out.println(s1);
                        System.out.println(s2);

                    }
                }
            }
        }.start();

        new Thread() {
            @Override
            public void run() {
                synchronized (s2) {
                    s1.append("c");
                    s2.append("3");

                    synchronized (s1) {
                        s1.append("d");
                        s2.append("4");

                        System.out.println(s1);
                        System.out.println(s2);

                    }
                }
            }
        }.start();
    }
}

1. 如何看待死锁？

   不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁。我们编写程序时，要避免出现死锁。

2. 诱发死锁的原因？

   • 互斥条件
   • 占用且等待
   • 不可抢夺（或不可抢占）
   • 循环等待

   以上4个条件同时出现就会触发死锁。

3. 如何避免死锁？

   • 针对条件1：互斥条件基本上无法破坏，因为线程需要通过互斥解决安全问题。
   • 针对条件2：可以考虑一次性申请所有所需的资源，这样就不存在等待的问题。
   • 针对条件3：占用部分资源的线程在进一步申请其他资源时，如果申请不到，就主动释放已经占用的资源。
   • 针对条件4：可以将资源改为线性顺序，申请资源时，先申请序号较小的，这样避免循环等待问题。

除了使用synchronized同步机制处理线程安全问题之外，还可以使用jdk5.0提供的lock锁的方式

步骤

1. 创建Lock的是实例，需要确保多个线程共用同一个Lock实例，需要考虑将此对象声明为static final
2. 执行lock()，锁定对共享资源的调用
3. unlock()的调用，释放对共享数据的锁定

private final ReentrantLock lock =new ReentrantLock();

try{
    lock.lock();
    //代码
}finally{
    lock.unlock();
}

面试题

synchronized同步的方式与Lock的对比？

• synchronized不管是同步代码块还是同步方法，都需要再结束一对{}之后，释放对同步监视器的调用。
• Lock是通过两个方法控制需要被同步的代码，更灵活一些。
• Lock作为接口，提供了多种实现类，适合更多更复杂的场景，效率更高。