詳解Java多線程編程中LockSupport類的線程壅塞用法。本站提示廣大學習愛好者：（詳解Java多線程編程中LockSupport類的線程壅塞用法）文章只能為提供參考，不一定能成為您想要的結果。以下是詳解Java多線程編程中LockSupport類的線程壅塞用法正文
LockSupport是用來創立鎖和其他同步類的根本線程壅塞原語。
LockSupport中的park() 和 unpark() 的感化分離是壅塞線程息爭除壅塞線程，並且park()和unpark()不會碰到“Thread.suspend 和 Thread.resume所能夠激發的逝世鎖”成績。
由於park() 和 unpark()有允許的存在；挪用 park() 的線程和另外一個試圖將其 unpark() 的線程之間的競爭將堅持活性。
根本用法
LockSupport 很相似於二元旌旗燈號量(只要1個允許證可供應用)，假如這個允許還沒有被占用，以後線程獲得允許並繼 續 履行；假如允許曾經被占用，以後線 程壅塞，期待獲得允許。
public static void main(String[] args)
{
LockSupport.park();
System.out.println("block.");
}
運轉該代碼，可以發明主線程一向處於壅塞狀況。由於 允許默許是被占用的 ，挪用park()時獲得不到允許，所以進入壅塞狀況。
以下代碼：先釋放允許，再獲得允許，主線程可以或許正常終止。LockSupport允許的獲得和釋放，普通來講是對應的，假如屢次unpark，只要一次park也不會湧現甚麼成績，成果是允許處於可用狀況。
public static void main(String[] args)
{
Thread thread = Thread.currentThread();
LockSupport.unpark(thread);//釋放允許
LockSupport.park();// 獲得允許
System.out.println("b");
}
LockSupport是可不重入 的，假如一個線程持續2次挪用 LockSupport .park()，那末該線程必定會一向壅塞下去。
public static void main(String[] args) throws Exception
{
Thread thread = Thread.currentThread();
LockSupport.unpark(thread);
System.out.println("a");
LockSupport.park();
System.out.println("b");
LockSupport.park();
System.out.println("c");
}
這段代碼打印出a和b，不會打印c，由於第二次挪用park的時刻，線程沒法獲得允許湧現逝世鎖。
上面我們來看下LockSupport對應中止的呼應性
public static void t2() 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");
}
終究線程會打印出thread over.true。這解釋 線程假如由於挪用park而壅塞的話，可以或許呼應中止要求(中止狀況被設置成true)，然則不會拋出InterruptedException 。
LockSupport函數列表
// 前往供給給比來一次還沒有消除壅塞的 park 辦法挪用的 blocker 對象，假如該挪用不受壅塞，則前往 null。 static Object getBlocker(Thread t) // 為了線程調劑，禁用以後線程，除非允許可用。 static void park() // 為了線程調劑，在允許可用之前禁用以後線程。 static void park(Object blocker) // 為了線程調劑禁用以後線程，最多期待指定的期待時光，除非允許可用。 static void parkNanos(long nanos) // 為了線程調劑，在允許可用前禁用以後線程，並最多期待指定的期待時光。 static void parkNanos(Object blocker, long nanos) // 為了線程調劑，在指定的時限前禁用以後線程，除非允許可用。 static void parkUntil(long deadline) // 為了線程調劑，在指定的時限前禁用以後線程，除非允許可用。 static void parkUntil(Object blocker, long deadline) // 假如給定線程的允許尚弗成用，則使其可用。 static void unpark(Thread thread)
LockSupport示例
比較上面的“示例1”和“示例2”可以更清楚的懂得LockSupport的用法。
示例1
public class WaitTest1 {
public static void main(String[] args) {
ThreadA ta = new ThreadA("ta");
synchronized(ta) { // 經由過程synchronized(ta)獲得“對象ta的同步鎖”
try {
System.out.println(Thread.currentThread().getName()+" start ta");
ta.start();
System.out.println(Thread.currentThread().getName()+" block");
// 主線程期待
ta.wait();
System.out.println(Thread.currentThread().getName()+" continue");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
static class ThreadA extends Thread{
public ThreadA(String name) {
super(name);
}
public void run() {
synchronized (this) { // 經由過程synchronized(this)獲得“以後對象的同步鎖”
System.out.println(Thread.currentThread().getName()+" wakup others");
notify(); // 叫醒“以後對象上的期待線程”
}
}
}
}
示例2
import java.util.concurrent.locks.LockSupport;
public class LockSupportTest1 {
private static Thread mainThread;
public static void main(String[] args) {
ThreadA ta = new ThreadA("ta");
// 獲得主線程
mainThread = Thread.currentThread();
System.out.println(Thread.currentThread().getName()+" start ta");
ta.start();
System.out.println(Thread.currentThread().getName()+" block");
// 主線程壅塞
LockSupport.park(mainThread);
System.out.println(Thread.currentThread().getName()+" continue");
}
static class ThreadA extends Thread{
public ThreadA(String name) {
super(name);
}
public void run() {
System.out.println(Thread.currentThread().getName()+" wakup others");
// 叫醒“主線程”
LockSupport.unpark(mainThread);
}
}
}
運轉成果：
main start ta main block ta wakup others main continue
解釋：park和wait的差別。wait讓線程壅塞前，必需經由過程synchronized獲得同步鎖。
