并发编程与高并发解决方案学习(安全发布对象Singleton、final)

一、相关概念

发布对象：使一个对象能够被当前范围之外的代码所使用

对象逸出：一种错误的发布。当一个对象还没有构造完成时，就使它被其他线程所见。

---

发布对象

import vip.fkandy.concurrency.annoations.NotThreadSafe;
import lombok.extern.slf4j.Slf4j;

import java.util.Arrays;

/**
 * https://blog.csdn.net/andy2019/article/details/79783980
 */
@Slf4j
@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();
        log.info("{}", Arrays.toString(unsafePublish.getStates()));

        unsafePublish.getStates()[0] = "d";
        log.info("{}", Arrays.toString(unsafePublish.getStates()));
    }
}

 

输出结果

11:24:03.912 [main] INFO vip.fkandy.chapter11.UnsafePublish - [a, b, c]
11:24:03.916 [main] INFO vip.fkandy.chapter11.UnsafePublish - [d, b, c]

 对象逸出

import com.mmall.concurrency.annoations.NotRecommend;
import com.mmall.concurrency.annoations.NotThreadSafe;
import lombok.extern.slf4j.Slf4j;

@Slf4j
@NotThreadSafe
@NotRecommend
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();
    }
}

 输出结果

11:25:41.041 [main] INFO vip.fkandy.chapter11.Escape - 0

二、安全发布对象的四种方式：

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

※ 将对象的引用保存到volatile类型域或者AtomicReference对象中

※ 将对象的引用保存到某个正确构造对象的final类型域中

※ 将对象的引用保存到一个由锁保护的域中

package vip.fkandy.chapter11;

/**
 * 懒汉模式
 * 单例实例在第一次使用时进行创建
 */
public class SingletonExample1 {
    // 私有构造函数
    private SingletonExample1() {
    }
 
    // 单例对象
    private static SingletonExample1 instance = null;
    // 静态的工厂方法(在多线程时候，可以通过加synchronized)
    public static SingletonExample1 getInstance() {
        if (instance == null) {
            instance = new SingletonExample1();
        }
        return instance;
    }
}

 要想实现线程安全，需要在getInstance()方法中添加synchronized关键字

package vip.fkandy.chapter11;


/**
 * 饿汉模式
 * 单例实例在类装载时进行创建
 */
public class SingletonExample2 {
    // 私有构造函数
    private SingletonExample2() {
    }
    // 单例对象
    private static SingletonExample2 instance = new SingletonExample2();
    // 静态的工厂方法
    public static SingletonExample2 getInstance() {
        return instance;
    }
}

 恶汉模式是天然的线程安全操作，但是如果构造方法里面有过多的处理，很让类加载的很慢，影响性能。并且如果加载完毕了，但是又没有用到，就会发生资源的浪费

package vip.fkandy.chapter11;

/**
 * 懒汉模式
 * 单例实例在第一次使用时进行创建
 */
public class SingletonExample3 {
    // 私有构造函数
    private SingletonExample3() {
    }
    // 单例对象
    private static SingletonExample3 instance = null;
    // 静态的工厂方法
    public static synchronized SingletonExample3 getInstance() {
        if (instance == null) {
            instance = new SingletonExample3();
        }
        return instance;
    }
}

上面这种写法会带来性能的开销，不建议使用了。。。。

package vip.fkandy.chapter11;


/**
 * 懒汉模式 -》 双重同步锁单例模式
 * 单例实例在第一次使用时进行创建
 */
//非线程安全
public class SingletonExample4 {
    // 私有构造函数
    private SingletonExample4() {
    }
 
    // 1、memory = allocate() 分配对象的内存空间
    // 2、ctorInstance() 初始化对象
    // 3、instance = memory 设置instance指向刚分配的内存
 
    // JVM和cpu优化，发生了指令重排
 
    // 1、memory = allocate() 分配对象的内存空间
    // 3、instance = memory 设置instance指向刚分配的内存
    // 2、ctorInstance() 初始化对象
 
    // 单例对象
    private static SingletonExample4 instance = null;
 
