熟悉Java中的线程：为什么这个程序的运行时间随着线程数量的增加而增加

Question

情况

我正在尝试熟悉 Java 中的线程。出于这个原因，我修改了我在一本书中找到的程序列表。它的作用非常简单：

1. 它创建一个包含 100.000.000 个元素的 boolean[]-array。
2. 它使用NUMBER_OF_SERVERS 线程使用true 或false 随机填充该数组的元素。
3. 最后，它使用NUMBER_OF_SERVERS 线程扫描该数组并计算有多少条目设置为true

更多详情，请查看本文底部的代码。

问题

当我用不同数量的线程运行代码并测量运行时，我得到一个非常奇怪的结果；或者至少是我不理解的行为：当我使用更多线程时，BuildService-Thread 会消耗更多运行时。仅在一个线程中构建整个数组（基于随机truedistribution）大约需要 10 秒。接下来，当我使用四个线程时，我预计运行时间会减少。但是，我得到了大约 17 秒的时间消耗。

我的 ScanService 按预期工作：时间消耗随着线程的增加而减少。

详情请看下表：

但是，如果更改我的代码中的一行并将if ((int) ((Math.random() * 2d)) == 0)-statement（用于随机true-distribution）替换为if (i % 2 == 0)（因此，每隔一个项目将是真的）我会得到我期望的行为：

问题

所以，我的问题是：

1. 为什么在使用 Math.random() 函数时，更多线程会导致更长的运行时间？
2. 反之亦然，为什么当只使用一个线程使用完全相同的函数时，运行时间会减少？
3. 当涉及到处理线程时，可以从这种行为中得出哪些“一般规则”？

背景信息

代码在 Intel core i3 上运行。

代码

public class AsynchService
{
    private static final int ARRAY_SIZE = 100000000; //100.000.000
    private static final int NUMBER_OF_SERVERS = 16;
    private static final int HOW_MANY = ARRAY_SIZE / NUMBER_OF_SERVERS;

    //build array asynch
    public static boolean[] buildArrayAsynch()
    {
        //build array with NUMBER_OF_SERVERS-Threads
        boolean[] array = new boolean[ARRAY_SIZE];
        Thread[] buildServerThread = new Thread[NUMBER_OF_SERVERS];

        long startTime = System.currentTimeMillis();

        for (int i = 0; i < NUMBER_OF_SERVERS; i++)
        {
            int start = i * HOW_MANY;
            int end = (i != NUMBER_OF_SERVERS - 1) ? (i + 1) * HOW_MANY - 1 : ARRAY_SIZE - 1;

            buildServerThread[i] = new BuildService(array, i, start, end);
        }

        //synchronize and wait for result
        int expectedResult = 0;

        for (int i = 0; i < NUMBER_OF_SERVERS; i++)
        {
            try
            {
                buildServerThread[i].join();
            }
            catch (InterruptedException ex) {}

            expectedResult += ((BuildService) buildServerThread[i]).getExpectedResult();
        }

        System.out.println("\nNumber of \"true\"s ==> Expected result: " + expectedResult);
        System.out.println("Build duration: " + (System.currentTimeMillis() - startTime) + " ms\n");

        return array;
    }

    //scan array asynch
    public static int scanArrayAsynch(boolean[] array)
    {
        //create services and server-threads
        Thread[] serverThread = new Thread[NUMBER_OF_SERVERS];

        long startTime = System.currentTimeMillis();

        for (int i = 0; i < NUMBER_OF_SERVERS; i++)
        {
            int start = i * HOW_MANY;
            int end = (i != NUMBER_OF_SERVERS - 1) ? (i + 1) * HOW_MANY - 1 : ARRAY_SIZE - 1;

            serverThread[i] = new ScanService(array, i, start, end);
        }

        //synchronize with servers, wait for server end
        int result = 0;

        for (int i = 0; i < NUMBER_OF_SERVERS; i++)
        {
            try
            {
                serverThread[i].join();
            }
            catch (InterruptedException ex) {}

            result += ((ScanService) serverThread[i]).getResult();
        }

        System.out.println("Search duration: " + (System.currentTimeMillis() - startTime) + " ms");
        return result;
    }

