1、Lock接口
锁是用来控制多个线程访问共享资源的方式，一般来说锁能够防止多个线程同时访问共享资源（有的锁可以允许多个线程访问共享资源，比如说读写锁），在Lock接口出现之前，java程序是靠synchronized关键字实现锁功能的，但是在JKD1.5之后并发包中新增了Lock接口及其实现来实现锁的功能。它提供了synchronized关键字类似的功能，但是Lock需要显示的获取锁、释放锁，而synchronized是通过隐式的方式来实现获取、释放锁。
Lock接口常见的API请自行查找
2、队列同步器
略...
3、重入锁
重入锁ReentrantLock，顾名思义，就是支持重进入的锁，重入锁支持同一个线程多次的获取锁。除此之外，该锁还支持获取锁时的公平和非公平性。
关于锁的公平性，如果在绝对的时间上，先对锁进行获取请求的操作一定会先被满足，则说明这个锁是公平的，反之则是不公平的。ReentrantLock的构造函数支持构造公平锁与非公平锁，默认为非公平锁，因为非公平锁能减少上下文切换，开销更小。
4、读写锁
读写锁支持同一时刻允许多个线程同时访问，但是在写线程访问时，所有的读线程与其他的写线程均被阻塞。读写锁维护了一对锁，读锁与写锁，通过读锁与写锁的分离，读写锁的并发性相比于其他排他锁都有很大的提升。
java并发包提供的读写锁是ReentrantReadWriteLock，它具有公平性选择、锁重入、锁降级三个特性。
读写锁实现简单缓存demo
package main.java.com.robot.demo;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
/**
* @author: 会跳舞的机器人
* @date: 2017/8/16 14:45
* @description: 读写锁实现缓存demo
*/
public class Cache {
static Map map = new HashMap<>();
static ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
static Lock writeLock = rwl.writeLock();
static Lock readLock = rwl.readLock();
/**
* 读缓存
*/
public static final Object get(String key) {
readLock.lock();
try {
return map.get(key);
} finally {
readLock.unlock();
}
}
/**
* 写入缓存
*/
public static final Object put(String key, Object value) {
writeLock.lock();
try {
return map.put(key, value);
} finally {
writeLock.unlock();
}
}
/**
* 清空缓存
*/
public static final void clear() {
writeLock.lock();
try {
map.clear();
} finally {
writeLock.unlock();
}
}
/**
* 获取缓存大小
*/
public static final int size() {
writeLock.lock();
try {
return map.size();
} finally {
writeLock.unlock();
}
}
}
5、LockSupport工具
略...
6、Condition接口
利用Condition接口来实现一个简单的有界阻塞队列，当队列为空时，队列的获取操作将会阻塞获取线程，知道有新的元素添加进来，当队列满时，队列的插入操作将会阻塞插入线程，知道队列出现“空位”。
package main.java.com.robot.demo;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* @author: 会跳舞的机器人
* @date: 2017/8/16 15:48
* @description: Condition实现有界阻塞队列demo
*/
public class BoundedQueue {
private Object[] items;
private int addIndex, removeIndex, count;
private Lock lock = new ReentrantLock();
private Condition notEmpty = lock.newCondition();
private Condition notFull = lock.newCondition();
public BoundedQueue(int size) {
items = new Object[size];
}
/**
* 添加一个元素，如果队列已满，则线程进入等待状态，直到有空位为止
*/
public void add(Object object) throws InterruptedException {
lock.lock();
try {
// 队列已满，阻塞线程
while (items.length == count) {
System.out.println("队列已满，等待......");
notFull.await();
}
items[addIndex] = object;
if (++addIndex == items.length) {
addIndex = 0;
}
++count;
// 唤醒
notEmpty.signal();
} finally {
lock.unlock();
}
}
/**
* 删除队列的第一个元素，如果队列为空，则线程进入等待状态，直到有新元素添加进来
*/
public Object remove() throws InterruptedException {
lock.lock();
try {
while (count == 0) {
System.out.println("空队列，等待......");
notEmpty.await();
}
Object obj = items[removeIndex];
if (++removeIndex == items.length) {
removeIndex = 0;
}
--count;
notFull.signal();
return obj;
} finally {
lock.unlock();
}
}
}