1.重入锁

重入锁的含义是一个线程获取这个锁的之后，可以重复多次进入。

Java的重入锁通过ReentrantLock类实现的，简单实例：

ReentrantLock lock = new ReentrantLock();
lock.lock();
.....
lock.unlock();

注意：lock可以使用多次，但是lock的次数必须和unlock的次数相同；如果unlock次数少了，那么相当于线程还持有这个锁，并没有释放；如果unlock次数多了，会抛出一个java.lang.IlegalMonitorStateException异常。

2.重入锁的高级特性

<1> 中断响应

看代码例子

    private int lock;

    public Test01(int lock) {
        this.lock = lock;
    }
    private static final ReentrantLock lock1 = new ReentrantLock();
    private static final ReentrantLock lock2 = new ReentrantLock();

    @Override
    public void run() {
        try {
            if (lock == 1) {
                lock1.lockInterruptibly();
                Thread.sleep(500);
                lock2.lockInterruptibly();

            } else {
                lock2.lockInterruptibly();
                Thread.sleep(500);
                lock1.lockInterruptibly();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            if (lock1.isHeldByCurrentThread()) {
                lock1.unlock();
            }
            if (lock2.isHeldByCurrentThread()) {
                lock2.unlock();
            }
            log.info("{} 退出", Thread.currentThread().getId());
        }

    }


    public static void main(String[] args) throws Exception {
        Test01 t1 = new Test01(1);
        Test01 t2 = new Test01(2);
        Thread thread1 = new Thread(t1);
        Thread thread2 = new Thread(t2);
        thread1.start();
        thread2.start();
        Thread.sleep(1000);
        thread2.interrupt();
    }

运行结果：

java.lang.InterruptedException
    at java.util.concurrent.locks.AbstractQueuedSynchronizer.doAcquireInterruptibly(AbstractQueuedSynchronizer.java:898)
    at ava.util.concurrent.locks.AbstractQueuedSynchronizer.acquireInterruptibly(AbstractQueuedSynchronizer.java:1222)
    at java.util.concurrent.locks.ReentrantLock.lockInterruptibly(ReentrantLock.java:335)
    at com.sample.jmh.Test01.run(Test01.java:34)
    at java.lang.Thread.run(Thread.java:745)`
02:08:49.574 [Thread-0] INFO com.sample.jmh.Test01 - 10 退出
02:08:49.574 [Thread-1] INFO com.sample.jmh.Test01 - 11 退出

对于synchronized，如果线程在等待锁，只有2种情况，要么获得锁继续执行，要么就保持等待；而重入锁则有另外情况，比如线程可以被中断；
上述的代码，会进入死循环，直到线程2被中断；线程2中断后，退出释放资源，线程1可以继续执行完成。

<2>锁申请等待限时

ReentrantLock lock = new ReentrantLock();
lock.tryLock(5, TimeUnit.SECONDS);

当使用锁申请等待时，可以在一定程度上避免死锁；

<3>公平锁

公平锁的优点是不会产生饥饿现象，只要排队，最终都可以等到资源。
创建一个公平锁

ReentrantLock lock = new ReentrantLock(true);

true代表公平锁

ReentrantLock重要方法：
lock() 获得锁，如果锁被其他线程占用，则等待
lockInterruptibly() 获得锁，但优先响应中断
tryLock() 尝试获取锁，如果成功则返回true，失败返回false
tryLock(long time, TimeUnit unit) 在给定时间内尝试获得锁
unlock() 释放锁

实现重入锁主要包含3个元素：
第一，原子状态，使用CAS操作来存储当前锁的状态，判断锁是否已经被别的线程持有
第二，等待队列，所有没有请求到锁的线程，会进入等待队列进行等待，待所有线程释放锁后，系统就能从等待队列中唤醒一个线程，继续工作；
第三，阻塞原语park()和unpark(),用来挂起和恢复线程，没有得到锁的线程会被挂起。

3.Condition条件

类似于Object的wait()和notify(), 但是wait(), notify()是和synchronized关键字配合使用的，condition是配合lock使用的；

condition接口提供的主要方法

await() 方法会使当前线程等待，同时释放当前锁；
awaitUninterruptibly() 方法和await() 方法基本相同，但是它并不会响应中断；
singal() 方法用于唤醒一个在等待的线程，singalAll() 方法会唤醒所有线程;

简单示例：

    private static final ReentrantLock lock = new ReentrantLock();
    private static final Condition condition = lock.newCondition();

    @Override
    public void run() {
        try {
            lock.lock();
            System.out.println(Thread.currentThread().getName() + "加锁完成");

            condition.await();

            System.out.println(Thread.currentThread().getName() + "继续执行");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
            System.out.println(Thread.currentThread().getName() + "释放锁");
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Test02 test02 = new Test02();
        Thread t = new Thread(test02);
        t.start();
        t.sleep(3000L);
        lock.lock();
        condition.signal();
        lock.unlock();
    }

和Object的wait()， notify()方法一样，当线程使用condition的await()方法时，要求线程持有相关的重入锁，当线程调用await()方法后，会释放锁；同理，在调用singal()方法时也需要获得锁。当调用singal()方法后，会从当前condition对象的等待队列中，唤醒一个线程，一旦线程被唤醒，它会重新尝试获得与之绑定的重入锁，一旦锁获取成功，则可以继续执行了。所以当singal()之后，需要unlock()释放锁，以使得其他线程可以获得锁。

在jdk内部condition对象被广泛应用，比如ArrayBlockQueue中的insert方法,put、take方法等都使用了该机制。

4.信号量semaphore

信号量是对锁的扩展，为多线程协作提供了更强大的控制方法，可以指定多个线程，同时访问某一个资源。
信号量构造函数

public Semaphore(int permits);
public Semaphore(int permits, boolean fair);

核心方法：
acquire() 尝试获取一个准入的许可，若无法获得，则线程会等待，知道有线程释放或者当前线程被中断;
acquireUninterruptibly() 和acquire()类似，但是不响应中断；
tryAcquire() 和tryAcquire(long timeout, TimeUnit unit) 尝试获取准入许可，并等待指定时间, 没有指定时间则不会等待，直接返回false;
release() 线程访问资源结束后，需要释放许可

5.读写锁ReadWriteLock

读与读之间不会有冲突，所以可以允许多个线程同时读，读与写，写与写之间有冲突，依然需要持有锁，所以当系统读操作远远大于写操作时，读写锁会发挥大的优势，提升性能。

读写之间的约束关系：
读-读： 不互斥，不阻塞
读-写：互斥，互相阻塞
写-写：互斥，互相阻塞

代码示例:

    private static ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    private static Lock readLock = readWriteLock.readLock();
    private static Lock wiriteLock = readWriteLock.writeLock();


    public static void main(String[] args) {
        Runnable write = new Runnable() {
            @Override
            public void run() {
                try {
                    wiriteLock.lock();
                    Thread.sleep(1000);

                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    wiriteLock.unlock();
                }

            }
        };

        Runnable read = new Runnable() {
            @Override
            public void run() {
                try {
                    readLock.lock();
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    readLock.unlock();
                }
            }
        };

        for (int i = 0; i < 10; i++) {
            new Thread(read).start();
        }
        for (int i = 0; i < 2; i++) {
            new Thread(write).start();
        }
    }

6.CountDownLatch

倒计时器，用于检查多线程都执行完成后，才继续执行；
核心方法：
构造器 CountDownLatch latch = new CountDownLatch(3); 指定需要3个线程完成任务，等待在countdownLatch商店额线程才能继续执行。
latch.countDown() 表示线程执行完成
latch.await() 表示等待，要求3个线程执行的任务全部完成，才能继续；

7.CyclicBarrier 循环栅栏

是一种多线程并发控制工具，具体思路是使用一个计数器，当线程数量达到计数器的数量后就执行任务，然后计数器清零继续循环。

代码示例：

8.线程阻塞工具类LockSupport

LockSupport是一个非常方便实用的线程阻塞工具，它可以在线程内的任意位置让线程阻塞，和Thread.suspend()相比，它弥补了由于resume()在前发生，导致线程无法继续执行的情况。和Object.wait()相比，它不需要先获得某个对象的锁，也不会抛出InterruptException异常。

LockSupport的静态方法park()可以阻塞当前线程，类似的parkNanos(),parkUntil()等

使用park()和unpark()始终可以正常结束，因为LockSupport类使用类似信号量的机制，它为每一个线程准备了一个许可，如果许可可用，那么park()函数会立即返回，并且消费这个许可，如果不可用，就会阻塞；而unpark()则使得一个许可变为可用。（和信号量不同的是，许可不能累加）

这个特点使得unpark()操作即使发生在park()之前，它也可以使下一次的park()操作立即停止返回。

注意：park()的挂起不会像suspend()一样，线程处于RUNNABLE状态，而是处于WAITING状态。

park(对象) 为当前线程设置一个阻塞对象，这样阻塞对象就会出现在线程dump中，便于分析问题；

park()还支持中断，但是不同的是park()不会抛出InterruptException异常，只会默默返回，但是从Thread.interrupt()等方法获得中断标记。