查看: 208|回复: 0

[Java代码] Java中unsafe操作实例总结

发表于 6 天前

Unsafe是Java无锁操作的基石,在无锁并发类中都少不了它们的身影,比如ConcurrentHashMap, ConcurrentLinkedQueue, 都是由Unsafe类来实现的。相对于与Java中的锁,它基本无开销,会原地等待。本文主要介绍下Unsafe中的主要操作。

1 compareAndSwap

  1. /**
  2. * 比较obj的offset处内存位置中的值和期望的值,如果相同则更新。此更新是不可中断的。
  3. *
  4. * @param obj 需要更新的对象
  5. * @param offset obj中整型field的偏移量
  6. * @param expect 希望field中存在的值
  7. * @param update 如果期望值expect与field的当前值相同,设置filed的值为这个新值
  8. * @return 如果field的值被更改返回true
  9. */
  10. public native boolean compareAndSwapInt(Object obj, long offset, int expect, int update);
复制代码

这个就是著名的CAS操作了,分为三步来做

  1. 获取obj对象中为offset的偏移值,这里假设为realVal
  2. 比较realVal和expect
  3. 如果相同,将该值更新为update,否则不更新

CAS家族还包括有,compareAndSwapObject(), compareAndSwapLong(), compareAndSwapInt()等等

用AtomicInteger中一个经典的例子来说明:

  1. public final int getAndAdd(int delta) {
  2. return unsafe.getAndAddInt(this, valueOffset, delta);
  3. }
  4. //unsafe.getAndAddInt
  5. public final int getAndAddInt(Object var1, long var2, int var4) {
  6. int var5;
  7. do {
  8. /**获取原始值*/
  9. var5 = this.getIntVolatile(var1, var2);
  10. /**确认原始值没有被其它线程修改时,再执行更新var5+var4操作*/
  11. } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));
  12. return var5;
  13. }
复制代码

2 putOrder

  1. /***
  2. * Sets the value of the integer field at the specified offset in the
  3. * supplied object to the given value. This is an ordered or lazy
  4. * version of <code>putIntVolatile(Object,long,int)</code>, which
  5. * doesn't guarantee the immediate visibility of the change to other
  6. * threads. It is only really useful where the integer field is
  7. * <code>volatile</code>, and is thus expected to change unexpectedly.
  8. *
  9. * @param obj the object containing the field to modify.
  10. * @param offset the offset of the integer field within <code>obj</code>.
  11. * @param value the new value of the field.
  12. * @see #putIntVolatile(Object,long,int)
  13. */
  14. public native void putOrderedInt(Object obj, long offset, int value);
复制代码

将obj对象的偏移量为offset的位置修改为value,因为Java中没有内存操作,而Unsafe的这个操作正好补充了内存操作的不足。也可以用于数组操作,比如ConcurrentHashMap中就大量用到了该操作

  1. Segment<K,V> s0 =
  2. new Segment<K,V>(loadFactor, (int)(cap * loadFactor),
  3. (HashEntry<K,V>[])new HashEntry[cap]);
  4. Segment<K,V>[] ss = (Segment<K,V>[])new Segment[ssize];
  5. // 往数组下标为0的位置,写入s0: ss[0]=s0
  6. UNSAFE.putOrderedObject(ss, SBASE, s0); // ordered write of segments[0]
复制代码

需要注意的是obj需要设置为Volatile,否则对于其它线程会不可见

3 putXxxVolatile

  1. /***
  2. * Sets the value of the integer field at the specified offset in the
  3. * supplied object to the given value, with volatile store semantics.
  4. *
  5. * @param obj the object containing the field to modify.
  6. * @param offset the offset of the integer field within <code>obj</code>.
  7. * @param value the new value of the field.
  8. */
  9. public native void putIntVolatile(Object obj, long offset, int value);
复制代码

感觉和putOrderInt一样,因为必须设置为Volatile,否则有什么用呢?

以上就是本次给大家分享的知识点的全部内容,感谢大家对程序员之家的支持。



回复

使用道具 举报