线程相关关键字及对象

synchronized

jdk5之前为重量级锁，性能较低
jdk5之后做了优化引入了锁升级概念
锁升级：
1.当仅有一个线程持有锁时为偏向锁（仅仅时做了个标记，实际上相当于没有锁）
2.出现其他线程竞争锁时，偏向锁升级为自旋锁(CAS)，未获得锁的线程进入循环，不停的尝试获得锁。
3.CAS循环10次之后，锁再次升级，成为由OS控制的重量级锁。

CAS

自旋锁，也叫无锁优化。
我自己理解的伪代码大概是：

cas（oldValue，expect，newValue）{
  if（expect！=oldValue）{
      //重新计算预期值和目标值
      cas（oldValue，expect2，newValue2）；   
  }else{
      oldValue = newValue；
  }
}

使用CAS原理实现的java类：
AtomicXXX，LongAdder，ReentrantLock等。

volatile

并非锁，无法保证线程同步
作用1：保证线程间变量可见
作用2：禁止指令重排（代码执行顺序并非原始顺序，CPU会进行指令重排）

公平锁

先到先得
谁抢到是谁的

可重入锁

同一个线程可重复获得锁

ReentrantLock

可重入锁，可完全代替synchronized。使用稍微复杂，但作用更加灵活。

Lock lock = new ReentrantLock(true);//公平锁，默认无参构造为非公平锁

tryLock尝试获取锁，可根据是否能获得锁灵活处理。

 boolean getLook = lock.tryLock();//尝试获得锁，返回值为是否获得
        try {
            //尝试获得锁，若无法获得最长等待5S
            lock.tryLock(5,TimeUnit.SECONDS);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

使用lock.lockInterruptibly();构建可被打断的锁，防止t1不释放锁t2无限等待锁。

Lock lock = new ReentrantLock(true);

        Thread t1 = new Thread(() -> {
            try {
                lock.lock();
                System.out.println("t1 start");
                TimeUnit.SECONDS.sleep(Integer.MAX_VALUE);
                System.out.println("t1 end");
            } catch (InterruptedException e) {
                System.out.println("t1 interrupted");
            } finally {
                lock.unlock();
            }
        });
        t1.start();
        Thread t2 = new Thread(() -> {
            try {
                lock.lockInterruptibly();
//                lock.lock();
                System.out.println("t2 start");
                TimeUnit.SECONDS.sleep(5);
                System.out.println("t2 end");
            } catch (InterruptedException e) {
                System.out.println("interrupted");
            } finally {
                try {
                    lock.unlock();
                }catch (Exception e){
                    t1.interrupt();
                }
            }
        });
        t2.start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t2.interrupt();
    }

CyclicBarrier

等待足够的资源后才执行。类似黑车司机等待乘客，人满发车。

CyclicBarrier cyclicBarrier = new CyclicBarrier(20,()-> System.out.println("人满 发车"));

        for (int i=0;i<100;i++){
            int finalI = i;
            new Thread(()->{
                try {
                    System.out.println("current value="+ finalI);
                    cyclicBarrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }).start();
        }

CountDownLatch 倒计数

                List<Worker> works = new ArrayList<Worker>();
                //for: get userlist
                List<Map> list = this.weixinDao.listPushUser();
                //for: get message by userid
                for(Map m:list){
                    try{
                        List<Map> msgList = warningDao.getWechatWarningData(userid);
                        for(Map msg:msgList){
                            //省略具体业务
                           Worker worker = new Worker()
                            works.add(worker);
                        }
                    }catch(Exception e){
                        e.printStackTrace();
                    }
                    
                }
                CountDownLatch latch=new CountDownLatch(works.size());
                // log.info("总线程数为-------" + works.size() + "-------");
                for(Worker w:works){
                    w.setLatch(latch);
                    w.start();
                }
                latch.await(2, TimeUnit.MINUTES);//主线程等待所有线程完成，最多等2分钟

    static class Worker extends Thread{  
        CountDownLatch latch;  
        public void setLatch(CountDownLatch latch) {
            this.latch = latch;
        }
        public Worker(){  
             //省略具体业务
        }  
        @Override
        public void run(){  
            try{
                //省略具体业务
            }catch(Exception e){
                log.error("Thread has Exception happend！！",e);
            }finally{
                this.latch.countDown();// 线程完成计数器减一
            }
        }  
}