1.ReentrantLock

    这个锁的意义相当于一个多线程安全的允许做某些事情的标志位，拥有该标志位则拥有执行权。

    1).可重入 （单线程可重入，但要重复退出）

     2).可中断  

           reentrantLock.lockInterruptibly();            //可中断锁

     3).可限时

            reentrantLock.tryLock(long timeout, TimeUnit unit);

            尝试申请锁限时，如果失败返回false

     4).公平锁 

            保证线程先到先得，默认是随机的

           public ReentrantLock(boolean fair) {

                    sync = fair ?new FairSync() :new NonfairSync();

            }

        注意事项推荐写法：

         reentrantLock.lock();

           try{}

            finally{

                reentrantLock.unlock();

            }

2.Condition

    配合ReetrantLock使用

       方法：

                void await ( ) throws InterruptedException; //等待在这个锁上

                boolean await (long timeout, TimeUnit unit) throws InterruptedException; //等待在这个锁上,有限时的等待

                void awaitUninterruptibly（); //该线程不可被中断，使用thread.interrupt()不会报错但是线程仍然存在

                注意：https://blog.csdn.net/XIANZHIXIANZHIXIAN/article/details/86633966（该博客错误引导）关键在于中断是否正常，而不是否catch到异常

                    其中使用await 方法可在外部中断线程，但中断会报错可以catch到中断信息

                    但是使用awaitUninterruptibly使用thread.interrupt();不会提示报错信息但是仍然在运行，并不能中断该线

                 void signal();//通知

                 void signalAll();//通知所有

                  long awaitNanos(long nanosTimeout)throws InterruptedException;

                   boolean awaitUntil(Date deadline)throws InterruptedException;

3.Semaphore 信号量

        排他性，共享锁        

        允许x个线程至临界区，但是超过的我的许可区间则必须等待

        方法：

                Semaphore semaphore=new Semaphore(5);// 构造函数输入许可数量

                void  acquire（）； //申请许可

                void acquire(int permits) ; //申请多个许可

                boolean tryAcquire() ；//尝试申请

                void tryAcquire(int permits) ; //尝试申请多个许可

                boolean tryAcquire(int permits,long timeout, TimeUnit unit) //尝试申请多个

                 void acquireUninterruptibly(); //申请不可中断

                  void release() //释放

                 void release(int permits)  //释放多个

4.ReadWriteLock

      读写锁 

5.CountDownLatch

     倒数计时器 

        CountDownLatch end=new CountDownLatch(10);

        end.countDown();

        end.await();

6.CyclicBarrier

        循环栅栏，和倒数计时器类似

        CyclicBarrier(int parties, Runnable barrierAction)

        当计数器完成一次之后系统执行动作

        await（）；//有两种等待

                1）.等待线程全部到达循环栅栏

                 2) .等待线程栅栏中的线程全部完成

        完成一次await调用一次barrierAction

---

代码：

System.out.println("线程： >>>"+Thread.currentThread().getName()+"<<<"+" 等待中");

cyclicBarrier.await();

System.out.println("线程： >>>"+Thread.currentThread().getName()+"<<<"+"  到达");

Thread.sleep(((int)Math.random()*10)*1000);

cyclicBarrier.await();

console：

 线程： >>>Thread-0<<< 等待中

线程： >>>Thread-1<<<  等待中

线程： >>>Thread-2<<<  等待中

线程： >>>Thread-3<<<  等待中

线程： >>>Thread-4<<<  等待中

到达一个线程

线程： >>>Thread-4<<<  到达

线程： >>>Thread-0<<<  到达

线程： >>>Thread-1<<<  到达

线程： >>>Thread-2<<<  到达

线程： >>>Thread-3<<<  到达

到达一个线程

---

        

       BrokenBarrierException如果当前 循环栅栏中的线程的其中一个线程被中断则会导致栅栏中其他线程继续执行下去，则其他线程会触发BrokenBarrierException异常；

7.LockSupport

        提供线程阻塞原语

        LockSupport.park();

        LockSupport.unpark(Thread thread);    

        与suspend（）方法比较：

                不容易引起线程冻结，suspend（）是不推荐使用的方法；

         

        中断响应：

                 能够响应中断，但不抛出异常。

                   已经被park（）之后被thread.interrupt();不会抛出异常，只能通过thread.isInterrupted（）获取中断标识

                 中断响应的结果是，park（）函数的返回，可以从Thread.isInterrupted（）得到中断的标志

8.集合包装

        Collections.synchronizedMap(new HashMap（）)    //还有更过，这里之举个例子

        只适合小场景使用，内部方法进行了锁操作，只能适应并发量不高的场景

9.ConcurrentHashMap

        这个是高性能的HashMap

10.BlockingQueue

    阻塞队列

    缺点   ：不是高性能容器

    优点：非常好的多线程共享数据的容器