jdk基础设施回顾：jdk中的concurrent包

1、并发和多线程（以jdk1.7为例）

并发是伴随着多核处理器的诞生而产生的，为了充分利用硬件资源，诞生了多线程技术。但是多线程又存在资源竞争的问题，引发了同步和互斥的问题，jdk中使用concurrent包来解决这些问题。

2、Atomic原子计算对象包

包括：

AtomicInteger

AtomicBoolean

AtomicLong

AtomicReference

原子操作，主要是用CAS操作保证对该对象的操作的原子性，比如a＋＋这样的操作实际上是分两步，第一步加1再赋值，如果a在＋1的过程中其它线程修改了值CAS会放弃本次赋值操作并重新加1赋值，从而保证操作的原子性。

3、锁

先解释一些名词：

自旋锁：当一个线程尝试去获取一个锁时如果当前锁已被其它线程获取那么该线程会不断尝试获取锁而不是挂起线程或使线程睡眠。

乐观锁：每次拿数据时都假设其它线程不会修改数据，只有修改数据时才判断其它线程有没有修改数据

悲观锁：相对于乐观锁的一个概念，每次拿数据时都会锁住数据这样其它线程就无法获取锁，数据库事务中一般都使用悲观锁

共享锁：常说的读锁，只能读取数据，其它线程只能获取读锁，sql原语支持，lock in share model（mysql）

互斥锁：常说的写锁，既能读也能写，其它线程不能获取锁，sql原语支持，for update（mysql）

数据库事务一般提供悲观锁，乐观锁一般通过版本号实现。

包括：

AbstractQueueSynchronizer(AQS)

Lock

ReentrantLock(可重入锁)

ReadWriteLock（读写锁）

ReentrantReadWriteLock（可重入的读写锁）

聊锁之前，先谈谈AQS这个在并发包里比较重要的类，此同步器提供了一套实现联动锁和基于先进先出等待队列的同步器的框架，其中有个内部类node，它组成了一个链表，这个链表实现了一个自旋锁。AQS内部有俩链表实现的队列，一个是main queue，一个是condition上的队列，当调用了condition.await()则生成一个新的node加入到condition队列，当调用condition.signal()时condition中的firstwaiter就被转移到main queue，如果调用aqs的acquire方法（比如lock方法会调用acquire）则在main queue的tail添加一个node，如果调用aqs的release方法（比如unlock方法会调用release方法）则在main queue中删除一个head指向的node。

可重入锁，比如特定的几个线程之间需要同步，那么它们可以使用同一个锁但不同的condition，通过condition去协调顺序，这时候可重入锁就能发挥作用应为使用同一个锁的lock方法的线程是不会阻塞的，如果使用不可重入锁那么这几个线程会死锁。

读写锁主要用于读写分离，但不能在同一线程中持有读锁的情况下尝试获取写锁，会发生死锁。ReentrantReadWriteLock和ReadWriteLock没有继承关系，他们都是使用aqs实现的。

 

3、同步设施CountDownLatch、CycilcBarrier、Semaphore

CountDownLatch和CycilcBarrier是可以交换使用的，唯一区别前者是一次性的后者可以服用，它们适合的场景是主线程需要阻塞等待多个线程执行完后再执行的场景。比如有a、b、c三个线程，a需要等b、c执行完后再执行。首先创建一个CountDownLatch(2)对象在a中调用其await函数阻塞掉a。b和c执行完后调用latch的countdown函数，当计数为0时a会被唤醒继续执行。

Semaphore直译为资源信号量，Semaphore(int permits)中的permits代表共享资源的个数，当所有资源都被占用时，后续的线程会被阻塞掉直到有资源被释放。

4、BlockingQueue、ConcurrentHashMap等线程安全的集合类

有时间再来补齐

5、线程池构造辅助类Executors、线程池ThreadPoolExecutor和Future、Callable

Executors提供了SingleThreadPool、FixedThreadPool、CachedThreadPool、ScheduledThreadPool四种线程池。

newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程
newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。
newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO , LIFO, 优先级)执行。

调用ExecutorService的submit(Callable callable)方法会返回一个future，再调用future的get()获取结果。下面是使用实例：

public class Test {
    public static void main(String[] args) {
        //第一种方式
        ExecutorService executor = Executors.newCachedThreadPool();
        Task task = new Task();
        FutureTask<Integer> futureTask = new FutureTask<Integer>(task);
        executor.submit(futureTask);
        executor.shutdown();
         
        //第二种方式，注意这种方式和第一种方式效果是类似的，只不过一个使用的是ExecutorService，一个使用的是Thread
        /*Task task = new Task();
        FutureTask<Integer> futureTask = new FutureTask<Integer>(task);
        Thread thread = new Thread(futureTask);
        thread.start();*/
         
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e1) {
            e1.printStackTrace();
        }
         
        System.out.println("主线程在执行任务");
         
        try {
            System.out.println("task运行结果"+futureTask.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
         
        System.out.println("所有任务执行完毕");
    }
}
class Task implements Callable<Integer>{
    @Override
    public Integer call() throws Exception {
        System.out.println("子线程在进行计算");
        Thread.sleep(3000);
        int sum = 0;
        for(int i=0;i<100;i++)
            sum += i;
        return sum;
    }
}

6、Fork/Join并行计算框架

包括ForkJoinPool、ForJoinTask、ForkJoinWorkerThread三个类，ExecutorService也可以完成任务分治的任务，但是Callable本质是同步的(获取结果的时候)，无法充分利用cpu资源。为了解决这个问题jdk7引入了Fork/Join框架。

可以调用一个task的fork函数将一个任务分成多个子任务，也可以调用task的join函数将当前的结果和它的父任务进行合并最后得到一个完整的结果。