Java 一个线程正在等待另一个线程的方法

我有一个线程（A）可以启动另一个线程（B）。线程A必须等待线程B的初始化方法完成后才能继续

我目前使用线程B作为锁，如下所示：

synchronized (B) {

            try {

                B.start();

                while (!B.getIsInitialized()) {
                    B.wait();
                }
            } catch (InterruptedException e) {
                Log.logStackTrace(this + " run: Exception detected", e);
            }
        }

在B的run方法的一开始，我有以下内容：

synchronized(this) {

        initialize();

        notify();
    }

这一切似乎都奏效了，但我可以；在网上找不到任何关于使用两个线程中的一个作为锁的信息。我做的对吗？我还应该注意，线程B不会在初始化完成后终止，需要继续，所以我不能简单地使用.join（）

---

感谢您的时间。

对于您想要实现的目标，此代码肯定会起作用。我要提到的唯一一点是，尽量少使用synchronized，因为同步是“昂贵的”。所以，如果代码的某些部分不需要在同步部分中，那么就不要。这部分代码将执行相同的操作，但同步仅在线程B中完成

public class Test {
 public static void main(String[] args) {       
     new ThreadA().start();
  }
}


class ThreadA extends Thread{       
    private void startThreadB(){
        ThreadB tb=new ThreadB();
        tb.start();                 
        // to some code if you need;
        tb.isInit();
    }

    public void run(){
            System.out.println("Thread A is started ");
            startThreadB(); 
            while(true){
                // your code for execution of thread A
                System.out.println("thread A is working");
                try{ Thread.sleep(2000);} catch(Exception e){}
            }
    }       
}



  class ThreadB extends Thread{
     private boolean init;               
     public ThreadB(){   init=false;     }
     private void init(){
         // some code here for init
         synchronized(this){
               init= true;
               notifyAll();
               System.out.println("Thread B has been inicialized !");
         }
     }


     public void isInit(){
         synchronized(this){
             while(!init) { try{ wait();}catch(InterruptedException e){}}
         }
     }

    public void run(){
        System.out.println("Thread B is started");
        init();
        while(true){
            // your code for execution of thread B
            System.out.println("Thread B is working");
            try{ Thread.sleep(2000);} catch(Exception e){}
        }
    }
}

---

不要对

线程

实例执行

同步

或

等待

或

通知

。这似乎与我在网上发现的线程实例没有锁定一致。我应该在线程A中使用某种公共静态对象吗？我不知道我可以将任何对象作为参数传递..有一件事会破坏这段代码--调用

notifyAll（）

而不是

notify

。其余的都有点古怪，但应该可以工作。所以在你看来，这段代码很好，但我需要调用notifyAll来代替？只有一个线程（a）等待线程B。您可以使用初始值为1的

CountDownLatch

。线程A调用

wait（）

等待初始化；初始化完成后，线程B立即调用倒计时（）。