如何将带有ReentrantLock的线程包装到CompletableFuture调用中？

Question

这是我当前的实现，它连续处理不同的文件读取/保存操作：

public void runThread(MyThreadImpl myThreadImpl) {
    synchronized (this) {
        this.myThreadImpl = myThreadImpl;
        notify();
    }
}

synchronized public void run() {
    while (true)
        try {
            wait();
            Global.myReentrantLock.lock();
            try {
                try {
                    myThreadImpl.call();
                } catch (FileException e) {
                    // trace e
                } catch (RuntimeException e) {
                    // trace e
                } catch (Exception e) {
                    // trace e
                }
            } finally {
                Global.myReentrantLock.unlock();
            }
        } catch (InterruptedException e) {
          // trace e
        } catch (Exception e) {
          // trace e
        }
}

我有一个问题，我不等待线程结果再执行其他操作，因此我认为有必要这样做。

由于我使用的是Java 8，因此我想将其包装在CompletableFuture中。 如何在当前的实现中执行此操作？

Answer 1

您可以执行以下操作：

• 您可以使用队列，而不是将要完成的下一个作业存储为在this.myThreadImpl锁后进行更新的单个引用（ this.myThreadImpl ）。
• 添加新作业后，将创建一个新的CompletableFuture ，并将对它的引用返回给调用方。
• 一旦工作完成，未来就完成了。

更新代码，并假设queue是类型为Queue<Pair<CompletableFuture<Void>, MyThreadImpl>>的阻塞队列，您将具有：

/**
 * @return a Future that will complete once the passed MyThreadImpl has been run.
 */
public CompletableFuture<Void> runThread(MyThreadImpl myThreadImpl) {
    Pair<CompletableFuture<Void>, MyThreadImpl> p = 
              new Pair<>(new CompletableFuture<>(),myThreadImpl);
    queue.add(p);
    return p.left;
}

public void run() {
    while (true) {
        try {

            Pair<CompletableFuture<MyThreadImpl>, MyThreadImpl> p = 
                  queue.take(); // will block until a job is added

            try {
                p.right.call();
                p.left.complete(null); // Future<Void> can only be completed with null. Alternatively, it could be completed with a relevant result.
            } catch (Exception e) {
                p.left.completeExceptionally(e);
            }

         } catch (InterruptedException e) {
            // trace e
         } 
   }
}

_{在这里， Pair只是需要像对一样的pojo。 （例如，它可能是apache commons的ImmutablePair 。）}

当需要处理东西时，阻塞队列通常很有用： https : //docs.oracle.com/javase/8/docs/api/java/util/concurrent/BlockingQueue.html

另外，您是否看过ExecutorService ？ 您可以使用基于单个线程的线程以串行方式执行作业：它的submit(Callable<> task)方法与上面定义的runThread()十分相似，因为它返回一个Future<Void> ，它将告诉您何时任务完成了。