发布对象
- 发布对象 ：使一个对象能够被当前范围之外的代码所使用
- 对象溢出： 一种错误的发布。当一个对象还没有构造完成时，就使它被其他线程所见(类的非私有方法返回对象的引用、通过公有静态变量发布对象)
安全发布对象
在对象初始化函数中初始化一个对象引用
将对象的引用保存到volatile类型域或者AtomicReference对象中
将对象的应用保存到某个正确构造对象的final类型域中
-
将对象的引用保存到一个由锁保护的域中
1.懒汉模式 线程不安全
package com.qjx.concurrency.singleton;
import com.qjx.concurrency.annotations.NotThreadSafe;
/**
* 单例
* 懒汉模式
* 单例的实例在第一次运行的时候进行创建
* 单线程下安全 ，多线程下不安全
*/
@NotThreadSafe
public class SingletonExample1 {
/**
* 私有构造函数
*/
private SingletonExample1(){
}
/**
* 单例对象
*/
public static SingletonExample1 instance= null;
/**
* 静态的工厂方法
* @return
*/
public static SingletonExample1 getInstance(){
if(instance==null){
instance = new SingletonExample1();
}
return instance;
}
}
2.饿模式 线程安全
单例的实例在类装载的时候进行创建
饿汉模式可能会导致线程资源的浪费
使用的时候注意的问题：
1.私有构造函数在实现的时候没有太多的处理，不然会导致该类加载过慢，出现性能问题
2.在使用过程中存在实际调用，不然会导致资源浪费
package com.qjx.concurrency.singleton;
import com.qjx.concurrency.annotations.ThreadSafe;
/**
* 单例
* 饿汉模式
* 单例的实例在类装载的时候进行创建
* 饿汉模式可能会导致线程资源的浪费
* 使用的时候注意的问题：
* 1.私有构造函数在实现的时候没有太多的处理，不然会导致该类加载过慢，出现性能问题
* 2.在使用过程中存在实际调用，不然会导致资源浪费
*/
@ThreadSafe
public class SingletonExample2 {
/**
* 私有构造函数
*/
private SingletonExample2(){
}
/**
* 单例对象
*/
public static SingletonExample2 instance= new SingletonExample2();
/**
* 静态的工厂方法
* @return
*/
public static SingletonExample2 getInstance(){
return instance;
}
}
3.懒汉模式 引入静态方法锁 线程安全
单例的实例在第一次运行的时候进行创建
不推荐，因为直接引入对象锁导致效率低
package com.qjx.concurrency.singleton;
import com.qjx.concurrency.annotations.NotRecommend;
import com.qjx.concurrency.annotations.ThreadSafe;
/**
* 单例
* 懒汉模式
* 单例的实例在第一次运行的时候进行创建
*/
@ThreadSafe
@NotRecommend
public class SingletonExample3 {
/**
* 私有构造函数
*/
private SingletonExample3(){
}
/**
* 单例对象
*/
public static SingletonExample3 instance= null;
/**
* 静态的工厂方法
* @return
*/
public static synchronized SingletonExample3 getInstance(){
if(instance==null){
instance = new SingletonExample3();
}
return instance;
}
}
4.懒汉模式 线程不安全
主要原因是JVM和CPU优化，发生了指令重排
懒汉模式 -》 双重同步锁单例模式
单例的实例在第一次运行的时候进行创建
package com.qjx.concurrency.singleton;
import com.qjx.concurrency.annotations.NotThreadSafe;
/**
* 单例
* 懒汉模式 -》 双重同步锁单例模式
* 单例的实例在第一次运行的时候进行创建
*/
@NotThreadSafe
public class SingletonExample4 {
/**
* 私有构造函数
*/
private SingletonExample4(){
}
//1.memory = allocate() 分配对象的内存空间
//2.ctorInstance() 初始化对象
//3.instance = memory 设置instance 指向刚分配的内存
//jvm 和cpu优化，发生了指令重排
//1.memory = allocate() 分配对象的内存空间
//3.instance = memory 设置instance 指向刚分配的内存
//2.ctorInstance() 初始化对象
/**
* 单例对象
*/
public static SingletonExample4 instance= null;
/**
* 静态的工厂方法
* @return
*/
public static SingletonExample4 getInstance(){
//双重检测机制
if(instance==null){
//同步锁
synchronized (SingletonExample4.class){
if(instance == null){
instance = new SingletonExample4();
}
}
}
return instance;
}
}
5.懒汉模式 引入volatile+双重检测机制禁止指令重拍使线程安全
package com.qjx.concurrency.singleton;
import com.qjx.concurrency.annotations.ThreadSafe;
/**
* 单例
* 懒汉模式 -》 双重同步锁单例模式
* 单例的实例在第一次运行的时候进行创建
*/
@ThreadSafe
public class SingletonExample5 {
/**
* 私有构造函数
*/
private SingletonExample5(){
}
//1.memory = allocate() 分配对象的内存空间
//2.ctorInstance() 初始化对象
//3.instance = memory 设置instance 指向刚分配的内存
/**
* 单例对象 volatile + 双重检测机制 -> 禁止指令重拍
*/
public volatile static SingletonExample5 instance= null;
/**
* 静态的工厂方法
* @return
*/
public static SingletonExample5 getInstance(){
//双重检测机制
if(instance==null){
//同步锁
synchronized (SingletonExample5.class){
if(instance == null){
instance = new SingletonExample5();
}
}
}
return instance;
}
}
6.饿汉模式 线程安全
静态代码块
package com.qjx.concurrency.singleton;
import com.qjx.concurrency.annotations.ThreadSafe;
/**
* 单例
* 饿汉模式
* 单例的实例在类装载的时候进行创建
* 饿汉模式可能会导致线程资源的浪费
* 使用的时候注意的问题：
* 1.私有构造函数在实现的时候没有太多的处理，不然会导致该类加载过慢，出现性能问题
* 2.在使用过程中存在实际调用，不然会导致资源浪费
*/
@ThreadSafe
public class SingletonExample6 {
/**
* 私有构造函数
*/
private SingletonExample6(){
}
/**
* 单例对象
*/
public static SingletonExample6 instance= null;
static {
instance = new SingletonExample6();
}
/**
* 静态的工厂方法
* @return
*/
public static SingletonExample6 getInstance(){
return instance;
}
public static void main(String[] args) {
System.out.println(getInstance().hashCode());
System.out.println(getInstance().hashCode());
}
}
7.枚举模式 线程安全 (最安全)
推荐使用
package com.qjx.concurrency.singleton;
import com.qjx.concurrency.annotations.Recommend;
import com.qjx.concurrency.annotations.ThreadSafe;
/**
* 单例
* 枚举模式
* 最安全
*/
@ThreadSafe
@Recommend
public class SingletonExample7 {
/**
* 私有构造方法
*/
private SingletonExample7 (){
}
public static SingletonExample7 getInstance(){
return Singleton.SINGLETON.getInstance();
}
/**
* 枚举类定义单利实现
*/
private enum Singleton{
/**
* 枚举单例
*/
SINGLETON;
private SingletonExample7 singleton;
/**
* JVM保证这个方法绝对只被调用一次
*/
Singleton(){
singleton = new SingletonExample7();
}
public SingletonExample7 getInstance(){
return singleton;
}
}
}
