安全发布对象

发布对象与对象逸出

package com.mmall.concurrency.demo.publish;

import com.mmall.concurrency.annoations.NotThreadSafe;

import java.util.Arrays;

@NotThreadSafe
public class UnsafePublish {
    private String[] states = {"a", "b", "c"};

    public String[] getStates() {
        return states;
    }

    public static void main(String[] args) {
        UnsafePublish unsafePublish = new UnsafePublish();
        System.out.println(Arrays.toString(unsafePublish.getStates()));

        unsafePublish.getStates()[0] = "d";
        System.out.println(Arrays.toString(unsafePublish.getStates()));
    }
}
/*
[a, b, c]
[d, b, c]
 */

package com.mmall.concurrency.demo.publish;

import com.mmall.concurrency.annoations.NotRecommend;
import com.mmall.concurrency.annoations.NotThreadSafe;

@NotThreadSafe
@NotRecommend
public class Escape {
    private int thisCanBeEscape = 0;

    public Escape() {
        new InnerClass();
    }

    private class InnerClass {
        public InnerClass() {
            System.out.println(Escape.this.thisCanBeEscape);
        }
    }

    public static void main(String[] args) {
        new Escape();
    }
}
/*
0
 */

安全发布对象的4种方法：

1. 在静态初始化函数中初始化一个对象引用

2. 把对象的引用保存到volatile类型域或者AtomicReference对象中

3. 把对象的引用保存到某个正确构造对象的final类型域中

4. 把对象的引用保存到一个由锁保护的域中

package com.mmall.concurrency.demo.singleton;

import com.mmall.concurrency.annoations.NotThreadSafe;

//懒汉模式
@NotThreadSafe
public class SingletonDemo1 {
    //私有构造函数
    private SingletonDemo1() {
    }
    //单例对象
    private static SingletonDemo1 instance = null;
    //静态的工厂方法 加上synchronized关键字可以实现线程安全，不过并不推荐
    public static SingletonDemo1 getInstance() {
        if (instance == null) {
            instance = new SingletonDemo1();
        }
        return instance;
    }

}

package com.mmall.concurrency.demo.singleton;

import com.mmall.concurrency.annoations.ThreadSafe;

//饿汉模式
@ThreadSafe
public class SingletonDemo2 {
    //私有构造函数
    private SingletonDemo2() {
    }
    //单例对象
    private static SingletonDemo2 instance = new SingletonDemo2();
    //静态的工厂方法
    public static SingletonDemo2 getInstance() {
        return instance;
    }

}

package com.mmall.concurrency.demo.singleton;

import com.mmall.concurrency.annoations.NotThreadSafe;

//懒汉模式 双重同步锁
@NotThreadSafe
public class SingletonDemo3 {
    //私有构造函数
    private SingletonDemo3() {
    }
    /*
    1.memory = allocate() 分配对象的内存空间
    2.ctorInstance() 初始化对象
    3.instance = memory 设置instance指向刚分配的内存

    JVM和cpu优化，发生了指令重排

    1.memory = allocate() 分配对象的内存空间
    3.instance = memory 设置instance指向刚分配的内存
    2.ctorInstance() 初始化对象

     */

    //单例对象 加上volatile关键字限制指令重排序可以实现线程安全
    private static SingletonDemo3 instance = null;
    //静态的工厂方法
    public static SingletonDemo3 getInstance() {
        if (instance == null) { //双重检测机制        // B
            synchronized (SingletonDemo3.class) { //同步锁
                if (instance == null) {
                    instance = new SingletonDemo3(); //A - 3
                }
            }
        }
        return instance;
    }
}

package com.mmall.concurrency.demo.singleton;

import com.mmall.concurrency.annoations.ThreadSafe;

//饿汉模式
@ThreadSafe
public class SingletonDemo4 {
    //私有构造函数
    private SingletonDemo4() {
    }
    //单例对象
    private static SingletonDemo4 instance;

    static {
        instance = new SingletonDemo4();
    }
    //静态的工厂方法
    public static SingletonDemo4 getInstance() {
        return instance;
    }

    public static void main(String[] args) {
        System.out.println(getInstance().hashCode());
        System.out.println(getInstance().hashCode());
    }
}

package com.mmall.concurrency.demo.singleton;

import com.mmall.concurrency.annoations.Recommend;
import com.mmall.concurrency.annoations.ThreadSafe;

//枚举模式：最安全
@ThreadSafe
@Recommend
public class SingletonDemo5 {
    //私有构造函数
    private SingletonDemo5() {
    }

    public static SingletonDemo5 getInstance() {
        return Singleton.INSTANCE.getInstance();
    }

    private enum Singleton {
        INSTANCE;
        private SingletonDemo5 singleton;
        //JVM保证这个方法绝对只调用一次
        Singleton() {
            singleton = new SingletonDemo5();
        }
        public SingletonDemo5 getInstance() {
            return singleton;
        }
    }
}