java - 同步改进以按特定顺序实现多线程完成

Question

问题陈述:公共(public)汽车可以按任何顺序启动，但会按特定顺序到达目的地。因此，如果之前预期的巴士尚未到达，巴士就会等待。

在遇到多个丢失信号并解决它们之后，我终于想出了以下解决方案。我的问题:首先，我们如何修改下面的代码以使其从设计角度变得健壮？其次，JAVA中有没有其他同步机制可以解决这个问题？

public class BusDestination implements Runnable {

private boolean[] busArrivalStatus;
private List<String> busSeq = new ArrayList<>();


private Lock lock = new ReentrantLock();
private Condition prevBusFlag = lock.newCondition();
private CountDownLatch latch;
boolean signalled = false;

public BusDestination(CountDownLatch latch) {
    busSeq.add("B1");
    busSeq.add("B2");
    busSeq.add("B3");
    busSeq.add("B4");
    busSeq.add("B5");

    busArrivalStatus = new boolean[busSeq.size()];
    for (int i = 0; i < this.busSeq.size(); i++) {
        busArrivalStatus[i] = false;
    }
    this.latch = latch;
}


public void run() {

    String busName = Thread.currentThread().getName();

    try{
        lock.lock();
        int busArrrivalSeq = busSeq.indexOf(busName);
        if(busArrrivalSeq==0){
            //first bus arrived
            System.out.println("********    Bus arriaved : "+busName);
            busArrivalStatus[0] = true;
            System.out.println(busName+" will signall");
            signalled = true;
            prevBusFlag.signalAll();
        } else {
            while(!isValidSeq(busName) && !signalled ){
                System.out.println(busName+" going to wait.");
                prevBusFlag.await();
            }
            System.out.println("********    Bus arriaved : "+busName);
            busArrivalStatus[busSeq.indexOf(busName)] = true;
            signalled = true;//getPreviousBusStatus(busName);
            prevBusFlag.signalAll();
        }
    } catch(Exception ex){
        ex.printStackTrace();
        System.out.println("Except--"+busName);
    }finally{
        lock.unlock();  
    }
    latch.countDown();
}

private boolean isValidSeq(String busName) {
    int prevIndex = busSeq.indexOf(busName)-1;
    if(!busArrivalStatus[prevIndex]){
        signalled = false;
    }
    return busArrivalStatus[prevIndex];
}

public static void main(String[] args) throws InterruptedException {
    CountDownLatch latch = new CountDownLatch(5);

    BusDestination destination = new BusDestination(latch);

    Thread b1 = new Thread(destination);
    Thread b2 = new Thread(destination);
    Thread b3 = new Thread(destination);
    Thread b4 = new Thread(destination);
    Thread b5 = new Thread(destination);

    b1.setName("B1");
    b2.setName("B2");
    b3.setName("B3");
    b4.setName("B4");
    b5.setName("B5");

    b4.start();
    b5.start();
    b3.start();
    b1.start();
    b2.start();

    latch.await();
}

}

Answer 1

这可以通过仅使用 CountDownLatch 实例来简化，而不需要锁实例。您试图解决的问题是线程 n 可以同时执行，但在某个点线程 t 必须等待，直到线程 t-1 到达某个点。这是我的解决方案。

public class BusDestination {

    private CountDownLatch pre, next;

    public BusDestination(CountDownLatch pre, CountDownLatch next) {
         this.pre = pre;
         this.next = next;
    }

    public void run() {
          // Do work....
          pre.await(); // wait until prior thread{s} are done
          // If required, do more work...
          pre.countDown(); // notify next set of thread{s} that you are done
          // If required, do more work...
    }

    public static void main(String args[]) {
         CountDownLatch first = new CountDownLatch(0); // await will return right away.
         CountDownLatch second = new CountDownLatch(1);
         // Continue creating CountDownLatch....
         CountDownLatch preLast =  new CountDownLatch(1);
         CountDownLatch last = new CountDownLatch(1); // used to wait by the main thread.

         BusDestination firstBus = new BusDestination(first, second);
         // create more destinations
         BusDestination lastBus = new BusDestination(preLast, last);

         // start threads....

        last.await(); // Waits until all of the threads complete

}

此解决方案的一个很好的功能是，您可以创建一个管道，其中步骤 n 必须等待两个或多个线程在步骤 n - 1 中完成才能继续。