在JDK5中新增了Lock锁接口，有ReentrantLock实现类等。ReentrantLock锁称为可重入锁，它的功能要比synchronized多。
7.1 锁的可重入性
锁的可重入性是指，当一个线程获得一个对象锁后，再次请求该对象锁时，可以再次获得该对象的锁。
以下代码可以顺利运行下去，代表synchronized里面的锁是具有可重入性的：
package lock.reentrant;
public class Test01 {
public synchronized void sm1() {
System.out.println("同步方法1");
sm2();
}
public synchronized void sm2() {
System.out.println("同步方法2");
sm3();
}
public synchronized void sm3() {;
System.out.println("同步方法3");
}
public static void main(String[] args) {
Test01 obj = new Test01();
new Thread(new Runnable() {
@Override
public void run() {
obj.sm1();
}
}).start();
}
}
7.2 ReentrantLock
ReentrantLock的基本使用：
package lock.reentrant;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* 使用lock锁同步不同方法中的同步代码块
*
* 只要使用了同一个Lock，不管在哪里的代码都可以进行同步
*/
public class Test03 {
static Lock lock = new ReentrantLock(); //定义锁对象
public static void sm1() {
//经常在try中获得Lock锁，在finally()代码块中释放锁
try {
lock.lock();
System.out.println(Thread.currentThread().getName() + "--method1--" + System.currentTimeMillis());
TimeUnit.SECONDS.sleep(1);
System.out.println(Thread.currentThread().getName() + "--method1--" + System.currentTimeMillis());
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
public static void sm2() {
//经常在try中获得Lock锁，在finally()代码块中释放锁
try {
lock.lock();
System.out.println(Thread.currentThread().getName() + "--method2--" + System.currentTimeMillis());
TimeUnit.SECONDS.sleep(1);
System.out.println(Thread.currentThread().getName() + "--method2--" + System.currentTimeMillis());
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
public static void main(String[] args) {
new Thread(new Runnable() {
@Override
public void run() {
sm1();
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
sm2();
}
}).start();
}
}
一般将lock.lock()写在try中，lock.unlock()写在finally中。
不管在哪里的代码，只要使用了同一个Lock，都可以进行线程同步。
lockInterruptibly()方法：
如果在获取锁的过程中，线程的中断标志位为true，则获取锁失败，且立即报InterruptedException异常，并将中断标志位的值置为false。
对于synchronized内部锁来说，如果一个线程在等待锁，只有两个结果。要么线程获得锁继续执行，要么就保持。
对于Reentrant Lock可重入锁来说，提供了另外一种可能，在等待锁的过程中，程序可以根据需要取消对锁的请求。
lockInterruptibly()方法解决死锁问题：
package lock.reentrant;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class Test06 {
static class IntLock implements Runnable {
public static ReentrantLock lock1 = new ReentrantLock();
public static ReentrantLock lock2 = new ReentrantLock();
int lockNum = 0; //定义整数变量，决定使用哪个锁
public IntLock(int lockNum) {
this.lockNum = lockNum;
}
@Override
public void run() {
try {
if(lockNum % 2 == 1) {
lock1.lockInterruptibly();
System.out.println(Thread.currentThread().getName() + "获得了锁1，还需要获得锁2");
TimeUnit.SECONDS.sleep(1);
lock2.lockInterruptibly();
System.out.println(Thread.currentThread().getName() + "同时获得了锁1和锁2");
} else { //偶数
lock2.lockInterruptibly();
System.out.println(Thread.currentThread().getName() + "获得了锁2，还需要获得锁1");
TimeUnit.SECONDS.sleep(1);
lock1.lockInterruptibly();
System.out.println(Thread.currentThread().getName() + "同时获得了锁1和锁2");
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
if(lock1.isHeldByCurrentThread()){
lock1.unlock();
System.out.println(Thread.currentThread().getName() + "释放了lock1");
}
if(lock2.isHeldByCurrentThread()) {
lock2.unlock();
System.out.println(Thread.currentThread().getName() + "释放了lock2");
}
System.out.println(Thread.currentThread().getName() + "线程退出");
}
}
public static void main(String[] args) throws InterruptedException {
IntLock intLock1 = new IntLock(1);
IntLock intLock2 = new IntLock(2);
Thread t1 = new Thread(intLock1);
Thread t2 = new Thread(intLock2);
t1.start();
t2.start();
//睡眠3s，如果程序还没结束，中断一个线程，让其放弃申请锁，并释放自己占有的锁
TimeUnit.SECONDS.sleep(3);
if(t1.isAlive()) t1.interrupt();
// if(t2.isAlive()) t2.interrupt();
}
}
}
tryLock(Long time, TimeUnit)：限时等待，在给定时间内如果能获得该锁就获得，得不到就放弃申请。
tryLock()：调用时如果该锁能获得就获得，否则就放弃申请。
代码示例：
package lock.reentrant;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;
public class Test08 {
static class TimeLock implements Runnable {
private static ReentrantLock lock = new ReentrantLock();
@Override
public void run() {
try {
if(lock.tryLock(3, TimeUnit.SECONDS)) {
System.out.println(Thread.currentThread().getName() + "获得锁，执行耗时任务");
TimeUnit.SECONDS.sleep(5);
} else { //没有获得锁
System.out.println(Thread.currentThread().getName() + "没有获得锁");
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
if(lock.isHeldByCurrentThread()) {
lock.unlock();
System.out.println(Thread.currentThread().getName() + "释放了锁");
}
}
}
}
public static void main(String[] args) {
TimeLock timeLock1 = new TimeLock();
TimeLock timeLock2 = new TimeLock();
Thread t1 = new Thread(timeLock1);
Thread t2 = new Thread(timeLock2);
t1.start();
t2.start();
}
}
tryLock()避免死锁：
package lock.reentrant;
import java.util.concurrent.locks.ReentrantLock;
/**
* 使用tryLock()避免死锁
*/
public class Test10 {
static class IntLock implements Runnable {
private static ReentrantLock lock1 = new ReentrantLock();
private static ReentrantLock lock2 = new ReentrantLock();
int lockNum = 0;
public IntLock(int lockNum) {
this.lockNum = lockNum;
}
@Override
public void run() {
try {
if(lockNum % 2 == 0) {
if(lock1.tryLock()) {
System.out.println(Thread.currentThread().getName() + "获取锁1，尝试获取锁2");
Thread.sleep(1000);
}
if(lock2.tryLock()) {
System.out.println(Thread.currentThread().getName() + "获取锁2，同时获取了锁1和锁2");
}
} else {
if(lock2.tryLock()) {
System.out.println(Thread.currentThread().getName() + "获取锁2，尝试获取锁1");
Thread.sleep(1000);
}
if(lock1.tryLock()) {
System.out.println(Thread.currentThread().getName() + "获取锁1，同时获取了锁1和锁2");
}
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
if(lock1.isHeldByCurrentThread()) {
lock1.unlock();
System.out.println(Thread.currentThread().getName() + "释放了锁1");
} else {
lock2.unlock();
System.out.println(Thread.currentThread().getName() + "释放了锁2");
}
}
}
}
public static void main(String[] args) {
IntLock intLock1 = new IntLock(1);
IntLock intLock2 = new IntLock(2);
new Thread(intLock1).start();
new Thread(intLock2).start();
}
}
newCondition()方法：
synchronized与wait()、notify()这两个方法一起使用可以实现等待/通知模式，Lock锁的newCondition()方法返回Condition对象，也可以实现等待/通知模式
使用notify()通知后，JVM会随机唤醒某个等待的线程，使用Condition类可以进行选择性地通知某和线程。Condition比较常用的两个方法：await()、singal()。注意，在调用这两个方法前，需要线程持有相关的Lock锁。调用await()后，线程会释放这个锁，调用signal()后，会从当前Condition对象的等待序列中唤醒一个线程。
公平锁与非公平锁：
大多数情况下，锁是非公平的，也就是说，当好几个线程在申请锁A时，可能某几个线程申请成功的概率大于其他线程。
公平锁：会按照时间先后顺序分配锁，保证先到先得，不会让线程饥饿。
synchronized这个内部锁是非公平的，ReentrantLock在定义是可以通过其构造方法让其变成公平锁，ReentrantLock(boolean fair)。
如果是非公平锁，系统会倾向于让一个已经获得了锁的线程继续获得锁，因为这样比较高效；如果是公平锁，系统会选择等待时间最长的那个线程获得锁。公平锁需要维护一个有序队列，所以性能不高。如果不是特别的需求，一般不使用公平锁。
package lock.method;
import java.util.concurrent.locks.ReentrantLock;
/**
* 公平锁和非公平锁
*/
public class Test01 {
// private static ReentrantLock lock = new ReentrantLock(); //默认是非公平锁
private static ReentrantLock lock = new ReentrantLock(true); //定义成公平锁
public static void main(String[] args) {
for(int i = 0; i < 5; i++) {
new Thread(new Runnable() {
@Override
public void run() {
while(true) {
try {
lock.lock();
System.out.println(Thread.currentThread().getName() + "获得了锁");
} finally {
lock.unlock();
}
}
}
}, "Thread" + i).start();
}
}
}
ReentrantLock的几个常用的方法：
1、 getHoldCount()：返回当前线程调用lock()方法的次数；
package lock.method;
import java.util.concurrent.locks.ReentrantLock;
public class Test02 {
private static ReentrantLock lock = new ReentrantLock();
public static void m1() {
try {
lock.lock();
System.out.println(Thread.currentThread().getName() + "持有了：" + lock.getHoldCount());
//引文ReentrantLock是可重入锁，所以可以继续在m2()方法中继续获得锁
m2();
} finally {
lock.unlock();
}
}
public static void m2() {
try {
lock.lock();
System.out.println(Thread.currentThread().getName() + "持有了：" + lock.getHoldCount());
} finally {
lock.unlock();
}
}
public static void main(String[] args) {
m1();
}
}
2、 getQueueLength()：返回正等待获得此锁的线程预估数；
package lock.method;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;
/**
* getQueueLength() 返回获得锁的线程预估数
*/
public class Test03 {
private static ReentrantLock lock = new ReentrantLock();
private static class SubThread extends Thread {
@Override
public void run() {
try {
lock.lock();
TimeUnit.SECONDS.sleep(1);
System.out.println(Thread.currentThread().getName() + "：" + lock.getQueueLength());
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
}
public static void main(String[] args) {
for(int i = 0; i < 10; i++) {
new SubThread().start();
}
}
}
3、 getWaitQueueLength(Conditioncondition)：返回在condition队列上等待的线程预估数；
4、 hasQueuedThread(Threadthread)：查询某线程是否在等待获得该锁；
5、 hasQueuedThreads()：查询是否有其他线程在等待获得该锁；
6、 hasWaiters(Conditioncondition)：查询在该condition队列上是否有线程在等待；
7、 isHeldByCurrentThread()：判断锁是否被当前线程锁持有；
8、 isLocked()：判断锁是否被任何一个线程锁持有；