LockSupport

LockSupport类是Java6(JSR166-JUC)引入的一个类，提供了基本的线程同步原语。

LockSupport实际上是调用了Unsafe类里的函数，归结到Unsafe里，只有两个函数：

 

public native void unpark(Thread jthread);  
public native void park(boolean isAbsolute, long time);  

 

isAbsolute参数是指明时间是绝对的，还是相对的。

 

仅仅两个简单的接口，就为上层提供了强大的同步原语。

先来解析下两个函数是做什么的。

unpark函数为线程提供“许可(permit)”，线程调用park函数则等待“许可”。

这个有点像信号量，但是这个“许可”是不能叠加的，“许可”是一次性的。

比如线程B连续调用了三次unpark函数，当线程A调用park函数就使用掉这个“许可”，如果线程A再次调用park，则进入等待状态。

 

注意，unpark函数可以先于park调用。比如线程B调用unpark函数，给线程A发了一个“许可”，那么当线程A调用park时，它发现已经有“许可”了，那么它会马上再继续运行。

实际上，park函数即使没有“许可”，有时也会无理由地返回，这点等下再解析。

park和unpark的灵活之处

上面已经提到，unpark函数可以先于park调用，这个正是它们的灵活之处。

 

一个线程它有可能在别的线程unPark之前，或者之后，或者同时调用了park，那么因为park的特性，它可以不用担心自己的park的时序问题，否则，如果park必须要在unpark之前，那么给编程带来很大的麻烦！！

 

考虑一下，两个线程同步，要如何处理？

在Java5里是用wait/notify/notifyAll来同步的。wait/notify机制有个很蛋疼的地方是，比如线程B要用notify通知线程A，那么线程B要确保线程A已经在wait调用上等待了，否则线程A可能永远都在等待。编程的时候就会很蛋疼。

 

另外，是调用notify，还是notifyAll？

notify只会唤醒一个线程，如果错误地有两个线程在同一个对象上wait等待，那么又悲剧了。为了安全起见，貌似只能调用notifyAll了。

 

park/unpark模型真正解耦了线程之间的同步，线程之间不再需要一个Object或者其它变量来存储状态，不再需要关心对方的状态。

 

举例：

park: 直接阻塞

public static void test2(){
		LockSupport.park();
		System.out.println("block.");
	}

 

unpark&park

 

public static void test1(){
		LockSupport.unpark(Thread.currentThread());
		System.out.println(LockSupport.getBlocker(Thread.currentThread()));;
		LockSupport.park();
		System.out.println("block.");
	}

 unpark&park&park （unpark只能许可一次）

 

public static void test1(){
		LockSupport.unpark(Thread.currentThread());
		System.out.println(LockSupport.getBlocker(Thread.currentThread()));;
		LockSupport.park();
		LockSupport.park();
		System.out.println("block.");
	}

 

 

park & unpark

public static void test4() throws Exception
	{
		Thread t = new Thread(new Runnable()
		{
			private int count = 0;

			@Override
			public void run()
			{
				long start = System.currentTimeMillis();
				long end = 0;

				while ((end - start) <= 1000)
				{
					count++;
					end = System.currentTimeMillis();
				}

				System.out.println("after 1 second.count=" + count);

			//等待或许许可
				LockSupport.park();
				System.out.println("thread over." + Thread.currentThread().isInterrupted());

			}
		});

		t.start();

		Thread.sleep(2000);

		// 中断线程
		LockSupport.unpark(t);

		
		System.out.println("main over");
	}

 

park&interrupt:

 

public static void test3() throws Exception
	{
		Thread t = new Thread(new Runnable()
		{
			private int count = 0;

			@Override
			public void run()
			{
				long start = System.currentTimeMillis();
				long end = 0;

				while ((end - start) <= 1000)
				{
					count++;
					end = System.currentTimeMillis();
				}

				System.out.println("after 1 second.count=" + count);

			//等待或许许可
				LockSupport.park();
				System.out.println("thread over." + Thread.currentThread().isInterrupted());

			}
		});

		t.start();

		Thread.sleep(2000);

		// 中断线程
		t.interrupt();

		
		System.out.println("main over");
	}