本文摘自:
https://blog.csdn.net/fanrenxiang/article/details/80623884
http://ifeve.com/sun-misc-unsafe/
https://blog.csdn.net/likailonghaha/article/details/70156858
一、前言
1、为什么需要AtomicInteger原子操作类?
对于全局变量的数值类型作 count++,若没有加 synchronized 关键字则是线程不安全的,count++ 解析为 :
①、读取 count 值 ②、赋值 count = count + 1;显然,这个操作不具备原子性,多线程时会出现问题,如下测试:
public static int count = 0; public static void main(String[] args) {
for(int i = 0; i < 100; i++) {
new Thread() {
public void run() {
count++;
}
}.start();
}
System.out.println("count: " + count);
}
输出的结果为count: 94,这个值不定,每次测试都可能不一样,很显然,100个线程跑++操作,结果并没有像预期的那样count: 100。
2、要是换成volatile修饰count变量呢?
volatile 修饰的变量能够在线程之间保持可见性,能被多个线程同时读但是又能保证只被单线程写,而且不会读到过期值,volatile 修饰字段的写入操作总是优先于读操作,即使多个线程同时修改 volatile 变量字段,总能保证获取到的是最新的值。如下测试:
public static volatile int count = 0; public static void main(String[] args) throws InterruptedException {
for (int i = 0; i < 100; i++) {
new Thread() {
public void run() {
for (int j = 0; j < 100; j++) {
count++;
}
}
}.start();
}
Thread.sleep(1000);
System.out.println("volatile count: " + count); }
结果似乎又失望了,出现volatile count: 9992,果然还是出现问题了,volatile仅仅保证变量在线程间保持可见性,却依然不能保证非原子性的操作。
3、用了AtomicInteger类后会变成什么样子呢?
public class AtomicIntegerTest2 { public static AtomicInteger count = new AtomicInteger(0); public static void main(String[] args) throws InterruptedException {
for (int i = 0; i < 100; i++) {
new Thread() {
public void run() {
for (int j = 0; j < 100; j++) {
count.getAndIncrement();
}
}
}.start();
}
Thread.sleep(1000);
System.out.println("AtomicInteger count: " + count);
}
}
结果每次都输出"AtomicInteger count: 10000",没毛病。
二、AtomicInteger、Unsafe 类介绍
1、AtomicInteger
来自 java.util.concurrent.atomic 包,atomic包下提供AtomicBoolean/AtomicLong/AtomicInteger三个原子更新基本类型,以AtomicInteger为例,其他两种基本类似。以下是AtomicInteger囊括的大致方法
//给AtomicInteger设置newValue并返回加oldValue
public final int getAndSet(int newValue) //如果输入的值和期望值相等就set并返回true/false
public final boolean compareAndSet(int expect, int update) //对AtomicInteger原子的加1并返回当前自增前的value
public final int getAndIncrement() //对AtomicInteger原子的减1并返回自减之前的的value
public final int getAndDecrement() //对AtomicInteger原子的加上delta值并返加之前的value
public final int getAndAdd(int delta) //对AtomicInteger原子的加1并返回加1后的值
public final int incrementAndGet() //对AtomicInteger原子的减1并返回减1后的值
public final int decrementAndGet() //给AtomicInteger原子的加上指定的delta值并返回加后的值
public final int addAndGet(int delta)
以getAndIncrement为例看下源码
public final int getAndIncrement() {
for (;;) { // 若 compareAndSet 为 false, 则一直循环查询
//先取出AtomicInteger的当前值
int current = get();
//对当前值加1操作
int next = current + 1;
//这里很关键,通过compareAndSet方法比较当前值有没有被其它线程修改
if (compareAndSet(current, next))
return current;
}
}
compareAndSet方法里面是调用了Unsafe类的compareAndSwapInt方法(后边讨论)
public final boolean compareAndSet(int expect, int update) {
return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
}
以下先介绍 Unsafe 类:
2、Unsafe 作用:Unsafe类提供了硬件级别的原子操作,提高了Java对底层操作的能力。
来自 sun.misc 包,Java最初被设计为一种安全的受控环境,但是 sun.misc.Unsafe 是 Java HotSpot 提供的操作内存和线程的"后门",提供了一些可以直接操控内存和线程的底层操作。
Unsafe被JDK广泛应用于 java.nio 和并发包等实现中,这个不安全的类提供了一个观察 HotSpot JVM 内部结构并且可以对其进行修改,但是不建议在生产环境中使用 先看部分 Unsafe 源码:
private Unsafe() { // 私有
} private static final Unsafe theUnsafe = new Unsafe(); @CallerSensitive
public static Unsafe getUnsafe() {
Class<?> caller = Reflection.getCallerClass();
if (!VM.isSystemDomainLoader(caller.getClassLoader()))
throw new SecurityException("Unsafe");
return theUnsafe;
}
1、获取Unsafe实例
- 不能直接new Unsafe(),原因是Unsafe被设计成单例模式,构造方法是私有的;
- 不能通过调用Unsafe.getUnsafe()获取,因为getUnsafe被设计成只能从引导类加载器(bootstrap class loader)加载
Unsafe 实例获取方法:
//方法一:我们可以令我们的代码“受信任”。运行程序时,使用bootclasspath选项,指定系统类路径加上你使用的一个Unsafe路径(但这太难了。)
java -Xbootclasspath:/usr/jdk1.7.0/jre/lib/rt.jar:. com.mishadoff.magic.UnsafeClient // 方法二: 使用反射,Unsafe
类包含一个私有的、名为theUnsafe的实例
,我们可以通过Java反射窃取该变量。
static {
try {
Field field = Unsafe.class.getDeclaredField("theUnsafe");
field.setAccessible(true);
UNSAFE = (Unsafe) field.get(null);
} catch (Exception e) {
}
}
2、Unsafe API
sun.misc.Unsafe类包含105个方法。实际上,对各种实体操作有几组重要方法,其中的一些如下:
Info.仅返回一些低级的内存信息
addressSize
pageSize
Objects.提供用于操作对象及其字段的方法
allocateInstance
objectFieldOffset
Classes.提供用于操作类及其静态字段的方法
staticFieldOffset
defineClass
defineAnonymousClass
ensureClassInitialized
Arrays.操作数组
arrayBaseOffset
arrayIndexScale
Synchronization.低级的同步原语
monitorEnter
tryMonitorEnter
monitorExit
compareAndSwapInt
putOrderedInt
Memory.直接内存访问方法
allocateMemory
copyMemory
freeMemory
getAddress
getInt
putInt
3、有趣的用例
①、避免初始化
当你想要跳过对象初始化阶段,或绕过构造器的安全检查,或实例化一个没有任何公共构造器的类,allocateInstance
方法是非常有用的。考虑以下类:
class A {
private long a; // not initialized value public A() {
this.a = 1; // initialization
} public long a() { return this.a; }
}
使用构造器、反射和unsafe初始化它,将得到不同的结果。
A o1 = new A(); // constructor
o1.a(); // prints 1 A o2 = A.class.newInstance(); // reflection
o2.a(); // prints 1 A o3 = (A) unsafe.allocateInstance(A.class); // unsafe
o3.a(); // prints 0
Unsafe 的 allocateInstance 方法可以绕过构造方法直接创建对象
objectFieldOffset 方法可以为对象属性赋值。
public static void main(String[] args) {
try {
Customer customer = (Customer) UNSAFE.allocateInstance(Customer.class);
customer.setName("King");
System.out.println(customer.toString()); Field name = customer.getClass().getDeclaredField("name");
UNSAFE.putObject(customer, UNSAFE.objectFieldOffset(name), "LoLa");
System.out.println(customer.toString());
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
②、内存崩溃(Memory corruption)
这对于每个C程序员来说是常见的。顺便说一下,它是绕过安全的常用技术。
考虑下那些用于检查“访问规则”的简单类:
class Guard {
private int ACCESS_ALLOWED = 1; public boolean giveAccess() {
return 42 == ACCESS_ALLOWED;
}
}
客户端代码是非常安全的,并且通过调用giveAccess()
来检查访问规则。可惜,对于客户,它总是返回false。只有特权用户可以以某种方式改变ACCESS_ALLOWED
常量的值并且得到访问
实际上,这并不是真的。演示代码如下:
Guard guard = new Guard();
guard.giveAccess(); // false, no access // bypass
Unsafe unsafe = getUnsafe();
Field f = guard.getClass().getDeclaredField("ACCESS_ALLOWED");
unsafe.putInt(guard, unsafe.objectFieldOffset(f), 42); // memory corruption guard.giveAccess(); // true, access granted
③、并发(Concurrency)
compareAndSwap
方法是原子的,并且可用来实现高性能的、无锁的数据结构。
比如,考虑问题:在使用大量线程的共享对象上增长值。
首先,我们定义简单的Counter
接口:
interface Counter {
void increment();
long getCounter();
}
然后,我们定义使用Counter的工作线程CounterClient
:
class CounterClient implements Runnable {
private Counter c;
private int num; public CounterClient(Counter c, int num) {
this.c = c;
this.num = num;
} @Override
public void run() {
for (int i = 0; i < num; i++) {
c.increment();
}
}
}
测试代码:
int NUM_OF_THREADS = 1000;
int NUM_OF_INCREMENTS = 100000;
ExecutorService service = Executors.newFixedThreadPool(NUM_OF_THREADS);
Counter counter = ... // creating instance of specific counter
long before = System.currentTimeMillis();
for (int i = 0; i < NUM_OF_THREADS; i++) {
service.submit(new CounterClient(counter, NUM_OF_INCREMENTS));
}
service.shutdown();
service.awaitTermination(1, TimeUnit.MINUTES);
long after = System.currentTimeMillis();
System.out.println("Counter result: " + c.getCounter());
System.out.println("Time passed in ms:" + (after - before));
第一个无锁版本的计数器:
运行快,但没有线程管理,结果是不准确的。
class StupidCounter implements Counter {
private long counter = 0; @Override
public void increment() {
counter++;
} @Override
public long getCounter() {
return counter;
}
}
输出:
Counter result: 99542945
Time passed in ms: 679
第二次尝试,添加上最简单的java式同步:
激进的同步有效,但耗时长。
class SyncCounter implements Counter {
private long counter = 0; @Override
public synchronized void increment() {
counter++;
} @Override
public long getCounter() {
return counter;
}
}
输出:
Counter result: 100000000
Time passed in ms: 10136
第三种,试试ReentrantReadWriteLock
:
仍然正确,耗时较短。
class LockCounter implements Counter {
private long counter = 0;
private WriteLock lock = new ReentrantReadWriteLock().writeLock(); @Override
public void increment() {
lock.lock();
counter++;
lock.unlock();
} @Override
public long getCounter() {
return counter;
}
}
第四种,atomics的运行效果如何?
AtomicCounter的运行结果更好。
class AtomicCounter implements Counter {
AtomicLong counter = new AtomicLong(0); @Override
public void increment() {
counter.incrementAndGet();
} @Override
public long getCounter() {
return counter.get();
}
}
第五种,试试
Unsafe
原始的compareAndSwapLong
,看看它是否真的只有特权才能使用它?
class CASCounter implements Counter {
private volatile long counter = 0;
private Unsafe unsafe;
private long offset; public CASCounter() throws Exception {
unsafe = getUnsafe();
offset = unsafe.objectFieldOffset(CASCounter.class.getDeclaredField("counter"));
} @Override
public void increment() {
long before = counter;
while (!unsafe.compareAndSwapLong(this, offset, before, before + 1)) {
before = counter;
}
} @Override
public long getCounter() {
return counter;
}
}
第四种、第五种时间大致一样,Unsafe 看起来似乎等价于atomics。atomics使用Unsafe
?(是的)
3、 CAS
1、CAS介绍
AtomicInteger的核心就是一个CAS算法(CompareAndSwap),比较并交换算法,此算法是由unsafe的底层代码实现,它是一个原子的操作。 (CAS能很高效的解决原子操作)
原理就是:如果内存中的实际值与update值相同,则将实际值更新为expect值,反之则返回失败,由上层系统循环获取实际值后,再次调用此CAS算法。
CAS 是设计并发算法时常用到的一种技术,java.util.concurrent包完全建立在CAS之上。
CAS是通过Unsafe实现的,java.util.concurrent包中借助CAS实现了区别于synchronouse同步锁的一种乐观锁。
看下Unsafe下的三个方法:
public final native boolean compareAndSwapObject(Object paramObject1, long paramLong, Object paramObject2, Object paramObject3); public final native boolean compareAndSwapInt(Object paramObject, long paramLong, int paramInt1, int paramInt2); public final native boolean compareAndSwapLong(Object paramObject, long paramLong1, long paramLong2, long paramLong3);
2、CAS 在 Unsafe 中应用
以 compareAndSwapInt 为例, CAS有3个操作数,内存值V,旧的预期值A,要修改的新值B。当且仅当预期值A和内存值V相同时,将内存值V修改为B,否则什么都不做。
unsafe.compareAndSwapInt(this, this, valueOffset, expect, update),包含 ①比较②更新两个操作,compareAndSwapInt如何这两个步骤的原子性呢?
3、CAS原理
CAS通过调用JNI的代码实现的。JNI:Java Native Interface为JAVA本地调用(用 native 关键字标注),允许java调用其他语言。
而compareAndSwapInt就是借助C来调用CPU底层指令实现的。
三、总结
这是我认真看了一天博客摘抄下来的整理,我要保持每天不断的学习,争取早日写出有水平的干货