java中Thread.join（）的反向使用

我知道我可以使用以下方法让线程B在继续之前等待线程A完成：

class A extends Thread{
    public void run(){
        ....
    }
}
class B extends Thread{
    private Thread someThread;
    B(Thread t){
        someThread=t;
    }
    public void run(){
        someThread.join();
        ...//then proceed
    }
}

但是如何在

A

的

run（）

中调用

B

并等待它完成后再继续？也就是说，我想要

class A extends Thread{
    private Thread someThread;
    B(Thread t){
        someThread=t;
    }
    public void run(){
        //*how to start B and wait it finish?
        ...//then proceed
    }
}
class B extends Thread{
    public void run(){
        ....
    }
}

同样的交易：

class A extends Thread{
    private Thread someThread;
    A(Thread t){
        someThread=t;
    }
    public void run(){
        someThread.start();
        someThread.join();
        // proceed
    }
}
class B extends Thread{
    public void run(){
        ....
    }
}

---

但你为什么要这么做？线程的思想是并行地做事情。为什么要启动一个线程并立即等待它完成？只要在A中就地执行B中的内容。

如果可能，一个更简单的解决方案是先启动

B

，然后启动

B.join（），并对客户端代码中的
A
执行相同操作：

b.start();
b.join();
a.start();
a.join();

启动一个线程，让它在继续之前启动并连接到另一个线程，这是没有意义的。
您可以使用join（）等待任何线程

final Thread a = Thread.currentThread();
new Thread(new Runnable() {
    public void run() {
        // do something
        a.join();
        // calling thread finished.
    }
 }).start();
 // do something.

查找下面的示例，了解如何反向执行线程

对于这种情况，我们可以使用join方法

    package interview.thread;
     public class RevarseThreadExcute {
    public static void main(String[] args) throws InterruptedException {
   Thread t3 = new Thread(new Runnable() {
    @Override
            public void run() {

                for (int i = 0; i < 10; i++) {
                    System.out.println("Thread 3 =" + i);

                }
            }
        });
        Thread t2 = new Thread(new Runnable() {

            @Override
            public void run() {
               try {
                t3.join();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
                for (int i = 0; i < 10; i++) {
                    System.out.println("Thread 2 =" + i);

                }
            }
        });

        Thread t1 = new Thread(new Runnable() {

            @Override
            public void run() {
                try {
                    t3.join();
                    t2.join();
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                for (int i = 0; i < 10; i++) {
                    System.out.println("Thread 1 =" + i);

                }
            }
        });

        t1.start();
        t2.start();
        t3.start();
    }


}

我想你把一个构造器放错地方了你想在这里完成什么？如果两个线程都在等待另一个线程完成，那么就会出现典型的死锁。这种设计非常可疑。
final Thread a = Thread.currentThread();
new Thread(new Runnable() {
    public void run() {
        // do something
        a.join();
        // calling thread finished.
    }
 }).start();
 // do something.

    package interview.thread;
     public class RevarseThreadExcute {
    public static void main(String[] args) throws InterruptedException {
   Thread t3 = new Thread(new Runnable() {
    @Override
            public void run() {

                for (int i = 0; i < 10; i++) {
                    System.out.println("Thread 3 =" + i);

                }
            }
        });
        Thread t2 = new Thread(new Runnable() {

            @Override
            public void run() {
               try {
                t3.join();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
                for (int i = 0; i < 10; i++) {
                    System.out.println("Thread 2 =" + i);

                }
            }
        });

        Thread t1 = new Thread(new Runnable() {

            @Override
            public void run() {
                try {
                    t3.join();
                    t2.join();
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                for (int i = 0; i < 10; i++) {
                    System.out.println("Thread 1 =" + i);

                }
            }
        });

        t1.start();
        t2.start();
        t3.start();
    }


}

Thread 3 =0
Thread 3 =1
Thread 3 =2
Thread 3 =3
Thread 3 =4
Thread 3 =5
Thread 3 =6
Thread 3 =7
Thread 3 =8
Thread 3 =9
Thread 2 =0
Thread 2 =1
Thread 2 =2
Thread 2 =3
Thread 2 =4
Thread 2 =5
Thread 2 =6
Thread 2 =7
Thread 2 =8
Thread 2 =9
Thread 1 =0
Thread 1 =1
Thread 1 =2
Thread 1 =3
Thread 1 =4
Thread 1 =5
Thread 1 =6
Thread 1 =7
Thread 1 =8
Thread 1 =9