第3章 JDK并发包

• 使用了重入锁后，线程可以被中断，即在等待锁的过程中可取消对锁的请求，lock.lockInterruptibly()以可以对中断进行响应方式申请锁，捕捉InterruptedException即可
• tryLock用于对锁请求限时，成功获得锁返回 true，否则返回 false，不带参数表示立即返回请求结果
• 重入锁支持公平模式，public ReentrantLock(boolean fair)，但是公平锁的性能相对更低

• 原子状态，使用CAS操作存储当前锁的状态
• 等待队列，没有请求到锁的线程会进入等待队列，待有线程释放锁后，系统就能从等待队列中唤醒一个线程
• 阻塞原语park, unpark，用来挂起和恢复线程

• await()会使当前线程等待，同时释放当前锁，当其他线程中使用signal、signalAll时，线程会重新获得锁并继续执行；而当线程被中断时，也能跳出等待
• awaitUninterruptibly()与await()基本相同，但是它并不会在等待过程中响应中断
• signal()、signalAll()用于唤醒线程，分别对应一个和所有

• acquire获取一个准入许可，若无法获取则等待，直到有线程释放一个许可或者当前线程被中断
• acquireUninterruptibly与acquire相似，但不会响应中断
• tryAcquire尝试获取一个许可，如果成功返回 true
• release用于在线程范文资源结束后释放一个许可

• newFixedThreadPool返回一个固定线程数量的线程池，当新任务提交但池中空闲线程不足时，新任务暂存在任务队列中
• newSingleThreadExecutor返回只有一个线程的线程池，多得任务会保存在任务队列中排队调度
• newCachedThreadPool返回动态数量的线程池，不够用时创建新的线程，够用时复用
• newSingleThreadShceduledExecutor返回线程数量为1的固定延时或者周期性执行某任务的线程池
• newScheduledThreadPool返回指定线程数量的固定延时或者周期性执行任务的线程池

• scheduleAtFixedRate在初始时延首次执行后，可以以固定的周期执行，initDelay + n * T，但前提是必须在上一周期任务执行完毕后，否则必须待上一周期结束后立即执行
• scheduleWithFixedDelay在初始时延首次执行后，可以按照上次执行结束后固定时延周期执行

• corePoolSize：指定了线程池中的线程数量
• maximumPoolSize：指定了线程池中的最大线程数量
• keepAliveTime：当线程池数量超过 corePoolSize 时，空闲线程的存活时间
• unit：keepAliveTime 的单位
• workQueue：任务队列，被提交但尚未被执行的任务。可用 SynchronousQueue（直接提交队列，没有空闲则执行拒绝策略），ArrayBlockingQueue（有界任务队列），LinkedBlockingQueue（无界任务队列），PriorityBlockingQueue（优先任务队列）
• threadFactory：线程工厂，用于创建线程
• handler：拒绝策略，需实现RejectedExecutionHandler接口
  a. AbortPolicy 直接抛出异常，阻止系统正常工作；
  b. CallerRunsPolicy 只要线程池未关闭，直接在调用者线程中运行当前被丢弃的任务；
  c. DiscardOledestPolicy 丢弃最老的一个请求；
  d. DiscardPolicy 丢弃无法处理的任务，不予任何处理

• 入参不同，execute只接受Runnable，而submit还可以接受Callable
• submit方法是有返回值的
• submit可以通过future.get来获取异常信息，execute只能用UncaughtExceptionHandler来处理异常，Thread.setDefaultUncaughtExceptionHandler

public class CountTask extends RecursiveTask<Long> {
    private static final int THRESHOLD = 10000;
    private long start;
    private long end;

    public CountTask(long start, long end) {
        this.start = start;
        this.end = end;
    }

    @Override
    protected Long compute() {
        long sum = 0;
        boolean canCompute = (end - start) < THRESHOLD;
        if (canCompute) {
            for (long i=start; i<=end; i++) {
                sum += i;
            }
        } else {
            long step = (start+end) / 100;
            ArrayList<CountTask> subTasks = new ArrayList<>();
            long pos = start;
            for (int i = 0; i < 100; i++) {
                long lastOne = pos + step;
                if (lastOne > end) {
                    lastOne = end;
                }
                CountTask subTask = new CountTask(pos, lastOne);
                pos += step + 1;
                subTasks.add(subTask);
                subTask.fork();
            }
            for (CountTask subTask : subTasks) {
                sum += subTask.join();
            }
        }
        return sum;
    }

    public static void main(String[] args) {
        ForkJoinPool forkJoinPool = new ForkJoinPool();
        CountTask task = new CountTask(0, 200000L);
        ForkJoinTask<Long> result = forkJoinPool.submit(task);

        try {
            long res = result.get();
            System.out.println("sum="+res);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

static final class Node<K, V> {
  final K key;
  volatile Object value;
  volatile Node<K, V> next;
}

static class Index<K, V> {
  final Node<K, V> node;
  final Index<K, V> down;
  volatile Index<K, V> right;
}