Java学习笔记7线程安全之原子操作
Java学习笔记7-线程安全之原子操作
讲原子操作之前先说下几个概念 竞态条件、临界区、共享资源及不可变对象。
竞态条件与临界区
多个线程访问了相同的资源，向这些资源做写操作时，对执行顺序有要求。
临界区：incr 方法内部就是临界区域，关键部分代码的多线程并发执行，会对执行结果产生影响。
竟态条件：可能发生在临界区域内的特殊条件。多线程执行incr 方法中的 i++关键代码时，产生了竞态条件。
public void incr() { i++;
}
共享资源
如果一段代码是线程安全的，则它不包括竞态条件。只有当多个线程更新共享资源时，才会发生竞态条件。
栈封闭时，不会在线程之间共享的变量，都是线程安全的。
局部对象引用本身不共享，但是引用的对象存储在共享堆中。如果方法内创建的对象，只是在方法中传递，并且不对其他线程可用，那么也是线程安全的。
判定规则：如果创建、使用和处理资源，永远不会逃脱单个线程的控制，该资源的使用是线程安全的。
public void method1() { LocalObject localObject = new LocalObject();
localObject.callMethod();
method2(localObject);
}
public void method2(LocalObject localObject) {
localObject.setValue("value");
}
不可变对象
创建不可变的共享对象来保证对象在线程间共享时不会被修改，从而实现线程安全。
实例被创建，value变量就不能再被修改，这就是不可变性，比如final
public class Demo { private int value = 0;
public Demo(int value) {
this.value = value;
}
public int getValue() {
return value;
}
}
final：强调不变性
- 修饰类：
- 被final修饰的类不能被继承。
- 类中的成员方法都会被隐式的指定为final方法。
- 修饰方法：
- 被final修饰的方法不能被重写。
- 一个类的private方法会被隐式的指定为final方法。
- 如果父类中有final修饰的方法，那么子类不能去重写。
- 修饰成员变量：
- 被fianl修饰的成员变量必须要赋初始值，有两种方式：1、直接赋值 2、在构造方法中赋值。
- 如果修饰的成员变量是基本类型，则表示这个变量的值不能改变。
- 如果修饰的成员变量是一个引用类型，则是说这个引用的地址的值不能修改，但是这个引用所指向的对象里面的内容还是可以改变的。
- 使用static final修饰：不能被修改，无需实例化，声明必须初始化 。
原子操作
原子操作可以是一个步骤，也可以是多个操作步骤，但是其顺序不可以被打乱，也不可以被分割而只执行其中的一部分（不可中断性）。将整个操作视作一个整体，资源在该次操作中保持一致，这是原子性的核心特征。
测试代码
import java.util.concurrent.TimeUnit;/**
* @Author: Wenx
* @Description:
* @Date: Created in 2019/11/14 12:55
* @Modified By：
*/
public class DemoTest {
volatile int i = 0;
public void incr() {
i++;
}
public static void main(String[] args) throws InterruptedException {
DemoTest demoTest = new DemoTest();
for (int i = 0; i < 2; i++) {
new Thread(() -> {
for (int j = 0; j < 10000; j++) {
demoTest.incr();
}
}).start();
}
TimeUnit.SECONDS.sleep(2);
System.out.println("结果为：" + demoTest.i);
}
}
结果和你期望相同吗？2个线程循环10000次，我的期望是20000，可结果……
解决办法：
Atomic
JDK在java.util.concurrent（JUC并发编程包）中提供了atomic原子操作包，其中有很多原子操作封装类，如AtomicInteger 来不及多说，赶紧上车……
import java.util.concurrent.TimeUnit;import java.util.concurrent.atomic.AtomicInteger;
/**
* @Author: Wenx
* @Description:
* @Date: Created in 2019/11/14 12:55
* @Modified By：
*/
public class DemoTest {
AtomicInteger i = new AtomicInteger(0);
public void incr() {
i.incrementAndGet();
}
public static void main(String[] args) throws InterruptedException {
DemoTest demoTest = new DemoTest();
for (int i = 0; i < 2; i++) {
new Thread(() -> {
for (int j = 0; j < 10000; j++) {
demoTest.incr();
}
}).start();
}
TimeUnit.SECONDS.sleep(2);
System.out.println("结果为：" + demoTest.i);
}
}
结果为20000 这回对了吧，我们来看下AtomicInteger它是怎么实现的，查看源码发现incrementAndGet方法内部实际使用了unsafe.compareAndSwapInt方法，也就是传说中的CAS机制，通过CAS自旋锁实现原子操作 。
CAS机制：
compare and swap 比较和交换。属于硬件同步原语，处理器提供了基本内存操作的原子性保证。
CAS操作需要输入两个数值，一个旧值A（期望操作前的值）和一个新值B，在操作期间先比较下旧值有没有发生变化，如果没有发生变化，才交换成新值，发生了变化则不交换。
我们也用unsafe实现一下原子操作吧，unsafe可以直接操作内存，修改对象，数组内存…简直就是一个字 强！但是看名字就不安全，所以正规方法它是不让你用的，但是我们有黑科技通过反射可以使用。
import sun.misc.Unsafe;import java.lang.reflect.Field;
import java.util.concurrent.TimeUnit;
public class DemoTest {
volatile int i = 0;
static Unsafe unsafe;
private static long valueOffset;
static {
try {
// 反射技术获取unsafe值
Field field = Unsafe.class.getDeclaredField("theUnsafe");
field.setAccessible(true);
unsafe = (Unsafe) field.get(null);
// 获取到 i 属性偏移量（用于定位 i 属性在内存中的具体地址）
valueOffset = unsafe.objectFieldOffset(DemoTest.class.getDeclaredField("i"));
} catch (Exception ex) {
ex.printStackTrace();
}
}
public void incr() {
// CAS自旋：CAS + 循环 重试
int current;
do {
// 操作耗时的话，那么线程就会占用大量的CPU执行时间
current = unsafe.getIntVolatile(this, valueOffset);
} while (!unsafe.compareAndSwapInt(this, valueOffset, current, current + 1));
// 可能会失败
}
public static void main(String[] args) throws InterruptedException {
DemoTest demoTest = new DemoTest();
for (int i = 0; i < 2; i++) {
new Thread(() -> {
for (int j = 0; j < 10000; j++) {
demoTest.incr();
}
}).start();
}
TimeUnit.SECONDS.sleep(2);
System.out.println("结果为：" + demoTest.i);
}
}
LongAdder：
因为之前CAS自旋的方法，在多线程中操作耗时的话，那么线程就会占用大量的CPU执行时间，在JDK1.8提供了几个专门用来计数的封装类，如LongAdder ，通过各线程独自累加，最后把结果求和的办法，效率有明显提升。
import java.util.concurrent.TimeUnit;import java.util.concurrent.atomic.LongAdder;
/**
* @Author: Wenx
* @Description:
* @Date: Created in 2019/11/14 12:55
* @Modified By：
*/
public class DemoTest {
LongAdder i = new LongAdder();
public void incr() {
i.increment();
}
public static void main(String[] args) throws InterruptedException {
DemoTest demoTest = new DemoTest();
for (int i = 0; i < 2; i++) {
new Thread(() -> {
for (int j = 0; j < 10000; j++) {
demoTest.incr();
}
}).start();
}
TimeUnit.SECONDS.sleep(2);
System.out.println("结果为：" + demoTest.i.sum());
}
}
synchronized
同步关键字也可以保证原子性操作
import java.util.concurrent.TimeUnit;/**
* @Author: Wenx
* @Description:
* @Date: Created in 2019/11/14 12:55
* @Modified By：
*/
public class DemoTest {
volatile int i = 0;
public void incr() {
synchronized (this) {
i++;
}
}
public static void main(String[] args) throws InterruptedException {
DemoTest demoTest = new DemoTest();
for (int i = 0; i < 2; i++) {
new Thread(() -> {
for (int j = 0; j < 10000; j++) {
demoTest.incr();
}
}).start();
}
TimeUnit.SECONDS.sleep(2);
System.out.println("结果为：" + demoTest.i);
}
}
Lock
加锁也可以实现原子性操作
import java.util.concurrent.TimeUnit;import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* @Author: Wenx
* @Description:
* @Date: Created in 2019/11/14 12:55
* @Modified By：
*/
public class DemoTest {
volatile int i = 0;
Lock lock = new ReentrantLock();
public void incr() {
lock.lock();
try {
i++;
} finally {
lock.unlock();
}
}
public static void main(String[] args) throws InterruptedException {
DemoTest demoTest = new DemoTest();
for (int i = 0; i < 2; i++) {
new Thread(() -> {
for (int j = 0; j < 10000; j++) {
demoTest.incr();
}
}).start();
}
TimeUnit.SECONDS.sleep(2);
System.out.println("结果为：" + demoTest.i);
}
}
以上是 Java学习笔记7线程安全之原子操作 的全部内容， 来源链接： utcz.com/z/511199.html
