聊聊高并发（十七）解析java.util.concurrent各个组件（一）了解sun.misc.Unsafe类

了解了并发编程中锁的基本原理之后，接下来看看Java是如何利用这些原理来实现各种锁，原子变量，同步组件的。在开始分析java.util.concurrent的源代码直接，首先要了解的就是sun.misc.Unsafe类，这个类可以说的java并发包的基础，基本上所有的组件都是依赖Unsafe来做底层的同步操作。

Unsafe类有100+个方法，大部分是native方法，可以理解为Java平台和底层操作系统直接的桥梁。它封装了大量的底层操作，比如直接操作内存的方法，低级同步的方法，CAS方法，直接操作Class的方法，直接操作Object的方法等等。有了Unsafe类，就可以像C, C++一样精确地操作内存。当然Java的一大优点就是可以安全的操作内存，所以不提倡开发者直接使用Unsafe类。JDK本身的类很多都利用了Unsafe来进行底层操作。

Unsafe和并发编程相关的有几类方法:

1. CAS方法

2. 操作条件队列的方法，比如park()让线程进入等待，unpark()唤醒线程

3. 存取volatile变量的方法，比如getBooleanVolatile, putBooleanVolatile

首先看看CAS方法，主要是3个comAndSwapXXX方法

1. compareAndSwapObject提供了对一个对象引用进行CAS的能力

2. compareAndSwapInt提供了对一个32位整数进行CAS操作的能力

3. compareAndSwapLong提供了对64位整数进行CAS操作的能力

关于CAS的概念请看这篇聊聊高并发（十二）分析java.util.concurrent.atomic.AtomicStampedReference源码来看如何解决CAS的ABA问题

public final class Unsafe{
public final native boolean compareAndSwapObject(Object o, long offset,
Object expected,
Object x);
/**
* Atomically update Java variable to <tt>x</tt> if it is currently
* holding <tt>expected</tt>.
* @return <tt>true</tt> if successful
*/
public final native boolean compareAndSwapInt(Object o, long offset,
int expected,
int x);
/**
* Atomically update Java variable to <tt>x</tt> if it is currently
* holding <tt>expected</tt>.
* @return <tt>true</tt> if successful
*/
public final native boolean compareAndSwapLong(Object o, long offset,
long expected,
long x);
..............
}

操作条件队列的方法有两个：

1. park(boolean isAbsolute, long time), 这个方法会让当前线程进入等待，并释放锁。Java并发包里的Condition接口的底层实现就是利用了Unsafe的park方法来实现的。第一个参数isAbsolute是表示用绝对时间还是相对事件，如果是绝对时间，就等待直到time，比如Condition接口的awaitUntil(Date deadline)。isAbsolute为false时，等待一个时间间隔

2. unpark(Object thread)唤醒等待的线程，Condition的signal方法就是基于unpark实现的

/**
* Unblock the given thread blocked on <tt>park</tt>, or, if it is
* not blocked, cause the subsequent call to <tt>park</tt> not to
* block. Note: this operation is "unsafe" solely because the
* caller must somehow ensure that the thread has not been
* destroyed. Nothing special is usually required to ensure this
* when called from Java (in which there will ordinarily be a live
* reference to the thread) but this is not nearly-automatically
* so when calling from native code.
* @param thread the thread to unpark.
*
*/
public native void unpark(Object thread);
/**
* Block current thread, returning when a balancing
* <tt>unpark</tt> occurs, or a balancing <tt>unpark</tt> has
* already occurred, or the thread is interrupted, or, if not
* absolute and time is not zero, the given time nanoseconds have
* elapsed, or if absolute, the given deadline in milliseconds
* since Epoch has passed, or spuriously (i.e., returning for no
* "reason"). Note: This operation is in the Unsafe class only
* because <tt>unpark</tt> is, so it would be strange to place it
* elsewhere.
*/
public native void park(boolean isAbsolute, long time);

存取volatile变量的方法，这些方法让Unsafe对象有了直接存取volatile变量的能力。