    public static void main(String[] args)
    {
        //build array
        boolean[] array = buildArrayAsynch();

        //scan array
        int result = scanArrayAsynch(array);

        //display result
        System.out.println("\nResult: " + result);

    }
}

class BuildService extends Thread
{
    private boolean[] array;
    private int start;
    private int end;
    private int expectedResult = 0;

    public BuildService(boolean[] array, int serviceId, int start, int end)
    {
        this.array = array;
        this.start = start;
        this.end = end;

        this.setName("BuildService " + serviceId);

        this.start();
    }

    public int getExpectedResult()
    {
        return expectedResult;
    }

    public void run()
    {
        if (start < 0 || end >= array.length) throw new IndexOutOfBoundsException();

        System.out.println(getName() + ": StartIndex = " + start + "; EndIndex = " + end);

        long startTime = System.currentTimeMillis();

        for (int i = start; i <= end; i++)
        {
            //if (i % 2 == 0)
            if ((int) ((Math.random() * 2d)) == 0)
            {
                array[i] = true;
                expectedResult++;
            }
            else
            {
                array[i] = false;
            }
        }

        System.out.println(getName() + " finished! \"true\" elements: " + expectedResult + "; duration = " + (System.currentTimeMillis() - startTime) + "ms");
    }
}

class ScanService extends Thread
{
    private boolean[] array;
    private int serviceId;
    private int start;
    private int end;
    private int result = 0;

    public ScanService(boolean[] array, int serviceId, int start, int end)
    {
        this.array = array;
        this.serviceId = serviceId;
        this.start = start;
        this.end = end;

        this.start();
    }

    public int getResult()
    {
        return result;
    }

    public void run()
    {
        if (start < 0 || end >= array.length) throw new IndexOutOfBoundsException();

        System.out.println("Server " + serviceId + ": StartIndex = " + start + "; EndIndex = " + end);

        for (int i = start; i <= end; i++)
        {
            if (array[i]) result++;
        }
    }
}

Answer 1

魔鬼在细节中。 Math.random()的documentation有答案：

此方法已正确同步，以允许多个线程正确使用。但是，如果许多线程需要以很高的速度生成伪随机数，则可能会减少每个线程对拥有自己的伪随机数生成器的争用。

要解决此问题，请尝试为您的 BuildService 类的每个实例创建一个 java.util.Random 实例，并使用它来代替 Math.random()。使用java.util.Random 的一个好处是您不必做不必要的双整数运算，而可以简单地使用nextBoolean() 方法。

Answer 2

您可能在Math.random() 中看到了线程争用的影响。 Java 7 具有 ThreadLocalRandom 特性来避免这个问题。

Answer 3

您的代码似乎使用了 16 个线程，每个线程都使用此处的 Join 方法

serverThread[i].join();

这似乎没有充分利用线程的潜力。

当使用连接时，您实际上是在说线程要等到另一个线程完成，而不是并行运行线程。

您可能希望使用 start 方法而不是 join 方法。

尝试运行更改后的代码并在时间线上发布您的分析。

祝你学习顺利

Answer 4

考虑到 Andreas Troelsen 的回答，我想出了下面显示的代码，导致以下运行时。

与之前发生的情况相比，这个解决方案现在更好地满足了我的期望！

import java.util.Random;

class BuildService extends Thread
{
    private boolean[] array;
    private int start;
    private int end;
    private int expectedResult = 0;
    private Random random = new Random();

    public BuildService(boolean[] array, int serviceId, int start, int end)
    {
        this.array = array;
        this.start = start;
        this.end = end;

        this.setName("BuildService " + serviceId);

        this.start();
    }

    public int getExpectedResult()
    {
        return expectedResult;
    }

    public void run()
    {
        if (start < 0 || end >= array.length) throw new IndexOutOfBoundsException();

        System.out.println(getName() + ": StartIndex = " + start + "; EndIndex = " + end);

        long startTime = System.currentTimeMillis();

        for (int i = start; i <= end; i++)
        {
            array[i] = random.nextBoolean();
            if (array[i]) expectedResult++;
        }

        System.out.println(getName() + " finished! \"true\" elements: " + expectedResult + "; duration = " + (System.currentTimeMillis() - startTime) + "ms");
    }
}