java并发问题

我想用CPU的两个核心对向量（数组）进行简单的数学运算。程序不能正常工作。请给我解释一下如何解决我的问题

public class MyRunnable implements Runnable {

private int startIndex;
private int endIndex;
private float[] tab;

public MyRunnable(int startIndex, int endIndex, float[] tab)
{
    this.startIndex = startIndex;
    this.endIndex = endIndex;
    this.tab = tab;
}

@Override
public void run() 
{
    System.out.println(Thread.currentThread());
    for(int i = startIndex; i < endIndex; i++)
    {
        tab[i] = i * 2;
    }

    System.out.println("Finished");
}

公共类MyRunnable实现Runnable{
私人int startIndex；
私有内部索引；
私有浮动[]选项卡；
公共MyRunnable（int startIndex、int endIndex、float[]选项卡）
{
this.startIndex=startIndex；
this.endIndex=endIndex；
this.tab=tab；
}
@凌驾
公开募捐
{
System.out.println（Thread.currentThread（））；
对于（int i=startIndex；i

}

公共类测试{
公共静态void main（字符串[]args）{
int size=10；
int n_线程=2；
浮动选项卡[]=新浮动[大小]；
对于（int i=0；i

---

}

您可以通过插入对以下对象的调用来等待线程完成执行：

在调用

x.start（）

函数后暂停，直到线程完成。否则，您无法知道它们是否已完成执行

---

您还应该考虑在Actudio> [Tab][/]Cuth.Access中用单独的线程来访问A，而不必直接对传入的数组引用执行计算，因为这可以限制并发量（如果存在）。

< P>看来，您不需要等待线程完成。请使用该方法并添加< /P>

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

---

就在输出循环之前。

正如其他人所指出的，您并不是在等待线程完成执行。您应该遵循@Howard和@JK的建议，这将解决您的基本问题。如果您决定在线程和并行处理方面做更多工作，尽管我强烈建议查看java.util.concurrent包，但你有很多有用的课程，可以让你的生活更轻松

我冒昧地使用Callable and ExecutorService重新编写了您的示例。请参见下面的示例代码：

public static void main(String[] args) {

    int size = 10;
    int n_threads = 2;
    float tab[] = new float[size];

    for (int i = 0; i < size; i++) {
        tab[i] = i;
    }

    System.out.println(Thread.currentThread());

    for (int i = 0; i < size; i++) {
        System.out.println(tab[i]);
    }

    // Determine batch size, based off of number of available
    // threads.
    int batchSize = (int) Math.ceil((double) size / n_threads);
    System.out.println("Size: " + size + " Num threads: " + n_threads
            + " Batch Size: " + batchSize);

    // Create list of tasks to run
    List<Callable<Object>> tasks = new ArrayList<Callable<Object>>(
            n_threads);

    for (int i = 0; i < n_threads; i++) {
        tasks.add(Executors.callable(new MyRunnable(i * batchSize,
                ((i + 1) * batchSize) - 1, tab)));
    }

    // Create an executor service to handle processing tasks
    ExecutorService execService = Executors.newFixedThreadPool(n_threads);

    try {
        execService.invokeAll(tasks);
    } catch (InterruptedException ie) {
        ie.printStackTrace();
} finally {
    execService.shutdown();
}

    for (int i = 0; i < size; i++) {
        System.out.println(tab[i]);
    }
}

publicstaticvoidmain（字符串[]args）{
int size=10；
int n_线程=2；
浮动选项卡[]=新浮动[大小]；
对于（int i=0；i

并在MyRunnable类中做了一个小小的更改，即跳过对上一个索引的处理：

@Override
public void run() {
    System.out.println(Thread.currentThread());
    for (int i = startIndex; i <= endIndex; i++) {
        tab[i] = i * 2;
    }

    System.out.println("Finished");
}

@覆盖
公开募捐{
System.out.println（Thread.currentThread（））；
对于（int i=startIndex；i）你应该添加不起作用的确切细节~！你所说的“不起作用”是什么意思？你希望这个程序做什么，它会做什么？你怎么知道它不起作用？我相信上一个索引是故意跳过的（他使用了开始包含/结束独占）您可以只保留新的MyRunnable（i*batchSize，（i+1）*batchSize，tab））

而不是您所做的（当您习惯于包含起始索引和排除结束索引时，它的可读性会更高。）

public static void main(String[] args) {

    int size = 10;
    int n_threads = 2;
    float tab[] = new float[size];

    for (int i = 0; i < size; i++) {
        tab[i] = i;
    }

    System.out.println(Thread.currentThread());

    for (int i = 0; i < size; i++) {
        System.out.println(tab[i]);
    }

    // Determine batch size, based off of number of available
    // threads.
    int batchSize = (int) Math.ceil((double) size / n_threads);
    System.out.println("Size: " + size + " Num threads: " + n_threads
            + " Batch Size: " + batchSize);

    // Create list of tasks to run
    List<Callable<Object>> tasks = new ArrayList<Callable<Object>>(
            n_threads);

    for (int i = 0; i < n_threads; i++) {
        tasks.add(Executors.callable(new MyRunnable(i * batchSize,
                ((i + 1) * batchSize) - 1, tab)));
    }

    // Create an executor service to handle processing tasks
    ExecutorService execService = Executors.newFixedThreadPool(n_threads);

    try {
        execService.invokeAll(tasks);
    } catch (InterruptedException ie) {
        ie.printStackTrace();
} finally {
    execService.shutdown();
}

    for (int i = 0; i < size; i++) {
        System.out.println(tab[i]);
    }
}

@Override
public void run() {
    System.out.println(Thread.currentThread());
    for (int i = startIndex; i <= endIndex; i++) {
        tab[i] = i * 2;
    }

    System.out.println("Finished");
}