等待/通知 vs 睡眠/中断 vs ReentrantLock.Condition

Question

我正在编写一个按你输入的搜索机制 (android)，它在后台线程中进行 sqlite 查询并将结果发布回 UI 线程。理想情况下，线程应该等待/睡眠，唤醒以执行任何接收到的 Runnable 对象并重新进入睡眠状态。实现这一目标的最佳方法是什么？为什么？

基本上我想了解这 3 个选项之间的主要区别是什么，以及哪一个最适合这个确切的场景

1. 睡眠/中断

   public class AsyncExecutorSleepInterrupt {
   private static Thread thread;
   private static Runnable runnable;
   
   static {
       thread = new Thread(() -> {
           while (true) {
               try {
                   Thread.sleep(10000);
               } catch (InterruptedException e) {
                   if (runnable != null) {
                       runnable.run();
                       runnable = null;
                   }
               }
           }
       });
       thread.start();
   }
   
   public static void execute(Runnable runnable) {
       AsyncExecutorSleepInterrupt.runnable = runnable;
       thread.interrupt();
   }}
   

2. 等待/通知

   public class AsyncExecutorWaitNotify {
   private static Thread thread;
   private static Runnable runnable;
   
   private static final Object monitor = new Object();
   
   static {
       thread = new Thread(() -> {
           while (true) {
               synchronized (monitor) {
                   try {
                       monitor.wait();
                   } catch (InterruptedException e) {
                       e.printStackTrace();
                       continue;
                   }
                   if (runnable != null) {
                       runnable.run();
                       runnable = null;
                   }
               }
           }
       });
       thread.start();
   }
   
   public static void execute(Runnable runnable) {
       AsyncExecutorWaitNotify.runnable = runnable;
       synchronized (monitor) {
           monitor.notify();
       }
   }}
   

3. 可重入锁

   public class AsyncExecutorLockCondition {
   
   private static final ReentrantLock lock = new ReentrantLock();
   
   private static final Condition cond = lock.newCondition();
   
   private static Thread thread;
   
   private static Runnable runnable;
   
   static {
       thread = new Thread(() -> {
           while(true){
               try {
                   lock.lock();
                   cond.await();
                   runnable.run();
                   lock.unlock();
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }
       });
       thread.start();
   }
   
   public static void execute(Runnable runnable) {
       AsyncExecutorLockCondition.runnable = runnable;
       lock.lock();
       cond.signal();
       lock.unlock();
   }}
   

Answer 1

就个人而言，我有点不喜欢第一种方法，可能主要是因为interrupt。如果有人、某事以某种方式调用并中断该线程怎么办？您将运行一些任意代码，可能不是最好的主意。此外，当您中断时，您实际上是在用异常链填充堆栈跟踪，这是抛出异常中最昂贵的部分。

但是假设您不关心第二点，而您完全控制了第一点；这种方法 IMO 可能没有任何问题。

现在这个例子中Conditional 和wait/notify 之间的区别很小。我不知道内部细节，哪个可能更快或更好，但总的来说Conditional 是首选；主要是因为它更容易阅读，至少对我来说是这样。与synchronized 不同，Conditional 也可以一直从不同的 锁中获取。

其他优点是（这里不相关）：可以创建多个条件，从而只唤醒你想要的线程；不像notifyAll 例如。然后是有过期的方法，比如awaitUntil(Date)或await(long, TimeUnit)或awaitNanos。甚至还有一种方法可以 await 并完全忽略 interrupts ：awaitUninterruptibly。

话虽如此，在await 之后您不需要lock::unlock，因为文档在这方面非常清楚：

与此 Condition 关联的锁被原子释放 ...

更直接的方法是：

static class AsyncExecutor {

    private static final ExecutorService service = Executors.newSingleThreadExecutor();

    public static void execute(Runnable runnable) {
        service.execute(runnable);
    }
}

Answer 2

以上都不是。第三个是最接近的，但仍然不是最好的方法。使用 looper+handler 或消息队列。此外，应该有一条消息可以发送给任何线程，告诉它退出循环并终止。否则，当不再需要它但会永远存在时，您将泄漏它可以引用的任何内存（这是很多，因为它将对其父级进行内部引用）。请记住，线程在退出之前永远不会被 GC。