- 发布对象：使一个对象能够被当前范围之外的代码所使用
package com.mmall.example.publish;
import com.mmall.annoations.NotThreadSafe;
import lombok.extern.slf4j.Slf4j;
import java.util.Arrays;
/**
* 线程不安全的-->发布对象
* Created by megan on 2018/3/22.
*/
@Slf4j
@NotThreadSafe
public class UnsafePublish {
private String[] states = {"a","b","c"};
/**
* 通过public发布级别发布了类的域，在类的外部，任何线程都可以访问这个域
* 这样是不安全的，因为我们无法检查其他线程是否会修改这个域导致了错误
* @return
*/
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()));
}
}
- 对象溢出： 一个错误的发布。当一个对象还没有构造完成时，就使它被其他线程所见。
package com.mmall.example.publish;
import lombok.extern.slf4j.Slf4j;
/**
* 线程不安全-->对象溢出
* 在对象构造完成之前，不可以将其发布
* Created by megan on 2018/3/22.
*/
@Slf4j
public class Escape {
private int thisCanBeEscape = 0;
public Escape(){
new InnerClass();
}
/**
* 包含了对封装实例的隐藏和引用，这样在对象没有被正确构造完成之前就会被发布，由此导致不安全的因素在里面
* 1.导致this引用在构造期间溢出的错误，他是在构造函数构造过程中启动了一个线程，造成this引用的溢出
* 新线程只是在对象构造完毕之前就已经看到他了，所以如果要在构造函数中创建线程，那么不要启动它，
* 而是应该才用一个专有的start，或是其他的方式统一启动线程
* 使用工厂方法和私有构造函数来完成对象创建和监听器的注册来避免不正确的发布
*/
private class InnerClass {
public InnerClass(){
log.info(" ---> {} ",Escape.this.thisCanBeEscape);
}
}
public static void main(String[] args) {
new Escape();
}
}
安全发布对象的四种办法：
- 在静态初始化函数中初始化一个对象的引用
- 将对象的引用保存到volatile类型域或者AtomicReference对象中
- 将对象的引用保存到某一个正确构造对象的final类型域中
- 将对象的引用保存到一个由锁保护的域中
package com.mmall.example.singleton;
import com.mmall.annoations.NotThreadSafe;
/**
* 懒汉模式
* 单例实例在第一次使用的时候创建
* Created by megan on 2018/3/22.
*/
@NotThreadSafe
public class SingletonExample1 {
/** 私有的构造函数 **/
private SingletonExample1(){
// 可能会进行很多操作，很多运算
}
/** 私有的构造函数 **/
private static SingletonExample1 instance = null;
/** 通过静态的工厂方法来获取一个单例对象 **/
public static SingletonExample1 getInstance(){
if(instance == null){
instance = new SingletonExample1();
}
return instance;
}
}
package com.mmall.example.singleton;
import com.mmall.annoations.NotThreadSafe;
/**
* 饿汉模式
* 单例实例在类装载的时候创建
* 缺点 1.如果创建过程中进行很多的运算，会导致类加载的时候特别的慢
* 2.如果创建出来的实例要很久以后才被调用，那么会导致资源的浪费
* Created by megan on 2018/3/22.
*/
@NotThreadSafe
public class SingletonExample2 {
/** 私有的构造函数 **/
private SingletonExample2(){
}
/** 私有的构造函数 **/
private static SingletonExample2 instance = new SingletonExample2();
/** 通过静态的工厂方法来获取一个单例对象 **/
public static SingletonExample2 getInstance(){
return instance;
}
}
package com.mmall.example.singleton;
import com.mmall.annoations.ThreadSafe;
/**
* 懒汉模式下实现线程安全 -> synchronized
* 单例实例在第一次使用的时候创建
* Created by megan on 2018/3/22.
*/
@ThreadSafe
public class SingletonExample3 {
/** 私有的构造函数 **/
private SingletonExample3(){
}
/** 私有的构造函数 **/
private static SingletonExample3 instance = null;
/** 通过静态的工厂方法来获取一个单例对象 **/
public static synchronized SingletonExample3 getInstance(){
if(instance == null){
instance = new SingletonExample3();
}
return instance;
}
}
package com.mmall.example.singleton;
import com.mmall.annoations.Recommend;
import com.mmall.annoations.ThreadSafe;
import lombok.Getter;
import lombok.extern.slf4j.Slf4j;
/**
* 改造后的饿汉模式-1
* 枚举类型的单例，最安全最简单
* 参考：https://www.jianshu.com/p/eb30a388c5fc?hmsr=toutiao.io&utm_medium=toutiao.io&utm_source=toutiao.io
* Created by megan on 2018/3/22.
*/
@Slf4j
@ThreadSafe
@Recommend
public class SingletonExample4 {
/**
* 私有构造函数
*/
private SingletonExample4() {
// 可能会进行很多操作，很多运算
}
/**
* 静态工厂方法 * @return
*/
public static SingletonExample4 getInstance() {
return Singleton.INSTANCE.getSingletonExample4();
}
/**
* 由枚举类创建单例对象
*/
@Getter
private enum Singleton {
INSTANCE;
private SingletonExample4 singletonExample4;
Singleton() {
singletonExample4 = new SingletonExample4();
}
}
}
package com.mmall.example.singleton;
import com.mmall.annoations.ThreadSafe;
/**
*《双重同步锁单例模式》
* 懒汉模式下实现线程安全 -> synchronized 双重检测机制
* 单例实例在第一次使用的时候创建
* Created by megan on 2018/3/22.
*/
@ThreadSafe
public class SingletonExample5 {
/** 私有的构造函数 **/
private SingletonExample5(){
}
/** 私有的构造函数 volatile + 双重检测机制 --> 指令重排 **/
private static volatile SingletonExample5 instance = null;
/** 通过静态的工厂方法来获取一个单例对象 **/
public static synchronized SingletonExample5 getInstance(){
if(instance == null){
/** 双重检测机制 **/
synchronized (SingletonExample5.class) {
instance = new SingletonExample5();
}
}
return instance;
}
}
