Java 加入两个不同的服务

我想连接两个正在ExecutorService中执行的线程

public class CURD {

  public static ExecutorService executorService = Executors.newCachedThreadPool();
  
 @Autowired
 Logging logging;

  public void Update(List<? extends HBase> save, List<? extends HBase> delete) {
        Thread t = new Thread(() -> {
            System.out.println("Started Main Thread...");
            try {
                Thread.sleep(1500);

            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("End Main Thread...");
        },"Thread-1");

        logging.setPredecessor(t);
        executorService.submit(t);
    }
}

---

如果要在一组线程之间进行同步，可以使用 Java类：

允许一组线程全部等待的同步辅助工具 彼此到达一个共同的障碍点。骑自行车的人很有用 在涉及固定大小线程组的程序中，必须 偶尔互相等待。这种势垒被称为循环势垒，因为 释放等待的线程后，可以重新使用它

为此，首先使用相应的参与方数量创建

CyclicBarrier

对象，即：

从Java文档中可以看出，各方是：

在触发屏障之前必须调用{@link#wait}的线程数

非正式地说，parties是指在所有线程向前移动之前，必须调用循环屏障并等待的线程数

之后，您需要将barrier实例对象引用传递给应该等待的每个线程，并相应地调用

wait

（即

barrier.wait（）

）。具体如下：

  public void Update(..., CyclicBarrier barrier) {
        Thread t = new Thread(() -> {
            System.out.println("Started Main Thread...");
            try {
                 Thread.sleep(1500);
                 barrier.await(); // <--- wait on the barrier
            } catch (InterruptedException | BrokenBarrierException e) {
                 e.printStackTrace();
             }
            System.out.println("End Main Thread...");
        },"Thread-1");
        ...
    }

并将其传递给

线程2

，由于您希望此线程等待

线程1

，因此调用

block_thread2.await（）

并向
线程1
添加
wait.countDown（）：

因此，以这种方式，
线程2
将等待
线程1
，但
线程1
将永远不会等待
线程2

private final CyclicBarrier barrier = new CyclicBarrier(NUMBER_OF_PARIES);

  public void Update(..., CyclicBarrier barrier) {
        Thread t = new Thread(() -> {
            System.out.println("Started Main Thread...");
            try {
                 Thread.sleep(1500);
                 barrier.await(); // <--- wait on the barrier
            } catch (InterruptedException | BrokenBarrierException e) {
                 e.printStackTrace();
             }
            System.out.println("End Main Thread...");
        },"Thread-1");
        ...
    }

private final CountDownLatch block_thread2 = new CountDownLatch(1);

      Thread run = new Thread( () ->{
                   try {
                        ....
                        block_thread2.await(); // wait for Thread 2
                   } catch (InterruptedException e) {
                        // deal with it
                   }
     });
            ...

  public void Update(...) {
        Thread t = new Thread(() -> {
                   System.out.println("Started Main Thread...");
                   try {
                        Thread.sleep(1500);
                        wait.countDown();
                   } catch (InterruptedException e) {
                        // deal with it
            }
            System.out.println("End Main Thread...");
        },"Thread-1");
        ...
    }