Java 以特定顺序实现多线程完成的同步改进

问题陈述：巴士可以按任何顺序启动，但会按特定顺序到达目的地。所以，若之前预期的巴士还并没有到达，巴士将等待

在遇到多个丢失的信号并解决它们之后，我最终提出了以下解决方案。 我的问题：首先，我们如何修改下面的代码，使其从设计的角度变得健壮？第二，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();
}

公共类BusDestination实现可运行{
私有布尔[]总线到达状态；
private List busSeq=new ArrayList（）；
private Lock=new ReentrantLock（）；
私有条件prevBusFlag=lock.newCondition（）；
私人倒计时闩锁；
布尔信号=假；
公共总线目的地（倒计时闩锁）{
busSeq.添加（“B1”）；
busSeq.添加（“B2”）；
busSeq.添加（“B3”）；
busSeq.添加（“B4”）；
busSeq.添加（“B5”）；
busArrivalStatus=新布尔值[busSeq.size（）]；
对于（int i=0；i

---

}

根据您试图实现的目标，此问题可能会对您有所帮助：但是，该问题中的答案侧重于线程完成工作后的同步，这与您想要的并不完全相同

除此之外，倒计时锁不是多余的吗？如果使用signal/wait同步线程，是否仍需要等待它们同时完成

我的想法是使用一个队列来定义公交车的顺序。线程窥视队列（不移除它），如果轮到它，如果从队列中移除元素并向其他线程发出信号。由于对队列的并发访问仅在关键部分完成，因此可以使用简单的

LinkedList

if/else检查

busarrivalseq==0

是非常冗余的，它们实际上做了非常相似的事情。使用队列，它可以简化为一种情况

public class BusDestination implements Runnable {


    private Lock lock = new ReentrantLock();
    private Condition prevBusFlag = lock.newCondition();
    private Queue<String> busSeq;

    public BusDestination(Queue<String> busSeq) {

        this.busSeq = busSeq;
    }


    public void run() {

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

        try {
            lock.lock();

                while (!busSeq.peek().equals(busName) ) {
                    System.out.println(busName + " going to wait.");
                    prevBusFlag.await();
                }
                System.out.println("********    Bus arriaved : " + busName);
                busSeq.remove();

                prevBusFlag.signalAll();
        } catch (Exception ex) {
            ex.printStackTrace();
            System.out.println("Except--" + busName);
        } finally {
            lock.unlock();
        }

    }

    public static void main(String[] args) throws InterruptedException {

        Queue<String> busSeq = new LinkedList<>();
        busSeq.add("B1");
        busSeq.add("B2");
        busSeq.add("B3");
        busSeq.add("B4");
        busSeq.add("B5");

        BusDestination destination = new BusDestination(busSeq);

        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();

    }
}

公共类BusDestination实现可运行{
private Lock=new ReentrantLock（）；
私有条件prevBusFlag=lock.newCondition（）；
专用队列总线；
公共总线目的地（队列总线顺序）{
this.busSeq=busSeq；
}
公开募捐{
字符串busName=Thread.currentThread（）.getName（）；
试一试{
lock.lock（）；
而（！busSeq.peek（）.equals（busName））{
System.out.println（busName+“正在等待”）；
prevBusFlag.wait（）；
}
System.out.println（“*********总线到达：“+busName”）；
busSeq.remove（）；
prevBusFlag.signalAll（）；
}捕获（例外情况除外）{
例如printStackTrace（）；
System.out.println（“除了--”+busName）；
}最后{
lock.unlock（）；
}
}
公共静态void main（字符串[]args）引发InterruptedException{
Queue busSeq=新链接列表（）；
busSeq.添加（“B1”）；
busSeq.添加（“B2”）；
busSeq.添加（“B3”）；
busSeq.添加（“B4”）；
busSeq.添加（“B5”）；
BusDestination=新的BusDestination（busSeq）；
线程b1=新线程（目标）；
线程b2=新线程（目标）；
线程b3=新线程（目标）；
线程b4=新线程（目标）；
线程b5=新线程（目标）；
b1.设定名称（“b1”）；
b2.设定名称（“b2”）；
b3.设定名称（“b3”）；
b4.设定名称（“b4”）；
b5.设定名称（“b5”）；
b4.开始（）；
b5.start（）；
b3.start（）；
b1.开始（）；
b2.start（）；
}
}

这可以通过只使用CountDownLatch实例而不需要lock实例来简化。您试图解决的问题是，线程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

}

这个解决方案的一个很好的特性是您可以创建一个pip