实战Java高并发程序设计之ReentrantLock(一)

重入锁的特性:

1.可重入.

public class ReentrantLockTest extends Thread {
public static ReentrantLock lock = new ReentrantLock();
public static int i = 0;
public void run(){
for(int j = 0;j<100000;j++){
lock.lock();
lock.lock();
try {
i++;
} finally{
lock.unlock();
lock.unlock();
}
}
}

public static void main(String[] args) throws Exception {
ReentrantLockTest lock = new ReentrantLockTest();
Thread t1 = new Thread(lock);
Thread t2 = new Thread(lock);
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println(i);
}
}

加几次锁释放几次.
与synchronized相比,重入锁需要开发人员手动指定何时加锁,何时释放锁

2.可中断

如果一个线程在等待锁,使用synchronized,那么结果只有两种,要么它获得锁继续执行,要么保持等待.

如果使用重入锁,就能提供另外一种可能,那就是线程可以被中断.

public class InLock implements Runnable{
public static ReentrantLock lock1 = new ReentrantLock();
public static ReentrantLock lock2 = new ReentrantLock();
int lock;
/**
* 控制加锁顺序,方便构造死锁
* @param lock
*/
public InLock(int lock){
this.lock = lock;
}
public void run() {
try {
if(lock == 1){
lock1.lockInterruptibly();		//是一个可以对中断进行相应的锁的申请
try {
Thread.sleep(500);
} catch (Exception e) {
}
lock2.lockInterruptibly();
}else{
lock2.lockInterruptibly();
try {
Thread.sleep(500);
} 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 {
InLock r1 = new InLock(1);
InLock r2 = new InLock(2);
Thread t1 = new Thread(r1);
Thread t2 = new Thread(r2);
t1.start();
t2.start();
Thread.sleep(1000);
t2.interrupt();
}
}

3.可限时,tryLcok

超时不能获得锁，就返回false，不会永久等待构成死锁

public class ReentrantLockTest implements Runnable{
public static ReentrantLock lock = new ReentrantLock();

@Override
public void run() {
try {
//等待5s,等不到就退出
if(lock.tryLock(5,TimeUnit.SECONDS)){
Thread.sleep(6000);
}else {
System.out.println("get lock failed");
}
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
if(lock.isHeldByCurrentThread())	//不加会抛出异常
//最后记得释放锁
lock.unlock();
}
}
public static void main(String[] args) {
ReentrantLockTest t = new ReentrantLockTest();
Thread t1 = new Thread(t);
Thread t2 = new Thread(t);
t1.start();
t2.start();
}
}

4.公平锁(先来先到)

公平锁需要维护一个有序队列,成本高,性能相对非常低下.因此默认锁是非公平的

public ReentrantLock(boolean fair);
public static ReentrantLock fairLock = new ReentrantLock(true);

下面来看看ReentrantLock源码:

public class ReentrantLock implements Lock, java.io.Serializable {
private static final long serialVersionUID = 7373984872572414699L;
/** 提供所有实现机制的同步器 */
private final Sync sync;

/**
* 无参构造.默认是false
*/
public ReentrantLock() {
sync = new NonfairSync();
}

/**
* 有参构造
*/
public ReentrantLock(boolean fair) {
//true则创建公平锁,false非公平
sync = fair ? new FairSync() : new NonfairSync();
}
}

此处只讲基础使用,至于ReentrantLock的实现原理,后面将讲到

如有不足之处望指正.