发布对象
使一个对象能够被当前范围之外的代码所使用,将创建的对象保存到容器中，也可能通过某个方法返回
对象的引用，或者将引用传递到其他类的方法中
对象逸出
一种错误的发布，当一个对象还没有构造完成时，就使它被其他线程所见
1、发布的对象只需要被它需要的线程被看见
2、避免对象逸出
发布错误对象：
import java.util.Arrays;
//线程不安全的
//发布对象
public class Student {
private String[] student = {"张三","李四","王五"};
public String[] getStudent(){
return student;
}
public static void main(String[] args) {
Student unsarePublish = new Student();
System.out.println(Arrays.toString(unsarePublish.getStudent()));
unsarePublish.getStudent()[1]="赵柳";
System.out.println(Arrays.toString(unsarePublish.getStudent()));
}
}
返回结果：
[张三, 李四, 王五]
[张三, 赵柳, 王五]
上述例子中我们可以看到，李四已经被赵柳替代，通过public 类的访问级别，发布了这些域，在外部都可以访问这些域，这样的发布对象其实是不安全的，因为无法假设其他线程会不会修改这个域，所以会导致student的值是不确定的，因此是线程不安全的。
如何来进行安全的发布对象呢：
看了网上好多博客，这里也整理了一下，我们就来使用最经典的，单例模式来设计
1 懒汉模式设计
1.1 懒汉模式
/**
* 懒汉模式
* 线程不安全
*/
public class LazyMode1 {
private LazyMode1(){//私有的构造函数}
private static LazyMode1 instance = null;//单例对象
//在单线程下是没有问题的
public static LazyMode1 getInstance(){
if(instance == null){
instance = new LazyMode1();
}
return instance;
}
}
这是一个比较正常的单例模式的，是一个线程不安全的类，那么如何让他变成一个线程安全的类呢，看下面一个例子
1.2 synchronized
/**
* 懒汉模式
* 线程安全
*/
public class LazyMode2 {
private LazyMode2(){//私有的构造函数}
private static LazyMode2 instance = null; //单例对象
public synchronized static LazyMode2 getInstance(){
if(instance == null){
instance = new LazyMode2();
}
return instance;
}
添加了synchronized后，在同一时间，只能允许一个线程访问，因此可以保证这个是线程安全的
虽然他是线程安全的，但是他带来的性能上的开销，而这个开销是我们不希望的，不推荐使用，别担心下面还有更好的，我们来看下面的知识点
1.3 双重同步锁
/**
* 懒汉模式
* 但是这个类并不是线程安全的类
*/
public class LazyMode3 {
private LazyMode3(){//私有的构造函数}
private static LazyMode3 instance = null; //单例对象
public static LazyMode3 getInstance(){
if(instance == null){
synchronized(LazyMode3.class){
if(instance == null){
instance = new LazyMode3();
}
}
}
return instance;
}
}
这个案例，我们使用了双重同步锁的单例模式，但是他并不是一个线程安全的类，因为在JVM和cpu优化，发生了指令重排，在单线程下，是没有影响的，但是在多线程下，就会打乱分配的内存空间和初始化对象的顺序，就会导致我们的结果和预期的不一致，虽然这个发生的概率很小，但是会发生，所以他是线程不安全的类，那么如何能够让他成为一个线程安全的类呢，看下面的例子。
1.4 volatile+双重同步锁
/**
* 懒汉模式
* 线程安全
*/
public class LazyMode4 {
private LazyMode4(){//私有的构造函数}
private volatile static LazyMode4 instance = null;
public static LazyMode4 getInstance(){
if(instance == null){
synchronized(LazyMode4.class){
if(instance == null){
instance = new LazyMode4();
}
}
}
return instance;
}
}
在这里呢，我们使用了volatile+双重检测机制 他可以禁止指令重排
为什么vloatle可以禁止指令重排？
1、通过加入内存屏障和禁止重排序优化来实现
2、对volatile变量写操作时，会在写操作后加入一条store屏障指令，讲本地内存中的共享变量值刷新到主内存中
3、对volatile变量读操作时，会在读操作前加入一条load屏障指令，从主内存中读取共享变量
2 饿汉模式设计
/**
* 饿汉模式
* 线程安全的
*/
public class HungryMode1 {
private HungryMode1(){//私有的构造函数}
private static HungryMode1 instance = new HungryMode1();//单例对象
public static HungryMode1 getInstance(){
return instance;
}
}
- 饿汉模式的不足：如果饿汉模式中存在过多的处理，会导致这个类在加载的时候特别慢，可能会引起性能问题，如果是只进行类的加载，没有实际的调用的话，会导致资源的浪费
- 所以我们需要考虑的一个点就是肯定会被使用，这样才不会导致过多的浪费，我们来看第二个例子
/**
* 饿汉模式
* 单例实例在类装载时进行创建
*/
@ThreadSafe
public class HungryMode2 {
private HungryMode2(){//私有的构造函数}
//单例对象
private static HungryMode2 instance = null;
//静态代码块
static {
instance = new HungryMode2();
}
public static HungryMode2 getInstance(){
return instance;
}
public static void main(String[] args) {
// System.out.println(getInstance());
// System.out.println(getInstance());
System.out.println(getInstance().hashCode());
System.out.println(getInstance().hashCode());
}
}
在这里呢我们要注意的是：
当我们写单例对象和静态代码块的时候呢，一定要注意他们的顺序，顺序不一样，执行结果会 有所不同
首先我们来看单例对象在静态代码块前面
//单例对象
private static HungryMode2 instance = null;
//静态代码块
static {
instance = new HungryMode2();
}
执行结果：
2061475679
2061475679
首先我们来看静态代码块在单例对象前面
//静态代码块
static {
instance = new HungryMode2();
}
//单例对象
private static HungryMode2 instance = null;
执行结果：
Exception in thread "main" java.lang.NullPointerException
at com.lyy.concurrency.singleton.HungryMode2.main(HungryMode2.java:37)
这里会报空指针异常，这里是为什么呢，是因为如果静态代码块在单例对象前面，会先执行静态代码块，本来执行后已经有值了，但是到了下一步单例对象这里，又会赋值为空，所以就看看到我们执行的结果是空指针异常
我们可以debug看一下：
当我们执行的静态代码块的时候是没有值的
完成之后，我们发现instance是有值的，继续往下走
到这里后，我们会发现instance已经被设置成了Null
枚举模式
/**
* 枚举模式
*/
public class EnumModel1 {
//私有的构造函数
private EnumModel1(){
}
public static EnumModel1 getInstance(){
return Singleton.INSTANCE.getInstance();
}
private enum Singleton{
INSTANCE;
private EnumModel1 singleton;
//构造函数
Singleton(){
singleton = new EnumModel1();
}
public EnumModel1 getInstance(){
return singleton;
}
}
}
当我们通过枚举来初始化这个对象的时候,JVM保证这个方法绝对只调用一次,并且是一个线程安全的类，不需要我们做过多的处理，使用起来也比较方便。所以我们推荐使用这种方式来进行安全发布对象
