java.单例类懒汉式线程安全问题

鄙渣渣最近在看多线程，在看线程安全问题的时候，不论是学习视频中强调，还是网上搜的单例类、同步、线程安全的面试题中，都有单例类懒汉式线程安全问题。然后又搜了搜，发现有大牛博客上面写了怎么处理懒汉式线程安全问题，却没有说明理由，所以渣渣我结合自己体会写一下。

先小小的介绍一下，单例类是什么

单例类是一种设计思想

简单的基本思想：私有化结构体，通过判断建立的实例是否为空来判断是否能创建对象。使获取对象的途径不是经过结构体，而是通过定义的get函数。

构建单例类的三个基本：

1.只能有一个实例

2.单例类本身必须要建立这个实例

3.要给其他其他对象提供这一实例

单例类有有两个主流格式，饿汉式和懒汉式，实例代码如下：

饿汉式：

class Single
{
private static final Single f = new Single();
private Single(){};
public static Single get()
{
return f;
}
}

public class Demo {
public static void main(String[] args) {
Single f =Single.get();  //因为饿汉式在一开始就建立的对象，所以这里只要通过get方法获取引用变量就可以了
}
}

懒汉式：

class Singleton
{
private Singleton(){}     //私有化结构体
private static Singleton single;   //建立一个变量缓存创建的实例
public static Singleton get()        //用来判断是否建立对象
{
if (single == null)
{
single =new Singleton();
}
return single;
}
}

public class person
{
public static void main(String[] args)
{
Singleton f = Singleton.get();    //获取对象不通过结构体，而是通过get方法
}
}

饿汉式因为在一开始就建立了一个静态对象，所以线程天生安全。

既然饿汉式这么简洁，还线程天生安全，为什么要弄懂懒汉式呢？

因为

面试考的

基本上都是懒汉式

懒汉式为什么线程不安全？

class Singleton
{
private Singleton(){}
private static Singleton single;
public static Singleton get()
{
//1.当有例如A、B、C等多个线程同时进入时
if (single == null)
{
//--》A
//--》B
//--》C
single =new Singleton();
//2.则会建立多次对象
}
return single;
}
}
public class person
{
public static void main(String[] args)
{
Singleton f = Singleton.get();
}
}

建立多次对象，这是单例类构造中不被允许的。所以存在线程安全问题。

线程安全用同步解决，但如果简单的同步，会使效率变低很多，ex：

class Single
{
private static  Single f = null;
private Single(){};
public static Single get()
{
//每一次线程进入，都要对是否持有锁进行判断，效率偏低
synchronized(Single.class)
{
if(f==null)
f = new Single();
}
return f;
}
}
public class Demo {
public static void main(String[] args) {
Single f =Single.get();
}
}

就如代码注释中所写，不论时间先后，每一个线程试图进入时，都要对是否持有锁进行判断，效率偏低。

PS。锁就是锁旗标，也有叫“监视器”的，在我看的视频教学中，讲师将其称之为锁，很形象，就这么叫了。具体请见我的另一片文章 java.关于线程同步 。

所以就有了双重判断的格式用来提高效率：

class Single
{
private static  Single f = null;
private Single(){};
//4.后续的C线程进入后
public static Single get()
{
//4.C线程将在这里被拦截，无法进入
//1.如果有A B两个线程同时进入了
if(f==null)
//2.--》A
// 2.--》B
synchronized(Single.class)
{
//3.只有一个线程能获取锁
//3.--》A
if(f==null)
//3.当A线程执行完之后，f就不为空了，当之后的B进入的时候，即使B持有锁，也不会进行对象的建立了
f = new Single();
}
return f;
}
}

public class Demo {
public static void main(String[] args) {
Single f =Single.get();
}
}

双重判定使第一个进入的线程执行完之后，两个if判断都将返还false，之后尝试进入的线程在if那一关就会停下，不必每个线程都要判断是否持有锁，在一定程度上提高的效率。

最后附加饿汉式线程安全的几个简单的问题

1.懒汉式和饿汉式的区别：懒汉式存在延迟加载

2.懒汉式的延迟加载有没有问题：有，如果多线程访问，会存在线程的安全问题

3.怎么解决：用同步解决，但用一些同步代码块和同步函数都稍微有些低效，用双重判定的形式，能在一定程度上解决低效问题。

4.加同步的时候，用的锁是哪一个：该类所属的字节码文件对象

可能写的不够形象精确。。。。但渣渣已经尽力了。如果有路过的大神发现哪个地方写的不对，还望指正。

以上。