Question

所以，我做了一个小程序来测试java中的多线程，并比较使用while循环扩展数组然后创建多个线程并运行这些线程所花费的时间。我不确定当程序结束时我得到的数字，所以我想知道我是否在某个时候犯了一个愚蠢的错误并弄乱了一些东西以获得非常不同的数字。

以下代码：

    import java.util.Scanner;

    public class arrayScaling {

      public static void main(String[] args) throws InterruptedException {
        Scanner input = new Scanner(System.in);
        System.out.println("Enter the amount of number you want the program to generate:");
        int numOfNumbs = input.nextInt();
        int [] arrayForNumbers = new int [numOfNumbs];
        int [] newArrayForNumbers = new int [numOfNumbs];

        for (int i = 0; i < arrayForNumbers.length; i++) {
            arrayForNumbers[i] = (int) ((Math.random() * 25) + 1);
        }

        long startTime = System.nanoTime();
        for (int i = 0; i < arrayForNumbers.length; i++) {
            newArrayForNumbers[i] = newArrayForNumbers[i] * 3;

        }

        long endTime = System.nanoTime();
        System.out.println();

        long totalExecutionTime = endTime-startTime;

        System.out.println("Time it takes execute scaling is " + 
                totalExecutionTime + " nanoseconds");
        System.out.println();

        int numOfNumLeftOver = numOfNumbs % 5;
        int numOfNumDivided = numOfNumbs / 5;

        int [] temp = null;
        int [] temp2 = null;
        int [] temp3 = null;
        int [] temp4 = null;
        int [] temp5 = null;

        MyThread thread1 = new MyThread (numOfNumbs/5);
        MyThread thread2 = new MyThread (numOfNumbs/5);
        MyThread thread3 = new MyThread (numOfNumbs/5);
        MyThread thread4 = new MyThread (numOfNumbs/5);
        MyThread thread5;
        if (numOfNumLeftOver != 0) {
            numOfNumDivided = numOfNumDivided + numOfNumLeftOver;
            thread5 = new MyThread (numOfNumDivided);   
        }
        else {
            thread5 = new MyThread (numOfNumbs/5);
        }

        int tempNum = 0;
        for ( int i = 0; i < thread1.getArray().length; i ++) {
            temp = thread1.getArray();
            temp[tempNum] = arrayForNumbers[tempNum];
            tempNum++;
        }
        for ( int i = 0; i < thread2.getArray().length; i ++) {
            temp2 = thread2.getArray();
            temp2[i] = arrayForNumbers[tempNum];
            tempNum++;
        }
        for ( int i = 0; i < thread3.getArray().length; i ++) {
            temp3 = thread3.getArray();
            temp3[i] = arrayForNumbers[tempNum];
            tempNum++;
        }
        for ( int i = 0; i < thread4.getArray().length; i ++) {
            temp4 = thread4.getArray();
            temp4[i] = arrayForNumbers[tempNum];
            tempNum++;
        }
        for ( int i = 0; i < thread5.getArray().length; i ++) {
            temp5 = thread5.getArray();
            temp5[i] = arrayForNumbers[tempNum];
            tempNum++;
        }       
        thread1.setArray(temp);
        thread2.setArray(temp2);
        thread3.setArray(temp3);
        thread4.setArray(temp4);
        thread5.setArray(temp5);

        long startTime2 = System.nanoTime();
        thread1.start(); 
        thread2.start(); 
        thread3.start(); 
        thread4.start();
        thread5.start();
        thread1.join();
        thread2.join();
        thread3.join();
        thread4.join();
        thread5.join();
        long endTime2 = System.nanoTime();

        long newTotalExecutionTime = endTime2 - startTime2;
        System.out.println("Time it takes execute scaling w/ multiple threads is " + 
                newTotalExecutionTime + " nanoseconds");

        if (newTotalExecutionTime < totalExecutionTime) {
            System.out.println("Multithreading was more effective");
        }
        else if (totalExecutionTime < newTotalExecutionTime) {
            System.out.println("The original algorithm was more effective");
        }
        else if (totalExecutionTime == newTotalExecutionTime) {
            System.out.println("Both method worked at the same speed");
        }
        input.close();
    }

}



    public class MyThread extends Thread {
    private int [] array;
    private int [] scaleArray;

    public MyThread(int size) {
        array = new int [size];
        scaleArray = new int [size];
    }

    public int[] getArray() {
        return array;
    }

    public void setArray(int[] array) {
        this.array = array;
    }

    public int[] getScaleArray() {
        return scaleArray;
    }

    public void setScaleArray(int[] scaleArray) {
        this.scaleArray = scaleArray;
    }

    public void run () {
        for (int z = 0; z < array.length; z++){
            scaleArray[z] = 3 * array[z];
        } 
    }

}

该程序的输出是：

输入您希望程序生成的数量： 16

执行缩放所需的时间为893纳秒

多线程执行扩展所花费的时间是590345纳秒原始算法更有效

Answer 1

你的结果丝毫不让我感到惊讶。创建线程，启动它们，等待它们完成等等有很多开销。别忘了，590345ns还不到一毫秒;但大多数情况与改组线程有关，而不是乘以数字。

如果你想看到程序的线程部分胜过其他部分，那么尝试生成超过16个数字。

需要帮助来代表该程序的结果

1 个答案: