线程之间的通信
在并发编程中,主要考虑两种方式来实现线程之间的通信:
- 共享内存
- 消息传递
共享内存的一致性就需要锁来维护了,而在erlang中采用消息传递的方式,每个线程都有自己的消息队列,存放从别的线程拿到的消息。
锁模式
锁的工作模式有两种:
- 独占模式
- 共享模式
用读写锁来理解这两种模式很方便:读锁占有时,可以在上面继续加读锁。写锁占有时,任何锁都不能往上加(包括写锁)。
synchronized
synchronized是java关键字,被它修饰的代码块同一时间只能有一个线程进入。常见的两种用法如下:
public class Test {
public void func1() {
synchronized (Test.this) {
}
}
public synchronized void func2() {
}
}
在JDK 1.5之前synchronized和concurrent之间的性能差距还是挺大的,但是在JDK 1.6中通过优化,性能已经有比较大的改善。所以有时候还是用JDK自带的东西比较好,他能不断持续优化。被修饰的对象会有四种状态:
- 无锁
- 偏向锁
- 轻量级锁
- 重锁
具体的实现方式是在对象头中保存信息。可以猜想一段时间内,统一资源的线程数不会很多。进一步说,一个线程很有可能连续的访问同一个资源。如果不停地去获取锁,这样效率就会下降很多。偏向锁是乐观锁,如果发现已经持有锁了,那么就省去了一大堆的操作。
一个线程一直持有锁的时间也不会很长,更常见的情况应该是中间会被短暂打断。此时不需要将当前线程放到阻塞队列里面去,只需要用CAS操作在其自旋几次就可以了,这就是轻量级锁的优势。
如果上面的这些情况都没有出现,那显然是一个悲观的情况,变为重锁。
concurrent
大家经常说的并发包就是指java.util.concurrent.*的内容,需要去花时间理解AQS,他对底层的操作(cas、pack、unpack)进行封装,你只需要实现它的几个抽象方法,就能实现不同策略的并发功能(可以把他们看做是关键入口的开关):
protected boolean tryAcquire(int arg) {
throw new UnsupportedOperationException();
}
protected boolean tryRelease(int arg) {
throw new UnsupportedOperationException();
}
protected int tryAcquireShared(int arg) {
throw new UnsupportedOperationException();
}
protected boolean tryReleaseShared(int arg) {
throw new UnsupportedOperationException();
}
下面来详细看AQS到底封装了什么。首先,被阻塞的线程会放到一个队列上等待被唤醒,相关的结构如下:
static final class Node {
volatile int waitStatus;
volatile Node prev;
volatile Node next;
volatile Thread thread;
Node nextWaiter;
}
private transient volatile Node head;
private transient volatile Node tail;
private volatile int state;
在并发包中对park、unpark等进行了封装,在LockSupport中实现:
public static void park(Object blocker) {
Thread t = Thread.currentThread();
setBlocker(t, blocker);
unsafe.park(false, 0L);
setBlocker(t, null);
}
public static void unpark(Thread thread) {
if (thread != null)
unsafe.unpark(thread);
}
在park、unpark中需要注意一点,被unpark的线程会在park的地方继续执行,而unpark的线程做完之后就接着干自己的事情。独占模式加锁
首先来看阻塞模式下加锁的代码:
public final void acquire(int arg) {
if (!tryAcquire(arg) && acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
final boolean acquireQueued(final Node node, int arg) {
try {
boolean interrupted = false;
for (;;) {
final Node p = node.predecessor(); // 获取前面的节点
if (p == head && tryAcquire(arg)) { // 在阻塞队列的最里面 || 尝试获取锁成功
setHead(node);
p.next = null;
return interrupted;
}
// 阻塞操作
if (shouldParkAfterFailedAcquire(p, node) && parkAndCheckInterrupt())
interrupted = true;
}
} catch (RuntimeException ex) {
cancelAcquire(node);
throw ex;
}
}
在acquire中的tryAcquire可以用来实现不同的加锁策略,这个可以看ReentrantLock中的FairSync和NonfairSync。在acquireQueued中实现了真正的逻辑:
不停地尝试获取资源(tryAcquire),如果成功,那么当前线程运行在独占模式,如果失败,则继续阻塞。
整个运行的过程在看完下面解锁的过程就明白了。
独占模式解锁
在独占模式下,要释放锁的时候,只需要将头结点后面的节点唤醒即可:
public final boolean release(int arg) {
if (tryRelease(arg)) {
Node h = head;
if (h != null && h.waitStatus != 0)
unparkSuccessor(h);
return true;
}
return false;
}
private void unparkSuccessor(Node node) {
int ws = node.waitStatus;
if (ws < 0)
compareAndSetWaitStatus(node, ws, 0);
Node s = node.next;
// 去掉之前CANCLE的节点
if (s == null || s.waitStatus > 0) {
s = null;
for (Node t = tail; t != null && t != node; t = t.prev)
if (t.waitStatus <= 0)
s = t;
}
// 唤醒后继节点中的线程
if (s != null)
LockSupport.unpark(s.thread);
}
独占模式下的解锁时分成两步来进行操作的:
- 释放掉占用状态
- 唤醒后面的线程
释放成功之后,后面的线程就工作在独占模式了,对应到加锁代码中的话,就是从parkAndCheckInterrupt中返回了。用一个简单的图来看独占模式:
共享模式加锁
共享与独占的模式有些不同,如果一个共享锁获取成功,那么后面正在被阻塞等待共享锁的线程也会被唤醒执行,看代码:
public final void acquireShared(int arg) {
if (tryAcquireShared(arg) < 0)
doAcquireShared(arg);
}
private void doAcquireShared(int arg) {
final Node node = addWaiter(Node.SHARED);
try {
boolean interrupted = false;
for (;;) {
final Node p = node.predecessor();
if (p == head) {
int r = tryAcquireShared(arg);
if (r >= 0) { // 获取成功
setHeadAndPropagate(node, r); // 设置头结点并唤醒后面的节点
p.next = null;
if (interrupted)
selfInterrupt();
return;
}
}
// 获取失败则被阻塞
if (shouldParkAfterFailedAcquire(p, node) && parkAndCheckInterrupt())
interrupted = true;
}
} catch (RuntimeException ex) {
cancelAcquire(node);
throw ex;
}
}
主要的不同点在setHeadAndPropagate中,如果节点是共享状态,那么会调用doReleaseShared方法来完成对后面节点唤醒操作。那么被唤醒的节点继续执行,在下一次循环中会继续唤醒后面的节点,所以可以看到这里是一个依次传递的过程。共享模式解锁
虽然在共享模式下加锁的时候会唤起后面的节点,但是如果后的节点没有继续运行的话(也就是说虽然这个节点没有被继续阻塞,但是它确实没有执行),那么后面的节点就没办法被唤醒了。
public final boolean releaseShared(int arg) {
if (tryReleaseShared(arg)) {
doReleaseShared();
return true;
}
return false;
}
private void doReleaseShared() {
for (;;) {
Node h = head;
if (h != null && h != tail) {
int ws = h.waitStatus;
if (ws == Node.SIGNAL) {
if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
continue;
unparkSuccessor(h);
} else if (ws == 0 && !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
continue;
}
if (h == head)
break;
}
}
在共享模式下可能出现下面一种情况:唤醒的线程B比当前线程A执行更快,以至于在A的循环还没执行完head已经变化了:
- 出现这种情况再次进去循环,将head的状态设置为Node.PROPAGATE。
还有一种情况是B执行的没有那么快,此时head没有发生变化:
- 在这种情况下当前线程不会沿着链表继续unpark下去。
下面用一张图来看共享模式下的操作:
下面来看concurrent包中的并发工具的用法。
ReentrantLock
可重入锁的含义就是说,一个拿到锁的线程还能再次拿到锁,它工作在独占模式下,用法如下:
lock.lock();
try {
// ...
} finally {
lock.unlock();
}
Condition
在很多时候线程会等到某个条件成熟之后才能恢复运行,在此之前它甚至没有机会去被unpark,因为在Condition上等待的线程没有在阻塞队列中:
lock.lock();
try {
while (count == capacity) {
notFull.await();
}
count++;
notEmpty.signalAll();
} finally {
lock.unlock();
}
CountDownLatch
一个计数器:
final CountDownLatch latch = new CountDownLatch(2);
new Thread() {
public void run() {
// TODO
latch.countDown();
}
}.start();
latch.await();
CyclicBarrier
等到线程数到齐了就一起启动,可以重复使用:
final CyclicBarrier barrier = new CyclicBarrier(2);
new Thread() {
public void run() { barrier.await();
// TODO
}
}.start();
Semaphore
信号量,用来控制访问资源的线程数目:
final Semaphore semaphore = new Semaphore(2);
new Thread() {
public void run() {
semaphore.acquire(1);
try {
} finally {
semaphore.release(1);
}
}
}.start();
ReentrantReadWriteLock
经典的读写锁实现:
final ReadWriteLock rwl = new ReentrantReadWriteLock();
final Lock readLock = rwl.readLock(); // 读锁
final Lock writeLock = rwl.writeLock(); // 写锁
new Thread() {
public void run() {
readLock.lock();
try {
} finally {
readLock.unlock();
}
}
}.start();
new Thread() {
public void run() {
writeLock.lock();
try {
} finally {
writeLock.unlock();
}
}
}.start();
----------END----------