多线程访问静态方法中的静态变量

背景：近期，项目中遇到一个场景，多线程访问一个数组，从下标0开始一直到最大长度，然后再从下标0开始，如此循环往复（线程0访问数组下标0，线程1访问数组下标1......）。下标的数值由一个静态变量共享。当时是这么写的，没有考虑多线程的问题：

public class AppUtils {

private final static int LIMIT = 10;
private final static int ORIGIN = 0;

// 共享变量
public static int counter = 0;
// 错误示范
public static int getKeyNumByNext() {

// 条件重置
if (counter == LIMIT) {
counter = ORIGIN;
}
System.out.println(Thread.currentThread().getName() +":"+counter);
counter += 1;
return counter;
}

private CountDownLatch cdl;

@Test
public void test() {
// 模拟并发数
int concurrentNum = 100;

cdl = new CountDownLatch(concurrentNum);

for (int i = 0; i < concurrentNum; i++) {
new Thread(new UserRequest()).start();
cdl.countDown();
}

try {
Thread.currentThread().sleep(5000);
System.out.println("======="+counter);
//System.out.println("======="+atomCounter.get());
} catch (InterruptedException e) {
e.printStackTrace();
}
}

class UserRequest implements Runnable {

@Override
public void run() {
try {
cdl.await();
// 非安全
getKeyNumByNext();
// 安全
//getAtomKeyNumByNext();
} catch (InterruptedException e) {
e.printStackTrace();
}

}
}
}

显然，静态变量counter可能在同一时间被多个线程修改，导致条件重置失败（数组下标最大为9，已经有线程到了10+）。

后来，把getKeyNumByNext方法改成了synchronized，保证了变量的线程安全。但是这样肯定会影响性能。于是想起了jdk提供的一种原子操作类型AtomicInteger：

// 原子操作
public static AtomicInteger atomCounter = new AtomicInteger();

public static int getAtomKeyNumByNext() {
atomCounter.incrementAndGet();
atomCounter.compareAndSet(LIMIT,ORIGIN);
System.out.println(Thread.currentThread().getName() +":"+atomCounter.get());
return atomCounter.get();
}

不仅保证了性能，也保证了计数变量atomCounter的线程安全。这里运用到了一个并发处理的技术：CAS（Compare and swap）。简单的说，比较和替换是使用一个期望值和一个变量的当前值进行比较，如果当前变量的值与我们期望的值相等，就使用一个新值替换当前变量的值；如果不等，就重新再取一次：

后台同时指出，还有更简单的方法，把错误示范中的条件重置 的 “==” 改为 “>=”  


相互探讨，如有缪误，还望指正。