锁分类参考文章
基本使用
1.继承与实现
public class ReentrantLock implements Lock, java.io.Serializable
Lock 接口
// 如果锁可用就获得锁，如果锁不可用就阻塞直到锁释放
void lock();
// 和lock()方法相似, 但阻塞的线程 可 中 断 ， 抛 出java.lang.InterruptedException 异常
void lockInterruptibly() throws InterruptedException;
// 非阻塞获取锁;尝试获取锁，如果成功返回 true
boolean tryLock();
//带有超时时间的获取锁方法
boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
// 释放锁
void unlock();
Condition newCondition();
2.ReentrantLock 重入锁
重入锁，表示支持重新进入的锁，也就是说，如果当前线程 t1 通过调用 lock 方法获取了锁之后，再次调用 lock，是不会再阻塞去获取锁的，直接增加重试次数就行了。synchronized 和 ReentrantLock 都是可重入锁。
- 可中断
- 可以设置超时时间
- 可以设置为公平锁
- 支持多个条件变量
基本语法
//获取锁
reetrantLock.lock();
try{
//临界区
}finally{
//释放锁
reentrantLock.unlock();
}
可重入
可重入指一个线程如果首次获取这把锁，他就是这把锁的拥有者，有权再次获取这把锁。如果是不可重入锁，那么第二次获得锁时，自己也会被锁挡住。
可打断
如果用的lock.lockInterruptibly()这个方法上锁的话，别的线程是可以通过interrupt方法打断的。比如：我的a线程正在尝试获取锁，但这个lock已经被b线程拿了，b可以如果执行Interrupt就可以把a线程正在尝试的打断直接获取失败不等待。就是一种防止无限制等待的机制，避免死等，减少死锁的产生。
锁超时
有个lock.tryLock()方法，返回boolean，获取到就返回true，获取不到锁就返回false，这个方法的可以传入两个参数超时时间，第一个参数数字代表时间，第二个是单位。代表他去tryLock()尝试获取锁的时候最多等待的实践，如果是1和秒就是最多尝试等待一秒，还没拿到就返回false。也是一直超时机制，防止死锁。
公平锁
syn就是非公平的，重量级的monitor的堵塞队列就是非公平的。
ReentrantLock默认是不公平，但是我们可以通过构造方法改成公平的，传的是boolean值
条件变量
syn不满足条件的线程都在一个休息室
而ReentranLock支持多休息室，唤醒的时候也是按照休息室来唤醒
使用流程：
- await进行等待（前需要获得锁）
- await执行后，会释放锁，进入conditionObject等待
- await的线程被唤醒（或打断或超时）去重新竞争lock锁
- 竞争lock锁成功后，从await后继续执行
在new完ReentranLock之后可以用newCondition()方法创建休息室，然后就可以用new出来的condition调用await方法进入休息室等待，唤醒的话是signal()方法
3.可调用的方法
4.构造
public ReentrantLock() {
sync = new NonfairSync();
}
//fair true 创建公平锁
public ReentrantLock(boolean fair) {
sync = fair ? new FairSync() : new NonfairSync();
}
5.获取锁
//获取锁，获取不到，会等待知道获取
public void lock() {
sync.lock();
}
//可被其它线程打断的锁
public void lockInterruptibly() throws InterruptedException {
sync.acquireInterruptibly(1);
}
//直接获取锁，成功则返回true 失败返回fasle
public boolean tryLock() {
return sync.nonfairTryAcquire(1);
}
//指定时间范围获取锁，传入超时时间和单位
public boolean tryLock(long timeout, TimeUnit unit)
throws InterruptedException {
return sync.tryAcquireNanos(1, unit.toNanos(timeout));
}
6.释放锁
public void unlock() {
sync.release(1);
}
7.查看锁的状态
//查询此锁是否由任何线程持有。此方法设计用于监视系统状态，而不是用于同步控制。
public boolean isLocked() {
return sync.isLocked();
}
8.是否是公平锁
public final boolean isFair() {
return sync instanceof FairSync;
}
9.tostring
//返回类型名@hashcode值，是否被锁，锁着的时候返回线程名
//java.util.concurrent.locks.ReentrantLock@30ee82d7[Locked by thread Thread-0]
public String toString() {
Thread o = sync.getOwner();
return super.toString() + ((o == null) ?
"[Unlocked]" :
"[Locked by thread " + o.getName() + "]");
}
测试使用
public class Test5 {
static ReentrantLock reentrantLock = new ReentrantLock();
static Test5 test5;
static Thread thread1;
public static int a = 5;
public void test() {
System.err.println("hashCode"+reentrantLock.hashCode());
boolean tryLock;
try {
tryLock = reentrantLock.tryLock(5, TimeUnit.SECONDS);
System.err.println("getHoldCount:"+reentrantLock.hasQueuedThreads());
/*Condition newCondition = reentrantLock.newCondition();
newCondition.awaitUninterruptibly();*/
System.out.println("线程"+Thread.currentThread().getName()+":开始调用Test5");
System.out.println("线程"+Thread.currentThread().getName()+":拿到锁"+reentrantLock.isLocked());
if(!tryLock)
return;
} catch (InterruptedException e1) {
e1.printStackTrace();
}
try {
try {
for (int i = 0; i < 20; i++) {
Thread.sleep(10);
a++;
System.out.println("线程"+Thread.currentThread().getName()+":"+ a);
}
} catch (InterruptedException e) {
e.printStackTrace();
}
} finally {
System.out.println("线程"+Thread.currentThread().getName()+":释放锁");
reentrantLock.unlock();
}
}
public static void main(String[] args) {
thread1 = new Thread() {
public void run() {
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
test5 = new Test5();
test5.test();
};
};
thread1.start();
new Thread() {
public void run() {
test5 = new Test5();
test5.test();
};
}.start();
new Thread() {
public void run() {
try {
Thread.sleep(60);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.err.println("getHoldCount:"+reentrantLock.getHoldCount());
};
}.start();
}
}
源码实现
1.Sync
abstract static class Sync extends AbstractQueuedSynchronizer
abstract void lock();
final boolean nonfairTryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
if (c == 0) {
if (compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
return true;
}
}
else if (current == getExclusiveOwnerThread()) {
int nextc = c + acquires;
if (nextc < 0) // overflow
throw new Error("Maximum lock count exceeded");
setState(nextc);
return true;
}
return false;
}
protected final boolean tryRelease(int releases) {
int c = getState() - releases;
if (Thread.currentThread() != getExclusiveOwnerThread())
throw new IllegalMonitorStateException();
boolean free = false;
if (c == 0) {
free = true;
setExclusiveOwnerThread(null);
}
setState(c);
return free;
}
protected final boolean isHeldExclusively() {
// While we must in general read state before owner,
// we don't need to do so to check if current thread is owner
return getExclusiveOwnerThread() == Thread.currentThread();
}
final ConditionObject newCondition() {
return new ConditionObject();
}
// Methods relayed from outer class
final Thread getOwner() {
return getState() == 0 ? null : getExclusiveOwnerThread();
}
final int getHoldCount() {
return isHeldExclusively() ? getState() : 0;
}
final boolean isLocked() {
return getState() != 0;
}
/**
* Reconstitutes the instance from a stream (that is, deserializes it).
*/
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
s.defaultReadObject();
setState(0); // reset to unlocked state
}
2.NonfairSync
static final class NonfairSync extends Sync{
private static final long serialVersionUID = 7316153563782823691L;
final void lock() {
if (compareAndSetState(0, 1))
setExclusiveOwnerThread(Thread.currentThread());
else
acquire(1);//AbstractQueuedSynchronizer 的方法
}
protected final boolean tryAcquire(int acquires) {
return nonfairTryAcquire(acquires);
}}
3.FairSync
static final class FairSync extends Sync {
private static final long serialVersionUID = -3000897897090466540L;
final void lock() {
acquire(1);
}
protected final boolean tryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
if (c == 0) {
if (!hasQueuedPredecessors() &&
compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
return true;
}
}
else if (current == getExclusiveOwnerThread()) {
int nextc = c + acquires;
if (nextc < 0)
throw new Error("Maximum lock count exceeded");
setState(nextc);
return true;
}
return false;
}
}
下篇文章继续学习
189
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
