Java多线程等待子线程死亡

我有以下Java代码：

import java.io.*;
class Global{
public static int a = 0 ;
public static int b = 0 ;
}
public class Example{
public static void main(String args[]) {
    try {
        FileOutputStream fos = new FileOutputStream("1.dat");
        DataOutputStream dos = new DataOutputStream(fos);

        for (int i = 0; i < 20000; i++) {
            dos.writeInt(i);
        }
        dos.close();

        FileOutputStream fos1 = new FileOutputStream("2.dat");
        DataOutputStream dos1 = new DataOutputStream(fos1);

        for (int i = 20000; i < 40000; i++) {
            dos1.writeInt(i);
        }
        dos1.close();

        Exampless.createArray(20000); //static method call to set the static arr variable
        Exampless ex1 = new Exampless("1.dat"); //found number of matches in file
        Exampless ex2 = new Exampless("2.dat");
        Thread t1 = new Thread(ex1);
        Thread t2 = new Thread(ex2);
        t1.start();
        t1.join();
        t2.start();
        t2.join();
        System.out.println("No. of Matches: " + (Global.a + Global.b ));

    } catch (Exception e) {
        System.err.println("Error: " + e.getMessage());
    }
}
}

class Exampless implements Runnable {

public static int[] arr = new int[20000];
public String _name;

public Exampless(String name) {
    this._name = name;
}

static void createArray(int z) {
    for (int i = z; i < z + 20000; i++) {
        arr[i - z] = i;
    }
}

public void run() {
    try {
        int cnt = 0;
        FileInputStream fin = new FileInputStream(_name);
        DataInputStream din = new DataInputStream(fin);
        for (int i = 0; i < 20000; i++) {
            int c = din.readInt();
            if (c == arr[i]) {
                cnt++;
            }
        }
        System.out.println("File name: " + _name + " No. of Matches: " + cnt);
        if(_name == "1.dat")
            Global.a = cnt ;
        else if(_name == "2.dat")
            Global.b = cnt ;
    } catch (Exception e) {
        System.err.println("Error: " + e.getMessage());
    }
}

}

import java.io.*；
类全局{
公共静态int a=0；
公共静态int b=0；
}
公开课范例{
公共静态void main（字符串参数[]）{
试一试{
FileOutputStream fos=新的FileOutputStream（“1.dat”）；
DataOutputStream dos=新的DataOutputStream（fos）；
对于（int i=0；i<20000；i++）{
dos.writeInt（i）；
}
dos.close（）；
FileOutputStream fos1=新的FileOutputStream（“2.dat”）；
DataOutputStream dos1=新的DataOutputStream（fos1）；
对于（int i=20000；i<40000；i++）{
dos1.书面文件（i）；
}
dos1.close（）；
createArray（20000）；//用于设置静态arr变量的静态方法调用
Exampless ex1=newexampless（“1.dat”）；//在文件中找到的匹配数
Exampless ex2=新的Exampless（“2.dat”）；
螺纹t1=新螺纹（ex1）；
螺纹t2=新螺纹（ex2）；
t1.start（）；
t1.join（）；
t2.start（）；
t2.连接（）；
System.out.println（“匹配数：”+（Global.a+Global.b））；
}捕获（例外e）{
System.err.println（“错误：+e.getMessage（））；
}
}
}
类Exampless实现可运行的{
公共静态整数[]arr=新整数[20000]；
公共字符串\u名称；
公共示例（字符串名称）{
这个。_name=name；
}
静态void createArray（int z）{
对于（int i=z；i

---

在这里，我尝试并行运行examplesclasses

run

method。但是，我想让主线程等待子线程完成，这是我使用

join

完成的。但是，它使得线程的执行一个接一个。有谁能帮我解决这个问题吗？另一点是，我想在两个线程之间共享一个变量（名为cnt，它在文件中找到了匹配数），我使用全局类找到了匹配总数。还有其他好的解决方案吗？

在加入之前，您是否尝试过先启动两个线程

    t1.start();
    t2.start();
    t1.join();
    t2.join();

---

在连接之前，您是否尝试过先启动两个线程

    t1.start();
    t2.start();
    t1.join();
    t2.join();

t1.join（）

t1.start();
t2.start();
t1.join();
t2.join();

但是，最好使用高级并发程序包，通常是：

你的下一个问题：

我想在两个线程之间共享一个变量（名为cnt，它在文件中找到了匹配数），我使用全局类找到了匹配总数。还有什么好办法吗

您所做的不是线程安全的，除非这些变量是可变的。如果不是，则在main中的打印可能不会打印这些变量的最新值

更好的解决方案是使用ExampleSimplement而不是Runnable，在这种情况下，您可以返回一个值

然后，您可以从执行者返回的未来中检索值：

Future<Integer> future1 = executor.submit(ex1);
Future<Integer> future2 = executor.submit(ex2);

count1 = future1.get();
count2 = future2.get();

Future future1=执行人提交（ex1）；
未来2=执行人提交（ex2）；
count1=future1.get（）；
count2=future2.get（）；

ps：您需要在
未来添加错误处理代码。get（）
调用
t1。join（）
等待t1完成，因此您需要反转两行：

t1.start();
t2.start();
t1.join();
t2.join();

但是，最好使用高级并发程序包，通常是：

你的下一个问题：

我想在两个线程之间共享一个变量（名为cnt，它在文件中找到了匹配数），我使用全局类找到了匹配总数。还有什么好办法吗

您所做的不是线程安全的，除非这些变量是可变的。如果不是，则在main中的打印可能不会打印这些变量的最新值

更好的解决方案是使用ExampleSimplement而不是Runnable，在这种情况下，您可以返回一个值

然后，您可以从执行者返回的未来中检索值：

Future<Integer> future1 = executor.submit(ex1);
Future<Integer> future2 = executor.submit(ex2);

count1 = future1.get();
count2 = future2.get();

Future future1=执行人提交（ex1）；
未来2=执行人提交（ex2）；
count1=future1.get（）；
count2=future2.get（）；

ps：您需要在
未来添加错误处理代码。get（）
调用
而不是在前一个线程完成后启动下一个线程，您可以使用来监视线程的状态
，而不是在前一个线程完成后启动下一个线程，您可以使用a来监视线程的状态
非常感谢。您能否对上面的代码稍加修改，以使代码线程安全。因为，“import java.util.concurrent”和“implements callable”表示找不到这样的方法和类。@ARPSSS我添加了一个指向可调用接口的链接-它类似于可运行的，只是您没有一个
public void run
方法。在您的例子中，您将实现
Callable
，因为您需要返回一个整数，而要实现的方法将是
public integer call（）
。您返回的值将是您的计数。如果您使用
future.get（）
阅读它，该值将以线程安全的方式返回，因此您无需添加任何其他内容。非常感谢。您能否对上面的代码稍加修改，以使代码线程安全。因为“import java.util.concurrent”和“implements callable”