单例模式
保证类只有一个实例。
当我们的类只需要有一种实例的时候就可以用这种模式。
比如各种管理类Manager,各种工厂类Factory
不要拘泥于任何一种写法,也不要纠结哪种写法叫什么名字,实际使用时要根据情况选择一种合适的写法即可,当然,不要使用有问题的写法。
下面简单分析一下各种写法和有问题的写法。
单例模式的8种写法
- 饿汉式
/**
* 类加载的时候就实例化一个实例,JVM保证线程安全
* 也称饿汉式
* 该方式简单实用
* @author traveler100
*/
public class Singleton_1 {
private static final Singleton_1 INSTANCE = new Singleton_1();
/**
* 私有的构造方法,其他地方不能new
*/
private Singleton_1() {
}
public static Singleton_1 getInstance() {
return INSTANCE;
}
/**
* for test
*/
public static void main(String[] args) {
Singleton_1 instance1 = Singleton_1.getInstance();
Singleton_1 instance2 = Singleton_1.getInstance();
System.out.println(instance1 == instance2);
}
}
- 意思同第一种,只是写法不同
/**
* 和Singleton_1是同一个意思
* 只是将new的动作放在了代码块里
* 类加载到内存的时候只加载一个实例
* @author traveler100
*/
public class Singleton_2 {
private static final Singleton_2 INSTANCE;
static {
INSTANCE = new Singleton_2();
}
/**
* 私有的构造方法,其他地方不能new
*/
private Singleton_2() {
}
public static Singleton_2 getInstance() {
return INSTANCE;
}
/**
* for test
*/
public static void main(String[] args) {
Singleton_2 instance1 = Singleton_2.getInstance();
Singleton_2 instance2 = Singleton_2.getInstance();
System.out.println(instance1 == instance2);
}
}
- 懒汉式,用到的时候才实例化
/**
* 懒汉式
* 这种写法虽然达到了用的时候才初始化的目的,但是存在多线程获取实例时相互影响的问题
* @author traveler100
*/
public class Singleton_3 {
private static Singleton_3 INSTANCE;
/**
* 私有的构造方法,其他地方不能new
*/
private Singleton_3() {
}
public static Singleton_3 getInstance() {
if (INSTANCE == null) {
// sleep一下,测试
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
INSTANCE = new Singleton_3();
}
return INSTANCE;
}
/**
* for test
*/
public static void main(String[] args) {
//同一个类的不同对象的hashcode不同
//跑100个线程,看看有没有不同的实例
for (int i = 0; i < 100; i++) {
new Thread(() -> System.out.println(Singleton_3.getInstance().hashCode())).start();
}
}
}
这种写法虽然达到了用的时候才初始化的目的,但是存在多线程获取实例时相互影响的问题
运行结果:
- 在上一种写法的基础上加synchronized锁,保证线程安全
/**
* lazy loading 懒汉式
* 这种写法虽然达到了用的时候才初始化的目的,但是存在多线程获取实例时相互影响的问题
* 可以用synchronized加锁,但是效率会降低
* @author traveler100
*/
public class Singleton_4 {
private static Singleton_4 INSTANCE;
/**
* 私有的构造方法,其他地方不能new
*/
private Singleton_4() {
}
/**
* 既然lazy loading的写法有线程安全问题,那就加把锁
*/
public static synchronized Singleton_4 getInstance() {
if (INSTANCE == null) {
// 测试,sleep一下,增加被其他线程打断的机会
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
INSTANCE = new Singleton_4();
}
return INSTANCE;
}
/**
* for test
*/
public static void main(String[] args) {
//同一个类的不同对象的hashcode不同
//跑100个线程,看看有没有不同的实例
for (int i = 0; i < 100; i++) {
new Thread(() -> System.out.println(Singleton_4.getInstance().hashCode())).start();
}
}
}
这种方式可行,但会带来效率下降的问题。下面继续“吹毛求疵”
- 既然4的的写法效率下降,那就在线程安全的基础上减少锁住的代码数量,这里有坑
/**
* lazy loading 懒汉式
* 这种写法虽然达到了用的时候才初始化的目的,但是存在多线程获取实例时相互影响的问题
* 可以用synchronized加锁,但是效率会降低
* 在加锁的基础上再优化一下,减少加锁代码块的数量
* @author traveler100
*/
public class Singleton_5 {
private static Singleton_5 INSTANCE;
/**
* 私有的构造方法,其他地方不能new
*/
private Singleton_5() {
}
public static Singleton_5 getInstance() {
if (INSTANCE == null) {
//不在方法上加锁而在new的时候才加锁,减少锁的代码,然而这种方式并不行
synchronized (Singleton_5.class) {
// 测试,sleep一下,增加被其他线程打断的机会
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
INSTANCE = new Singleton_5();
}
}
return INSTANCE;
}
/**
* for test
*/
public static void main(String[] args) {
//同一个类的不同对象的hashcode不同
//跑100个线程,看看有没有不同的实例
for (int i = 0; i < 100; i++) {
new Thread(() -> System.out.println(Singleton_5.getInstance().hashCode())).start();
}
}
}
先看运行结果:
说明这种写法看似在线程安全有减少了锁的代码量,其实是达不到“永远”单例的目的的。
原因:线程A运行完
if(INSTANCE == null)
,还没拿到锁时候,线程B也运行到if(INSTANCE == null)
这一句了,并且拿到锁进行了new实例化,然后线程B释放锁,线程A得到锁继续运行if
语句块里面的内容进行new的过程,这样就出现了不同的实例了。
- 那就来个双重检查吧
/**
* lazy loading 懒汉式
* 这种写法虽然达到了用的时候才初始化的目的,但是存在多线程获取实例时相互影响的问题
* 可以用synchronized加锁,但是效率会降低
* 在加锁的基础上再优化一下,减少加锁代码块的数量---事实证明不可行
* 那就双重检查DCL
* @author traveler100
*/
public class Singleton_6 {
private static Singleton_6 INSTANCE;
/**
* 私有的构造方法,其他地方不能new
*/
private Singleton_6() {
}
public static Singleton_6 getInstance() {
if (INSTANCE == null) { //第一重检查
synchronized (Singleton_6.class) {
if (INSTANCE == null) { //第二重检查
// 测试,sleep一下,增加被其他线程打断的机会
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
INSTANCE = new Singleton_6();
}
}
}
return INSTANCE;
}
/**
* for test
*/
public static void main(String[] args) {
//同一个类的不同对象的hashcode不同
//跑100个线程,看看有没有不同的实例
for (int i = 0; i < 100; i++) {
new Thread(() -> System.out.println(Singleton_6.getInstance().hashCode())).start();
}
}
}
INSTANCE要不要加
volatile
?
答案是肯定的。众所周知,
volatile
的作用是保证线程可见性和禁止指令重排序。在DCL单利模式写法中,volatile主要是用于禁止指令重排序的。因为如果不加volatile关键字,那么可能会出现指令重排序。一个
线程A
执行到INSTANCE = new Singleton_6()
的时候,经过编译器编译,会分成三个指令:
- 给指令申请内存
- 给成员变量初始化
- 把这块内存的内容赋值给INSTANCE
既然有值了,那么
线程B
上来先进行检查发现已经有值,就不会进入加锁那部分的代码了。加了
volatile
后,就不允许指令重排序了。所以此时一定是保证线程A
初始化完了才会复制给这个变量。
- 静态内部类方式
/**
* 静态内部类方式
* JVM保证单例
* 加载外部类时不会加载内部类---也可实现懒加载
* @author traveler100
*/
public class Singleton_7 {
/**
* 私有的构造方法,其他地方不能new
*/
private Singleton_7() {
}
private static class SingletonHolder {
private static final Singleton_7 INSTANCE = new Singleton_7();
}
public static Singleton_7 getInstance() {
return SingletonHolder.INSTANCE;
}
/**
* for test
*/
public static void main(String[] args) {
//同一个类的不同对象的hashcode不同
//跑100个线程,看看有没有不同的实例
for (int i = 0; i < 100; i++) {
new Thread(() -> System.out.println(Singleton_7.getInstance().hashCode())).start();
}
}
}
即可保证单例(虚拟机保证),也能实现懒加载。
如果非要追求完美,那么可以用这种方式。
- 完美中的完美方式,Enum实现单例
/**
* 枚举单例
* 不仅可以解决线程同步,还可以防止反序列化
* @author travler100
*/
public enum Singleton_8 {
INSTANCE;
/**
* for test
*/
public static void main(String[] args) {
//同一个类的不同对象的hashcode不同
//跑100个线程,看看有没有不同的实例
for (int i = 0; i < 100; i++) {
new Thread(() -> System.out.println(Singleton_8.INSTANCE.hashCode())).start();
}
}
}
这是Java创始人之一的神仙在《Effective Java》这本书中推荐的写法。
膜拜中!!!