6、Java并发编程入门与高并发面试-线程安全策略

慕课网 Jimin老师 Java并发编程入门与高并发面试 学习笔记
Java并发编程入门与高并发面试

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

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

方式（可参考String类）：

• 将类申明为final
• 将所有的成员申明为私有
• 对变量不提供set方法，将所有可变成员声明为final，这样只能对其赋值一次
• 通过构造器初始化所有成员，进行深度拷贝
• 在get方法中，不返回对象的本身，而是返回其对象的拷贝

final关键字:类、 方法、变量

◆修饰类:不能被继承
◆修饰方法: 1、锁定方法不被继承类修改; 2、效率
◆修饰变量:基本数据类型变量、引用类型变量

package com.huhao.concurrency.example.immutable;

import com.google.common.collect.Maps;
import com.huhao.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));
        log.info("{}", map);
    }

    private void test(final int a) {
        //不可以改
        //a = 1;
    }

}

除了final可设置不可变变量，还可以通过以下类

◆Collections.unmodifiableXXX : Collection. List. Set. Map...
◆Guava : ImmutableXXX : Collection、List, Set、 Map...

package com.huhao.concurrency.example.immutable;

import com.google.common.collect.Maps;
import com.huhao.concurrency.annoations.NotThreadSafe;
import com.huhao.concurrency.annoations.ThreadSafe;
import lombok.extern.slf4j.Slf4j;

import java.util.Collections;
import java.util.Map;

/**
 * unmodifiableMap
 * 不可修改
 * 修改时不会编译报错，但是运行会报错抛出异常
 */
@Slf4j
@ThreadSafe
public class ImmutableUnmodifiableMap {
    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) {
        //unmodifiableMap后，修改会报错
        map.put(1, 3);
        log.info("{}", map.get(1));
        log.info("{}", map);
    }
}

package com.huhao.concurrency.example.immutable;


import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
import com.huhao.concurrency.annoations.ThreadSafe;
import lombok.extern.slf4j.Slf4j;

/**
 * ImmutableImmutable
 */
@Slf4j
@ThreadSafe
public class ImmutableImmutable {
    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);

        //会抛出异常
//        map.put(1, 4);
//        map2.put(1, 4);
    }
}

线程封闭

1、Ad-hoc线程封闭:程序控制实现,最糟糕，忽略
2、堆栈封闭:局部变量，无并发问题，能用局部变量就不用全局变量
3、ThreadLocal 线程封闭：特别好的封闭方法
eg：动态数据源切换时候， 每个线程请求取到的context_holder都是独立的

image.png

线程不安全类与写法

StringBuilder ->StringBuffer
builder是不安全的，buffer是安全的。不过在方法里的私有的，用builder效率更高
SimpleDateFormat -> JodaTime
SimpleDateFormat 不安全、每次都是要new SimpleDateFormat ()，不然会报错。JodaTime是线程安全    的，推荐使用，而且还有其他优势。
ArrayList，HashSet，HashMap等Collections

同步容器

◆ArrayList -> Vector, Stack
◆HashMap -> HashTable (key、value不能为null)
◆Collections.synchronizedXXX (List、Set、 Map)

并发容器J.U.C

◆ArrayList -> CopyOnWriteArrayList
HashSet、TreeSet -> CopyOnWriteArraySet
ConcurrentSkipListSet
◆HashMap、 TreeMap -> ConcurrentHashMap
ConcurrentSkipListMap