Java 如何删除主线程中手动创建的暂停？ 问题描述：

我们有一个随机填充数字的给定矩阵，并且必须为矩阵的每一行创建单独的线程，计算数字在该行中遇到的次数

如果主线程中没有这些休眠，它将无法正常工作

这是我的 这里还有以下内容：

公共类TestingMatrixThreads{
公共静态void main（字符串[]arr）引发InterruptedException{
int[]a=新int[67][6]；
//类。计数与类一起工作。矩阵，这就是我为什么这样做的原因
矩阵m=新矩阵（a）；
m、 start（）；
Thread.sleep（1000）；//下面是一个大问题->如何避免这些
//手动创建的暂停
计数c；
螺纹t；
//为矩阵的每一行创建新线程
对于（int i=0；i”+Count.containments[i]）；
总和+=计数遇到[i]；
}
System.out.println（“总位数：“+sum”）；
}

}

类计数实现可运行{
int行；
public static int[]conferences=new int[10]；//这里我存储了每个数字（数组的索引）的遭遇次数
公共计数（整数行）{
this.row=行；
}
公共同步静态无效增量（整数）{
遭遇[数字]+；
}
@凌驾
公开募捐{
System.out.println（Thread.currentThread（）.getName（）+”，在行“+行+”中搜索已启动）；
对于（int col=0；col

}

类矩阵扩展线程{
静态int[]matr；
公共矩阵（int[]matr）{
Matrix.matr=matr；
}
@凌驾
公开募捐{
//打印（）；
填充（）；
系统输出打印项次（“矩阵填充”）；
打印（）；
}
公共静态空隙填充（）{
对于（int i=0；i

}

顺便说一句，如果这个问题对你来说太愚蠢而无法回答，我很抱歉，但我是Java编程的新手，而且这是我在stackoverflow中的第一篇文章，所以请原谅我的格式错误：）

---

提前谢谢你

通过m.join（）更改Thread.sleep

这样做将使主线程等待另一个线程完成其工作，然后继续执行

---

为回答您的主要问题干杯：

Thread.join();

例如：

public static void main(String[] args) throws Exception {
    final Thread t = new Thread(new Runnable() {

        @Override
        public void run() {
            System.out.println("Do stuff");
        }
    });
    t.start();
    t.join();
}

如您所知，

start

调用启动另一个

线程

，并运行

Runnable

。然后，

join

调用等待启动的线程完成

处理多线程的更高级方法是使用。这会将线程本身与它们执行的任务分离。您可以拥有一个

n

线程池和

m>n

任务池

例如：

public static void main(String[] args) throws Exception {
    final class PrintMe implements Callable<Void> {

        final String toPrint;

        public PrintMe(final String toPrint) {
            this.toPrint = toPrint;
        }

        @Override
        public Void call() throws Exception {
            System.out.println(toPrint);
            return null;
        }

    }
    final List<Callable<Void>> callables = new LinkedList<>();
    for (int i = 0; i < 10; ++i) {
        callables.add(new PrintMe("I am " + i));
    }
    final ExecutorService es = Executors.newFixedThreadPool(4);
    es.invokeAll(callables);
    es.shutdown();
    es.awaitTermination(1, TimeUnit.DAYS);
}

publicstaticvoidmain（字符串[]args）引发异常{
最后一个类PrintMe实现了Callable{
最终字符串打印；
公共PrintMe（最终字符串toPrint）{
this.toPrint=toPrint；
}
@凌驾
public Void call（）引发异常{
系统输出打印项次（toPrint）；
返回null；
}
}
final List callables=new LinkedList（）；
对于（int i=0；i<10；++i）{
添加（新的PrintMe（“我是”+I））；
}
final Executors服务es=Executors.newFixedThreadPool（4）；
es.invokeAll（可调用项）；
es.shutdown（）；
等待终止（1，时间单位：天）；
}

这里我们有4个线程和10个任务

---

如果沿着这条路线走下去，您可能需要查看

未来的
API，以便检查任务是否成功完成。您还可以从任务返回一个值；在您的情况下，
Callable
似乎是合适的，这样您就可以从
call
方法返回计算结果，并从
未来
收集结果，正如其他答案所述，您可以使用
join
来实现这一点；e、 g

Matrix m = new Matrix(a);
m.start();
m.join();

但是，我只想指出，如果这样做，您将无法从
矩阵
线程获得任何并行性。您最好这样做：

Matrix m = new Matrix(a);
m.run();

i、 e.在主线程上执行
run（）
方法。通过将
m
传递给每个“计数器”线程，并让它们全部
加入
矩阵
线程，您可能会获得一些并行性。。。但我怀疑这是否值得

坦白地说，如果您在这里尝试的任何多线程都得到了值得的加速，我会感到惊讶：


如果矩阵很小，创建线程的开销将占主导地位

如果矩阵较大，则可能会遇到内存争用问题

与并行化的第二阶段相比，初始化阶段需要进行O（N^2）次计算，第二阶段有N个线程进行O（N）次计算。即使你能在第二阶段获得不错的加速，第一阶段也很可能占据主导地位

谢谢您的帮助！：）嗨，谢谢你！我知道我不能加快速度
public static void main(String[] args) throws Exception {
    final class PrintMe implements Callable<Void> {

        final String toPrint;

        public PrintMe(final String toPrint) {
            this.toPrint = toPrint;
        }

        @Override
        public Void call() throws Exception {
            System.out.println(toPrint);
            return null;
        }

    }
    final List<Callable<Void>> callables = new LinkedList<>();
    for (int i = 0; i < 10; ++i) {
        callables.add(new PrintMe("I am " + i));
    }
    final ExecutorService es = Executors.newFixedThreadPool(4);
    es.invokeAll(callables);
    es.shutdown();
    es.awaitTermination(1, TimeUnit.DAYS);
}

Matrix m = new Matrix(a);
m.start();
m.join();

Matrix m = new Matrix(a);
m.run();