Java AtomicInteger何时优于同步?
既然Java AtomicInteger何时优于同步?,java,multithreading,performance,concurrency,atomicity,Java,Multithreading,Performance,Concurrency,Atomicity,既然AtomicInteger可以比受synchronized保护的int至少慢一个数量级,我为什么要使用AtomicInteger呢 例如,如果我只想以线程安全的方式增加int值,为什么不使用: 而不是使用更慢的 既然AtomicInteger可以比受synchronized保护的int至少慢一个数量级,为什么我要使用AtomicInteger呢 原子整数要快得多 static final Object LOCK1 = new Object(); static final Object LOC
AtomicInteger
可以比受synchronized
保护的int
至少慢一个数量级,我为什么要使用AtomicInteger呢
例如,如果我只想以线程安全的方式增加int
值,为什么不使用:
而不是使用更慢的
既然AtomicInteger可以比受synchronized保护的int至少慢一个数量级,为什么我要使用AtomicInteger呢
原子整数要快得多
static final Object LOCK1 = new Object();
static final Object LOCK2 = new Object();
static int i1 = 0;
static int i2 = 0;
static final AtomicInteger ai1 = new AtomicInteger();
static final AtomicInteger ai2 = new AtomicInteger();
public static void main(String... args) throws IOException {
for(int i=0;i<5;i++) {
testSyncInt();
testAtomicInt();
}
}
private static void testSyncInt() {
long start = System.nanoTime();
int runs = 10000000;
for(int i=0;i< runs;i+=2) {
synchronized (LOCK1) {
i1++;
}
synchronized (LOCK2) {
i2++;
}
}
long time = System.nanoTime() - start;
System.out.printf("sync + incr: Each increment took an average of %.1f ns%n", (double) time/runs);
}
private static void testAtomicInt() {
long start = System.nanoTime();
int runs = 10000000;
for(int i=0;i< runs;i+=2) {
ai1.incrementAndGet();
ai2.incrementAndGet();
}
long time = System.nanoTime() - start;
System.out.printf("incrementAndGet: Each increment took an average of %.1f ns%n", (double) time/runs);
}
如@assylias所示,添加了一些争用。它表明,当您只真正使用一个线程时,CPU可以优化访问
static final Object LOCK1 = new Object();
static final Object LOCK2 = new Object();
static int i1 = 0;
static int i2 = 0;
static final AtomicInteger ai1 = new AtomicInteger();
static final AtomicInteger ai2 = new AtomicInteger();
public static void main(String... args) throws ExecutionException, InterruptedException {
for(int i=0;i<5;i++) {
testSyncInt();
testAtomicInt();
}
}
private static void testSyncInt() throws ExecutionException, InterruptedException {
long start = System.nanoTime();
final int runs = 1000000;
ExecutorService es = Executors.newFixedThreadPool(2);
List<Future<Void>> futures = new ArrayList<>();
for(int t=0;t<8;t++) {
futures.add(es.submit(new Callable<Void>() {
public Void call() throws Exception {
for (int i = 0; i < runs; i += 2) {
synchronized (LOCK1) {
i1++;
}
synchronized (LOCK2) {
i2++;
}
}
return null;
}
}));
}
for (Future<Void> future : futures) {
future.get();
}
es.shutdown();
long time = System.nanoTime() - start;
System.out.printf("sync + incr: Each increment took an average of %.1f ns%n", (double) time/runs/2);
}
private static void testAtomicInt() throws ExecutionException, InterruptedException {
long start = System.nanoTime();
final int runs = 1000000;
ExecutorService es = Executors.newFixedThreadPool(2);
List<Future<Void>> futures = new ArrayList<>();
for(int t=0;t<8;t++) {
futures.add(es.submit(new Callable<Void>() {
public Void call() throws Exception {
for (int i = 0; i < runs; i += 2) {
ai1.incrementAndGet();
ai2.incrementAndGet();
}
return null;
}
}));
}
for (Future<Void> future : futures) {
future.get();
}
es.shutdown();
long time = System.nanoTime() - start;
System.out.printf("incrementAndGet: Each increment took an average of %.1f ns%n", (double) time/runs/2);
}
如果您真的想了解更多关于为什么
java.util.concurrent
东西更好以及与经典同步方法相比有什么区别的详细信息,请阅读(以及整个博客)我现在真的很困惑。这不是我从@Gray的回答中理解的:我遗漏了什么?我想他是指AtomicInteger
比不同步的int
慢;他说的是为什么你不应该在没有正当理由的情况下用原子整数替换所有的int
成员。但它不是慢一个数量级,也不是快一个数量级。在大多数情况下,这些都是我们正在讨论的小差异。我记得在某个地方读到过,原子材料的锁定机制也不同,但现在无法获得参考。我可能也错了,原子类型通常不使用锁定。它们使用原子“比较和交换”指令等。参考资料:@StephenC:谢谢你的链接,它将刷新我的理解。
sync + incr: Each increment took an average of 32.4 ns
incrementAndGet: Each increment took an average of 20.6 ns
sync + incr: Each increment took an average of 31.4 ns
incrementAndGet: Each increment took an average of 12.9 ns
sync + incr: Each increment took an average of 29.6 ns
incrementAndGet: Each increment took an average of 12.9 ns
sync + incr: Each increment took an average of 35.1 ns
incrementAndGet: Each increment took an average of 16.6 ns
sync + incr: Each increment took an average of 29.9 ns
incrementAndGet: Each increment took an average of 13.0 ns
static final Object LOCK1 = new Object();
static final Object LOCK2 = new Object();
static int i1 = 0;
static int i2 = 0;
static final AtomicInteger ai1 = new AtomicInteger();
static final AtomicInteger ai2 = new AtomicInteger();
public static void main(String... args) throws ExecutionException, InterruptedException {
for(int i=0;i<5;i++) {
testSyncInt();
testAtomicInt();
}
}
private static void testSyncInt() throws ExecutionException, InterruptedException {
long start = System.nanoTime();
final int runs = 1000000;
ExecutorService es = Executors.newFixedThreadPool(2);
List<Future<Void>> futures = new ArrayList<>();
for(int t=0;t<8;t++) {
futures.add(es.submit(new Callable<Void>() {
public Void call() throws Exception {
for (int i = 0; i < runs; i += 2) {
synchronized (LOCK1) {
i1++;
}
synchronized (LOCK2) {
i2++;
}
}
return null;
}
}));
}
for (Future<Void> future : futures) {
future.get();
}
es.shutdown();
long time = System.nanoTime() - start;
System.out.printf("sync + incr: Each increment took an average of %.1f ns%n", (double) time/runs/2);
}
private static void testAtomicInt() throws ExecutionException, InterruptedException {
long start = System.nanoTime();
final int runs = 1000000;
ExecutorService es = Executors.newFixedThreadPool(2);
List<Future<Void>> futures = new ArrayList<>();
for(int t=0;t<8;t++) {
futures.add(es.submit(new Callable<Void>() {
public Void call() throws Exception {
for (int i = 0; i < runs; i += 2) {
ai1.incrementAndGet();
ai2.incrementAndGet();
}
return null;
}
}));
}
for (Future<Void> future : futures) {
future.get();
}
es.shutdown();
long time = System.nanoTime() - start;
System.out.printf("incrementAndGet: Each increment took an average of %.1f ns%n", (double) time/runs/2);
}
sync + incr: Each increment took an average of 478.6 ns
incrementAndGet: Each increment took an average of 191.5 ns
sync + incr: Each increment took an average of 437.5 ns
incrementAndGet: Each increment took an average of 169.8 ns
sync + incr: Each increment took an average of 408.1 ns
incrementAndGet: Each increment took an average of 180.8 ns
sync + incr: Each increment took an average of 511.5 ns
incrementAndGet: Each increment took an average of 313.4 ns
sync + incr: Each increment took an average of 441.6 ns
incrementAndGet: Each increment took an average of 219.7 ns