PHP在后台进程完成后启动脚本？(PHP Launch script after background process completes?)

 从Java 5中的ArrayList开始，如果数组具有正确的大小（或更大），则该数组将被填充。 所以 
 
MyClass[] arr = myList.toArray(new MyClass[myList.size()]);
 
 将创建一个数组对象，填充它并将其返回到“arr”。 另一方面 
 
MyClass[] arr = myList.toArray(new MyClass[0]);
 
 将创建两个数组。 第二个是长度为0的MyClass数组。因此，对象的对象创建将立即被抛出。 就源代码而言，编译器/ JIT不能优化这个，因此它不会被创建。 另外，使用零长度对象会导致toArray（） - 方法中的转换。 
 
 看到ArrayList.toArray（）的源码： 
 
public <T> T[] toArray(T[] a) {
    if (a.length < size)
        // Make a new array of a's runtime type, but my contents:
        return (T[]) Arrays.copyOf(elementData, size, a.getClass());
    System.arraycopy(elementData, 0, a, 0, size);
    if (a.length > size)
        a[size] = null;
    return a;
}
 
 使用第一种方法，以便只创建一个对象并避免（隐含但仍然昂贵）的铸件。 

Counterintuitively, the fastest version, on Hotspot 8, is:
 
MyClass[] arr = myList.toArray(new MyClass[0]);
 
I have run a micro benchmark using jmh the results and code are below, showing that the version with an empty array consistently outperforms the version with a presized array. Note that if you can reuse an existing array of the correct size, the result may be different.
 
Benchmark results (score in microseconds, smaller = better):
 
Benchmark                      (n)  Mode  Samples    Score   Error  Units
c.a.p.SO29378922.preSize         1  avgt       30    0.025 ▒ 0.001  us/op
c.a.p.SO29378922.preSize       100  avgt       30    0.155 ▒ 0.004  us/op
c.a.p.SO29378922.preSize      1000  avgt       30    1.512 ▒ 0.031  us/op
c.a.p.SO29378922.preSize      5000  avgt       30    6.884 ▒ 0.130  us/op
c.a.p.SO29378922.preSize     10000  avgt       30   13.147 ▒ 0.199  us/op
c.a.p.SO29378922.preSize    100000  avgt       30  159.977 ▒ 5.292  us/op
c.a.p.SO29378922.resize          1  avgt       30    0.019 ▒ 0.000  us/op
c.a.p.SO29378922.resize        100  avgt       30    0.133 ▒ 0.003  us/op
c.a.p.SO29378922.resize       1000  avgt       30    1.075 ▒ 0.022  us/op
c.a.p.SO29378922.resize       5000  avgt       30    5.318 ▒ 0.121  us/op
c.a.p.SO29378922.resize      10000  avgt       30   10.652 ▒ 0.227  us/op
c.a.p.SO29378922.resize     100000  avgt       30  139.692 ▒ 8.957  us/op
 
 
For reference, the code:
 
@State(Scope.Thread)
@BenchmarkMode(Mode.AverageTime)
public class SO29378922 {
  @Param({"1", "100", "1000", "5000", "10000", "100000"}) int n;
  private final List<Integer> list = new ArrayList<>();
  @Setup public void populateList() {
    for (int i = 0; i < n; i++) list.add(0);
  }
  @Benchmark public Integer[] preSize() {
    return list.toArray(new Integer[n]);
  }
  @Benchmark public Integer[] resize() {
    return list.toArray(new Integer[0]);
  }
}
 
 
You can find similar results, full analysis, and discussion in the blog post Arrays of Wisdom of the Ancients. To summarize: the JVM and JIT compiler contains several optimizations that enable it to cheaply create and initialize a new correctly sized array, and those optimizations can not be used if you create the array yourself.