Java 严格按照顺序执行两个单独的线程

我想以严格的顺序执行两个独立的线程，即“A->B->A->B”，谁知道怎么做

我不希望序列之间有任何延迟（如睡眠、产量）

以下是一些我编写但无法运行的代码：

    public void onClick_start_thread_a(View v) {
    logger.d("onClick_start_thread_a");
    Runnable r = new Runnable() {

        @Override
        public void run() {
            // TODO Auto-generated method stub
            while (true) {
                synchronized (flag) {
                    try {
                        flag.wait();
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    logger.d("Thread A!");
                }
            }
        }
    };
    Thread t = new Thread(r);
    t.start();
}

public void onClick_start_thread_b(View v) {
    logger.d("onClick_start_thread_b");
    Runnable r = new Runnable() {
        @Override
        public void run() {
            // TODO Auto-generated method stub
            while (true) {
                synchronized (flag) {
                flag.notify();
                logger.d("Thread B!");
                }
            }
        }
    };
    Thread t = new Thread(r);
    t.start();
}

onClick_start_thread_a和onClick_start_thread_b由两个不同的按钮触发，单击按钮后，输出为：

01-11 22:49:40.705: D/THING(25877): {Thread:Thread-619}[MainActivity:] Thread A!
01-11 22:49:40.705: D/THING(25877): {Thread:Thread-620}[MainActivity:] Thread B!
01-11 22:49:40.705: D/THING(25877): {Thread:Thread-619}[MainActivity:] Thread A!
01-11 22:49:40.705: D/THING(25877): {Thread:Thread-620}[MainActivity:] Thread B!
01-11 22:49:40.705: D/THING(25877): {Thread:Thread-619}[MainActivity:] Thread A!
01-11 22:49:40.705: D/THING(25877): {Thread:Thread-620}[MainActivity:] Thread B!
01-11 22:49:40.705: D/THING(25877): {Thread:Thread-619}[MainActivity:] Thread A!
01-11 22:49:40.705: D/THING(25877): {Thread:Thread-620}[MainActivity:] Thread B!
01-11 22:49:40.705: D/THING(25877): {Thread:Thread-620}[MainActivity:] Thread B!
01-11 22:49:40.705: D/THING(25877): {Thread:Thread-620}[MainActivity:] Thread B!
01-11 22:49:40.705: D/THING(25877): {Thread:Thread-620}[MainActivity:] Thread B!
01-11 22:49:40.705: D/THING(25877): {Thread:Thread-620}[MainActivity:] Thread B!
01-11 22:49:40.705: D/THING(25877): {Thread:Thread-620}[MainActivity:] Thread B!
01-11 22:49:40.705: D/THING(25877): {Thread:Thread-620}[MainActivity:] Thread B!
01-11 22:49:40.705: D/THING(25877): {Thread:Thread-620}[MainActivity:] Thread B!
01-11 22:49:40.705: D/THING(25877): {Thread:Thread-620}[MainActivity:] Thread B!
01-11 22:49:40.705: D/THING(25877): {Thread:Thread-620}[MainActivity:] Thread B!
01-11 22:49:40.705: D/THING(25877): {Thread:Thread-620}[MainActivity:] Thread B!
01-11 22:49:40.705: D/THING(25877): {Thread:Thread-620}[MainActivity:] Thread B!
01-11 22:49:40.705: D/THING(25877): {Thread:Thread-620}[MainActivity:] Thread B!
01-11 22:49:40.705: D/THING(25877): {Thread:Thread-620}[MainActivity:] Thread B!

---

你可能想要的是某种信号量和麦加主义的信号

Start Threads A and B
B - waits on semaphore
A - does stuff
A - when finished A signals B
A - waits on semaphore
B - does stuff
B - when finished B signals A
...... repeat until done

---

看一看文档

如果这是一个像您这样的简单案例（只有两个线程），那么我认为您可以使用一个简单的布尔值（Java中的AtomicBoolean）

1） 将布尔值（我们称之为decider）设置为false

2） 启动两个线程

3） 线程1将具有：

while(true) {
  if(decider.get()) {
    // do stuff
    decider.set(false);
  }
}

另一个：

while(true) {
  if(!decider.get()) {
    // do stuff
    decider.set(true);
  }
}

while（true）（或其他条件）似乎有点开销，因此您可以在两个if语句中添加一个锁（lock#lock（）将等待锁释放）

---

如果你想把它推广到更多的线程，你只需要用一些可以接受更多状态的东西来代替布尔值。每个线程可能都有一个ID（从0到N），并且只有当invocationNr modulo nrOfThreads==ID时才会输入if。

它的可能重复在我的脑海中不是重复的，我想使用对象wait/notify我在我的计算机上测试它，它工作得很好。你的结果是什么？

01-12 11:13:07.211:I/System.out（30483）：线程a
01-12 11:13:07.211:I/System.out（30483）：线程A
01-12 11:13:07.211:I/System.out（30483）：线程B
01-12 11:13:07.211:I/System.out（30483）：线程B可能错误来自日志-可能不会立即输出日志文本？我想我可以确认我的假设：在每个函数的“System.out.println（xxxx）”之前添加“Thread.sleep（10）”后，输出是正确的。所以这应该是一个跟踪问题。谢谢你的回答，这很有用。
    public void onClick_start_thread_a(View v) {
    logger.d("onClick_start_thread_a");
    Runnable r = new Runnable() {

        @Override
        public void run() {
            // TODO Auto-generated method stub
            while (true) {
                synchronized (flag) {
                    System.out.println("Thread A!");
                    flag.notifyAll();
                    try
                    {
                        flag.wait();
                    } catch (InterruptedException e)
                    {
                        e.printStackTrace();
                    }
                }
            }
        }
    };
    Thread t = new Thread(r);
    t.start();
}

public void onClick_start_thread_b(View v) {
    logger.d("onClick_start_thread_b");
    Runnable r = new Runnable() {
        @Override
        public void run() {
            // TODO Auto-generated method stub
            while (true) {
                synchronized (flag) {
                    System.out.println("Thread B!");
                    flag.notifyAll();
                    try
                    {
                        flag.wait();
                    } catch (InterruptedException e)
                    {
                        e.printStackTrace();
                    }
                }
            }
        }
    };
    Thread t = new Thread(r);
    t.start();
}