单例-保证一个类的具体的实例在整个应用程序中只有唯一的一个
- 构造私有化
- 提供这个类的唯一(静态)实例
- 提供一个公开的静态方法来返回这个实例
1. 饿汉式
单线程/多线程场景下都是安全的
package com.lsmallice.design.Singleton.v1;
/**
* @Description 饿汉式单例
* @Author: kevin
* @Date: 2024-07-5
*/
public class Singleton {
//提供唯一的一个实例
private static final Singleton singleton = new Singleton();
//1. 构造私有化
private Singleton() {
}
//提供一个接口
public static Singleton getInstance() {
return singleton;
}
}
class SingletonTest {
public static void main(String[] args) {
Singleton singleton = Singleton.getInstance();
Singleton singleton2 = Singleton.getInstance();
System.out.println(singleton2 == singleton);
}
}
2. 懒汉式
单线程下是ok的,多线程下是不ok的 无法在多线程下保证这个实例是唯一的
package com.lsmallice.design.Singleton.v2;
/**
* @Description 懒汉式
* @Author: kevin
* @Date: 2024-07-05
*/
public class Singleton {
private static Singleton singleton;
// 构造私有化
private Singleton() {
}
// 懒汉式,当getSingleton第一次被调用的时候才去创建实例
public static Singleton getSingleton() {
return singleton == null ? singleton = new Singleton() : singleton;
}
}
class SingletonTest {
public static void main(String[] args) {
Singleton singleton = Singleton.getSingleton();
Singleton singleton2 = Singleton.getSingleton();
System.out.println(singleton2 == singleton);
}
}
3. 剖析线程不安全
package com.lsmallice.design.Singleton.v2;
/**
* @Description 懒汉式
* @Author: kevin
* @Date: 2024-07-5
*/
public class Singleton {
private static Singleton instance;
private Singleton() {
System.out.println("构造块");
}
// 懒汉式,当getSingleton第一次被调用的时候才去创建实例
public static Singleton getInstance() {
return instance == null ? instance = new Singleton() : instance;
}
}
class SingletonTest {
public static void main(String[] args) {
//模拟一个多线程的场景
for (int i = 0; i < 100; i++) {
Thread t = new Thread(() -> {
Singleton s1 = Singleton.getInstance();
});
t.start();
}
}
}
会存在多个线程 判断instance == null 为true,导致都会走到 new Singleton() 这一步。
构造块
构造块
构造块
构造块
构造块
构造块
构造块
4. 懒汉式-线程安全
使用同步锁– synchronized
package com.lsmallice.design.Singleton.v2;
/**
* @Description 懒汉式
* @Author: kevin
* @Date: 2024-07-5
*/
public class Singleton {
private static Singleton singleton;
// 构造私有化
private Singleton() {
}
// 懒汉式,当getSingleton第一次被调用的时候才去创建实例
public static synchronized Singleton getSingleton() {
return singleton == null ? singleton = new Singleton() : singleton;
}
}
class SingletonTest {
public static void main(String[] args) {
Singleton singleton = Singleton.getSingleton();
Singleton singleton2 = Singleton.getSingleton();
System.out.println(singleton2 == singleton);
}
}
5. 饿汉式/懒汉式的区别
- 线程安全性方面
饿汉模式 - 单线程/多线程 - 都是线程安全的 - 因为类加载的时候(线程对象还不存在!),就会初始化那个单例的实例.
懒汉模式 - 需要通过加锁的方式,来实现多线程安全.
-
效率方面
懒汉模式通常是需要加锁的,所以涉及到频繁加锁和释放锁的动作,而”锁”也是一个比较昂贵的资源对象[占内存]
效率不如饿汉模式.
-
占内存方面
饿汉模式比较占内存 - 类加载的时候,它在内存中就存在了. 懒汉模式是你需要使用它实例的时候,它才会第一次实例化.
6.双重锁检查
package com.lsmallice.design.Singleton.v5;
/**
* @Description 懒汉式- 正真开发中使用的 volatile关键字 禁止指令重排
* @Author: kevin
* @Date: 2024-07-5
*/
public class Singleton {
private static volatile Singleton instance;
private Singleton() {
System.out.println("构造块");
}
public static Singleton getInstance() {
//创建对象的标准的流程 - "自认为的"
//①申请空间,②初始化,调用构造方法(是一个完整的对象),③将对象在堆空间的内存地址赋值给引用变量
//TODO... 实际的顺序,jvm会进行指令重排,重排后的顺序①-③-②
//N=100个线程
//假设10个线程可以同时判断为null
//等第一个线程执行①-③之后,另外90个线程进来了,判断不为null,直接return instance
//但是这个90个线程拿到的是一个不完整对象的引用,然后可能就去使用这个不完整的对象 - 造成不可预期的结果.
if (instance == null) {
//10个线程竞争锁资源
synchronized (Singleton.class) {//skip
//其中的一个线程进入...
if (instance == null) {
//按照指令重排后的顺序, 第一个线程进入之后按照①-③ , instance已经不为null
//此时instance指向的那个对象仍然是一个不完整的对象,因为还没有来得及执行完构造.
instance = new Singleton();
}
}
//抢到锁的线程会立即释放锁资源
}
return instance;
}
}
class SingletonTest {
public static void main(String[] args) {
//模拟一个多线程的场景
for (int i = 0; i < 100; i++) {
Thread t = new Thread(() -> {
Singleton s1 = Singleton.getInstance();
});
t.start();
}
}
}
7.枚举
public enum Singleton {
INSTANCE;
}