atomic包-原子类
java
it书童
2021-01-09 17:15:43
0赞
0踩
59阅读
0评论
什么是原子类
-
不可分割
-
一个操作是不可中断的,即便是多线程的情况下也可以保证
原子类的作用和锁类似,是为了保证并发情况下线程安全。不过原子类相比于锁,有一定的优势:
- 粒度更细
原子变量可以把竞争范围缩小到变量级别
- 效率更高
除了高度竞争的情况,通常使用原子类的效率会比使用锁的效率更高
6类原子类纵览
AtomicInteger
package juc.lock.atomic;
import java.util.concurrent.atomic.AtomicInteger;
public class AtomicIntegerDemo1 implements Runnable {
private static final AtomicInteger atomicInteger = new AtomicInteger();
public void incrementAtomic() {
atomicInteger.getAndIncrement();
}
private static volatile int basisCount = 0;
public void incrementBasic() {
basisCount++;
}
public static void main(String[] args) throws InterruptedException {
AtomicIntegerDemo1 r = new AtomicIntegerDemo1();
Thread t1 = new Thread(r);
Thread t2 = new Thread(r);
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println("原子类的结果:" + atomicInteger.get());
System.out.println("普通变量的结果:" + basisCount);
}
@Override
public void run() {
for (int i = 0; i < 10000; i++) {
incrementAtomic();
incrementBasic();
}
}
}
Atomic数组
package juc.lock.atomic;
import java.util.concurrent.atomic.AtomicIntegerArray;
public class AtomicArrayDemo {
public static void main(String[] args) throws InterruptedException {
AtomicIntegerArray atomicIntegerArray = new AtomicIntegerArray(1000);
Thread[] threadsIncrementer = new Thread[100];
Thread[] threadsDecrementer = new Thread[100];
Incrementer incrementer = new Incrementer(atomicIntegerArray);
Decrementer decrementer = new Decrementer(atomicIntegerArray);
for (int i = 0; i < 100; i++) {
threadsIncrementer[i] = new Thread(incrementer);
threadsDecrementer[i] = new Thread(decrementer);
threadsIncrementer[i].start();
threadsDecrementer[i].start();
threadsDecrementer[i].join();
threadsIncrementer[i].join();
}
for (int i = 0; i < atomicIntegerArray.length(); i++) {
if (atomicIntegerArray.get(i) != 0) {
System.out.println("发现了错误 " + i);
}
}
System.out.println("运行结束");
}
}
class Decrementer implements Runnable {
private AtomicIntegerArray array;
public Decrementer(AtomicIntegerArray array) {
this.array = array;
}
@Override
public void run() {
for (int i = 0; i < array.length(); i++) {
array.getAndDecrement(i);
}
}
}
class Incrementer implements Runnable {
private AtomicIntegerArray array;
public Incrementer(AtomicIntegerArray array) {
this.array = array;
}
@Override
public void run() {
for (int i = 0; i < array.length(); i++) {
array.getAndIncrement(i);
}
}
}
AtomicReference 可以让一个对象保证原子性,功能比 AtomicInteger 强,因为一个对象里可以包含很多属性
把普通变量升级为原子变量
AtomicIntegerFieldUpdater 适用场景:
-
类不是我们自己创建的
-
偶尔需要一个原子 get-set 操作
package juc.lock.atomic;
import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
public class AtomicIntegerFiledUpdaterDemo implements Runnable {
static Candidate tom;
static Candidate peter;
public static AtomicIntegerFieldUpdater<Candidate> scoreUpdater = AtomicIntegerFieldUpdater.newUpdater(Candidate.class, "score");
@Override
public void run() {
for (int i = 0; i < 10000; i++) {
peter.score++;
scoreUpdater.getAndIncrement(tom);
}
}
public static class Candidate {
volatile int score;
}
public static void main(String[] args) throws InterruptedException {
tom = new Candidate();
peter = new Candidate();
AtomicIntegerFiledUpdaterDemo r = new AtomicIntegerFiledUpdaterDemo();
Thread t1 = new Thread(r);
Thread t2 = new Thread(r);
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println("普通变量:" + peter.score);
System.out.println("升级后的结果:" + tom.score);
}
}
LongAdder
Adder 累加器:高并发下 LongAdder 比 AtomicLong 效率高,本质是空间换时间
package juc.lock.atomic;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicLong;
/**
* 演示高并发场景下,LongAdder 比 AtomicLong 性能好
*/
public class AtomicLongDemo {
public static void main(String[] args) throws InterruptedException {
AtomicLong counter = new AtomicLong(0);
ExecutorService service = Executors.newFixedThreadPool(20);
long start = System.currentTimeMillis();
for (int i = 0; i < 10000; i++) {
service.submit(new Task(counter));
}
service.shutdown();
while (!service.isTerminated()) {
}
long end = System.currentTimeMillis();
System.out.println(counter.get());
System.out.println("AtomicLong 耗时:" + (end - start));
}
private static class Task implements Runnable {
private AtomicLong counter;
public Task(AtomicLong counter) {
this.counter = counter;
}
@Override
public void run() {
for (int i = 0; i < 10000; i++) {
counter.incrementAndGet();
}
}
}
}
package juc.lock.atomic;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicLong;
import java.util.concurrent.atomic.LongAdder;
/**
* 演示高并发场景下,LongAdder 比 AtomicLong 性能好
*/
public class LongAdderDemo {
public static void main(String[] args) throws InterruptedException {
LongAdder counter = new LongAdder();
ExecutorService service = Executors.newFixedThreadPool(20);
long start = System.currentTimeMillis();
for (int i = 0; i < 10000; i++) {
service.submit(new Task(counter));
}
service.shutdown();
while (!service.isTerminated()) {
}
long end = System.currentTimeMillis();
System.out.println(counter.sum());
System.out.println("LongAdder 耗时:" + (end - start));
}
private static class Task implements Runnable {
private LongAdder counter;
public Task(LongAdder counter) {
this.counter = counter;
}
@Override
public void run() {
for (int i = 0; i < 10000; i++) {
counter.increment();
}
}
}
}
AtomicLong 每次都要 flush 与 refresh
LongAdder 不需要这么操作,每个线程都有自己的一个计数器,仅用来在自己线程内计数
- 上一篇: 不得不说的锁事
- 下一篇: CAS-不可中断的典范

关于我
一个文科出身的程序员,追求做个有趣的人,传播有价值的知识,微信公众号主要分享读书思考心得,不会有代码类文章,非程序员的同学请放心订阅
转载须注明出处:https://www.itshutong.com/articles/1019
精品付费
个人开发者通过payjs接入微信支付
2583
0
这一次,真正掌握composer
1509
0
相关推荐
idea 集成以及配置 maven
136
0
Java super 关键字使用
246
0
Mybatis 框架快速入门
173
0
Mybatis 与 JDBC 编程的比较
149
0
Mybatis 一对多关系
140
0
java 通过工厂模式解耦
170
0
springboot 访问静态资源
129
0
Java 服务调用方式
187
0
maven 标准目录结构
141
0
java 设置线程为后台线程
124
0
迪米特原则
91
0
枚举实现单例模式
92
0
筛选购物车商品-引出函数式接口妙用
46
0