加入两个不同的服务

我想连接两个正在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);
    }
}

第二类：这个类线程应该等待第一个线程完成。但它并不等待第一个线程完成。我不确定这样做是否正确。
请有人让我知道如何连接两个线程正在执行一个executorservice？

import static com.demo.executorService;

public class Logging {

   private Thread predecessor;
   public void  setPredecessor(Thread t) {
        this.predecessor = t;
    }

  private void loggingInfo() {
      Thread run = new Thread( () ->{
                try {
                    if (predecessor != null) {
                        System.out.println(Thread.currentThread().getName() + " Started");
                        predecessor.join();
                        System.out.println(Thread.currentThread().getName() + " Finished");
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
            addTask(run);
   }

   public void addTask(Runnable run) {
        System.out.println("Runnable Thread logAround.....");
        CompletableFuture.runAsync((run), executorService).exceptionally(ex -> {
            System.out.println("exception occurred " + ex);
            return null;
        });
    }
}

如果要在一组线程之间进行同步，可以使用java cyclicbarrier类：
一种同步辅助工具，允许一组线程都等待彼此到达一个共同的障碍点。cyclicbarrier在涉及固定大小的线程组的程序中很有用，这些线程偶尔必须等待对方。这个屏障被称为循环的，因为它可以在等待的线程被释放后重新使用。
为此，首先创建 CyclicBarrier 有相应数量的当事人，即：

private final CyclicBarrier barrier = new CyclicBarrier(NUMBER_OF_PARIES);

从java文档中可以看出，各方是：
在屏障被触发之前必须调用{@link#await}的线程数
非正式地说，parties是在所有线程都向前移动之前，必须调用循环屏障并等待的线程数。
之后，需要将barrier示例对象引用传递给应该等待并调用的每个线程 wait （即。， barrier.await() )，相应地。如下所示：

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");
        ...
    }

对其他必须等待的线程重复此过程。确保参与方的数量（即。， NUMBER_OF_PARIES )匹配应在循环屏障上等待的线程数，否则将发生死锁。
现在你正在使用 cyclic barrier 您可以清理代码的某些部分，例如，可以删除与字段相关的所有逻辑 predecessor 的 Logging 班级。
如果你只是想 Thread 2 等待 Thread 1 ，则可以改用倒计时闩锁。
一种同步辅助工具，允许一个或多个线程等待一组在其他线程中执行的操作完成。倒计时锁存器用给定的计数初始化。由于countdown（）方法的调用，await方法一直阻塞，直到当前计数达到零，之后释放所有等待的线程，并立即返回任何后续的await调用。这是一种一次性现象——计数无法重置。如果需要重置计数的版本，请考虑使用cyclicbarrier。
首先创建 CountDownLatch 对象仅具有 1 计数：

private final CountDownLatch block_thread2 = new CountDownLatch(1);

把它传给 Thread 2 ，并且由于您希望此线程等待 Thread 1 ，呼叫 block_thread2.await(); ```
Thread run = new Thread( () ->{
try {
....
block_thread2.await(); // wait for Thread 2
} catch (InterruptedException e) {
// deal with it
}
});
...

以及 `Thread 1` 添加 `wait.countDown();` :

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");
...
}

所以，以这种方式， `Thread 2` 将等待 `Thread 1` ，但是 `Thread 1` 永远不会等待 `Thread 2` .

加入两个不同的服务

1条答案

相关问题

热门标签

最新问答