Java，多线程，线程安全的懒汉式、死锁、ReentrantLock的使用以及一些知识点补充

news2025/1/16 17:42:59

关于线程安全地懒汉式有以下几种方式：

/**
 * 实现线程安全的懒汉式
 */
public class BankTest
{
    Bank b1 = null;
    Bank b2 = null;
    public static void main(String[] args)
    {
        BankTest bb = new BankTest();
        Thread t1 = new Thread(){
            @Override
            public void run()
            {
                bb.b1 = Bank.getInstance();
            }
        };
        Thread t2 = new Thread(){
            @Override
            public void run()
            {
                bb.b2 = Bank.getInstance();
            }
        };


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


        try
        {
            t1.join();
        } catch (InterruptedException e)
        {
            e.getStackTrace();
        }
        try
        {
            t2.join();
        } catch (InterruptedException e)
        {
            e.getStackTrace();
        }
        System.out.println(bb.b1);
        System.out.println(bb.b2);
        System.out.println(bb.b1 == bb.b2);
    }
}


//          方式一：同步方法
//class Bank
//{
//    private Bank(){};//私有化构造器
//    private static Bank instance = null;//私有的类变量
//    //实现线程安全的方式一
//    public static synchronized Bank getInstance()//此时的同步监视器为Bank.class
//    {
//        if(instance == null)//只有当instance是非空指针时，才会创建新的对象
//        {
//            try
//            {
//                Thread.sleep(100);
//            } catch (InterruptedException e)
//            {
//                e.getStackTrace();
//            }
//            instance = new Bank();
//        }
//        return instance;
//    }
//}


//         方式二：同步代码块
//class Bank
//{
//    private Bank(){};//私有化构造器
//    private static Bank instance = null;//私有的类变量
//    //实现线程安全的方式一
//    public static Bank getInstance()
//    {
//        synchronized (Bank.class)
//        {
//            if(instance == null)//只有当instance是非空指针时，才会创建新的对象
//            {
//                try
//                {
//                    Thread.sleep(100);
//                } catch (InterruptedException e)
//                {
//                    e.getStackTrace();
//                }
//                instance = new Bank();
//            }
//            return instance;
//        }
//    }
//}


//          方式三：加了一层if，相较于方式一和方式二效率更高
//为了避免指令重排,需要将instance声明为volatile。
class Bank
{
    private Bank(){};//私有化构造器
    //私有的类变量
    private static volatile Bank instance = null;
    //实现线程安全的方式一
    public static Bank getInstance()
    {
        if(instance == null)
        {
            synchronized (Bank.class)
            {
                if (instance == null)//只有当instance是非空指针时，才会创建新的对象
                {
                    try
                    {
                        Thread.sleep(100);
                    } catch (InterruptedException e)
                    {
                        e.getStackTrace();
                    }
                    instance = new Bank();
                }


            }
        }
        return instance;//让较后的线程可以更快地拿到instance对象。
    }
}

方式三中，如果没有volatile关键字，可能会出现指令重排，当对象还未完全创建，但是已经提前return了。后面的线程判断时，未完全创建的对象也被判断为非空，对象的创建就会失败。从jdk2开始，分配空间、初始化、调用构造器会在线程的工作存储区一次性完成，然后复制到主存储区。但是需要volatile关键字，避免指令重排。

所以，要在instance的声明处加上volatile关键字。

死锁：

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

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

诱发死锁的原因：

①互斥条件

②占用且等待

③不可抢夺（或不可抢占）

④循环等待（一直等待）

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

解决死锁：

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