我有这段代码，我有自己的自制数组类，我想用它来测试Java中一些不同的并发工具的速度

public class LongArrayListUnsafe {
   private static final ExecutorService executor
      = Executors.newFixedThreadPool(1);
   public static void main(String[] args) {
   LongArrayList dal1 = new LongArrayList();
    int n = 100_000_000;
    Timer t = new Timer();

List<Callable<Void>> tasks = new ArrayList<>();

tasks.add(() -> {
  for (int i = 0; i <= n; i+=2){
    dal1.add(i);
  }
  return null;
});

tasks.add(() -> {
  for (int i = 0; i < n; i++){
    dal1.set(i, i + 1);
  }
  return null;});
tasks.add(() -> {
  for (int i = 0; i < n; i++) {

    dal1.get(i);
  }
  return null;});
tasks.add(() -> {
  for (int i = n; i < n * 2; i++) {

    dal1.add(i + 1);
  }
  return null;});
try {
  executor.invokeAll(tasks);
} catch (InterruptedException exn) {
  System.out.println("Interrupted: " + exn);
}
executor.shutdown();
try {
  executor.awaitTermination(1000, TimeUnit.MILLISECONDS);
} catch (Exception e){
  System.out.println("what?");
}

System.out.println("Using toString(): " + t.check() + " ms");

}
}

class LongArrayList {
 // Invariant: 0 <= size <= items.length
    private long[] items;
    private int size;

    public LongArrayList() {
       reset();
    }

    public static LongArrayList withElements(long... initialValues){
    LongArrayList list = new LongArrayList();
    for (long l : initialValues) list.add( l );
         return list;
      }


    public void reset(){
       items = new long[2];
       size = 0;
     }

     // Number of items in the double list
      public int size() {
      return size;
      }

      // Return item number i
       public long get(int i) {
          if (0 <= i && i < size)
             return items[i];
          else
             throw new IndexOutOfBoundsException(String.valueOf(i));
        }

    // Replace item number i, if any, with x
     public long set(int i, long x) {
       if (0 <= i && i < size) {
           long old = items[i];
           items[i] = x;
          return old;
       } else
        throw new IndexOutOfBoundsException(String.valueOf(i));
       }

       // Add item x to end of list
       public LongArrayList add(long x) {
          if (size == items.length) {
           long[] newItems = new long[items.length * 2];
          for (int i=0; i<items.length; i++)
              newItems[i] = items[i];
          items = newItems;
      }
      items[size] = x;
      size++;
      return this;
       }


       public String toString() {
         return Arrays.stream(items, 0,size)
        .mapToObj( Long::toString )
        .collect(Collectors.joining(", ", "[", "]"));
        }
           }

       public class Timer {
         private long start, spent = 0;
         public Timer() { play(); }
         public double check() { return (System.nanoTime()-start+spent)/1e9; }
         public void pause() { spent += System.nanoTime()-start; }
         public void play() { start = System.nanoTime(); }
         }

LongArrayList类的实现不是那么重要，它不是线程安全的。

带有executorservice的驱动程序代码在arraylist上执行一堆操作，并执行4个不同的任务，每次执行100_000_000次。

问题是，当我为线程池分配更多线程时，“ Executors.newFixedThreadPool（2）;” 它只会变慢。例如，对于一个线程，典型的计时时间是1.0366974毫秒，但是如果我使用3个线程运行它，则时间将增加到5.7932714毫秒。

到底是怎么回事？为什么更多的线程这么慢？

编辑：

为了解决这个问题，我简化了驱动程序代码，其中包含四个仅添加元素的任务：

ExecutorService executor
      = Executors.newFixedThreadPool(2);
LongArrayList dal1 = new LongArrayList();
int n = 100_000_00;
Timer t = new Timer();

for (int i = 0; i < 4 ; i++){
  executor.execute(new Runnable() {
    @Override
    public void run() {
      for (int j = 0; j < n ; j++)
        dal1.add(j);
    }
  });
}


executor.shutdown();
try {
  executor.awaitTermination(1000, TimeUnit.MILLISECONDS);
} catch (Exception e){
  System.out.println("what?");
}

System.out.println("Using toString(): " + t.check() + " ms");

在这里，我分配多少线程似乎并不重要，根本没有加速，这可能仅仅是因为开销吗？