安全发布对象(二)

• 在静态初始化函数中初始化一个对象引用
• 将对象的引用保存到volatile类型域或者AtomicReference对象中
• 将对象的引用保存到某个正确构造对象的final类型域中
• 将对象的引用保存到一个由锁保护的域中

如何保证一个类的实例只被初始化一次且线程安全呢？
懒汉模式(非线程安全)

package io.haitaoc.concurrency.example.singleton;

import io.haitaoc.concurrency.annotation.NotThreadSafe;

/**
 * 懒汉模式
 * 单例的实例在第一次使用的时候进行创建
 */
@NotThreadSafe
public class SingletonExample {

    // 首先要保证这个类不能随便被new一个新的对象出来，所以将构造函数私有化
    private SingletonExample(){

    }

    // 定义一个单例对象，每次都是只返回这同一个对象
    private static SingletonExample instance = null;

    // 静态的工厂方法获取一个单例对象
    public static SingletonExample getInstance(){
        if(instance==null){
            instance = new SingletonExample();
        }
        return instance;
    }
}

饿汉模式(线程安全)

package io.haitaoc.concurrency.example.singleton;


import io.haitaoc.concurrency.annotation.ThreadSafe;

/**
 * 饿汉模式
 * 单例的实例在类装载的时候进行创建
 *
 * 缺点：如果构造函数中有过多的操作处理，会导致类加载的时候特别慢，可能会引起性能问题
 *  如果使用饿汉模式只进行类加载而没有实际调用   会造成资源的浪费
 *
 */
@ThreadSafe
public class SingletonExample2 {

    // 首先要保证这个类不能随便被new一个新的对象出来，所以将构造函数私有化
    private SingletonExample2(){

    }

    // 定义一个单例对象，每次都是只返回这同一个对象
    private static SingletonExample2 instance = new SingletonExample2();

    // 静态的工厂方法获取一个单例对象
    public static SingletonExample2 getInstance(){
        return instance;
    }
}

懒汉模式的线程安全写法(不推荐)

package io.haitaoc.concurrency.example.singleton;

import io.haitaoc.concurrency.annotation.NotRecommend;
import io.haitaoc.concurrency.annotation.NotThreadSafe;
import io.haitaoc.concurrency.annotation.ThreadSafe;

/**
 * 懒汉模式
 * 获取实例的静态工厂方法在添加了synchronized修饰以后
 * 方法内的所有实现，在同一时间内只允许一个线程访问
 * 因此可以保证是线程安全的
 * 但是带来了性能上的开销
 */
@ThreadSafe
@NotRecommend
public class SingletonExample3 {

    // 首先要保证这个类不能随便被new一个新的对象出来，所以将构造函数私有化
    private SingletonExample3(){

    }

    // 定义一个单例对象，每次都是只返回这同一个对象
    private static SingletonExample3 instance = null;

    // 静态的工厂方法获取一个单例对象
    public static synchronized SingletonExample3 getInstance(){
        if(instance==null){
            instance = new SingletonExample3();
        }
        return instance;
    }
}

双重检测机制的不安全版本

package io.haitaoc.concurrency.example.singleton;

import io.haitaoc.concurrency.annotation.NotRecommend;
import io.haitaoc.concurrency.annotation.NotThreadSafe;
import io.haitaoc.concurrency.annotation.ThreadSafe;

/**
 * 懒汉模式 》 双重同步锁单例模式
 * 首先将synchronized放到方法内部去
 */
@NotThreadSafe
@NotRecommend
public class SingletonExample4 {

    // 首先要保证这个类不能随便被new一个新的对象出来，所以将构造函数私有化
    private SingletonExample4(){

    }

    // 定义一个单例对象，每次都是只返回这同一个对象
    private static SingletonExample4 instance = null;

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

    // JVM和cpu优化，发生了指令重排：
    // 1. memeory = allocate()  分配对象的内存空间
    // 3. instance=memory 设置instance指向刚分配的内存
    // 2. contructInstance()   初始化对象

    // 线程A 经过了第1步直接进行第3步, 线程B发现instance不为null
    // 就直接return instance  但instance没有初始化就返回了  就会出现问题

    // 静态的工厂方法获取一个单例对象
    public static  SingletonExample4 getInstance(){
        if(instance==null){         // 双重检测机制       // B
            synchronized (SingletonExample4.class){     // 同步锁
                if(instance==null){
                    instance = new SingletonExample4();     // A - 3
                }
            }

        }
        return instance;
    }
}

双重检测的安全版本(volatile用于双重检测-防止指令重排)

package io.haitaoc.concurrency.example.singleton;

import io.haitaoc.concurrency.annotation.NotRecommend;
import io.haitaoc.concurrency.annotation.NotThreadSafe;
import io.haitaoc.concurrency.annotation.ThreadSafe;

/**
 * 懒汉模式 》 双重同步锁单例模式
 * 用volatile修饰单例对象   不会出现指令重排的问题
 */
@ThreadSafe
@NotRecommend
public class SingletonExample5 {

    // 首先要保证这个类不能随便被new一个新的对象出来，所以将构造函数私有化
    private SingletonExample5(){

    }

    // 定义一个单例对象 volatile + 双重检测机制 -> 禁止指令重排(原因是这里面的instance的写操作)
    private volatile static SingletonExample5 instance = null;

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

    // 静态的工厂方法获取一个单例对象
    public static SingletonExample5 getInstance(){
        if(instance==null){         // 双重检测机制       // B
            synchronized (SingletonExample5.class){     // 同步锁
                if(instance==null){
                    instance = new SingletonExample5();     // A - 3
                }
            }

        }
        return instance;
    }
}

饿汉模式中静态方法的定义顺序

package io.haitaoc.concurrency.example.singleton;


import io.haitaoc.concurrency.annotation.ThreadSafe;

/**
 * 饿汉模式
 * 单例的实例在类装载的时候进行创建
 *
 * 缺点：如果构造函数中有过多的操作处理，会导致类加载的时候特别慢，可能会引起性能问题
 *  如果使用饿汉模式只进行类加载而没有实际调用   会造成资源的浪费
 *
 */
@ThreadSafe
public class SingletonExample6 {

    // 首先要保证这个类不能随便被new一个新的对象出来，所以将构造函数私有化
    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());
    }
}

枚举法线程安全（推荐）

1. 初始化过程只发生一次
2. 后续需要使用实例时会直接返回已经初始化过的那个实例 不会造成资源的浪费且线程安全

package io.haitaoc.concurrency.example.singleton;

import io.haitaoc.concurrency.annotation.Recommend;
import io.haitaoc.concurrency.annotation.ThreadSafe;

@ThreadSafe
@Recommend
public class SingletonExample7 {

    private SingletonExample7(){

    }

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

    private enum Singleton{
        INSTANCE;

        private SingletonExample7 singleton;

        // JVM保证这个方法绝对只被调用一次
        Singleton(){
            singleton = new SingletonExample7();
        }

        public SingletonExample7 getInstance(){
            return singleton;
        }
    }
}