java 实现队列读写锁_读书笔记之《Java并发编程的艺术》-java中的锁
读书笔记部分内容来源书出版书，版权归本书作者，如有错误，请指正。
欢迎star、fork，读书笔记系列会同步更新
git
module
j360-jdk-thread/me.j360.jdk.concurrent
本书前三章分别为
并发编程的挑战，也就是并发编程的缘由所在
底层的实现原理
java内存模型
分别从cpu x86，x64以及内存模型等概念中描述java对并发编程的实现和控制，概念较为底层和基础，读书笔记略过前三章直接从第四章应用实现及原理基础开始。
章节
并发编程基础
java中的锁
并发容器和框架(重点)
13个操作原子类
java并发工具类
线程池
Execurot框架
内容
java中的锁
Lock接口
Lock接口出现之前，java是通过synchronized关键字实现的锁功能，javase5之后，并发包新增了Lock接口
Lock使用方式，和分布式锁的构造很像。
Lock lock = new ReentrantLock
lock.lock();
try{
}finally{
lock.unlock();
}
Lock接口提供了Synchronized关键字不具备的特性
尝试非阻塞地获取锁
当前线程尝试获取锁，没有其他线程获取锁，则成功
能被中断的获取锁
超时获取锁
在指定的时间内获取锁
Lock接口的API
void lock()
void lockInterruptibly() throws InterruptedException
boolean tryLock()
boolean tryLock(long time,TimeUtil unit) throws InterruptedException
void unlock()
Condition newCondition
获取等待通知组件，该组件和当前的锁绑定，当前线程只有获取了锁，才能调用该组件的wait()方法，而调用后，当前线程将会释放锁
队列同步器
锁的实现基于队列同步器完成，AbstractQueuedSynchronized(简称同步器)，使用一个int成员变量表示同步状态，通过内置的FIFO队列来完成资源获取线程的排队工作
public class ReentrantLock implements Lock, java.io.Serializable {
private static final long serialVersionUID = 7373984872572414699L;
/** Synchronizer providing all implementation mechanics */
private final Sync sync;
/**
* Base of synchronization control for this lock. Subclassed
* into fair and nonfair versions below. Uses AQS state to
* represent the number of holds on the lock.
在这里！！！
*/
abstract static class Sync extends AbstractQueuedSynchronizer {
private static final long serialVersionUID = -5179523762034025860L;
/**
* Performs {@link Lock#lock}. The main reason for subclassing
* is to allow fast path for nonfair version.
*/
abstract void lock();
/**
* Performs non-fair tryLock. tryAcquire is
* implemented in subclasses, but both need nonfair
* try for trylock method.
*/
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
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 this lock instance from a stream.
* @param s the stream
*/
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
s.defaultReadObject();
setState(0); // reset to unlocked state
}
}
/**
* Sync object for non-fair locks
非公平锁
*/
static final class NonfairSync extends Sync {
private static final long serialVersionUID = 7316153563782823691L;
/**
* Performs lock. Try immediate barge, backing up to normal
* acquire on failure.
*/
final void lock() {
if (compareAndSetState(0, 1))
setExclusiveOwnerThread(Thread.currentThread());
else
acquire(1);
}
protected final boolean tryAcquire(int acquires) {
return nonfairTryAcquire(acquires);
}
}
/**
* Sync object for fair locks
公平锁
*/
static final class FairSync extends Sync {
private static final long serialVersionUID = -3000897897090466540L;
final void lock() {
acquire(1);
}
/**
* Fair version of tryAcquire. Don't grant access unless
* recursive call or no waiters or is first.
*/
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
throw new Error("Maximum lock count exceeded");
setState(nextc);
return true;
}
return false;
}
}
重入锁 ReetrentLock
支持重进入的锁，能够支持一个线程对资源的重复加锁，代码见上面。
读写锁 ReetrentReadWriteLock
特性
公平性选择
重进入
锁降级
接口示例
int getReadLockCount()
读锁被或许的次数
int getReadHoldCount()
当前线程或许读锁的次数
int getWriteLockCount()
int getWriteHoldCount()
通过Cache来解释读写锁，HashMap是非线程安全的，通过读写锁实现Cache的线程安全
public class Cache {
static Map map = new HashMap();
static ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
static Lock r = rwl.readLock();
static Lock w = rwl.writeLock();
public static final Object get(String key){
r.lock();
try {
return map.get(key);
}finally {
r.unlock();
}
}
public static final Object put(String key,Object value){
w.lock();
try {
return map.put(key,value);
}finally {
w.unlock();
}
}
public static final void clear() {
w.lock();
try {
map.clear();
}finally {
w.unlock();
}
}
}
Condition接口和示例
public class ConditionUseCase {
private Lock lock = new ReentrantLock();
private Condition condition = lock.newCondition();
public static void main(String[] args){
}
public void conditionWait() throws InterruptedException {
lock.lock();
try {
condition.await();
}finally {
lock.unlock();
}
}
public void conditionSignal(){
lock.lock();
try {
condition.signal();
}finally {
lock.unlock();
}
}
}
部分方法描述
void await()
当前线程进入等待状态，直到被通知或中断
void awaitUninterruptibly()
当前线程进入等待状态，对中断不敏感
long awaitNanos(long nanosTimeout)
当前线程进入等待状态，直到被通知，中断或者超时，返回值表示剩余的时间，返回值如果是0或者负数，那么可以认定已经超时了
boolean awaitUntil(Date deadline)
当前线程进入等待状态，直到被通知、中断或者到某个时间，如果没有到指定时间，返回true，否则到了指定时间，返回false
void signal()
唤醒一个等待在condition中的线程，该线程从等待方法返回前必须获取与Condition相关联的锁
void signlAll()
唤醒所有等待的condition中的线程，能够从等待方法返回的线程必须获得与condition相关联的锁
有界队列BoundedQueue解释Condition
public class BoundedQueue {
private Object[] items;
private int addIndex,removeIndex,count;
private Lock lock = new ReentrantLock();
private Condition notEmpty = lock.newCondition();
private Condition notFull = lock.newCondition();
public BoundedQueue(int size){
items = new Object[size];
}
public void add(T t) throws InterruptedException {
lock.lock();
try {
while(count == items.length)
notFull.await();
items[addIndex] = t;
if(++addIndex == items.length)
addIndex = 0;
++count;
notEmpty.signal();
}finally {
lock.unlock();
}
}
public T remove() throws InterruptedException {
lock.lock();
try {
while(count == 0)
notEmpty.await();
Object x = items[removeIndex];
if(++removeIndex == items.length)
removeIndex = 0;
--count;
notFull.signal();
return (T) x;
}finally {
lock.unlock();
}
}
}