concurrent包

一、Atomic
Atomic变量通过cpu的cas指令结果与实际计算结果对比，false继续下一次计算对比（乐观锁）。存在ABA问题。
对比volatile变量，(轻量级锁)，直接写主内存。可见性的，但是i++不是原子性的。Atomic声明变量是 volatile 的，JVM 保证了每次读变量都从内存中读，跳过 CPU cache 这一步。
对比sychronize，(重量级锁)。
Atomic包提供了以下三个类：
AtomicBoolean：原子更新布尔类型。addAndGet、getAndIncrement、getAndSet返回就值
AtomicInteger：原子更新整型。
AtomicLong：原子更新长整型。
AtomicBoolean是把boolean转成整型再调用compareAndSwapInt进行CAS来实现的，类似的short和byte也可以转成整形，float和double可以利用Float.floatToIntBits，Double.doubleToLongBits转成整形和长整形进行相应处理。
二、集合(List,Map,Que)
ConcurrentMap；
ConcurrentHashMap:分段同步写锁，volatile变量，读不加锁。
ConcurrentNavigableMap:
BlockingQueue:
ArrayBlockingQueue:先进先出

抛出异常	特殊值	阻塞	超时
插入	add(e)	offer(e)	put(e)	offer(e, time, unit)
移除	remove()	poll()	take()	poll(time, unit)
检查	element()	peek()	不可用	不可用

DelayQueue:
LinkedBlockingQueue:
SynchronousQueue:

三、线程执行框架(Excutor,callable,Future)
1、Excutor是ExcutorService的工厂，ExcutorService有1个子类ThreadPoolExecutor,根据构造参数的不同可以分为四类。可以直接通过Excutor调方法创建。
(1)CachedThreadPool：有新任务需要执行时，首先查询池中是否有空闲线程并且还为到空闲截止时间，如果有，则使用空闲线程，如果没有，则创建新线程并放入池中。用于执行一些生存期很短的异步型任务。不适用于IO等长延时操作，因为这可能会创建大量线程，导致系统崩溃。使用SynchronousQueue作为阻塞队列。
(2)SingleThreadPool：只有一个线程在执行。适用于有明确执行顺序但是不影响主线程的任务，压入池中的任务会按照队列顺序执行。使用无界的LinkedBlockingQueue，要综合考虑生成与消费能力，生成过剩，可能导致堆内存溢出。
(3)FixedThreadPool：线程数量固定，不会发生变化。适用一些很稳定很固定的正规并发线程，多用于服务器。使用无界的LinkedBlockingQueue，要综合考虑生成与消费能力，生成过剩，可能导致堆内存溢出。 
(4)ScheduledThreadPool：定长线程池，支持定时及周期性任务执行。
2、ExcutorService的方法：
(1)shutdown(); // 已经提交的任务继续执行，不接受新的任务提交
List<Runnable> shutdownNow(); // 尝试终止正在执行的任务、取消正在等待执行的任务并返回它们
execute(Runnable command)执行
<T> Future<T> submit(Callable<T> task);返回task的结果封装的Future
<T> Future<T> submit(Runnable task);无返回
<T> Future<T> submit(Runnable task, T result);返回result封装的Future
(2)使用FutureTask构造，executor.submit(new FutureTask<Integer>(Callable task))返回task结果封装的Future
                                        executor.submit(new FutureTask<Integer>(Runnable,result));返回result封装的Future
(3)还可以直接执行线程集合Set
set.add(callable)
invokeAny(set) 返回任意一个callable的return
invokeAll(set) 返回list

19      ExecutorService pool = Executors.newFixedThreadPool(2);
20 
21      // 可以执行Runnable对象或者Callable对象代表的线程
22      pool.submit(new MyRunnable());
23      pool.submit(new MyRunnable());

四、线程管理类(CyclicBarrier,CountDownLatch)
new CyclicBarrier(N)让一组线程等待至barrier状态之后再全部同时执行。
方法：await();await(long timeout, TimeUnit unit);//等待多长时间后无论有没有n个barrier线程都执行。
new CountDownLatch(N)等待其他任务执行完毕之后执行。
方法: countDown(); //将count值减1;await();await(long timeout, TimeUnit unit)
五、锁(Lock)
1、Lock比synchronized的优势
(1)Lock可以设置锁的有效时间；
(2)同一个对象的一块synchronized代码被锁，其他synchronized代码也会被锁。Lock可以实现只读不上锁；
(3)Lock可以知道线程有没有成功获取到锁，tryLock
2、子类
ReentrantLock可重入锁(synchronized):当一个线程执行到某个synchronized方法时，比如说method1，而在method1中会调用另外一个synchronized方法method2，此时线程不必重新去申请锁，而是可以直接执行方法method2。
ReadWriteLock(接口)：ReentrantReadWriteLock：readLock().lock()和writeLock().lock()用来获取读锁和写锁。
3、Lock方法
lock()、tryLock()、tryLock(long time, TimeUnit unit)和lockInterruptibly()获取锁的。
lock()没有获取锁的对象会等待。if(tryLock())...不会等待。
unLock()释放锁一般在finally块中调用。

newCondition()实现线程通信

public interface Lock {
    void lock();
    void lockInterruptibly() throws InterruptedException;
    boolean tryLock(); //tryLock()方法是有返回值的，它表示用来尝试获取锁，如果获取成功，则返回true
    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
    void unlock();
    Condition newCondition();//返回condition对象。condition对象拥有await、signal方法实现线程间通信。可以获取多个condition对象实现指定线程notify。
}

//Lock必须在try{}catch{}块中进行，并且将释放锁的操作放在finally块中进行，以保证锁一定被被释放
Lock lock = ...;
if(lock.tryLock()) {
     try{
         //处理任务
     }catch(Exception ex){
         
     }finally{
         lock.unlock();   //释放锁
     } 
}else {
    //如果不能获取锁，则直接做其他事情
}

锁的类型
1、可重入锁，当一个线程执行到某个synchronized方法时，比如说method1，而在method1中会调用另外一个synchronized方法method2，此时线程不必重新去申请锁。synchronized和ReentrantLock
2、可中断锁，Lock.lockInterruptibly().synchronized就不是可中断锁
3、公平锁 以请求锁的顺序来获取锁。·synchronized就是非公平锁。Lock，默认情况下是非公平锁，可以设置成公平锁。ReentrantLock中定义了2个静态内部类，一个是NotFairSync，一个是FairSync，分别用来实现非公平锁和公平锁。    
ReentrantLock lock = new ReentrantLock(true);//公平锁