Lock是一个接口提供无条件的，可轮询的 ，定时的，可中断的锁获取操作，所有加锁和解锁的方法都是显示的。
Lock接口方法
public abstract void lock(); //获取锁
这个就是平常用的最多的方法，用来获取锁，如果没有获取到锁则等待。不过为了避免产生死锁，一般都要跟try{}finally{} 一起使用
lock.lock(); //获取锁
try {
//业务处理
}finally {
lock.unlock(); //释放锁
}
}
public abstract void unlock(); //释放锁
用来释放锁，这个没什么好细说，用的时候，注意一定在finally包裹里使用，不然容易出现死锁。
public abstract void lockInterruptibly()throws InterruptedException; //获取锁
这个方法是也是获取锁，跟lock() 跟相似，获取锁，获取不到，等待直到获取到锁为止。但是它是可以被中断的，这个方法直接throws InterruptedException 就是为了让调用者，自己去处理线程的中断。这个方法强调的是线程在获取锁的时候可以被中断，获取到锁的时候也可以被中断，详细看下面的例子。
void method()throws InterruptedException{
try {
//业务处理
}finally {
lock.unlock(); //释放锁
}
}
public abstract boolean tryLock(); //获取锁，有返回值
这个方法与lock()主要的区别在，lock()方法获取不到锁，会等待，直到获取到锁为止。tryLock()只会获取一次，并将结果返回，获取到锁返回true，反之false。代码模板：
if(lock.tryLock()) {
try {
//上锁的业务处理
}finally {
lock.unlock(); //释放锁
}
}else {
//获取锁失败的业务处理
}
public void tryLock(long paramLong,TimeUnit paramTimeUnit) throws InterruptedException;
这个方法与tryLock()有点类似，在指定的时间内获取锁，如果没有获取到返回false，如果在指定的时间内，获取到锁则返回true。使用模板也与tryLock() 一样。
public abstract Condition newCondition();
返回用来与此Lock实例一起使用的Condition实例。
Lock实现ReentrantLock 使用
lock() 方法使用
public class LockDemo {
private List<String> list = new ArrayList<>();
private final ReentrantLock lock = new ReentrantLock();
public static void main(String[] args) throws InterruptedException {
final LockDemo l = new LockDemo();
for(int i = 0; i < 5 ; i++) {
new Thread(()->{l.insert(Thread.currentThread());}).start();
}
Thread.sleep(2000); //为了看到list的结果，谁两秒钟
System.out.println("执行完成了");
l.list.forEach(System.out::println);
}
public void insert(Thread thread) {
lock.lock();
try {
System.out.println("此线程已经获取到锁了 "+thread.getName());
list.add(thread.getName());
}finally {
lock.unlock();
System.out.println("此线程已经释放锁了 "+thread.getName());
}
}
}
}
执行结果
此线程已经获取到锁了 Thread-1
此线程已经释放锁了 Thread-1
此线程已经获取到锁了 Thread-0
此线程已经释放锁了 Thread-0
此线程已经获取到锁了 Thread-3
此线程已经释放锁了 Thread-3
此线程已经获取到锁了 Thread-4
此线程已经释放锁了 Thread-4
此线程已经获取到锁了 Thread-2
此线程已经释放锁了 Thread-2
执行完成了
Thread-1
Thread-0
Thread-3
Thread-4
Thread-2
可以看出获取锁的顺序跟list的顺序是一样。每个线程都是先获取到锁，释放锁在到下一个线程，不存在交叉的情况。
tryLock() 方法使用
public class LockDemo {
private List<String> list = new ArrayList<>();
private final ReentrantLock lock = new ReentrantLock();
public static void main(String[] args) throws InterruptedException {
final LockDemo l = new LockDemo();
for(int i = 0; i < 5 ; i++) {
new Thread(()->{l.tryInsert(Thread.currentThread());}).start();
}
Thread.sleep(2000);
System.out.println("执行完成了");
l.list.forEach(System.out::println);
}
void tryInsert(Thread thread) {
if(lock.tryLock()) {//tryLock()方法是有返回值的，它表示用来尝试获取锁，如果获取成功，则返回true，如果获取失败（
System.out.println("此线程已经获取到锁了 "+thread.getName()); //即锁已被其他线程获取），
try { //则返回false，也就说这个方法无论如何都会立即返回。在拿不到锁时不会一直在那等待。 这个方法就是线程 去竞争锁，获取到执行 不然到else里面去
list.add(thread.getName());
}finally {
lock.unlock();
System.out.println("此线程已经释放锁了 "+thread.getName());
}
}else {
System.out.println("此线程获取锁失败 "+thread.getName());
}
}
}
执行的结果
此线程获取锁失败 Thread-0
此线程获取锁失败 Thread-3
此线程获取锁失败 Thread-1
此线程获取锁失败 Thread-2
此线程已经获取到锁了 Thread-4
此线程已经释放锁了 Thread-4
执行完成了
Thread-4
可以看出5个线程同时获取锁，只有一个线程成功的，其他的线程都进入else中。这个对应开头说的可轮询的，如果加上时间就是定时的。
lockInterruptibly()方法使用
public class LockDemo {
private List<String> list = new ArrayList<>();
private final ReentrantLock lock = new ReentrantLock();
public static void main(String[] args) throws InterruptedException {
final LockDemo l = new LockDemo();
for (int i = 0; i < 5; i++) {
Thread t = new Thread(() -> {
l.interruptInsert(Thread.currentThread());
});
t.start();
if (i % 2 == 0) {//对偶数进行中断，为了不让全部的线程都中断，list没有结果集
Thread.sleep(10); //让线程获取去获取锁，在进行中断
t.interrupt(); // 直接执行中断
}
}
Thread.sleep(5000);
System.out.println("执行完成了");
l.list.forEach(System.out::println);
}
void interruptInsert(Thread thread) {
try {
lock.lockInterruptibly();
System.out.println("线程已经获取到锁了 : " + thread.getName());
Thread.sleep(2000);
list.add(thread.getName());
} catch (InterruptedException e) {
System.out.println("当前线程直接执行中断: " + thread.getName());
e.printStackTrace();
} finally {
lock.unlock(); // 释放锁
System.out.println("此线程已经释放锁了 " + thread.getName());
}
}
}
可以看出Thread-0，Thread-2 已经获取到锁了，还是被中断，Thread-4在等待获取锁，直接被中断的，终止等待。
