1.定义
重入锁ReentrantLock，支持重入的锁，表示一个线程对资源的重复加锁。2.底层实现
每个锁关联一个线程持有者和计数器，当计数器为0时表示该锁没有被任何线程持有，那么任何线程都可能获得该锁而调用相应的方法；成功后，JVM会记下锁的持有线程，并且将计数器置为1；此时其它线程请求该锁，则必须等待；而该持有锁的线程如果再次请求这个锁，就可以再次拿到这个锁，同时计数器会递增；当线程退出同步代码块时，计数器会递减，如果计数器为0，则释放该锁。3.使用样例
eg:
import java.util.concurrent.locks.ReentrantLock;
public class ReentrantLockTest implements Runnable{
public static int i = 100;
public static ReentrantLock rl = new ReentrantLock();
@Override
public void run() {
while(true){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
rl.lock();
if(i>0){
System.out.println(Thread.currentThread().getName() + " : " + i--);
}
rl.unlock();
}
}
public static void main(String[] args) {
ReentrantLockTest rlt = new ReentrantLockTest();
Thread t1 = new Thread(rlt);
Thread t2 = new Thread(rlt);
t1.start();
t2.start();
}
}
中断响应
synchronized:线程等待锁，要么获得锁继续执行，要么保持等待。
ReentrantLock:等待锁的过程中，可以根据需求取消对锁的请求。
eg:
import java.util.concurrent.locks.ReentrantLock;
public class IntLock implements Runnable {
int lock;
public static ReentrantLock lock1 = new ReentrantLock();
public static ReentrantLock lock2 = new ReentrantLock();
public IntLock(int lock){
this.lock = lock;
}
@Override
public void run() {
try{
if(lock == 1){
try{
lock1.lockInterruptibly(); // 如果当前线程未被中断，则获取锁。
}catch(Exception e){
e.printStackTrace();
}
lock2.lockInterruptibly();
System.out.println(Thread.currentThread().getId()+"执行完毕");
}else{
lock2.lockInterruptibly();
try{
Thread.sleep(1000);
}catch(Exception e){
}
lock1.lockInterruptibly();
}
}catch(Exception e){
e.printStackTrace();
}finally{
if(lock1.isHeldByCurrentThread()){ //查询当前线程是否保持此锁
lock1.unlock();
}
if(lock2.isHeldByCurrentThread()){ //查询当前线程是否保持此锁
lock2.unlock();
}
System.out.println(Thread.currentThread().getId()+":线程退出");
}
}
public static void main(String[] args) throws InterruptedException {
IntLock l1 = new IntLock(1);
IntLock l2 = new IntLock(2);
Thread t1 = new Thread(l1);
Thread t2 = new Thread(l2);
t1.start();
t2.start();
Thread.sleep(2000);
t2.interrupt(); //中断线程,不中断，则产生死锁
}
}
锁申请等待限时
如果锁在给定等待时间内没有被另一个线程保持，且当前线程未被中断，则获取该锁。
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;
public class TimeLock implements Runnable {
public static ReentrantLock rl = new ReentrantLock();
@Override
public void run() {
try {
if(rl.tryLock(5, TimeUnit.SECONDS)){
Thread.sleep(6000);
System.out.println(Thread.currentThread().getId()+"执行完毕");
}else{
System.out.println(Thread.currentThread().getId()+"get lock failed");
}
} catch (InterruptedException e) {
e.printStackTrace();
}finally{
if(rl.isHeldByCurrentThread())rl.unlock();
}
}
public static void main(String[] args) {
TimeLock tl = new TimeLock();
Thread t1 = new Thread(tl);
Thread t2 = new Thread(tl);
t1.start();
t2.start();
}
}
公平锁
在ReentrantLock中很明显可以看到其中同步包括两种，分别是公平的FairSync和非公平的NonfairSync。公平锁的作用就是严格按照线程启动的顺序来执行的，不允许其他线程插队执行的；而非公平锁是允许插队的。默认情况下ReentrantLock是通过非公平锁来进行同步的，包括synchronized关键字都是如此，因为这样性能会更好。public ReentrantLock(boolean fair) //如果此锁应该使用公平的排序策略，则该参数为 true
import java.util.concurrent.locks.ReentrantLock;
public class FairLock implements Runnable{
public static ReentrantLock rl = new ReentrantLock(true);
@Override
public void run() {
while(true){
try {
rl.lock();
System.out.println(Thread.currentThread().getName()+" ： get lock");
} catch (Exception e) {
}finally{
rl.unlock();
}
}
}
public static void main(String[] args) {
FairLock fl = new FairLock();
Thread t1 = new Thread(fl,"Thread_One");
Thread t2 = new Thread(fl,"Thread_Two");
t1.start();
t2.start();
}
}
在重入锁的实现中，包含3个要素
1.原子状态，使用CAS操作来存储当前锁的状态，判断锁是否被别的线程持有
2.等待队列，所有没有请求到锁的线程，会进入到队列进行等待，待有线程释放锁后，系统能从等待队列唤醒一个线程继续工作。
3.阻塞原语park()和unpark(),用来挂起和恢复线程，没有得到锁的线程会被挂起
Condition
Condition中的await()方法相当于Object的wait()方法，Condition中的signal()方法相当于Object的notify()方法，Condition中的signalAll()相当于Object的notifyAll()方法。不同的是，Object中的wait(),notify(),notifyAll()方法是和”同步锁”(synchronized关键字)捆绑使用的；而Condition是需要与”互斥锁”/”共享锁”捆绑使用的。
Condition函数列表
void await() //造成当前线程在接到信号或被中断之前一直处于等待状态。
boolean await(long time, TimeUnit unit) //造成当前线程在接到信号、被中断或到达指定等待时间之前一直处于等待状态。
long awaitNanos(long nanosTimeout) //造成当前线程在接到信号、被中断或到达指定等待时间之前一直处于等待状态。
void awaitUninterruptibly() //造成当前线程在接到信号之前一直处于等待状态。
boolean awaitUntil(Date deadline) //造成当前线程在接到信号、被中断或到达指定最后期限之前一直处于等待状态。
void signal() //唤醒一个等待线程。
void signalAll() //唤醒所有等待线程。
eg:
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
public class ReentrantLockCondition implements Runnable {
public static ReentrantLock rl = new ReentrantLock();
public static Condition condition = rl.newCondition();
@Override
public void run() {
rl.lock();
try {
condition.await(); //与此 Condition 相关的锁以原子方式释放
System.out.println("Thread is going on");
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally{
rl.unlock();
}
}
public static void main(String[] args) throws InterruptedException {
ReentrantLockCondition rlc = new ReentrantLockCondition();
Thread t1 = new Thread(rlc);
t1.start();
Thread.sleep(3000);
rl.lock();
condition.signal();
rl.unlock();
}
}
ReentrantLock和synchronized关键字的区别
1.ReentrantLock在等待锁时可以使用lockInterruptibly()方法选择中断， 改为处理其他事情，而synchronized关键字，线程需要一直等待下去。同样的，tryLock()方法可以设置超时时间，用于在超时时间内一直获取不到锁时进行中断。
2.ReentrantLock可以实现公平锁，而synchronized的锁是非公平的。
3.ReentrantLock拥有方便的方法用于获取正在等待锁的线程。
4.ReentrantLock可以同时绑定多个Condition对象，而synchronized中，锁对象的wait()和notify()或notifyAll()方法可以实现一个隐含的条件，如果要和多于一个条件关联时，只能再加一个额外的锁，而ReentrantLock只需要多次调用newCondition方法即可。
一般情况下都是用synchronized实现同步，除非下列情况使用ReentrantLock:
1.某个线程在等待一个锁的控制权的这段时间需要中断
2.需要分开处理一些wait-notify，ReentrantLock里面的Condition应用，能够控制notify哪个线程
3.具有公平锁功能，每个到来的线程都将排队等候
