线程并发学习
线程并发学习—-核心概念（转载）
线程并发学习—-线程阻塞（sleep、wait、notifyAll、notify、join）
线程并发学习—-线程阻塞（synchronized）
线程并发学习—-线程阻塞（lock）
线程并发学习—-Thread、Runnable、Callable
线程并发学习—-队列（Queue）
spring学习—-线程池
java中一些锁概念整理（转载）
Lock类图
Lock与synchronized比较
- synchronized是java内置特性；Lock不是java内置的，是通过一个类实现同步
- synchronized不需要手动释放锁，被修饰的方法或代码块执行完或者异常，jvm会自动释放锁；lock必需手动释放锁，否则有可能会造成死锁，并且一般在finally中释放锁
- synchronized修饰，一个线程获取锁后，其它线程只能等待，其执行完成释放或异常释放；lock提供可以 只等待一定的时间或者能够响应中断，而且lock可以知道获取锁是否成功
- synchronized不会区分读写；lock可以有读写锁，实现读操作不被阻塞
- synchronized使用简单，直接使用关键字就行；lock需要创建对象，调用对象方法实现同步
Lock简介
源码
public interface Lock {
//获取锁，如果当前有线程获取锁了，则进入等待队列
void lock();
//获取锁，如果当前有线程获取锁了，则进入等待队列 不过可以在该线程使用interrupt()方法能够中断线程的等待过程
void lockInterruptibly() throws InterruptedException;
//顾名思义，尝试获取锁，获取到了返回true，否则返回false 不会阻塞
boolean tryLock();
//顾名思义，尝试获取锁，获取到了返回true，否则等待设置的超时时间，如没有返回false，如果获取到锁返回true
boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
//顾名思义，释放锁，一般在finally块中使用，确保一定可以执行到，防止造成死锁
void unlock();
Condition newCondition();
}Lock的两个常用实现ReentrantLock和ReentrantReadWriteLock
ReentrantLock 可重入锁
源码
public class ReentrantLock implements Lock, java.io.Serializable {
private static final long serialVersionUID = 7373984872572414699L;
private final Sync sync;
abstract static class Sync extends AbstractQueuedSynchronizer {...}
static final class NonfairSync extends Sync {...}
static final class FairSync extends Sync {...}
//默认实现非公平锁
public ReentrantLock() {
sync = new NonfairSync();
}
//通过参数 true创建公平锁 false创建非公平锁
public ReentrantLock(boolean fair) {
sync = fair ? new FairSync() : new NonfairSync();
}
//所有获取释放锁的具体实现都是内部类Sync
public void lock() {
sync.lock();
}
public void lockInterruptibly() throws InterruptedException {
sync.acquireInterruptibly(1);
}
public boolean tryLock() {
return sync.nonfairTryAcquire(1);
}
public boolean tryLock(long timeout, TimeUnit unit)
throws InterruptedException {
return sync.tryAcquireNanos(1, unit.toNanos(timeout));
}
public void unlock() {
sync.release(1);
}
} 从源码可知ReentrantLock实现功能主要依赖三个内部类Sync、NonfairSync、FairSync ，下面一起看看内部具体实现
Sync 继承 AbstractQueuedSynchronizer
源码
abstract static class Sync extends AbstractQueuedSynchronizer {
private static final long serialVersionUID = -5179523762034025860L;
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() {
return getExclusiveOwnerThread() == Thread.currentThread();
}
final ConditionObject newCondition() {
return new ConditionObject();
}
//获取当前持有锁的线程
final Thread getOwner() {
return getState() == 0 ? null : getExclusiveOwnerThread();
}
final int getHoldCount() {
return isHeldExclusively() ? getState() : 0;
}
//当前锁是否有线程获取
final boolean isLocked() {
return getState() != 0;
}
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
s.defaultReadObject();
setState(0); // reset to unlocked state
}
}AbstractQueuedSynchronizer源码
//判断锁是否被持有是使用volatile修饰的int变量来判断的
private volatile int state;
protected final boolean compareAndSetState(int expect, int update) {
return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
}
public final void acquire(int arg) {
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
public final boolean release(int arg) {
if (tryRelease(arg)) {
Node h = head;
if (h != null && h.waitStatus != 0)
unparkSuccessor(h);
return true;
}
return false;
}代码分析
可重入锁的实现
1、默认方式创建非公平锁
2、通过调用lock获取锁。因为是非公平锁，从代码可以看出它是直接尝试去获取锁（通过CAS），获取不到锁就和公平锁流程一样了,可以参考tryAcquire这个方法，如果获取不到锁就进入等待队列
3、获取锁后，执行相关逻辑，释放锁，删去当前持有锁的线程重置为null
锁是否被持有是通过private volatile int state; 值的变更实现的
NonfairSync 非公平锁（默认锁） 继承Sync
源码
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);
}
protected final boolean tryAcquire(int acquires) {
return nonfairTryAcquire(acquires);
}
}FairSync 继承Sync
源码
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;
}
}公平锁和非公平锁比较
非公平锁获取锁时，不管锁是否被持有，直接去尝试获取锁，获取不到接下来流程与公平锁相同；共平锁先判断锁是否被持有，如果被持有，则进入等待队列，否则持有锁，修改相关状态
ReentrantReadWriteLock 读写锁
读写锁实现与ReentrantLock有点类似，也是通过内部类Sync、NonfairSync、FairSync，同时增加ReadLock、WriteLock，这里不列出源码了，感兴趣自己看，下面分析一下读写锁
读写锁底层也是volatile修饰的state，不过将其分为高16位和低16位；高16位为读锁数量，低16位为写锁数量（锁的持有最大数65535）
写锁
通过lock方法获取写锁，判断当前锁是否被持有，state是否为0
如果state不为0，判断是否有读锁或者当前持有锁的线程是否为当前线程，若没有读锁或不是当前线程持有，则进入等待队列，否则判断当前读锁的数量是否大于最大数，若是抛出异常，否则读锁数量加1
如果state为0，通过CAS获取锁，若成功，设置锁的持有者为当前线程，否则进入等待队列，接下来获取写锁逻辑与ReentrantLock一样
读锁
读锁的逻辑比写锁稍微复杂一些，这里列出大体逻辑，具体可参考“参考资料”，或者自己看源码
通过lock获取读锁，判断锁是否被线程持有写锁，并且不是当前线程，则等待
否则判断是否需要阻塞或读锁数是否大于最大数，如不大于通过CAS获取读锁，如果成功设置相关内部变量，否则进入fullTryAcquireShared，判断是否有写锁，及是否走写锁在等待，如果是进入等待队列
参考资料
https://www.cnblogs.com/dolphin0520/p/3923167.html
http://blog.csdn.net/prestigeding/article/details/53286756
992
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
