int[] a = new int[100000];        for(int i=0;i<a.length;i++){            a[i] = i;        }                int[] b = new int[100000];                int[] c = new int[100000];        for(int i=0;i<c.length;i++){            c[i] = i;        }                int[] d = new int[100000];                for(int k=0;k<10;k++){            long start1 = System.nanoTime();            for(int i=0;i<a.length;i++){                b[i] = a[i];            }            long end1 = System.nanoTime();            System.out.start1));                                    long start2 = System.nanoTime();            System.arraycopy(c, 0, d, 0, 100000);            long end2 = System.nanoTime();            System.out.println("end2 - start2 = "+(end2-start2));                        System.out.println();        }

end1 - start1 = 366806end2 - start2 = 109154end1 - start1 = 380529end2 - start2 = 79849end1 - start1 = 421422end2 - start2 = 68769end1 - start1 = 344463end2 - start2 = 72020end1 - start1 = 333174end2 - start2 = 77277end1 - start1 = 377335end2 - start2 = 82285end1 - start1 = 370608end2 - start2 = 66937end1 - start1 = 349067end2 - start2 = 86532end1 - start1 = 389974end2 - start2 = 83362end1 - start1 = 347937end2 - start2 = 63638

    public static native void arraycopy(Object src,  int  srcPos,                                        Object dest, int destPos,                                        int length);

JVM_ENTRY(void, JVM_ArrayCopy(JNIEnv *env, jclass ignored, jobject src, jint src_pos,                               jobject dst, jint dst_pos, jint length))  JVMWrapper("JVM_ArrayCopy");  // Check if we have null pointers  if (src == NULL || dst == NULL) {    THROW(vmSymbols::java_lang_NullPointerException());  }  arrayOop s = arrayOop(JNIHandles::resolve_non_null(src));  arrayOop d = arrayOop(JNIHandles::resolve_non_null(dst));  assert(s->is_oop(), "JVM_ArrayCopy: src not an oop");  assert(d->is_oop(), "JVM_ArrayCopy: dst not an oop");  // Do copy  Klass::cast(s->klass())->copy_array(s, src_pos, d, dst_pos, length, thread);JVM_END

void typeArrayKlass::copy_array(arrayOop s, int src_pos, arrayOop d, int dst_pos, int length, TRAPS) {  assert(s->is_typeArray(), "must be type array");  // Check destination  if (!d->is_typeArray() || element_type() != typeArrayKlass::cast(d->klass())->element_type()) {    THROW(vmSymbols::java_lang_ArrayStoreException());  }  // Check is all offsets and lengths are non negative  if (src_pos < 0 || dst_pos < 0 || length < 0) {    THROW(vmSymbols::java_lang_ArrayIndexOutOfBoundsException());  }  // Check if the ranges are valid  if  ( (((unsigned int) length + (unsigned int) src_pos) > (unsigned int) s->length())     || (((unsigned int) length + (unsigned int) dst_pos) > (unsigned int) d->length()) ) {    THROW(vmSymbols::java_lang_ArrayIndexOutOfBoundsException());  }  // Check zero copy  if (length == 0)    return;  // This is an attempt to make the copy_array fast.  int l2es = log2_element_size();  int ihs = array_header_in_bytes() / WordSize;  char* src = (char*) ((oop*)s + ihs) + ((size_t)src_pos << l2es);  char* dst = (char*) ((oop*)d + ihs) + ((size_t)dst_pos << l2es);  Copy::conjoint_memory_atomic(src, dst, (size_t)length << l2es);//還是在這里處理copy}

// Copy bytes; larger units are filled atomically if everything is aligned.void Copy::conjoint_memory_atomic(void* from, void* to, size_t size) {  address src = (address) from;  address dst = (address) to;  uintptr_t bits = (uintptr_t) src | (uintptr_t) dst | (uintptr_t) size;  // (Note:  We could improve performance by ignoring the low bits of size,  // and putting a short cleanup loop after each bulk copy loop.  // There are plenty of other ways to make this faster also,  // and it's a slippery slope.  For now, let's keep this code simple  // since the simplicity helps clarify the atomicity semantics of  // this Operation.  There are also CPU-specific assembly versions  // which may or may not want to include such optimizations.)  if (bits % sizeof(jlong) == 0) {    Copy::conjoint_jlongs_atomic((jlong*) src, (jlong*) dst, size / sizeof(jlong));  } else if (bits % sizeof(jint) == 0) {    Copy::conjoint_jints_atomic((jint*) src, (jint*) dst, size / sizeof(jint));  } else if (bits % sizeof(jshort) == 0) {    Copy::conjoint_jshorts_atomic((jshort*) src, (jshort*) dst, size / sizeof(jshort));  } else {    // Not aligned, so no need to be atomic.    Copy::conjoint_jbytes((void*) src, (void*) dst, size);  }}

// jints,                 conjoint, atomic on each jint  static void conjoint_jints_atomic(jint* from, jint* to, size_t count) {    assert_params_ok(from, to, LogBytesPerInt);    pd_conjoint_jints_atomic(from, to, count);  }

static void pd_conjoint_jints_atomic(jint* from, jint* to, size_t count) {  _Copy_conjoint_jints_atomic(from, to, count);}

void _Copy_conjoint_jints_atomic(jint* from, jint* to, size_t count) {    if (from > to) {      jint *end = from + count;      while (from < end)        *(to++) = *(from++);    }    else if (from < to) {      jint *end = from;      from += count - 1;      to   += count - 1;      while (from >= end)        *(to--) = *(from--);    }  }