【Java多线程】AtomicInteger使用

AtomicInteger 提供了线程安全的方法，一般用于多线程并发计数。

在今天遇到使用AtomicInteger的源码，发现它的逻辑有点漏洞，故写了以下代码抽象出大概逻辑，来验证自己的想法。

废话少说先上代码，UILCacheSizeTest该类提供指定大小上限sizeLimit，而以下代码时上限失效了。

存在该问题的原因是AtomicInteger 的方法是线程安全的，但UILCacheSizeTest的方法并非线程安全。这样的写法会让cacheSize被多线程重入。

从而导致实际的cacheSize会偶尔超出sizeLimit。感兴趣的朋友可以运行下代码。

解决方案很简单：就是一个方法内对cacheSize的操作都放进synchronize的同步块中。

import java.util.Random;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

public class UILCacheSizeTest implements Runnable{

private static final int MAX_COUNT = 1000;

private final int sizeLimit;

private AtomicInteger cacheSize = new AtomicInteger();

public UILCacheSizeTest(int sizeLimit) {
this.sizeLimit = sizeLimit;
}

private int randomInt(int min, int max) {
Random random = new Random();
int s = random.nextInt(min+1) + max-min;
return s;
}
private int randomInner() {
return randomInt(100, 200);
}

public void run() {
int sizeToADD = randomInner();
int curCacheSize = cacheSize.get();
while (curCacheSize + sizeToADD > sizeLimit) {
curCacheSize = cacheSize.addAndGet(-100);
}
cacheSize.addAndGet(sizeToADD);
int newCacheSize = cacheSize.get();

if (newCacheSize > sizeLimit) {
System.out.println("confict = " + newCacheSize);
}
}

public static void main(String[] args) {
ThreadPoolExecutor exe = new ThreadPoolExecutor(10, 10, 3000, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(1000));
UILCacheSizeTest runObj = new UILCacheSizeTest(1000);
for (int i = 0; i < MAX_COUNT; i ++) {
exe.execute(runObj);
}
}
}