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()等方法获得中断标记。
