15. Lock和Condition（下）：Dubbo如何用管程实现异步转同步？- 并发工具类

Condition 实现了管程模型里面的条件变量。

Java 语言内置的管程里只有一个条件变量，而 Lock&Condition 实现的管程是支持多个条件变量的，这是二者的一个重要区别。

1. 如何利用两个条件变量快速实现阻塞队列呢？

一个阻塞队列，需要两个条件变量，一个是队列不空（空队列不允许出队），另一个是队列不满（队列已满不允许入队）。

public class BlockedQueue<T> {
	final Lock lock = new ReentrantLock();
	// 条件变量：队列不满
	final Condition notFull = lock.newCondition();
	// 条件变量：队列不空
	final Condition notEmpty = lock.newCondition();

	// 入队
	void enq(T x) {
		lock.lock();
		try {
			while (队列已满) {
				// 等待队列不满
				notFull.await();
			}
			// 省略入队操作...
			// 入队后, 通知可出队
			notEmpty.signal();
		} finally {
			lock.unlock();
		}
	}

	// 出队
	void deq() {
		lock.lock();
		try {
			while (队列已空) {
				// 等待队列不空
				notEmpty.await();
			}
			// 省略出队操作...
			// 出队后，通知可入队
			notFull.signal();
		} finally {
			lock.unlock();
		}
	}
}

Lock 和 Condition 实现的管程，线程等待和通知只能调用 await()、signal()、signalAll()，它们的语义和用synchronized 实现管程所用的wait()、notify()、notifyAll() 是相同的，两种管程实现所用的方法不能弄错了。

2. 同步和异步

通俗点来讲就是调用方是否需要等待结果，如果需要，就是同步；如果不需要，就是异步。

实现异步的两种方法：

• 调用方创建一个子线程，在子线程中执行方法的调用，称为异步调用；
• 方法实现的时候，创建一个新的线程执行主要逻辑，主线程直接return，称为异步方法。

3. Dubbo源码分析

TCP 协议本身就是异步的，在 TCP 协议层面，发送完 RPC 请求后，线程是不会等待 RPC 的响应结果的。

Dubbo 做了异步转同步的事情。
对于下面一个简单的 RPC 调用，默认情况下 sayHello() 方法，是个同步方法，也就是说，执行 service.sayHello(“dubbo”) 的时候，线程会停下来等结果。

DemoService service = 初始化部分省略
String message = service.sayHello("dubbo");
System.out.println(message);

dump线程出来查看，发现线程阻塞，状态为TIMED_WAITING。本来发送请求是异步的，但是调用线程却阻塞，说明Dubbo 做了异步转同步的事情。线程是阻塞在 DefaultFuture.get() 方法。

DubboInvoker 的 108 行调用了 DefaultFuture.get()，这一行先调用了 request(inv, timeout) 方法，这个方法其实就是发送 RPC 请求，之后通过调用 get() 方法等待 RPC 返回结果。

public class DubboInvoker{
  Result doInvoke(Invocation inv){
    // 下面这行就是源码中 108 行
    // 为了便于展示，做了修改
    return currentClient 
      .request(inv, timeout)
      .get();
  }
}

相关的代码精简，重复一下我们的需求：当 RPC 返回结果之前，阻塞调用线程，让调用线程等待；当 RPC 返回结果后，唤醒调用线程，让调用线程重新执行。 经典的等待 - 通知机制。以下为Dubbo实现

// 创建锁与条件变量
	private final Lock lock = new ReentrantLock();
	private final Condition done = lock.newCondition();

	// 调用方通过该方法等待结果
	Object get(int timeout) {
		long start = System.nanoTime();
		lock.lock();
		try {
			while (!isDone()) {
				done.await(timeout);
				long cur = System.nanoTime();
				if (isDone() || cur - start > timeout) {
					break;
				}
			}
		} finally {
			lock.unlock();
		}
		if (!isDone()) {
			throw new TimeoutException();
		}
		return returnFromResponse();
	}

	// RPC 结果是否已经返回
	boolean isDone() {
		return response != null;
	}

	// RPC 结果返回时调用该方法
	private void doReceived(Response res) {
		lock.lock();
		try {
			response = res;
			if (done != null) {
				done.signal();
			}
		} finally {
			lock.unlock();
		}
	}

调用线程通过调用 get() 方法等待 RPC 返回结果，这个方法里面，你看到的都是熟悉的“面孔”：调用 lock() 获取锁，在 finally 里面调用 unlock() 释放锁；获取锁后，通过经典的在循环中调用 await() 方法来实现等待。

当 RPC 结果返回时，会调用 doReceived() 方法，这个方法里面，调用 lock() 获取锁，在 finally 里面调用 unlock() 释放锁，获取锁后通过调用 signal() 来通知调用线程，结果已经返回，不用继续等待了。

4. 总结

Lock&Condition 是管程的一种实现。还是要理解前面提到的管程模型。Lock&Condition 实现的管程相对于 synchronized 实现的管程来说更加灵活、功能也更丰富。

5.课后思考

DefaultFuture 里面唤醒等待的线程，用的是 signal()，而不是 signalAll()，你来分析一下，这样做是否合理呢？