    // 静态的工厂方法
    public static SingletonExample4 getInstance() {
        if (instance == null) { // 双重检测机制        // B
            synchronized (SingletonExample4.class) { // 同步锁
                if (instance == null) {
                    instance = new SingletonExample4(); // A - 3
                }
            }
        }
        return instance;
    }
}

以上这个例子也不是线程安全的，在发生CPU指令重排的时候会发生线程安全问题。

package vip.fkandy.chapter11;


/**
 * 懒汉模式 -》 双重同步锁单例模式
 * 单例实例在第一次使用时进行创建
 */
//线程安全
public class SingletonExample5 {
    // 私有构造函数
    private SingletonExample5() {
    }
 
    // 1、memory = allocate() 分配对象的内存空间
    // 2、ctorInstance() 初始化对象
    // 3、instance = memory 设置instance指向刚分配的内存
 
    // 单例对象 volatile + 双重检测机制 -> 禁止指令重排
    private volatile static SingletonExample5 instance = null;
 
    // 静态的工厂方法
    public static SingletonExample5 getInstance() {
        if (instance == null) { // 双重检测机制        // B
            synchronized (SingletonExample5.class) { // 同步锁
                if (instance == null) {
                    instance = new SingletonExample5(); // A - 3
                }
            }
        }
        return instance;
    }
}

双重检测锁通过添加volatile关键字达到线程安全

import com.mmall.concurrency.annoations.ThreadSafe;

/**
 * 饿汉模式
 * 单例实例在类装载时进行创建
 */
@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());
    }
}

import com.mmall.concurrency.annoations.Recommend;
import com.mmall.concurrency.annoations.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;
        }
    }
}

三、不可变对象需要满足的条件：

※对象创建以后其状态就不能修改

※对象所有域都是final类型

※对象时正确创建的(在对象创建期间，this引用没有逸出)

 

四、final关键字：类、方法、变量

※修饰类：不能被继承

※修饰方法：1、锁定方法不被继承类修改；2、效率

※修饰变量：基本数据类型变量、应用类型变量(初始化之后不能再指向另外变量)

import com.google.common.collect.Maps;
import com.mmall.concurrency.annoations.NotThreadSafe;
import lombok.extern.slf4j.Slf4j;
import java.util.Map;

@Slf4j
@NotThreadSafe
public class ImmutableExample1 {
    private final static Integer a = 1;
    private final static String b = "2";
    private final static Map<Integer, Integer> map = Maps.newHashMap();
    static {
        map.put(1, 2);
        map.put(3, 4);
        map.put(5, 6);
    }
    public static void main(String[] args) {
//        a = 2;
//        b = "3";
//        map = Maps.newHashMap();
        map.put(1, 3);
        log.info("{}", map.get(1));
    }
    private void test(final int a) {
//        a = 1;
    }
}

import com.google.common.collect.Maps;
import com.mmall.concurrency.annoations.ThreadSafe;
import lombok.extern.slf4j.Slf4j;
import java.util.Collections;
import java.util.Map;

@Slf4j
@ThreadSafe
public class ImmutableExample2 {
    //这里没有final
    private static Map<Integer, Integer> map = Maps.newHashMap();
    static {
        map.put(1, 2);
        map.put(3, 4);
        map.put(5, 6);
        map = Collections.unmodifiableMap(map); //定义不可变对象
    }
    public static void main(String[] args) {
        map.put(1, 3);
        log.info("{}", map.get(1));
    }

}

import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
import com.mmall.concurrency.annoations.ThreadSafe;

@ThreadSafe
public class ImmutableExample3 {
    private final static ImmutableList<Integer> list = ImmutableList.of(1, 2, 3);
    private final static ImmutableSet set = ImmutableSet.copyOf(list);
    private final static ImmutableMap<Integer, Integer> map = ImmutableMap.of(1, 2, 3, 4);
    private final static ImmutableMap<Integer, Integer> map2 = ImmutableMap.<Integer, Integer>builder()
            .put(1, 2).put(3, 4).put(5, 6).build();
    public static void main(String[] args) {
//        list.add(4);
//        set.add(2)
        System.out.println(map2.get(3));
    }
}

无、不可变对象创建方式

Collections.unmodifiableXXX:Collection、List、Set、Map....

Guava:ImmutableXXX:Collection、List、Set、Map.....