Question

我希望线程按特定顺序运行。假设我有三个线程 T1，T2，T2 。

T1打印0
T2打印1
T3打印2

我希望输出的顺序为 0 1 2 ， 0 1 2 一段时间。

如果有两个主题 T1 和 T2 。使用synchronization 生产者 - 消费者问题打印 0 1,0 1 ... 。

Answer 1

创建一个类UnitOfWork：

public class UnitOfWork implements Runnable
{
    String text;

    public UnitOfWork(String text){
        this.text = text;
    }

    public void run(){
        System.out.println(text);
    }
}

然后创建单个线程执行器服务：

ExecutorService executor = ExecutorService.newSingleThreadExecutor();

你会像这样使用：

UnitOfWork uow0 = new UnitOfWork("0");
UnitOfWork uow1 = new UnitOfWork("1");
UnitOfWork uow2 = new UnitOfWork("2");

for(int i = 0; i < 5; i++){
    executor.submit(uow0);
    executor.submit(uow1);
    executor.submit(uow2);
}

当您对单个线程不满意时，您可以开始使用多个线程执行器服务，这实际上会同时运行任务。

Answer 2

在线程类中使用join（）方法可以实现这一点。

join方法允许一个线程等待另一个线程的完成。如果t是其当前正在执行其线程的Thread对象，则

t.join（）;

导致当前线程暂停执行，直到t的线程终止。连接过载允许程序员指定等待期。但是，与sleep一样，join依赖于操作系统进行计时，因此您不应该假设连接将等待您指定的时间。

与sleep一样，join通过退出InterruptedException来响应中断。

Answer 3

使用 Thread.join 确保它在下一个线程启动之前终止。

public static void main(String[] args) throws InterruptedException {
        final Thread th1 = new Thread(new Runnable() {
            public void run() {
                try {
                    Thread.sleep((long) (Math.random() * 1000));
                    System.out.println("Thread 1");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        Thread th2 = new Thread(new Runnable() {
            public void run() {
                try {
                    Thread.sleep((long) (Math.random() * 1000));
                    System.out.println("Thread 2");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        Thread th3 = new Thread(new Runnable() {
            public void run() {
                try {
                    Thread.sleep((long) (Math.random() * 1000));
                    System.out.println("Thread 3");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        th1.start();
        th1.join();
        th2.start();
        th2.join();
        th3.start();
    }

Answer 4

这是一段极简主义的代码，字面上你所要求的。它依赖于wait-notify机制。

我坚持认为你不需要任何线程来满足你的要求。打印0-1-2的简单循环就是你真正需要的。

import static java.lang.Thread.currentThread;

public class A {
  static int coordinator, timesPrinted;
  static final int numThreads = 3, timesToPrint = 300;
  public static void main(String[] args) {
    for (int i = 0; i < numThreads; i++) {
      final int myId = i;
      new Thread(new Runnable() { public void run() {
        while (true) synchronized (A.class) {
          if (coordinator%numThreads == myId) {
            System.out.println(myId+1);
            coordinator++;
            if (timesPrinted++ > timesToPrint) currentThread().interrupt();
            A.class.notifyAll();
          }
          try {A.class.wait();} catch (InterruptedException e) {break;}
        }
      }}).start();
    }
  }
}

以特定顺序运行两个以上的线程

4 个答案: