终止Executor服务和极快的Java代码？

Question

在下面的代码中,我通过线程池多次调用一个函数.在这个函数中,我通过名为FastestMemory的全局属性跟踪函数的最快执行.

但是,当我打印出值时,在线程池循环之后,我被赋予原始值,就好像全局变量与每次循环迭代更新的变量不同.当我知道FastestMemory的值被分配给(例如)253475时,我只有2000000000返回.

1)我是否需要重新构造此代码以便能够跟踪最快的迭代？

2)我似乎能够非常快地执行此代码,它在四个Xeon x7550上每次迭代采用(ob平均值)小于1毫秒.这是正常的还是我的时间错误？C#平均需要大约400毫秒？!？

public class PoolDemo {

    static long FastestMemory = 2000000000;
    static long SlowestMemory = 0;
    static long TotalTime;
    static long[] FileArray;
    static DataOutputStream outs;
    static FileOutputStream fout;


  public static void main(String[] args) throws InterruptedException, FileNotFoundException {

        int Iterations = Integer.parseInt(args[0]);
        int ThreadSize = Integer.parseInt(args[1]);

        FileArray = new long[Iterations];
        fout = new FileOutputStream("server_testing.csv");

        // fixed pool, unlimited queue
        ExecutorService service = Executors.newFixedThreadPool(ThreadSize);
        ThreadPoolExecutor executor = (ThreadPoolExecutor) service;

        for(int i = 0; i<Iterations; i++) {
          Task t = new Task(i);
          executor.execute(t);
        }

        executor.shutdown();
        service.shutdown();

        System.out.println("Fastest: " + FastestMemory);

        for(int j=0; j<FileArray.length; j++){
            new PrintStream(fout).println(FileArray[j] + ",");
        }
      }

  private static class Task implements Runnable {

        private int ID;

        static Byte myByte = 0;

        public Task(int index) {
          this.ID = index;
        }

        @Override
        public void run() {
            long Start = System.nanoTime();

          int Size1 = 100000;
            int Size2 = 2 * Size1;
            int Size3 = Size1;

            byte[] list1 = new byte[Size1];
            byte[] list2 = new byte[Size2];
            byte[] list3 = new byte[Size3];

            for(int i=0; i<Size1; i++){
                list1[i] = myByte;
            }

            for (int i = 0; i < Size2; i=i+2)
            {
                list2[i] = myByte;
            }

            for (int i = 0; i < Size3; i++)
            {
                byte temp = list1[i];
                byte temp2 = list2[i];
                list3[i] = temp;
                list2[i] = temp;
                list1[i] = temp2;
            }

            long Finish = System.nanoTime();
            long Duration = Finish - Start;
            FileArray[this.ID] = Duration;
            TotalTime += Duration;
            System.out.println("Individual Time " + this.ID + " \t: " + (Duration) + " nanoseconds");


            if(Duration < FastestMemory){
                FastestMemory = Duration;
            }
            if (Duration > SlowestMemory)
            {
                SlowestMemory = Duration;
            }
        }
      }
}

Answer 1

问题是您的主线程正在退出而不等待提交给执行程序的任务终止.

您可以通过在调用后简单地向ExecutorService #awaitTermination添加一个调用来实现ExecutorService#shutdown.

您将遇到的另一个问题是您没有考虑线程安全性,因为您的static long值会跟踪最快的时间.您将需要添加synchronize块或使用an AtomicLong来获得安全的Compare-And-Set操作.