Question

我遇到了多线程java程序的麻烦。该程序包含一个具有多线程的整数数组的总和，而不是切片的总和。问题是计算时间不会因增加线程数而减少（我知道在计算时间慢于线程较少之后，线程数有限制）。我希望在该限制线程数之前看到执行时间减少（并行执行的好处）。我在run方法中使用变量fake来制作时间＆＃34;可读＆＃34;。

public class MainClass {

private final int MAX_THREAD = 8;
private final int ARRAY_SIZE = 1000000;

private  int[] array;
private SimpleThread[] threads;
private int numThread = 1;
private int[] sum;
private int start = 0;
private int totalSum = 0;
long begin, end;
int fake;


MainClass() {
    fillArray();

    for(int i = 0; i < MAX_THREAD; i++) {
        threads = new SimpleThread[numThread];
        sum = new int[numThread];

        begin = (long) System.currentTimeMillis();

        for(int j = 0 ; j < numThread; j++) {
            threads[j] = new SimpleThread(start, ARRAY_SIZE/numThread, j);
            threads[j].start();
            start+= ARRAY_SIZE/numThread;
        }



        for(int k = 0; k < numThread; k++) {
            try {
                threads[k].join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }


        end = (long) System.currentTimeMillis();


        for(int g = 0; g < numThread; g++) {
            totalSum+=sum[g];
        }


        System.out.printf("Result with %d thread-- Sum = %d Time = %d\n", numThread, totalSum, end-begin);
        numThread++;
        start = 0;
        totalSum = 0;
    }

}


public static void main(String args[]) {
    new MainClass();
}


private void fillArray() {
    array = new int[ARRAY_SIZE];
    for(int i = 0; i < ARRAY_SIZE; i++) 
        array[i] = 1;
}


private class SimpleThread extends Thread{
    int start;
    int size;
    int index;

    public SimpleThread(int start, int size, int sumIndex) {
        this.start = start;
        this.size = size;
        this.index = sumIndex;
    }

    public void run() {
        for(int i = start; i < start+size; i++) 
            sum[index]+=array[i];

        for(long i = 0; i < 1000000000; i++) {
            fake++;
        }
    }
}

Unexpected Result Screenshot

Answer 1

启动线程非常繁重，您只会看到它对不会竞争相同资源的大型进程的好处（这里没有适用）。

Answer 2

为什么总和有时会出错？

因为ARRAY_SIZE/numThread可能包含小数部分（例如1000000/3 = 333333.3333333333），因此start变量会丢失一些，因此总和可能小于1000000，具体取决于除数。

为什么花费的时间会随着线程数量的增加而增加？

因为在每个线程的run函数中你都这样做：

for(long i = 0; i < 1000000000; i++) {
    fake++;
}

我不明白你的问题：

我在run方法中使用变量fake来节省时间＆＃34;可读＆＃34;。

这意味着什么。但是每个线程都需要将fake变量增加1000000000次。

Answer 3

作为一般规则，如果＆＃34;工作＆＃34;你不会从多线程获得加速。每个线程执行的操作都少于使用线程的开销。

其中一个开销是启动新线程的成本。这非常高。每次启动一个线程时，JVM都需要执行系统调用来分配线程堆栈内存段和＆＃34; red zone＆＃34;内存段，并初始化它们。（默认的线程堆栈大小通常为500KB或1MB。）然后还有进一步的系统调用来创建本机线程并安排它。

在这个例子中，你有1,000,000个要求和的元素，你将这个工作分成N个线程。随着N增加，每个线程执行的工作量减少。

不难看出，总计1,000,000个元素所需的时间将小于启动4个线程所需的时间......仅基于计算内存读写操作。然后，您需要考虑父线程一次创建一个子线程。

如果你完全进行分析，很明显，即使你有足够的内核来并行运行所有线程，添加更多线程实际上会减慢计算。你的基准测试似乎建议¹这个点大约是2个线程。

顺便说一句，还有第二个原因可能导致你没有达到像你预期的那样的速度。＆＃34;工作＆＃34;每个线程正在做的基本上是扫描一个大型数组。读取和写入数组将生成对存储器系统的请求。理想情况下，这些请求将由（快速）片上存储器缓存满足。但是，如果您尝试读取/写入大于内存高速缓存的数组，则许多/大多数请求将变为（慢）主内存请求。更糟糕的是，如果你有N个内核都这样做，那么你可以发现主内存请求的数量太多，内存系统无法跟上....并且线程变慢。

最重要的是，多线程不能自动使应用程序更快，如果你以错误的方式做到这一点肯定不会。

在你的例子中：

与创建和启动线程的开销相比，每个线程的工作量太小，

内存带宽效应可能是一个问题，如果可以＆＃34;分解＆＃34;线程创建开销

^{1 - 我不明白＆＃34;假的＆＃34;计算。它可能使基准测试无效，尽管JIT编译器可能会对其进行优化。}

Answer 4

作为旁注，对于您正在尝试做的事情，有Fork / Join-Framework。它允许您以递归方式轻松分割任务，并实现一种自动分配工作负载的算法。

有一个guide available here;它的例子与你的情况非常相似，可归结为RecursiveTask这样：

class Adder extends RecursiveTask<Integer>
{
    private int[] toAdd;
    private int from;
    private int to;

    /** Add the numbers in the given array */
    public Adder(int[] toAdd)
    {
        this(toAdd, 0, toAdd.length);
    }

    /** Add the numbers in the given array between the given indices;
        internal constructor to split work */
    private Adder(int[] toAdd, int fromIndex, int upToIndex)
    {
        this.toAdd = toAdd;
        this.from = fromIndex;
        this.to = upToIndex;
    }

    /** This is the work method */
    @Override
    protected Integer compute()
    {
        int amount = to - from;
        int result = 0;
        if (amount < 500)
        {
            // base case: add ints and return the result
            for (int i = from; i < to; i++)
            {
                result += toAdd[i];
            }
        }
        else
        {
            // array too large: split it into two parts and distribute the actual adding
            int newEndIndex = from + (amount / 2);
            Collection<Adder> invokeAll = invokeAll(Arrays.asList(
                    new Adder(toAdd, from, newEndIndex),
                    new Adder(toAdd, newEndIndex, to)));
            for (Adder a : invokeAll)
            {
                result += a.invoke();
            }
        }
        return result;
    }
}

要实际运行此功能，您可以使用

RecursiveTask adder = new Adder(fillArray(ARRAY_LENGTH));
int result = ForkJoinPool.commonPool().invoke(adder);

多线程编程不是预期的结果

4 个答案: