ThreadLocal线程重用bug、ConcurrentHashMap只能保证原子写线程安全

ThreadLocal线程重用bug

在有多核的计算机上运行如下代码，threadLocal/wrong 这个多请求几次，用不同的整数请求，before并非总是null！！！tomcat在运行时默认值不是1个线程，线程重用时，ThreadLocal变量就被下一个线程拥有了！

在controller中声明：

    private ThreadLocal<Integer> currentUser = ThreadLocal.withInitial(() -> null);

@ApiOperation(value = "测试ThreadLocal，线程池线程数不为1时，线程变量可能是线程当前线程的上一个变量")
    @GetMapping("threadLocal/wrong")
    public Map wrong(@RequestParam("userId") Integer userId) {
        String before = Thread.currentThread().getName() + ":" + currentUser.get();
        currentUser.set(userId);
        // 设置用户信息之后再取一次
        String after = Thread.currentThread().getName() + ":" + currentUser.get();
        Map result = new HashMap();
        result.put("Before", before);
        result.put("After", after);
        return result;
    }

    @ApiOperation(value = "测试ThreadLocal，线程池线程数不为1时，ThreadLocal变量使用完释放")
    @GetMapping("threadLocal/correct")
    public Map correct(@RequestParam("userId") Integer userId) {
        String before = Thread.currentThread().getName() + ":" + currentUser.get();
        currentUser.set(userId);
        // 设置用户信息之后,再取
        String after = Thread.currentThread().getName() + ":" + currentUser.get();
        Map result = new HashMap();
        result.put("Before", before);
        result.put("After", after);
        currentUser.remove();
        return result;
    }

线程重用： 

 {

    "Before": "http-nio-10086-exec-1:4",

    "After": "http-nio-10086-exec-1:5"

}

threadLocal/correct 用完释放，或者设置tomcat最大工作线程数为1

并发工具包下的ConcurrentHashMap是线程安全的么？

    //线程个数
    private static int THREAD_COUNT = 10;
    //总元素数量
    private static int ITEM_COUNT = 1000;

    private ConcurrentHashMap<String, Long> getData(int count) {
        return LongStream.rangeClosed(1, count)
                .boxed()
                .collect(Collectors.toConcurrentMap(i -> UUID.randomUUID().toString(), Function.identity(),
                        (o1, o2) -> o1, ConcurrentHashMap::new));
    }

    @ApiOperation(value = "测试并发工具包ConcurrentHashMap集合，示例并发操作错误。线程池线程数不为1时")
    @GetMapping("concurrentHashMap/wrong")
    public String concurrentHashMapWrong() throws InterruptedException {
        ConcurrentHashMap<String, Long> concurrentHashMap = getData(ITEM_COUNT - 100);
        System.out.println("===>wrong,线程个数：" + Runtime.getRuntime().availableProcessors());
        log.info("===>wrong,初始化的concurrentHashMap size = {}", concurrentHashMap.size());
        ForkJoinPool forkJoinPool = new ForkJoinPool(THREAD_COUNT);
        forkJoinPool.execute(() -> IntStream.rangeClosed(1, 10).parallel().forEach(i -> {
            int gap = ITEM_COUNT - concurrentHashMap.size();
            log.info("===>wrong,gap size: {}", gap);
            concurrentHashMap.putAll(getData(gap));
        }));

        forkJoinPool.shutdown();
        forkJoinPool.awaitTermination(1, TimeUnit.SECONDS);
        log.info("===>wrong,concurrentHashMap size: {}", concurrentHashMap.size());
        return "ok";
    }

    @ApiOperation(value = "测试并发工具包ConcurrentHashMap集合，线程池线程数不为1时")
    @GetMapping("concurrentHashMap/correct")
    public String concurrentHashMapCorrect() throws InterruptedException {
        ConcurrentHashMap<String, Long> concurrentHashMap = getData(ITEM_COUNT - 100);
        log.info("===>correct,初始化的concurrentHashMap size = {}", concurrentHashMap.size());
        ForkJoinPool forkJoinPool = new ForkJoinPool(THREAD_COUNT);
        forkJoinPool.execute(() -> IntStream.rangeClosed(1, 10).parallel().forEach(i -> {
            synchronized (concurrentHashMap) {
                int gap = ITEM_COUNT - concurrentHashMap.size();
                log.info("===>correct,gap size: {}", gap);
                concurrentHashMap.putAll(getData(gap));
            }
        }));

        forkJoinPool.shutdown();
        forkJoinPool.awaitTermination(1, TimeUnit.SECONDS);
        log.info("===>correct,concurrentHashMap size: {}", concurrentHashMap.size());
        return "ok";
    }

可以自己动手跑跑这俩方法！

 再看下上锁的示例

对ConcurrentHashMap的操作，大小何放元素时整段加锁！

        ConcurrentHashMap这容器本身，可以确保多个线程在put元素时，不会互相干扰，但是无法确保线程1看到还需要put 1000个元素但还未put 时，线程2就看不到容器中的元素数量。
你往这个容器put 1000个元素的操作不是原子性的，在其它线程看来可能会有一瞬间，容器里有964个元素，还需要填36个元素。

        所以，当只是往里put数据的话它是安全的，只是并发往里塞一定量(如1000个)的数据也是安全的，如果塞的时候还要监控当前塞了多少个的时候是会出问题的(中间状态)！