java - 如何命令线程完成并使用 join()

Question

如何命令线程完成？我想要以下订单。

第三 ---> 第二 --> 第一 --> 第四。

我应该在代码中进行哪些更改。我是新人。另请详细说明线程优先级和连接。我可以在两个线程上调用 join() 吗，例如 thread3 等待 thread2 完成。

class TJoin implements Runnable {
Thread tj;
String tname;
int tint, tloop;
public TJoin(String name, int time, int loop) {
    tj = new Thread(this, name);
    tint = time;
    tloop = loop;
    tj.start();
    }

    public void run() {
        System.out.println("\n\t\t\t\t" + tj.getName() + " starts now.");
        for (int j = 0; j < tloop; j++) {
            System.out.println("\n" + tj.getName() + " running.");
            try {
                Thread.sleep(tint * 1000);
               } catch (InterruptedException e) {
                e.getMessage();
            }
        }
    System.out.println("\n\t\t\t\t" + tj.getName() + " ends now.");
    }
}

public class ThreadJoin {
    public static void main(String[] args) {
        System.out.println("\n\t\t\t\t" + Thread.currentThread().getName().toUpperCase() + " starts now.");
        TJoin tj1 = new TJoin("First", 1, 15);
        tj1.tj.setPriority(Thread.NORM_PRIORITY + 1);
        TJoin tj2 = new TJoin("Second", 1, 15);
        tj2.tj.setPriority(Thread.NORM_PRIORITY);
        TJoin tj3 = new TJoin("Third", 1, 15);
        tj3.tj.setPriority(Thread.MIN_PRIORITY);
        TJoin tj4 = new TJoin("Fourth", 1, 15);
        tj4.tj.setPriority(Thread.MAX_PRIORITY);

        for (int j = 0; j < 5; j++) {
            System.out.println("\n" + Thread.currentThread().getName() + " running.");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.getMessage();
            }
        }
        try {
            tj2.tj.join();
            tj3.tj.join();
            tj1.tj.join();
            tj4.tj.join();
        } catch (InterruptedException e) {
            e.getMessage();
        }
        System.out.println("\n\t\t\t\tMAIN thread ends now.");
    }
}

Answer 1

每当您希望一系列事情按特定顺序一个接一个地发生时，您都需要使用一个线程来使这些事情按该顺序发生。

因此，假设您有四个线程正在运行，并且您希望这四个线程以特定顺序终止。我不知道您为什么想要这样做，但可以这样做:

您必须编写每个线程，以便它执行它所做的任何事情，然后它等待许可终止。

class MyTask implements Runnable {
    private final Semaphore permissionToDie = new Semaphore(0);

    public void grantPermissionToDie() {
        permissionToDie.release();
    }

    @Override
    public void run() {
        doWhatever();
        permissionToDie.acquire();
    }
}

然后，在主线程中，您将授予每个线程死亡权限，然后等待它死亡(即join())，然后再授予下一个线程的权限。

public void main(...) {
    MyTask tj1 = new Thread(new MyTask());
    MyTask tj2 = new Thread(new MyTask());
    MyTask tj3 = new Thread(new MyTask());
    MyTask tj4 = new Thread(new MyTask());

    tj1.start();
    tj2.start();
    tj3.start();
    tj4.start();

    ...

    t3.grantPermissionToDie();
    t3.join();

    t2.grantPermissionToDie();
    t2.join();

    t1.grantPermissionToDie();
    t1.join();

    t4.grantPermissionToDie();
    t4.join();
}