public native Object getObjectVolatile(Object obj, long l);
public native void putObjectVolatile(Object obj, long l, Object obj1);
public native int getIntVolatile(Object obj, long l);
public native void putIntVolatile(Object obj, long l, int i);
public native boolean getBooleanVolatile(Object obj, long l);
public native void putBooleanVolatile(Object obj, long l, boolean flag);
public native byte getByteVolatile(Object obj, long l);
public native void putByteVolatile(Object obj, long l, byte byte0);
public native short getShortVolatile(Object obj, long l);
public native void putShortVolatile(Object obj, long l, short word0);
public native char getCharVolatile(Object obj, long l);
public native void putCharVolatile(Object obj, long l, char c);
public native long getLongVolatile(Object obj, long l);
public native void putLongVolatile(Object obj, long l, long l1);
public native float getFloatVolatile(Object obj, long l);
public native void putFloatVolatile(Object obj, long l, float f);
public native double getDoubleVolatile(Object obj, long l);
public native void putDoubleVolatile(Object obj, long l, double d);

关于Unsafe对象的其他信息，比如如何得到Unsafe对象，比如如何直接操作内存，类似反射机制存取对象属性，请查看这篇Java Magic 4. Part 4: sun.misc,Unsafe

java.util.concurrent包提供了一个LockSupport类来封装了Unsafe对象，来提供操作条件队列的方法。

来看一下LockSupport的实现，有几点比较有意思

1. 利用Unsafe直接操作内存来存取对象的能力来设置blocker

Unsafe.objectFieldOffset可以获得某个字段在对象所在内存的offset，有了这个offset，就可以通过对象的引用来找到字段所在的实际内存地址。这种做法在C++中常见，但是在Java中不推荐上层程序使用。

这段代码的意思是把arg对象设置到Thread的parkBlocker属性上。

Thread的parkBlocker属性用来指出当前线程是在哪个对象上阻塞

