JAVA并发编程与高并发解决方案 - 并发编程 三 之 线程安全策略

JAVA并发编程与高并发解决方案 - 并发编程 三

版本	作者	内容
2018.5.17	chuIllusions	线程安全策略

线程安全策略

​ 创建后状态不能被修改的对象叫作不可变对象。不可变对象天生就是线程安全的。它们的常量（变量）是在构造函数中创建的，既然它们的状态无法被修改，那么这些常量永远不会被改变——不可变对象永远是线程安全的。

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

• 对象创建以后其状态就不能修改
• 对象所有域都是final类型
• 对象是正确创建的（在对象创建期间，this引用没有逸出）

不可变对象

final

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

• 修饰类：不能被继承，final类中的成员属性可以根据需要设置为final，但final类中所有的成员方法都被隐式指定为final方法。一般不建议将类设置为final类型。可以参考String类。
• 修饰方法：1）锁定方法不被继承类修改；2）效率
• 修饰变量：1）基本数据类型变量，初始化后便不能进行修改；2）引用类型变量，初始化之后不能再指向别的引用

@Slf4j
@NotThreadSafe
public class ImmutableExample1 {

    private final static Integer a = 1;
    private final static String b = "2";
    //引用类型不允许引用指向改变，但是对象值还是可以进行修改的  
    private final static Map 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;
    }
}

Collections

​ java提供Collections工具类，在类中提供了多种不允许修改的方法

​ Collections.unmodifiableXXX：Collection、List、Set、Map…

@Slf4j
@ThreadSafe
public class ImmutableExample2 {

    private static Map map = Maps.newHashMap();

    static {
        map.put(1, 2);
        map.put(3, 4);
        map.put(5, 6);
        //处理过后的map是不可以再进行修改的
        map = Collections.unmodifiableMap(map);
    }

    public static void main(String[] args) {
        //允许操作，但是操作会报错，扔出异常
        map.put(1, 3);
        log.info("{}", map.get(1));
    }

}

public class Collections {
    public static  Map unmodifiableMap(Map m) {
        return new UnmodifiableMap<>(m);
    }
    private static class UnmodifiableMap<K,V> implements Map<K,V>, Serializable {
        @Override
        public boolean remove(Object key, Object value) {
            throw new UnsupportedOperationException();
        }

        @Override
        public boolean replace(K key, V oldValue, V newValue) {
            throw new UnsupportedOperationException();
        }
    }
}

Guava

​ 谷歌的Guava提供类似Java中的Collections

​ ImmutableXXX：Collection、List、Set、Map…

pom.xml

<dependency>
   <groupId>com.google.guavagroupId>
   <artifactId>guavaartifactId>
   <version>23.0version>
dependency>

@ThreadSafe
public class ImmutableExample3 {

    private final static ImmutableList list = ImmutableList.of(1, 2, 3);

    private final static List lists = ImmutableList.of(1, 2, 3);

    private final static ImmutableSet set = ImmutableSet.copyOf(list);

    private final static ImmutableMap map = ImmutableMap.of(1, 2, 3, 4);

    private final static ImmutableMap map2 = ImmutableMap.builder()
            .put(1, 2).put(3, 4).put(5, 6).build();

    public static void main(String[] args) {
        System.out.println(map2.get(3));
    }
}

​ 介绍了不可变对象，通过在某些情况下，将不能被修改的类对象，设置为不可变对象，来让对象在多个线程间是线程安全的。归根到底，其实是躲避开了并发的问题。除了不可变对象，还存在一个方法 就是线程封闭

线程封闭

​ 把对象封装到一个线程里，只有这一个线程能看到该对象，那么就算这个对象不是线程安全的，也不会出现任何线程安全的问题，因为它只能在一个线程中被访问，如何实现线程封闭：

• Ad-hoc 线程封闭：程序控制实现，非常脆弱、最糟糕，忽略
• 堆栈封闭：简单的说就是局部变量，无并发问题。多个线程访问同一个方式的时候，方法中的局部变量都会被拷贝一份到线程栈中，方法的局部变量是不被多个线程共享的，因此不会出现线程安全问题，能用局部变量就不推荐使用全局变量，全局变量容易引起并发问题，注意，全局的变量而不是全局的常量。
• ThreadLocal 线程封闭：特别好的封闭方法

ThreadLocal

/**
 * This class provides thread-local variables.  These variables differ from
 * their normal counterparts in that each thread that accesses one (via its
 * {@code get} or {@code set} method) has its own, independently initialized
 * copy of the variable.  {@code ThreadLocal} instances are typically private
 * static fields in classes that wish to associate state with a thread (e.g.,
 * a user ID or Transaction ID).
 */
public class ThreadLocal<T> {}

​ 从类描述上:ThreadLocal提供线程级别的变量.这些变量不同于它们正常下的变量副本,在每一个线程中都有它自己获取方式(通过它的get和set方法)，不依赖变量副本的初始化。它的实例通常都是私有的静态的，用于关联线程的上下文。

​ 这些变量在多线程环境下访问(通过get或set方法访问)时能保证各个线程里的变量相对独立于其他线程内的变量

​ 总结：ThreadLocal的作用是提供线程内部的局部变量，这种变量只存在线程的生命周期。

声明方式：private static ThreadLocal