让人抓头的Java并发(一) 轻松认识多线程

Java线程的实现

Java线程之间的通信由Java内存模型(JMM)控制，JMM决定了一个线程对共享变量的写入何时对其他线程可见。Java多线程同时访问一个对象或者变量时，由于每个线程拥有的只是这个变量的拷贝(为了加快程序的执行)，所以在执行过程中，一个线程看到的变量并不一定是最新的。

:bulb:小提示：线程私有的本地内存是一个缓存、写缓冲等的抽象概念

Java内存模型

Java中的线程通信方式有以下几种:

• synchronized -- 一个线程释放锁之后会使同步队列中阻塞状态的线程重新尝试获取锁
• volatile -- 一个线程对变量的修改必须同步刷新回主存中，保证了其他线程对变量的可见性， 但并不保证原子性
• Object的wait()/notify()机制 -- 调用对象的notify()方法会使处于对象等待队列中的线程从对象的wait()方法返回，重新进入同步队列尝试获取锁
• 管道输入/输出流 -- 线程之间数据传输(单向)，媒介为内存

线程间的通信方式：共享内存、消息队列；

//等待通知模式的经典范式:
synchronized (object) {
    while (boolean) {
        object.wait();
    }
    doSomeThing();
}

synchronized (object) {
    change boolean;
    object.notify();
}
复制代码

将操作共享变量的代码行作为一个整体，同一时间只允许一个线程执行。目的是为了防止多个线程访问一个变量时出现不一致。

Java中实现线程同步的方式:

• synchronized
• Lock
• CountDownLatch
• CyclicBarrier
• Semaphore
• 阻塞队列

除了synchronized其它几种同步方式的实现都与AQS有关，后续文章中会详细介绍，下面给大家来个demo感受下本篇文章的内容。

/**
 * @author XiaMu
 */
public class FutureTaskDemo {

    private static volatile Integer count = 0;

    private static CountDownLatch countDownLatch = new CountDownLatch(500);

    private static ReentrantLock lock = new ReentrantLock();

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 不推荐，为了方便使用了
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        List<FutureTask<Integer>> resultList = new ArrayList<>(500);
        for (int i = 0; i < 500; i++) {
            FutureTask<Integer> task = new FutureTask<>(() -> {
//                lock.lock();(1)
                int result = count++;
//                lock.unlock();(1)
//                countDownLatch.countDown();(2)
                return result;
            });
            executorService.submit(task);
            resultList.add(task);
        }
//        countDownLatch.await();(2)
        System.out.println("第一处计算结果:" + count);
        // 为了查看每个任务的执行结果
        Map<Integer, Integer> resultMap = new HashMap<>(500);
        for (FutureTask<Integer> result : resultList) { // (3)
            Integer sum = result.get();
            if (resultMap.containsKey(sum)) {
                System.out.println(sum + "计算过了");
            } else {
                resultMap.put(sum, 1);
            }
        }
        System.out.println("第二处计算结果:" + count);
        executorService.shutdown();
    }
}
复制代码

取两次执行结果：

第一处计算结果:0                        第一处计算结果:270
135计算过了                             492计算过了
163计算过了                             16计算过了
454计算过了                             437计算过了
458计算过了                             445计算过了
463计算过了                             第二处计算结果:496
470计算过了
317计算过了
319计算过了
第二处计算结果:492
复制代码

:bulb:：毫无疑问，计算结果出现了错误，可以将(1)注释打开加锁保证计算正确。第一处计算结果不等于第二处是因为主线程执行到第一处时，子任务并没有执行完。如果没有(3)的for循环中获取结果的Future.get()阻塞主线程,那么第二处计算结果打印时子任务可能还没执行完。注释(2)打开可以解决两次打印不一致问题，因为CountDownLatch会将主线程阻塞直到第500个子任务执行完毕。