多线程-线程安全的懒汉式_死锁-ReentrantLock的使用

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

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

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

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

package thread.demo04_threadsafemore.singleton;

//实现线程安全的懒汉式

import oop.demo07.B;

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();

        //这一段t1/t2.join(),为了让分线程先执行，因为这还是在主线程里面
        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 volatile Bank instance = null;


    //实现线程安全的方式1：
//    public static synchronized Bank getInstance(){  //同步监视器，默认为Book.class,类就加载一次，是唯一的
//        if (instance == null){
//
//            try {
//                Thread.sleep(100);
//            } catch (InterruptedException e) {
//                e.printStackTrace();
//            }
//
//            instance = new Bank();
//        }
//        return instance;
//    }

    //实现线程安全的方式2：
//    public static Bank getInstance(){  //同步监视器，默认为Book.class,类就加载一次，是唯一的
//        synchronized(Bank.class){
//        if (instance == null){
//
//            try {
//                Thread.sleep(100);
//            } catch (InterruptedException e) {
//                e.printStackTrace();
//            }
//
//            instance = new Bank();
//        }
//        return instance;
//    }
//        }

    //实现线程安全的方式3：相较于方式1和方式2来讲，效率更高。为了避免出现指令重排，需要将instance声明为volatile
    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;
    }


}

单例模式饿汉式和懒汉式区别

死锁

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

【小故事】
面试官：你能解释清楚什么是死锁，我就录取你！
面试者：你录取我，我就告诉你什么是死锁！

……
恭喜你，面试通过了

一旦出现死锁，整个程序既不会发生异常，也不会给出任何提示，只是所有线程处于阻塞状态，无法继续。

举例：

package thread.demo04_threadsafemore.deadlock;

public class DeadLockTest {
    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(100);
                    } 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");

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

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

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

                }
            }


        }.start();

    }
}

诱发死锁的原因：

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

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

死锁

解决死锁：

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

针对条件1：互斥条件基本上无法被破坏。因为线程需要通过互斥解决安全问题。

针对条件2：可以考虑一次性申请所有所需的资源，这样就不存在等待的问题。

针对条件3：占用部分资源的线程在进一步申请其他资源时，如果申请不到，就主动释放掉已经占用的资源。

针对条件4：可以将资源改为线性顺序。申请资源时，先申请序号较小的，这样避免循环等待问题。

ReentrantLock（可重入锁）的使用

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

1. 步骤：
    （1）创建Lock的实例，需要确保多个线程共用同一个Lock实例！需要考虑将此对象声明为static final。
    （2）执行lock方法，锁定对共享资源的调用。
    （3）unlock()的调用，释放对共享数据的锁定。
    
	static final ReentrantLock lock = new ReentrantLock();	
	l.lock(); 
	try { 
		//需要被同步的代码（操作共享数据的代码）
    } finally { 
        l.unlock(); 
    } 


2. 面试题：
synchronized同步的方式 与Lock的对比？

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

举例：

package thread.demo04_threadsafemore.lock;

//使用继承Thread类的方式，实现卖票。

import java.util.concurrent.locks.ReentrantLock;

public class LockTest {
    public static void main(String[] args) {

        SaleTicket1 s1 = new SaleTicket1("窗口1");
        SaleTicket1 s2 = new SaleTicket1("窗口2");
        SaleTicket1 s3 = new SaleTicket1("窗口3");

        s1.start();
        s2.start();
        s3.start();

    }
}


class SaleTicket1 extends Thread{

    public SaleTicket1() {
    }

    public SaleTicket1(String name) {
        super(name);
    }

    static int ticket = 100;//没有static直接300张票，每个窗口都卖1——100
    //一个对象一份的是实例变量。
    //所有对象一份的是静态变量。

    //1. 创建Lock的实例，需要确保多个线程共用同一个Lock实例！需要考虑将此对象声明为static final。
    private static final ReentrantLock lock = new ReentrantLock();//几个线程共用同一个lock，就用static,同上

    @Override
    public void run() {
        while (true){

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

                if (ticket > 0) {    //这一块就是需要被同步的代码（操作共享数据的代码），前面和后面用lock.lock(); 和lock.unlock();

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

                    System.out.println(Thread.currentThread().getName() + "票号为： " + ticket);
                    ticket--;
                } else {
                    break;
                }
            }finally {
                //3. unlock()的调用，释放对共享数据的锁定。
                lock.unlock();//为了能够解锁，就要确保他必须执行，可以用try{}finally{},如果没有，就不会停止
            }

        }
    }
}

ReentrantLock的基本使用&常用方法

ReentrantLock详解