加入两个不同的服务

slsn1g29  于 2021-06-30  发布在  Java
关注(0)|答案(1)|浏览(361)

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

quhf5bfb1#

如果要在一组线程之间进行同步,可以使用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 您可以清理代码的某些部分,例如,可以删除与字段相关的所有逻辑 predecessorLogging 班级。
如果你只是想 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` .

相关问题