推荐学习
- 给力!啃烂这套“核心知识”+“高级面试”,成功定级腾讯JavaT4
举个通俗的例子:我们电脑桌面上的一些软件快捷方式,我们可以创建多个这样的快捷方式,但是它们都是同一个,也就是说我们运行软件只有一个,其他地方只是引用这一个实例。
好了,有了例子打底后,我们来看看通常情况下new实例化会创建新的一个对象,那么同理,new多个时也会创建多个新的对象。打印它的hashCode(相等的对象必须有相等的散列码即hashCode),会发现下面的hashCode不相同。
![5bafd1084b7349b123867a747b938821.png](https://i-blog.csdnimg.cn/blog_migrate/4034e9a398fc5b24421577af2e5cc840.jpeg)
代码实例
class Singleton1{ Singleton1(){}}public class demo1 { public static void main(String[] args) { System.out.println(new Singleton1().hashCode()); System.out.println(new Singleton1().hashCode()); }}
运行结果
![9e3cebdf8b9ac0d2ca54bda18cda7293.png](https://i-blog.csdnimg.cn/blog_migrate/a61aeb59da56b354747a27e32110ba31.jpeg)
接下来我们来解决一下上面出现的问题,实现单例模式,单例模式又分为两种,一种是比较简单的饿汉式和问题比较多的懒汉式。
饿汉式
(饿汉式顾名思义,很冲动,一上来就开干)
可以看到代码的一个关键点:用private声明了构造方法,这样做其他类就不能直接通过new实例化了,我们知道一旦用private封装,就需要用get方式获取(搞这么多事情,其实就是为了由该类创建自己唯一的一个对象,然后不管后面多少类需要用到它,都杜绝了用new开辟新的实例浪费内存空间,通通都得用它这个唯一的,通过它的类然后调用get方法获取,这样保证全局的唯一性)
class Singleton2{ private static final Singleton2 singleton = new Singleton2(); private Singleton2(){} public static Singleton2 getSingleton(){ return singleton; }}
测试(可以看到相同的HashCode)
public class demo2 { public static void main(String[] args) { System.out.println( Singleton2.getSingleton().hashCode()); System.out.println( Singleton2.getSingleton().hashCode()); }}
运行结果
![a4470a7fdf586368a0290e16feefbece.png](https://i-blog.csdnimg.cn/blog_migrate/8d7d47fcb4871cd54b02d784b1ee11f2.jpeg)
上面的饿汉式实现了我们的单例模式,多线程下它是安全的,但是可以发现不管你有没有用到它,它都会一上来就建好给你,(类加载时就初始化)这样就会浪费了内存空间。
懒汉式
(懒汉式正好和饿汉式相反,没有饿汉式的冲动,有点懒,问题也多)
我们可以比较着来学,看懒汉式和饿汉式的它们的相同点和不同点,先看相同点:不管是懒汉式和饿汉式都有一个关键的代码是一样的,就是:私有化构造方法(这里你还问为什么的话,看上面饿汉式那里有解释),不同点是:没有一上来就new,而是在get方法里多了一个判断,如果还没实例化那么就实例化一个,如果实例化了,返回这个实例化好的。
详细看代码示例
class Singleton{ private Singleton(){} private static Singleton instance; public static Singleton getInstance(){ if(instance == null){ instance = new Singleton(); } return instance; }}public class demo3 { public static void main(String[] args) { System.out.println(Singleton.getInstance().hashCode()); System.out.println(Singleton.getInstance().hashCode()); }}
运行结果
![428350d536ccc253c100d96a4bd6d859.png](https://i-blog.csdnimg.cn/blog_migrate/fa3e84b98d4978e423af45ab18305917.jpeg)
可以看到现在懒汉式实现了单例模式,第一次调用才初始化,避免内存浪费,但是上面说了,懒汉式是有问题的,它多线程下是不同步的。我们来测试一下懒汉式多线程情况下
class Singleton{ private Singleton(){ System.out.println(Thread.currentThread().getName()); } private static Singleton instance; public static Singleton getInstance(){ if(instance == null){ instance = new Singleton(); } return instance; }}public class demo3 { public static void main(String[] args) { //多线程下 for(int i = 0;i<10;i++){ new Thread(new Runnable(){ @Override public void run() { Singleton.getInstance(); } }).start(); } }}
运行结果(结果是不一致)
![9d9954d87bd478d431f98860eb6e6ba7.png](https://i-blog.csdnimg.cn/blog_migrate/faa62cd8d4be60d7c6b729164992b0f8.jpeg)
那么怎么解决呢?用双检锁/双重校验锁(也称DCL)(你可能会疑问了,为什么不直接在get方法上加synchronized不也可以吗,是可以的,但是会影响性能,因为我们的目的只是针对实例执行一次这个关键的代码才需要同步,所以用双检锁可以安全且在多线程情况下保持高性能)
双检锁的代码示例,你可能还有一个疑问,为什么加上volatile关键字,有什么用呢?可以这么理解,用volatile解决指令重排的问题,因为new的时候不是原子性(什么是原子性很好理解,要么完整的执行,要么就完全的不执行,这是它的一个特性),我们创建的时候会经过这么一个过程,1.分配内存空间、2.执行构造方法,对象初始化、3.指针指向这个内存空间。正常情况一个线程是按着顺序123走的,但是当两个或多个线程出现,它就不一定会按着顺序来,那么就会出现一个指令重排的问题。(所以简单的理解volatile就是用来避免指令重排,不按顺序来)
class Singleton{ private Singleton(){ System.out.println(Thread.currentThread().getName()); } private volatile static Singleton instance; public static Singleton getInstance(){ if(instance == null){ synchronized (Singleton.class){ if (instance == null){ instance = new Singleton(); } } } return instance; }}public class demo3 { public static void main(String[] args) { //多线程下 for(int i = 0;i<100;i++){ new Thread(new Runnable(){ @Override public void run() { Singleton.getInstance(); Singleton.getInstance(); } }).start(); } }}
运行结果(多次运行结果一致)
![d834b356c8f65832cee8f970a7a87d00.png](https://i-blog.csdnimg.cn/blog_migrate/a20ddce88e97c29ce1e8d16721b17fbf.jpeg)
作者:一颗彪悍的种子
原文链接:https://blog.csdn.net/A_hxy/article/details/106142617