标签：类型 写法 发布 存在 静态块 escape 过多 直接 模式
发布对象是指使一个对象能够被当前范围之外的代码所使用
对象逸出是一种错误的发布，指当一个对象还没有构造完成时，就使它被其他线程所见
@Slf4j
public class Escape {
private int thisCanBeEscape = 0;
public Escape() {
new InnerClass();
}
private class InnerClass{
public InnerClass() {
log.info("{}", Escape.this.thisCanBeEscape);
}
}
public static void main(String[] args) {
new Escape();
}
}
在此实例中Escape对象还没有构造完成，就访问了该对象的成员变量thisCanBeEscape,该类是线程不安全的，并且非常不推荐这么写。
@Slf4j
public class UnsafePublish {
private String[] states = {"a", "b", "c"};
public String[] getStates() {
return states;
}
public static void main(String[] args) {
UnsafePublish unsafePublish = new UnsafePublish();
log.info("{}", Arrays.toString(unsafePublish.getStates()));
unsafePublish.getStates()[0] = "d";
log.info("{}", Arrays.toString(unsafePublish.getStates()));
}
}
输出为：[a,b,c]和[d,b,c] 这样发布的对象为线程不安全的，因为无法保证其他线程是否会修改states域，从而造成状态错误
a、在静态初始化函数中初始化一个对象引用
b、将对象的引用保存到volatile类型域或AtomicReference对象中
c、将对象的引用保存到某个正确构造对象的final类型域中
d、将对象的引用保存到一个由锁保护的域中
我们以对不同单例的实现，来说明一下安全发布对象的方法
public class SingletonExample1 {
//私有构造函数
private SingletonExample1() {
}
//单例对象
private static SingletonExample1 instance = null;
//静态的工厂方法
public static SingletonExample1 getInstance() {
//单线程没有问题，多线程的时候会出现问题
if (instance == null) {
instance = new SingletonExample1();
}
return instance;
}
}
此实例在单线程模式下没有任何问题，但在多线程模式下，如两个线程都同时运行到判断instance==null时，就有可能new出两个实例来，所以说这是线程不安全的，这也就是懒汉模式，此实例满足了a条件，如果再加上d条件，在判断是否为null时加锁，就可以变为线程安全的
public class SingletonExample2 {
//饿汉模式不足，如果构造方法中有过多的处理，会导致类加载的时候特别慢
//私有构造函数
private SingletonExample2() {
}
//单例对象
private static SingletonExample2 instance = new SingletonExample2();
//静态的工厂方法
public static SingletonExample2 getInstance() {
return instance;
}
}
此demo是线程安全的，使用饿汉模式时需要注意两点，一是此类肯定被使用（避免造成资源浪费），二是私有的构造方法中没有过多的处理4
public class SingletonExample3 {
//私有构造函数
private SingletonExample3() {
}
//单例对象
private static SingletonExample3 instance = null;
//静态的工厂方法
public static synchronized SingletonExample3 getInstance() {
//单线程没有问题，多线程的时候会出现问题
if (instance == null) {
instance = new SingletonExample3();
}
return instance;
}
}
此demo即为demo1加锁的情况，是线程安全的，但是并不推荐这么写，因为这样虽然保证了线程安全，但在性能上有一定的开销
/**
* 懒汉模式 双重同步锁单例模式
* 单例实例在第一次使用时进行创建
* 双重检测机制不一定线程安全，因为有指令重排的存在
*/
public class SingletonExample4 {
//私有构造函数
private SingletonExample4() {
}
//单例对象
private static SingletonExample4 instance = null;
//静态的工厂方法
public static SingletonExample4 getInstance() {
//单线程没有问题，多线程的时候会出现问题
if (instance == null) { //双重检测机制
//同步锁
synchronized (SingletonExample4.class) {
if (instance == null) {
instance = new SingletonExample4();
}
}
}
return instance;
}
}
此demo是懒汉模式的优化版本，但注意此demo不是线程安全的，因为有指令重排的存在，当执行instance=new SingletonExample4（）时，cpu会执行三步操作：1、memory=allocate() 分配对象的内存空间 2、ctorInstance()初始化对象 3、instance = memory 设置instance指向刚分配的内存， 但是由于jvm和cpu的优化，会发生指令重排，如重排的结果变为1,3,2，在单线程的情况下没有任何问题，但是在多线程的情况下就可能发生问题，如果此时A线程执行到instance=new SingletonExample4（），发生了指令重排，执行到了第二步的3，此时instance已经执行了该对象的内存，但是该对象还没有初始化，如果在此时B线程正好执行到if（instance==null），此时该条件已经不成立，直接return，因为这个对象还没有初始化，直接去使用这个对象就可能发生问题。
/**
* 懒汉模式 双重同步锁单例模式
* 单例实例在第一次使用时进行创建
* 双重检测机制不一定线程安全，因为有指令重排的存在
*/
public class SingletonExample5 {
//私有构造函数
private SingletonExample5() {
}
//1、memory = allocate() 分配对象的内存空间
// 2、 ctorInstance() 初始化对象
// 3、 instance = memeory 设置instance指向刚分配的内存
//通过volatile和双重检测机制限制指令重排，volatile限制了代码的写操作
//单例对象,通过volatile限制代码发生指令重排
private volatile static SingletonExample5 instance = null;
//静态的工厂方法
public static SingletonExample5 getInstance() {
//单线程没有问题，多线程的时候会出现问题
if (instance == null) { //双重检测机制
//同步锁
synchronized (SingletonExample5.class) {
if (instance == null) {
instance = new SingletonExample5();
}
}
}
return instance;
}
}
此demo是demo4的升级版，只要解决了指令重排问题，在上篇博客“线程安全性中”我们已经介绍了volatile可以限制代码发生指令重排，此demo是线程安全的。
/**
* 饿汉模式
* 单例实例在类装载时进行创建
*/
@ThreadSafe
public class SingletonExample6 {
//饿汉模式不足，如果构造方法中有过多的处理，会导致类加载的时候特别慢
//私有构造函数
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());
}
}
demo2是饿汉模式的静态代码域方式，此demo是饿汉模式的静态代码块方式，此demo也是线程安全的
/**
* 枚举模式：最安全
* 相比于懒汉模式在安全性方面更容易保证
* 相比于饿汉模式是在实际调用的时候才做最开始的初始化
*/
public class SingletonExample7 {
private SingletonExample7() {
}
//静态的工厂方法
public static SingletonExample7 getInstance() {
return Singleton.INSTANCE.getSingleton();
}
private enum Singleton{
INSTANCE;
private SingletonExample7 singleton;
//JVM保证这个方法绝对只调用一次，且是在这个类调用之前初始化的
Singleton() {
singleton = new SingletonExample7();
}
public SingletonExample7 getSingleton() {
return singleton;
}
}
}
此demo是我们最推荐的单例写法，并且是线程安全的，它相比于懒汉模式在安全性方面更容易保证，相比于饿汉模式是在实际调用的时候才做最开始的初始化
标签：类型 写法 发布 存在 静态块 escape 过多 直接 模式
原文地址：https://www.cnblogs.com/Mirma/p/9004530.html
