如何让join（）或wait（）在这里工作？Java线程与并发

这个问题中的代码显然太长了，所以我写了一个示例，您可以直接复制和粘贴它，我认为它包含了我遇到的概念问题。 感谢那些通读上一版本的人

两个文件

一个调用另一个并传递ArrayList

第二个文件修改ArrayList，并为第一个文件提供一个getter来访问修改后的文件

如何使第一个文件在调用getter之前等待第二个文件中的处理。目前，这段代码为您提供了一个NullPointerException，因为第一个文件没有等待

执行线程上的join（）似乎不起作用，如果使用wait（），如何从第二个文件通知第一个文件

代码如下：

public class Launcher implements Runnable {

private ArrayList al = new ArrayList();
private ArrayProcessor ap;

public Launcher(ArrayList al){
    this.al = al;
    ArrayProcessor ap = new ArrayProcessor(al);
}
public static void main(String[] args){
    ArrayList anArray = new ArrayList();
    anArray.add(new Integer(1));
    anArray.add(new Integer(13));
    anArray.add(new Integer(19));
    Launcher l = new Launcher(anArray);
    l.liftOff();
}

public void liftOff(){
    Thread t = new Thread(new Launcher(al));
    synchronized(t){
        t.start();
        try {
            t.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    this.ap = new ArrayProcessor(al);
    System.out.println("the array: " + ap.getArray());
}
public void run() {
    ap.doProcess(al);
}

}

和被调用的文件：

public class ArrayProcessor extends Thread{

private ArrayList al;

public ArrayProcessor(ArrayList al){
    this.al = al; 
}

public void doProcess(ArrayList myAL){
    this.start();
}

public void run() {
            // this should increment the ArrayList elements by one
    for (int i=0; i<al.size(); i++){
        int num = ((Integer)al.get(i)).intValue();
        al.set(i, new Integer(++num));
    }
}

public ArrayList getArray(){
    return al;
}

}

公共类ArrayProcessor扩展线程{
私人ArrayList al；
公共阵列处理器（ArrayList al）{
this.al=al；
}
公共无效数据处理（ArrayList myAL）{
这个。start（）；
}
公开募捐{
//这将使ArrayList元素增加1
对于（int i=0；i如果希望一个线程等待另一个线程完成，则可以使用倒计时锁存器

  public static void main(String[] args) throws Exception {

    final CountDownLatch latch = new CountDownLatch(1);

    new Thread(new Runnable() {
        @Override
        public void run() {
            try {
                System.out.println("Thread doing some work...");
                Thread.sleep(10 * 1000);
                System.out.println("Thread done!");
                latch.countDown();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }).start();


    System.out.println("Main Thread waiting...");
    latch.await();
    System.out.println("Main Thread can continue");
}

这段代码真的是演示问题的最小数量的代码吗？我不这么认为…请阅读并以您的提问方式删减代码down@Bohemian公正的评论。我会试试…@Bohemian我同意你的评论。新版本怎么样？