- 在静态初始化函数中初始化一个对象引用
- 将对象的引用保存到
volatile类型域或者AtomicReference对象中 - 将对象的引用保存到某个正确构造对象的
final类型域中 - 将对象的引用保存到一个由锁保护的域中
如何保证一个类的实例只被初始化一次且线程安全呢？
懒汉模式(非线程安全)
package io.haitaoc.concurrency.example.singleton;
import io.haitaoc.concurrency.annotation.NotThreadSafe;
/**
* 懒汉模式
* 单例的实例在第一次使用的时候进行创建
*/
@NotThreadSafe
public class SingletonExample {
// 首先要保证这个类不能随便被new一个新的对象出来，所以将构造函数私有化
private SingletonExample(){
}
// 定义一个单例对象，每次都是只返回这同一个对象
private static SingletonExample instance = null;
// 静态的工厂方法获取一个单例对象
public static SingletonExample getInstance(){
if(instance==null){
instance = new SingletonExample();
}
return instance;
}
}
饿汉模式(线程安全)
package io.haitaoc.concurrency.example.singleton;
import io.haitaoc.concurrency.annotation.ThreadSafe;
/**
* 饿汉模式
* 单例的实例在类装载的时候进行创建
*
* 缺点：如果构造函数中有过多的操作处理，会导致类加载的时候特别慢，可能会引起性能问题
* 如果使用饿汉模式只进行类加载而没有实际调用 会造成资源的浪费
*
*/
@ThreadSafe
public class SingletonExample2 {
// 首先要保证这个类不能随便被new一个新的对象出来，所以将构造函数私有化
private SingletonExample2(){
}
// 定义一个单例对象，每次都是只返回这同一个对象
private static SingletonExample2 instance = new SingletonExample2();
// 静态的工厂方法获取一个单例对象
public static SingletonExample2 getInstance(){
return instance;
}
}
懒汉模式的线程安全写法(不推荐)
package io.haitaoc.concurrency.example.singleton;
import io.haitaoc.concurrency.annotation.NotRecommend;
import io.haitaoc.concurrency.annotation.NotThreadSafe;
import io.haitaoc.concurrency.annotation.ThreadSafe;
/**
* 懒汉模式
* 获取实例的静态工厂方法在添加了synchronized修饰以后
* 方法内的所有实现，在同一时间内只允许一个线程访问
* 因此可以保证是线程安全的
* 但是带来了性能上的开销
*/
@ThreadSafe
@NotRecommend
public class SingletonExample3 {
// 首先要保证这个类不能随便被new一个新的对象出来，所以将构造函数私有化
private SingletonExample3(){
}
// 定义一个单例对象，每次都是只返回这同一个对象
private static SingletonExample3 instance = null;
// 静态的工厂方法获取一个单例对象
public static synchronized SingletonExample3 getInstance(){
if(instance==null){
instance = new SingletonExample3();
}
return instance;
}
}
双重检测机制的不安全版本
package io.haitaoc.concurrency.example.singleton;
import io.haitaoc.concurrency.annotation.NotRecommend;
import io.haitaoc.concurrency.annotation.NotThreadSafe;
import io.haitaoc.concurrency.annotation.ThreadSafe;
/**
* 懒汉模式 》 双重同步锁单例模式
* 首先将synchronized放到方法内部去
*/
@NotThreadSafe
@NotRecommend
public class SingletonExample4 {
// 首先要保证这个类不能随便被new一个新的对象出来，所以将构造函数私有化
private SingletonExample4(){
}
// 定义一个单例对象，每次都是只返回这同一个对象
private static SingletonExample4 instance = null;
// 1. memeory = allocate() 分配对象的内存空间
// 2. contructInstance() 初始化对象
// 3. instance=memory 设置instance指向刚分配的内存
// JVM和cpu优化，发生了指令重排：
// 1. memeory = allocate() 分配对象的内存空间
// 3. instance=memory 设置instance指向刚分配的内存
// 2. contructInstance() 初始化对象
// 线程A 经过了第1步直接进行第3步, 线程B发现instance不为null
// 就直接return instance 但instance没有初始化就返回了 就会出现问题
// 静态的工厂方法获取一个单例对象
public static SingletonExample4 getInstance(){
if(instance==null){ // 双重检测机制 // B
synchronized (SingletonExample4.class){ // 同步锁
if(instance==null){
instance = new SingletonExample4(); // A - 3
}
}
}
return instance;
}
}
双重检测的安全版本(volatile用于双重检测-防止指令重排)
package io.haitaoc.concurrency.example.singleton;
import io.haitaoc.concurrency.annotation.NotRecommend;
import io.haitaoc.concurrency.annotation.NotThreadSafe;
import io.haitaoc.concurrency.annotation.ThreadSafe;
/**
* 懒汉模式 》 双重同步锁单例模式
* 用volatile修饰单例对象 不会出现指令重排的问题
*/
@ThreadSafe
@NotRecommend
public class SingletonExample5 {
// 首先要保证这个类不能随便被new一个新的对象出来，所以将构造函数私有化
private SingletonExample5(){
}
// 定义一个单例对象 volatile + 双重检测机制 -> 禁止指令重排(原因是这里面的instance的写操作)
private volatile static SingletonExample5 instance = null;
// 1. memeory = allocate() 分配对象的内存空间
// 2. contructInstance() 初始化对象
// 3. instance=memory 设置instance指向刚分配的内存
// 静态的工厂方法获取一个单例对象
public static SingletonExample5 getInstance(){
if(instance==null){ // 双重检测机制 // B
synchronized (SingletonExample5.class){ // 同步锁
if(instance==null){
instance = new SingletonExample5(); // A - 3
}
}
}
return instance;
}
}
饿汉模式中静态方法的定义顺序
package io.haitaoc.concurrency.example.singleton;
import io.haitaoc.concurrency.annotation.ThreadSafe;
/**
* 饿汉模式
* 单例的实例在类装载的时候进行创建
*
* 缺点：如果构造函数中有过多的操作处理，会导致类加载的时候特别慢，可能会引起性能问题
* 如果使用饿汉模式只进行类加载而没有实际调用 会造成资源的浪费
*
*/
@ThreadSafe
public class SingletonExample6 {
// 首先要保证这个类不能随便被new一个新的对象出来，所以将构造函数私有化
private SingletonExample6(){
}
// 定义一个单例对象，每次都是只返回这同一个对象
private static SingletonExample6 instance = null;
static{
instance = new SingletonExample6();
}
// 静态的工厂方法获取一个单例对象
public static SingletonExample6 getInstance(){
return instance;
}
public static void main(String[] args) {
System.out.println(getInstance().hashCode());
System.out.println(getInstance().hashCode());
}
}
枚举法线程安全（推荐）
- 初始化过程只发生一次
- 后续需要使用实例时会直接返回已经初始化过的那个实例 不会造成资源的浪费且线程安全
package io.haitaoc.concurrency.example.singleton;
import io.haitaoc.concurrency.annotation.Recommend;
import io.haitaoc.concurrency.annotation.ThreadSafe;
@ThreadSafe
@Recommend
public class SingletonExample7 {
private SingletonExample7(){
}
public static SingletonExample7 getInstance(){
return Singleton.INSTANCE.getInstance();
}
private enum Singleton{
INSTANCE;
private SingletonExample7 singleton;
// JVM保证这个方法绝对只被调用一次
Singleton(){
singleton = new SingletonExample7();
}
public SingletonExample7 getInstance(){
return singleton;
}
}
}
