参考网址：
http://blog.csdn.net/qq_19431333/article/details/70568478
011
& 001
——————
001
static final int SHARED_SHIFT = 16;
static final int SHARED_UNIT = (1 << SHARED_SHIFT)=65536;
static final int MAX_COUNT = (1 << SHARED_SHIFT) - 1 = 65535;
static final int EXCLUSIVE_MASK = (1 << SHARED_SHIFT) - 1 = 65535;
//当c>65535时不为0， 0<=c<65535时为0， c<0时为65535
static int sharedCount(int c) { return c >>> SHARED_SHIFT; }
//当c>65535时不为c-65536*i， 0<=c<65535时为c， c<0时c+65536*i
static int exclusiveCount(int c) { return c & EXCLUSIVE_MASK; }
m”<<”n 有符号左移: 不管m是正数还是负数,m向左移n位后,在低位补n个0.
m>>n 有符号右移: 如果m是正数,m向右移n位,在高位补n个0.如果m是负数,m向右移n位,在高位补n个1.
m>>>n 无符号右移(java不存在无符号左移符号): 不管m是正数还是负数,m向右移n位,都在高位补n个0.
ReentrantReadWriteLock类
int sharedCount(int c) 获取读线程数，包括重入数
int exclusiveCount(int c) 获取写线程数（包括重入数）
boolean tryRelease(int releases)
释放锁后状态为0返回true，否则返回false
1、非公平锁(吞吐率比公平锁高)
第一个尝试获取锁的线程都可以获得锁资源
当写锁时，该线程的读锁和写锁可以获得锁，其他线程的写锁和读锁都得不到锁资源，进入队列等待。
读锁时，所有读锁可以得到锁，所有写锁进入队列等待。
2、公平锁
线程将会以队列的顺序获取锁。当当前线程释放锁后，等待时间最长的写锁线程就会被分配写锁；或者有一组读线程组等待时间比写线程长，那么这组读线程组将会被分配读锁。
3、支持锁重入，即同一个thread对调用多次lock.lock()方法,且获得锁资源。
4、允许写锁降低为读锁 ，即同一个thread当调用 writeLock.lock()获得锁资源后，readLock.lock()也可以获得锁资源，writeLock.unlock()是否所后降级为读锁.
5、在读锁和写锁的获取过程中支持中断，方法为WriteLock和ReadLock中的 lockInterruptibly()、tryLock(long timeout, TimeUnit unit)会抛出InterruptedException
6、写锁提供Condition实现 ，读锁不支持Condition实现。
public class ReentrantReadWriteLock
implements ReadWriteLock, java.io.Serializable {
private static final long serialVersionUID = -6992448646407690164L;
private final ReentrantReadWriteLock.ReadLock readerLock;
private final ReentrantReadWriteLock.WriteLock writerLock;
final Sync sync;
/**
* 默认非公平锁
*/
public ReentrantReadWriteLock() {
this(false);
}
public ReentrantReadWriteLock(boolean fair) {
sync = fair ? new FairSync() : new NonfairSync();
readerLock = new ReadLock(this);
writerLock = new WriteLock(this);
}
public ReentrantReadWriteLock.WriteLock writeLock() { return writerLock; }
public ReentrantReadWriteLock.ReadLock readLock() { return readerLock; }
/**
* 继承AbstractQueuedSynchronizer
*/
abstract static class Sync extends AbstractQueuedSynchronizer {
private static final long serialVersionUID = 6317671515068378041L;
static final int SHARED_SHIFT = 16;
static final int SHARED_UNIT = (1 << SHARED_SHIFT);
static final int MAX_COUNT = (1 << SHARED_SHIFT) - 1;
static final int EXCLUSIVE_MASK = (1 << SHARED_SHIFT) - 1;
/** 获取读锁线程数，高16位代表读锁的个数 ，即是 SHARED_UNIT的倍数*/
static int sharedCount(int c) { return c >>> SHARED_SHIFT; }
/** 获取写锁线程数 ，低16位代表写锁的状态*/
static int exclusiveCount(int c) { return c & EXCLUSIVE_MASK; }
/**
* 记录当前读线程的锁重入数，相当于计数器
*/
static final class HoldCounter {
int count = 0;
// 当前线程的id，不直接使用Thread.currentThread()，防止对线程的依赖，有利于GC回收
final long tid = getThreadId(Thread.currentThread());
}
//线程安全变量计数器
static final class ThreadLocalHoldCounter
extends ThreadLocal<HoldCounter> {
public HoldCounter initialValue() {
return new HoldCounter();
}
}
/**
* 线程安全变量记录当前线程的占用锁重入数
* 当读线程持有数为0时移除
* 与使用cachedHoldCounter相比，从readHolds读取数据资源消耗大很多，故因先判断cachedHoldCounter是不是当前线程计数器，不是则从readHolds读取
*/
private transient ThreadLocalHoldCounter readHolds;
/**
* 保存最后持有锁的读线程
*/
private transient HoldCounter cachedHoldCounter;
/**
* 第一个持有锁的读线程
*/
private transient Thread firstReader = null;
/**
* 第一个持有锁的读线程的重入数
*/
private transient int firstReaderHoldCount;
Sync() {
readHolds = new ThreadLocalHoldCounter();
setState(getState()); // ensures visibility of readHolds
}
/**
* 获取读锁时是否应该阻塞，true:进入队列排队 false:可以获得锁资源
*/
abstract boolean readerShouldBlock();
/**
* 获取写锁时是否应该阻塞，true:进入队列排队 false:可以获得锁资源
*/
abstract boolean writerShouldBlock();
/**
* 尝试 释放写锁
*/
protected final boolean tryRelease(int releases) {
//如果没有线程持有写锁，但是仍要释放，抛出异常
if (!isHeldExclusively())
throw new IllegalMonitorStateException();
int nextc = getState() - releases;
boolean free = exclusiveCount(nextc) == 0;
if (free)
//如果没有写锁了，那么将AQS的线程置为null
setExclusiveOwnerThread(null);
setState(nextc);
return free;
}
/**
* 获取写锁
*/
protected final boolean tryAcquire(int acquires) {
/*
* 1. 如果当前有写锁或者读锁。如果只有读锁，返回false，因为这时如果可以写，那么读线程得到的数据就有可能错误；如果有写锁，但是线程不同，即不符合写锁重入规则，返回false
2. 如果写锁的数量将会超过最大值65535，抛出异常；否则，写锁重入
3. 如果没有读锁或写锁的话，如果需要阻塞或者CAS失败，返回false；否则将当前线程置为获得写锁的线程
*/
Thread current = Thread.currentThread();
int c = getState();
//获取写锁
int w = exclusiveCount(c);
//有写锁或者读锁
if (c != 0) {
// 有读锁或者其他写锁返回false
if (w == 0 || current != getExclusiveOwnerThread())
return false;
//如果写锁的个数超过了最大值，抛出异常
if (w + exclusiveCount(acquires) > MAX_COUNT)
throw new Error("Maximum lock count exceeded");
// 写锁重入，返回true
setState(c + acquires);
return true;
}
//当前没有写锁或者读锁，如果写线程应该阻塞或者CAS失败，返回false
//公平锁需要判断当前线程是否为队列头节点，是则立即CAS更新队列状态
//非公平锁立即CAS更新队列状态
if (writerShouldBlock() ||
!compareAndSetState(c, c + acquires))
return false;
//否则将当前线程置为获得写锁的线程,返回true
setExclusiveOwnerThread(current);
return true;
}
/**
* 尝试释放读锁
*/
protected final boolean tryReleaseShared(int unused) {
Thread current = Thread.currentThread();
//第一个获得读锁线程未当前线程
if (firstReader == current) {
// 当前读锁重入数为1则当前线程释放锁资源
if (firstReaderHoldCount == 1)
firstReader = null;
else
firstReaderHoldCount--;
} else {
//获取最后一个获取读锁的线程计数器
HoldCounter rh = cachedHoldCounter;
//最后一个获取读锁计数器为null 或者 读锁线程id不等于当前线程id
if (rh == null || rh.tid != getThreadId(current))
//从当前线程安全变量中读取，消耗较从缓存中读取大很多
rh = readHolds.get();
int count = rh.count;
if (count <= 1) {
//移除
readHolds.remove();
if (count <= 0)
throw unmatchedUnlockException();
}
--rh.count;
}
for (;;) {
int c = getState();
//释放一把读锁，因为读锁采用高16位， nextc为 SHARED_UNIT的整数倍
int nextc = c - SHARED_UNIT;
if (compareAndSetState(c, nextc))
//读锁全部释放返回true
return nextc == 0;
}
}
private IllegalMonitorStateException unmatchedUnlockException() {
return new IllegalMonitorStateException(
"attempt to unlock read lock, not locked by current thread");
}
/**
* 尝试获取读锁（lock方法流程会用到该方法）
*/
protected final int tryAcquireShared(int unused) {
Thread current = Thread.currentThread();
int c = getState();
//有写锁且不为当前线程返回-1
if (exclusiveCount(c) != 0 &&
getExclusiveOwnerThread() != current)
return -1;
//获取读锁线程数
int r = sharedCount(c);
//读线程不应该阻塞并且读锁的个数小于最大值65535，成功更新状态值
//非公平锁通过判断锁是否被写线程占用，被占用则不允许获取读锁
//公平锁 通过判断当前线程未队列头结点
if (!readerShouldBlock() &&
r < MAX_COUNT &&
compareAndSetState(c, c + SHARED_UNIT)) {
//没有其他读线程，设置当前线程为第一个读线程，firstReaderHoldCount=1
if (r == 0) {
firstReader = current;
firstReaderHoldCount = 1;
} else if (firstReader == current) {
//锁重入
firstReaderHoldCount++;
} else {
//获取最后一个获取读锁的线程计数器
HoldCounter rh = cachedHoldCounter;
//最后一个获取读锁计数器为null 或者 读锁线程id不等于当前线程id
if (rh == null || rh.tid != getThreadId(current))
从当前线程安全变量中读取，消耗较从缓存中读取大很多,并设置最后一个获取读锁为当前线程计数器
cachedHoldCounter = rh = readHolds.get();
//最后一个获取读锁计数器值为0
else if (rh.count == 0)
//设置线程安全变量值
readHolds.set(rh);
//计数器加1
rh.count++;
}
return 1;
}
//不满足获取读锁条件则循环，直到获得读锁成功或抛出异常
return fullTryAcquireShared(current);
}
/**
* 循环获取读锁，直到获得读锁成功或抛出异常，逻辑类似tryAcquireShared方法
*/
final int fullTryAcquireShared(Thread current) {
HoldCounter rh = null;
//循环
for (;;) {
int c = getState();
//有写锁且不为当前线程返回-1
if (exclusiveCount(c) != 0) {
if (getExclusiveOwnerThread() != current)
return -1;
}
//不允许获得读锁（比如公平锁必须当前线程未头节点）
else if (readerShouldBlock()) {
// Make sure we're not acquiring read lock reentrantly
if (firstReader == current) {
// assert firstReaderHoldCount > 0;
} else {
//其他线程持有锁
if (rh == null) {
rh = cachedHoldCounter;
//最后一个获取读锁计数器为null 或者 读锁线程id不等于当前线程id
if (rh == null || rh.tid != getThreadId(current)) {
rh = readHolds.get();
//计数器值为0移除
if (rh.count == 0)
readHolds.remove();
}
}
if (rh.count == 0)
return -1;
}
}
//如果读锁达到了最大值，抛出异常
if (sharedCount(c) == MAX_COUNT)
throw new Error("Maximum lock count exceeded");
//和tryAcquireShared方法逻辑一致
if (compareAndSetState(c, c + SHARED_UNIT)) {
if (sharedCount(c) == 0) {
firstReader = current;
firstReaderHoldCount = 1;
} else if (firstReader == current) {
firstReaderHoldCount++;
} else {
if (rh == null)
rh = cachedHoldCounter;
if (rh == null || rh.tid != getThreadId(current))
rh = readHolds.get();
else if (rh.count == 0)
readHolds.set(rh);
rh.count++;
cachedHoldCounter = rh; // cache for release
}
return 1;
}
}
}
/**
* 除了writerShouldBlock判断，其他与tryAcquire一致
*/
final boolean tryWriteLock() {
Thread current = Thread.currentThread();
int c = getState();
if (c != 0) {
int w = exclusiveCount(c);
if (w == 0 || current != getExclusiveOwnerThread())
return false;
if (w == MAX_COUNT)
throw new Error("Maximum lock count exceeded");
}
if (!compareAndSetState(c, c + 1))
return false;
setExclusiveOwnerThread(current);
return true;
}
/**
* 除了readerShouldBlock判断，其他与tryAcquireShared一致
* 非公平锁可以直接调用这个
*/
final boolean tryReadLock() {
Thread current = Thread.currentThread();
for (;;) {
int c = getState();
if (exclusiveCount(c) != 0 &&
getExclusiveOwnerThread() != current)
return false;
int r = sharedCount(c);
if (r == MAX_COUNT)
throw new Error("Maximum lock count exceeded");
if (compareAndSetState(c, c + SHARED_UNIT)) {
if (r == 0) {
firstReader = current;
firstReaderHoldCount = 1;
} else if (firstReader == current) {
firstReaderHoldCount++;
} else {
HoldCounter rh = cachedHoldCounter;
if (rh == null || rh.tid != getThreadId(current))
cachedHoldCounter = rh = readHolds.get();
else if (rh.count == 0)
readHolds.set(rh);
rh.count++;
}
return true;
}
}
}
protected final boolean isHeldExclusively() {
return getExclusiveOwnerThread() == Thread.currentThread();
}
final ConditionObject newCondition() {
return new ConditionObject();
}
/**
* 如果有写锁则返回写锁
*/
final Thread getOwner() {
return ((exclusiveCount(getState()) == 0) ?
null :
getExclusiveOwnerThread());
}
//返回占用锁资源的读线程个数
final int getReadLockCount() {
return sharedCount(getState());
}
//是否有写锁
final boolean isWriteLocked() {
return exclusiveCount(getState()) != 0;
}
//返回占用锁资源的写线程个数
final int getWriteHoldCount() {
return isHeldExclusively() ? exclusiveCount(getState()) : 0;
}
//获取当前读线程锁重入次数
final int getReadHoldCount() {
if (getReadLockCount() == 0)
return 0;
Thread current = Thread.currentThread();
//是否为第一个线程
if (firstReader == current)
return firstReaderHoldCount;
//是否为最后一个线程
HoldCounter rh = cachedHoldCounter;
if (rh != null && rh.tid == getThreadId(current))
return rh.count;
//从当前线程安全变量中获取计数器
int count = readHolds.get().count;
if (count == 0) readHolds.remove();
return count;
}
final int getCount() { return getState(); }
}
/**
* 非公平锁
*/
static final class NonfairSync extends Sync {
private static final long serialVersionUID = -8159625535654395037L;
final boolean writerShouldBlock() {
return false; // writers can always barge
}
final boolean readerShouldBlock() {
//该方法在当前线程是写锁占用的线程时，返回true；否则返回false
return apparentlyFirstQueuedIsExclusive();
}
}
/**
* 公平锁
*/
static final class FairSync extends Sync {
private static final long serialVersionUID = -2274990926593161451L;
//当前线程为队列头结点
final boolean writerShouldBlock() {
return hasQueuedPredecessors();
}
final boolean readerShouldBlock() {
return hasQueuedPredecessors();
}
}
public static class ReadLock implements Lock, java.io.Serializable {
private static final long serialVersionUID = -5992448646407690164L;
private final Sync sync;
protected ReadLock(ReentrantReadWriteLock lock) {
sync = lock.sync;
}
/**
* 读锁没有占用锁资源 立马占用锁资源并返回
* 否则进入队列等待
*/
public void lock() {
sync.acquireShared(1);
}
/**
/**
* 读锁没有占用锁资源 立马占用锁资源并返回
* 否则进入队列等待获取锁资源，获得锁资源立马返回，否则直到其他线程调用该线程的Interrupt()方法则抛出异常
*/
public void lockInterruptibly() throws InterruptedException {
sync.acquireSharedInterruptibly(1);
}
public boolean tryLock() {
return sync.tryReadLock();
}
public boolean tryLock(long timeout, TimeUnit unit)
throws InterruptedException {
return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout));
}
/**
* 释放锁资源
*/
public void unlock() {
sync.releaseShared(1);
}
/**
* 不支持Condition
*/
public Condition newCondition() {
throw new UnsupportedOperationException();
}
public String toString() {
int r = sync.getReadLockCount();
return super.toString() +
"[Read locks = " + r + "]";
}
}
public static class WriteLock implements Lock, java.io.Serializable {
private static final long serialVersionUID = -4992448646407690164L;
private final Sync sync;
protected WriteLock(ReentrantReadWriteLock lock) {
sync = lock.sync;
}
public void lock() {
sync.acquire(1);
}
public void lockInterruptibly() throws InterruptedException {
sync.acquireInterruptibly(1);
}
public boolean tryLock( ) {
return sync.tryWriteLock();
}
public boolean tryLock(long timeout, TimeUnit unit)
throws InterruptedException {
return sync.tryAcquireNanos(1, unit.toNanos(timeout));
}
public void unlock() {
sync.release(1);
}
public Condition newCondition() {
return sync.newCondition();
}
public String toString() {
Thread o = sync.getOwner();
return super.toString() + ((o == null) ?
"[Unlocked]" :
"[Locked by thread " + o.getName() + "]");
}
public boolean isHeldByCurrentThread() {
return sync.isHeldExclusively();
}
public int getHoldCount() {
return sync.getWriteHoldCount();
}
}
public final boolean isFair() {
return sync instanceof FairSync;
}
/**
* 如果有写锁则返回写锁
*/
protected Thread getOwner() {
return sync.getOwner();
}
/**
* 返回占用锁资源的读线程个数
*/
public int getReadLockCount() {
return sync.getReadLockCount();
}
/**
* 是否有写锁
*/
public boolean isWriteLocked() {
return sync.isWriteLocked();
}
/**
* 现在是否是写锁占用锁资源
*/
public boolean isWriteLockedByCurrentThread() {
return sync.isHeldExclusively();
}
/**
* 返回占用锁资源的写线程个数，锁重入
*/
public int getWriteHoldCount() {
return sync.getWriteHoldCount();
}
/**
* 返回占用锁资源的读线程个数
*/
public int getReadHoldCount() {
return sync.getReadHoldCount();
}
/**
* 返回队列中所有写线程的集合
*/
protected Collection<Thread> getQueuedWriterThreads() {
return sync.getExclusiveQueuedThreads();
}
/**
* 返回队列中所有读线程的集合
*/
protected Collection<Thread> getQueuedReaderThreads() {
return sync.getSharedQueuedThreads();
}
/**
* 队列里面是否有线程等待获取锁资源
*/
public final boolean hasQueuedThreads() {
return sync.hasQueuedThreads();
}
/**
* thread是否在队列中等待获取资源
*/
public final boolean hasQueuedThread(Thread thread) {
return sync.isQueued(thread);
}
/**
* 返回队列长度
*/
public final int getQueueLength() {
return sync.getQueueLength();
}
/**
* 返回队列中所有读线程和写线程的集合
*/
protected Collection<Thread> getQueuedThreads() {
return sync.getQueuedThreads();
}
/**
* condition队列中是否有等待被唤醒的写线程
*/
public boolean hasWaiters(Condition condition) {
if (condition == null)
throw new NullPointerException();
if (!(condition instanceof AbstractQueuedSynchronizer.ConditionObject))
throw new IllegalArgumentException("not owner");
return sync.hasWaiters((AbstractQueuedSynchronizer.ConditionObject)condition);
}
/**
*返回condition队列中所有等待被唤醒（waitState=-2）写线程的个数
*/
public int getWaitQueueLength(Condition condition) {
if (condition == null)
throw new NullPointerException();
if (!(condition instanceof AbstractQueuedSynchronizer.ConditionObject))
throw new IllegalArgumentException("not owner");
return sync.getWaitQueueLength((AbstractQueuedSynchronizer.ConditionObject)condition);
}
/**
* 返回condition队列中所有等待被唤醒（waitState=-2）写线程的集合
*/
protected Collection<Thread> getWaitingThreads(Condition condition) {
if (condition == null)
throw new NullPointerException();
if (!(condition instanceof AbstractQueuedSynchronizer.ConditionObject))
throw new IllegalArgumentException("not owner");
return sync.getWaitingThreads((AbstractQueuedSynchronizer.ConditionObject)condition);
}
public String toString() {
int c = sync.getCount();
int w = Sync.exclusiveCount(c);
int r = Sync.sharedCount(c);
return super.toString() +
"[Write locks = " + w + ", Read locks = " + r + "]";
}
/**
* 获取线程变量thread的id
*/
static final long getThreadId(Thread thread) {
return UNSAFE.getLongVolatile(thread, TID_OFFSET);
}
private static final sun.misc.Unsafe UNSAFE;
private static final long TID_OFFSET;
static {
try {
UNSAFE = sun.misc.Unsafe.getUnsafe();
Class<?> tk = Thread.class;
TID_OFFSET = UNSAFE.objectFieldOffset
(tk.getDeclaredField("tid"));
} catch (Exception e) {
throw new Error(e);
}
}
}
扫一扫
200
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
