写在前面

1. int和long是人尽皆知的两个基本数据类型，int所控制的for循环又叫【可数循环】，long所控制的for循环又叫【不可数循环】。
2. safepoint是与GC垃圾回收有关的安全点，当整个程序都达到了安全点才会进行GC。
3. Thread.sleep() 属于native 方法，结束后进入safepoint。

代码实例

public static AtomicInteger atomicInteger = new AtomicInteger(0);
public static void main(String[] args) throws InterruptedException {Runnable runnable=()->{for (int i = 0; i < 1000000000; i++) {atomicInteger.getAndIncrement();}System.out.println(Thread.currentThread().getName()+" run end !");};Thread t1 = new Thread(runnable,"thread 1 ");Thread t2 = new Thread(runnable,"thread 2 ");t1.start();t2.start();Thread.sleep(1000);System.out.println("atomicInteger = " + atomicInteger.get());
}

执行结果1

执行了34s后打印以下内容。

atomicInteger = 2000000000
thread 1  run end !
thread 2  run end !

代码修改

将for循环的i由int变为long

public static AtomicInteger atomicInteger = new AtomicInteger(0);
public static void main(String[] args) throws InterruptedException {Runnable runnable=()->{// ===================修改位置=========================for (long i = 0; i < 1000000000; i++) {atomicInteger.getAndIncrement();}System.out.println(Thread.currentThread().getName()+" run end !");};Thread t1 = new Thread(runnable,"thread 1 ");Thread t2 = new Thread(runnable,"thread 2 ");t1.start();t2.start();Thread.sleep(1000);System.out.println("atomicInteger = " + atomicInteger.get());
}

执行结果2

执行了1s后打印第一行内容。
执行了34s后打印后两行内容。

atomicInteger = 55519333
thread 2  run end !
thread 1  run end !

结果分析

程序执行过程

1. 执行程序，两个线程跑起来。
2. 主线程sleep结束之后，程序来到安全点（native 方法结束后，来到安全点）。
3. 线程的两个大体量for循环还未结束，没有达到GC的条件（全局安全点）。
4. 主线程完成任务，等待两个子线程全部完成任务，打印日志，垃圾回收。
5. 修改程序int -> long后重新执行。
6. 主线程sleep结束之后，程序来到安全点。
7. 两个子线程的for循环同时完成一次循环并两个线程同时达到安全点。
8. 虽然两个子线程还没有执行完毕，但是主线程和两个子线程当前是全局安全点状态，垃圾回收，打印日志。
9. 两个子线程执行任务完毕，打印【子线程任务结束】日志。

分析总结

这个现象你要是马上问我，我也答不到点上，直接跟大家说明原因吧。

1. long控制的【不可数循环】会导致每次循环结束都会来到一个safepoint。
2. int控制的【可数循环】会导致直到整体循环结束才会来到一个safepoint。
3. 一个循环此次数超多的循环体，如果知道循环结束才进行GC，可能会导致GC耗时过长，所以，根据循环次数的量级和每次循环产生的垃圾量来判断使用【不可数循环】还是【可数循环】，提高程序的性能。