线程并发学习
线程并发学习—-核心概念(转载)
线程并发学习—-线程阻塞(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