public class LockSupport {
private LockSupport() {} // Cannot be instantiated.
// Hotspot implementation via intrinsics API
private static final Unsafe unsafe = Unsafe.getUnsafe();
private static final long parkBlockerOffset;
static {
try {
parkBlockerOffset = unsafe.objectFieldOffset
(java.lang.Thread.class.getDeclaredField("parkBlocker"));
} catch (Exception ex) { throw new Error(ex); }
}
private static void setBlocker(Thread t, Object arg) {
// Even though volatile, hotspot doesn't need a write barrier here.
unsafe.putObject(t, parkBlockerOffset, arg);
}
public class Thread{
/**
* The argument supplied to the current call to
* java.util.concurrent.locks.LockSupport.park.
* Set by (private) java.util.concurrent.locks.LockSupport.setBlocker
* Accessed using java.util.concurrent.locks.LockSupport.getBlocker
*/
volatile Object parkBlocker;
}

2. park方法需要指明锁对象，可以看到，park方法先setBlocker标记当前线程是在哪个锁对象上等待，然后调用Unsafe的park方法，当Unsafe的park方法返回时表示已经退出等待，就把blocker设置为null.

用jstack命令查看过线程状态的同学肯定知道jstack能打印出线程是在哪个对象上block，这个对象就是这里的blocker

public static void park(Object blocker) {
Thread t = Thread.currentThread();
setBlocker(t, blocker);
unsafe.park(false, 0L);
setBlocker(t, null);
}

LockSupport的park()和unpark()方法和Object.wait(), notify方法都可以操作线程的等待和唤醒，但是两者主要有两个区别

1. 面向的主体不同，LockSupport的park, unpark面向的是线程，而Object.wait, nofify面向的是对象

2. 底层实现机制不同，可以看到Object的wait, notify方法也是native方法，Unsafe的park和unpark方法也是native方法，底层实现不同，Object.notify不能唤醒Unsafe park的线程。

public class Object{
public final native void wait(long timeout) throws InterruptedException;
public final native void notify();
public final native void notifyAll();
}

聊聊高并发（十七）解析java.util.concurrent各个组件（一）了解sun.misc.Unsafe类相关推荐

聊聊高并发（二十一）解析java.util.concurrent各个组件（三）深入理解AQS（一）
AQS是AbstractQueuedSynchronizer的缩写,AQS是Java并包里大部分同步器的基础构件,利用AQS可以很方便的创建锁和同步器.它封装了一个状态,提供了一系列的获取和释放操作, ...
聊聊高并发（二十九）解析java.util.concurrent各个组件（十一）再看看ReentrantReadWriteLock可重入读-写锁
上一篇聊聊高并发(二十八)解析java.util.concurrent各个组件(十) 理解ReentrantReadWriteLock可重入读-写锁讲了可重入读写锁的基本情况和主要的方法,显示了如何 ...
聊聊高并发（二十五）解析java.util.concurrent各个组件（七）理解Semaphore
前几篇分析了一下AQS的原理和实现,这篇拿Semaphore信号量做例子看看AQS实际是如何使用的. Semaphore表示了一种可以同时有多个线程进入临界区的同步器,它维护了一个状态表示可用的票据, ...
聊聊高并发（二十二）解析java.util.concurrent各个组件（四）深入理解AQS（二）
上一篇介绍了AQS的基本设计思路以及两个内部类Node和ConditionObject的实现聊聊高并发(二十一)解析java.util.concurrent各个组件(三) 深入理解AQS(一) 这篇 ...
聊聊高并发（二十九）解析java.util.concurrent各个组件（十一）再看看ReentrantReadWriteLock可重入读-写锁...
上一篇聊聊高并发(二十八)解析java.util.concurrent各个组件(十) 理解ReentrantReadWriteLock可重入读-写锁讲了可重入读写锁的基本情况和基本的方法,显示了怎样 ...
聊聊高并发（二十）解析java.util.concurrent各个组件（二） 12个原子变量相关类
这篇说说java.util.concurrent.atomic包里的类,总共12个,网上有很多文章解析这几个类,这里挑些重点说说. 这12个类可以分为三组: 1. 普通类型的原子变量 2. 数组类型的 ...
聊聊高并发（二十七）解析java.util.concurrent各个组件（九）理解ReentrantLock可重入锁
这篇讲讲ReentrantLock可重入锁,JUC里提供的可重入锁是基于AQS实现的阻塞式可重入锁.这篇聊聊高并发(十六)实现一个简单的可重入锁模拟了可重入锁的实现.可重入锁的特点是: 1. 是互 ...
聊聊高并发（二十八）解析java.util.concurrent各个组件（十）理解ReentrantReadWriteLock可重入读-写锁
这篇讲讲ReentrantReadWriteLock可重入读写锁,它不仅是读写锁的实现,并且支持可重入性. 聊聊高并发(十五)实现一个简单的读-写锁(共享-排他锁) 这篇讲了如何模拟一个读写锁. 可重 ...
聊聊高并发（三十一）解析java.util.concurrent各个组件（十三）理解Exchanger交换器
这篇讲讲Exchanger交互器,它是一种比较特殊的两方(Two-Party)栅栏,可以理解成Exchanger是一个栅栏,两边一方是生产者,一方是消费者, 1. 生产者和消费者各自维护了一个容器,生 ...

聊聊高并发（十七）解析java.util.concurrent各个组件（一）了解sun.misc.Unsafe类

聊聊高并发（十七）解析java.util.concurrent各个组件（一）了解sun.misc.Unsafe类相关推荐

最新文章

热门文章

聊聊高并发（十七）解析java.util.concurrent各个组件（一） 了解sun.misc.Unsafe类

聊聊高并发（十七）解析java.util.concurrent各个组件（一） 了解sun.misc.Unsafe类相关推荐

最新文章

热门文章

聊聊高并发（十七）解析java.util.concurrent各个组件（一）了解sun.misc.Unsafe类

聊聊高并发（十七）解析java.util.concurrent各个组件（一）了解sun.misc.Unsafe类相关推荐