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

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

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

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

public class BankTest {
    static Bank b1 = null;
    static Bank b2 = null;
    public static void main(String[] args) {
        Thread t1 = new Thread(){
            @Override
            public void run() {
                b1 = Bank.getInstance();
            }
        };
        Thread t2 = new Thread(){
            @Override
            public void run() {
                b2 = Bank.getInstance();
            }
        };

        t1.start();
        t2.start();

        try {
            t1.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        try {
            t2.join();
        } 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;
    //实现线程安全的方式1
//    public static synchronized Bank getInstance(){//同步监视器，默认为Bank.class
//        if (instance == null){
//            try {
//                Thread.sleep(100);
//            } catch (InterruptedException e) {
//                e.printStackTrace();
//            }
//            instance = new Bank();
//        }
//        return instance;
//    }
    //实现线程安全的方式2
//    public static  Bank getInstance(){
//        synchronized (Bank.class) {
//            if (instance == null){
//                try {
//                    Thread.sleep(100);
//                } catch (InterruptedException e) {
//                    e.printStackTrace();
//                }
//                instance = new Bank();
//            }
//        }
//        return instance;
//    }

    //实现线程安全的方式3  效率更高
    public static  Bank getInstance(){
        if (instance == null) {
            synchronized (Bank.class) {
                if (instance == null) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    instance = new Bank();
                }
            }
        }
        return instance;
    }
}

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

1.如何看待死锁？

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

2.诱发死锁的原因？

互斥条件
占用且等待
不可抢夺
循环等待

以上四个条件，同时出现就会出发死锁。

3.如何避免死锁？

死锁一旦出现，基本很难人为干预，只能尽量规避。可以考虑打破上面的诱发条件。

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

 Lock锁

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

1.步骤

步骤1.创建Lock实例，确保多个线程共用同一个lock实例，声明为static

private static final ReentrantLock lock = new ReentrantLock();

步骤2.执行lock方法，锁定对共享资源的调用

try {
                //2.执行lock方法，锁定对共享资源的调用
                lock.lock();

                if (ticket > 0){
                    try {
                        Thread.sleep(10);
                    }catch (InterruptedException e){
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "售票，票号：" + ticket);
                    ticket--;
                }else {
                    break;
                }
            } 

步骤3.unlock的调用，释放对共享数据的锁定

                lock.unlock();

2.面试题

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

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