AtomicInteger这个类的存在是为了满足在高并发的情况下,原生的整形数值自增线程不安全的问题。比如说
int i = 0 ;
i++;上面的写法是线程不安全的。
有的人可能会说了,可以使用synchronized关键字啊。
但是这里笔者要说的是,使用了synchronized去做同步的话系统的性能将会大大下降。
所以此时AtomicInteger这个类的使用就可以满足上述的情况。
当我们统计一个页面的浏览量的时候,可以使用该类来统计,而不再使用++运算符。
但是在使用的过程中,笔者发现,使用++运算符和AtomicInteger的结果都是对的。。。
结果有点晕了,难道结论是错的么?当然不是了。
注意这个类使用的情况下是在高并发量的情况下。不是同时启10个20个线程,而是成千上万个线程。
我们先看看AtomicInteger类起作用的代码
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicInteger;
public class AtomicIntegerTest {
public static final AtomicInteger atomicInteger = new AtomicInteger(0);
public static void main(String[] args) throws InterruptedException {
atomicIntegerTest();
Thread.sleep(3000);
System.out.println("最终结果是" + atomicInteger.get());
}
private static void atomicIntegerTest() {
ExecutorService executorService = Executors.newFixedThreadPool(10000);
for (int i = 0; i < 10000; i++) {
executorService.execute(() -> {
for (int j = 0; j < 4; j++) {
System.out.println(atomicInteger.getAndIncrement());
}
});
}
executorService.shutdown();
}
}
打印的结果是4万
再看看++操作符
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class IntValueIncrementTest {
public static int value = 0;
public static void main(String[] args) throws InterruptedException {
ExecutorService executorService = Executors.newFixedThreadPool(10000);
for (int i = 0; i < 10000; i++) {
executorService.execute(() -> {
for (int j = 0; j < 4; j++) {
System.out.println(value++);
}
});
}
executorService.shutdown();
Thread.sleep(3000);
System.out.println("最终结果是" + value);
}
}
我们可以看到结果是39972,显然结果丢失了一些。
所以在高并发的情况下应当使用AtomicInteger类
当我们在并发情况下,但是并发量又不是那么大的时候,
我们将上述的代码改掉,改为同时只有10个线程在修改数值。
我们贴代码
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicInteger;
public class AtomicIntegerTest {
public static final AtomicInteger atomicInteger = new AtomicInteger(0);
public static void main(String[] args) throws InterruptedException {
atomicIntegerTest();
Thread.sleep(3000);
System.out.println("最终结果是" + atomicInteger.get());
}
private static void atomicIntegerTest() {
ExecutorService executorService = Executors.newFixedThreadPool(10000);
for (int i = 0; i < 10; i++) {
executorService.execute(() -> {
for (int j = 0; j < 4; j++) {
System.out.println(atomicInteger.getAndIncrement());
}
});
}
executorService.shutdown();
}
}
运行的结果是40
再贴10个线程的并发量的情形。
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class IntValueIncrementTest {
public static int value = 0;
public static void main(String[] args) throws InterruptedException {
ExecutorService executorService = Executors.newFixedThreadPool(10000);
for (int i = 0; i < 10; i++) {
executorService.execute(() -> {
for (int j = 0; j < 4; j++) {
System.out.println(value++);
}
});
}
executorService.shutdown();
Thread.sleep(3000);
System.out.println("最终结果是" + value);
}
}
发现此时的结果也是40。
所以这就给人一种假象:
1)AtomicInteger类不起作用.
2)i++或者++i是线程安全的
其实上面两点观念都是错误的。是因为并发量不够高而已
但是需要注意的是AtomicInteger类只能保证在自增或者自减的情况下保证线程安全