Java并发编程学习之Unsafe类与LockSupport类源码详析

static {
 try {
 valueOffset = unsafe.objectFieldOffset(AtomicLong.class.getDeclaredField("value"));
 } catch (Exception ex) {
 throw new Error(ex);
 }

 }

public final long getAndSetLong(Object obj, long offset, long update)
 {
 long l;
 do
 {
 l = getLongVolatile(obj, offset);//(1)
 } while (!compareAndSwapLong(obj, offset, l, update));
 return l;
 }

public final long getAndAddLong(Object obj, long offset, long addValue)
 {
 long l;
 do
 {
 l = getLongVolatile(obj, offset);
 } while (!compareAndSwapLong(obj, offset, l, l + addValue));
 return l;
 }

package com.hjc;
import sun.misc.Unsafe;
/**
 * Created by cong on 2018/6/6.
 */
public class TestUnSafe {
 //获取Unsafe的实例（2.2.1）
 static final Unsafe unsafe = Unsafe.getUnsafe();
 //记录变量state在类TestUnSafe中的偏移值（2.2.2）
 static final long stateOffset;
 //变量(2.2.3)
 private volatile long state = 0;
 static {
 try {
  //获取state变量在类TestUnSafe中的偏移值(2.2.4)
  stateOffset = unsafe.objectFieldOffset(TestUnSafe.class.getDeclaredField("state"));

 } catch (Exception ex) {
  System.out.println(ex.getLocalizedMessage());
  throw new Error(ex);
 }
 }

 public static void main(String[] args) {
 //创建实例，并且设置state值为1(2.2.5)
 TestUnSafe test = new TestUnSafe();
 //(2.2.6)
 Boolean sucess = unsafe.compareAndSwapInt(test, stateOffset, 0, 1);
 System.out.println(sucess);
 }
}

private static final Unsafe theUnsafe = new Unsafe();
 public static Unsafe getUnsafe(){
 //（2.2.7）
 Class localClass = Reflection.getCallerClass();
 //（2.2.8)
 if (!VM.isSystemDomainLoader(localClass.getClassLoader())) {
 throw new SecurityException("Unsafe");
 }
 return theUnsafe;
}

 //判断paramClassLoader是不是BootStrap类加载器(2.2.9)
 public static boolean isSystemDomainLoader(ClassLoader paramClassLoader){
 return paramClassLoader == null;
 }

package com.hjc;
import sun.misc.Unsafe;
import java.lang.reflect.Field;
/**
 * Created by cong on 2018/6/6.
 */
public class TestUnSafe {
 static final Unsafe unsafe;
 static final long stateOffset;
 private volatile long state = 0;
 static {
 try {
  // 反射获取 Unsafe 的成员变量 theUnsafe（2.2.10）
  Field field = Unsafe.class.getDeclaredField("theUnsafe");
  // 设置为可存取（2.2.11）
  field.setAccessible(true);

  // 获取该变量的值（2.2.12）
  unsafe = (Unsafe) field.get(null);
  //获取 state 在 TestUnSafe 中的偏移量 （2.2.13）
  stateOffset = unsafe.objectFieldOffset(TestUnSafe.class.getDeclaredField("state"));
 } catch (Exception ex) {
  System.out.println(ex.getLocalizedMessage());
  throw new Error(ex);
 }
 }

 public static void main(String[] args) {
 TestUnSafe test = new TestUnSafe();
 Boolean sucess = unsafe.compareAndSwapInt(test, stateOffset, 0, 1);
 System.out.println(sucess);
 }
}

package com.hjc;
import java.util.concurrent.locks.LockSupport;
/**
 * Created by cong on 2018/6/6.
 */
public class LockSupportTest {
 public static void main( String[] args ) {
 System.out.println( "park start!" );
 LockSupport.park();
 System.out.println( "park stop!" );
 }
}

package com.hjc;
import java.util.concurrent.locks.LockSupport;
/**
 * Created by cong on 2018/6/6.
 */
public class LockSupportTest {
 public static void main( String[] args ) {
 System.out.println( "park start!" );
 //使当前线程获取到许可证
 LockSupport.unpark(Thread.currentThread());
 //再次调用park
 LockSupport.park();
 System.out.println( "park stop!" );
 }
}

import java.util.concurrent.locks.LockSupport;
/**
 * Created by cong on 2018/6/6.
 */
public class LockSupportTest {
 public static void main(String[] args) throws InterruptedException {
 Thread thread = new Thread(new Runnable() {
  @Override
  public void run() {
  System.out.println("子线程 park start!");
  // 调用park方法，挂起自己
  LockSupport.park();
  System.out.println("子线程 unpark!");
  }
 });

 //启动子线程
 thread.start();
 //主线程休眠1S
 Thread.sleep(1000);
 System.out.println("主线程 unpark start!");
 //调用unpark让thread线程持有许可证，然后park方法会返回
 LockSupport.unpark(thread);
 }
}

import java.util.concurrent.locks.LockSupport;
/**
 * Created by cong on 2018/6/6.
 */
public class LockSupportTest {
 public static void main(String[] args) throws InterruptedException {
 Thread thread = new Thread(new Runnable() {
  @Override
  public void run() {
  System.out.println("子线程 park start!");
  // 调用park方法，挂起自己,只有中断才会退出循环
  while (!Thread.currentThread().isInterrupted()) {
   LockSupport.park();

  }
  System.out.println("子线程 unpark!");
  }
 });

 //启动子线程
 thread.start();
 //主线程休眠1S
 Thread.sleep(1000);
 System.out.println("主线程 unpark start!");
 //中断子线程
 thread.interrupt();
 }
}

import java.util.concurrent.locks.LockSupport;
/**
 * Created by cong on 2018/6/6.
 */
public class TestPark {
 public void testPark(){
  LockSupport.park();//(1)
 }
 public static void main(String[] args) {
  TestPark testPark = new TestPark();
  testPark.testPark();
 }
}

 LockSupport.park(this);//(1)

public static void park(Object blocker) {
 //获取调用线程
 Thread t = Thread.currentThread();
 //设置该线程的 blocker 变量
 setBlocker(t, blocker);
 //挂起线程
 UNSAFE.park(false, 0L);
 //线程被激活后清除 blocker 变量，因为一般都是线程阻塞时候才分析原因
 setBlocker(t, null);
}

public static void parkUntil(Object blocker, long deadline) {
  Thread t = Thread.currentThread();
  setBlocker(t, blocker);
  //isAbsolute=true,time=deadline;表示到 deadline 时间时候后返回
  UNSAFE.park(true, deadline);
  setBlocker(t, null);
 }

import java.util.Queue;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.locks.LockSupport;
/**
 * Created by cong on 2018/6/6.
 */
public class FIFOMutex {
 private final AtomicBoolean locked = new AtomicBoolean(false);
 private final Queue<Thread> waiters = new ConcurrentLinkedQueue<Thread>();
 public void lock() {
  boolean wasInterrupted = false;
  Thread current = Thread.currentThread();
  waiters.add(current);
  // 只有队首的线程可以获取锁（1）
  while (waiters.peek() != current || !locked.compareAndSet(false, true)) {
   LockSupport.park(this);
   if (Thread.interrupted()) // （2）
    wasInterrupted = true;
  }

  waiters.remove();
  if (wasInterrupted) // （3）
   current.interrupt();
 }

 public void unlock() {
  locked.set(false);
  LockSupport.unpark(waiters.peek());
 } 
}