2. 程式人生 > >java多執行緒之Lock類的使用

java多執行緒之Lock類的使用

阿新 • • 發佈：2019-02-18

1.ReentrantLock類的使用

   1.1ReentrantLock實現執行緒間同步

public class MyService {
	private Lock lock=new ReentrantLock();
	public void service(){
		lock.lock();
		for(int i=0;i<5;i++){
			System.out.println("ThreadName="+Thread.currentThread().getName()+(" "+(i+1)));
		}
		lock.unlock();
	}
}

public class MyThread extends Thread{
    private MyService myService;
    public MyThread(MyService myService) {
        super();
        this.myService = myService;
    }
    @Override
    public void run() {
        myService.service();
    }    
}

public class Test {
    public static void main(String[] args) {
        MyService myService=new MyService();
        MyThread mt1=new MyThread(myService);
        MyThread mt2=new MyThread(myService);
        MyThread mt3=new MyThread(myService);
        MyThread mt4=new MyThread(myService);
        MyThread mt5=new MyThread(myService);
        mt1.start();
        mt2.start();
        mt3.start();
        mt4.start();
        mt5.start();
    }
}

結果：

ThreadName=Thread-1 1
ThreadName=Thread-1 2
ThreadName=Thread-1 3
ThreadName=Thread-1 4
ThreadName=Thread-1 5
ThreadName=Thread-0 1
ThreadName=Thread-0 2
ThreadName=Thread-0 3
ThreadName=Thread-0 4
ThreadName=Thread-0 5
ThreadName=Thread-2 1
ThreadName=Thread-2 2
ThreadName=Thread-2 3
ThreadName=Thread-2 4
ThreadName=Thread-2 5
ThreadName=Thread-3 1
ThreadName=Thread-3 2
ThreadName=Thread-3 3
ThreadName=Thread-3 4
ThreadName=Thread-3 5
ThreadName=Thread-4 1
ThreadName=Thread-4 2
ThreadName=Thread-4 3
ThreadName=Thread-4 4
ThreadName=Thread-4 5
解釋：執行緒間是競爭的關係，所以執行緒間執行的順序是不同的。

   1.2通過Condition實現等待通知機制

     Condition類可以實現多路通知功能，就是Lock物件可以建立多個Condition，將執行緒物件註冊在指定的Condition中，就可以實現

     有通知性地進行執行緒通知，在排程執行緒上更加靈活了。

public class MyService {
	private Lock lock=new ReentrantLock();
	public Condition condition=lock.newCondition();
	public void awaitService(){
		try{
			lock.lock();
			System.out.println("await時間：   "+System.currentTimeMillis());
			condition.await();
		}catch(InterruptedException e){
			e.printStackTrace();
		}finally{
			lock.unlock();
		}
	}
	public void signalService(){
		try{
			lock.lock();
			System.out.println("signal時間："+System.currentTimeMillis());
			condition.signal();
		}finally{
			lock.unlock();
		}
	}
}

public class ThreadA extends Thread{
    private MyService myService;
    public ThreadA(MyService myService) {
        super();
        this.myService = myService;
    }
    @Override
    public void run() {
        myService.awaitService();
    }
}

public class Test {
    public static void main(String[] args) throws InterruptedException {
        MyService myService=new MyService();
        ThreadA a=new ThreadA(myService);
        a.start();
        Thread.sleep(3000);
        myService.signalService();
    }
} 
結果：

await時間 ：  1474879823968
signal時間：  1474879826978

   1.3實現一生產一消費

public class MyService {
	private Lock lock=new ReentrantLock();
	private Condition condition=lock.newCondition();
	private boolean hasValue=true;
	public void set(){
		try{
			lock.lock();
			while(hasValue){
				condition.await();
			}
			System.out.println("列印#");
			hasValue=true;
			condition.signal();
		}catch(InterruptedException e){
			e.printStackTrace();
		}finally{
			lock.unlock();
		}
	}
	public void get(){
		try{
			lock.lock();
			while(!hasValue){
				condition.await();
			}
			System.out.println("列印&");
			hasValue=false;
			condition.signal();
		}catch(InterruptedException e){
			e.printStackTrace();
		}finally{
			lock.unlock();
		}
	}
}

public class ThreadA extends Thread{
    private MyService myService;
    public ThreadA(MyService myService) {
        super();
        this.myService = myService;
    }
    @Override
    public void run() {
        for(int i=0;i<3;i++){
            myService.set();
        }
    }
}

public class ThreadB extends Thread{
    private MyService myService;
    public ThreadB(MyService myService) {
        super();
        this.myService = myService;
    }
    @Override
    public void run() {
        for(int i=0;i<3;i++){
            myService.get();
        }
    }
}

public class Test {
    public static void main(String[] args) throws InterruptedException {
        MyService myService=new MyService();
        ThreadA a=new ThreadA(myService);
        a.start();
        ThreadB b=new ThreadB(myService);
        b.start();
    }
}
結果：

列印&
列印#
列印&
列印#
列印&
列印#

  1.4.實現多生產多消費

     程式照上面一生產一消費沒有區別，只是Test測試時，裡面new了多個生產者和多個消費者。上篇執行緒通訊中瞭解到當出現多個生產者和多個消費者會出現所謂的執行緒假死現象，最終導致專案停掉。在我看來其原因是生產者和消費者共用了同一個condition，

以至於將消費者的鎖和生產者的鎖用了同一把鎖，以至於有時候喚醒的是同類，就是生產者喚醒生產者，而沒有喚醒消費者，以至於生產者沒有對應的消費者，產生執行緒的假死。解決此辦法就是將signal();喚醒方法換成signalAll();方法。將所有的執行緒都喚醒，這樣每時每刻都有生產者和消費者相互對應了。

   1.5公平鎖與非公平鎖

     公平鎖：從字面來看 "公平"兩個字型現，執行緒獲取鎖的順序是按照執行緒加鎖的順序來分配的，也就是佇列中常說的先進先出的順序。

     非公平鎖：就是以一種搶佔的方式來獲取鎖，是隨機獲得鎖，這樣靠搶佔的方式肯定會出現有的執行緒會獲不到鎖，所以說叫非公平的。

      1.5.1實現：

      先看下ReentrantLock為我們提供的API，是通過構造傳參的方式來實現的。


public class Service {
	private ReentrantLock lock;

	public Service(boolean isFair) {
		lock=new ReentrantLock(isFair);
	}
	public void toService(){
		try{
			lock.lock();
			System.out.println("ThreadName="+Thread.currentThread().getName()+"獲得鎖定！");
		}finally{
			lock.unlock();
		}
	}
}

public class Test {
    public static void main(String[] args) {
        final Service service=new Service(true);
        Runnable runnable=new Runnable(){
            @Override
            public void run() {
                // TODO Auto-generated method stub
                System.out.println("執行緒"+Thread.currentThread().getName()+"運行了！");
                service.toService();
            }    
        };
        Thread[] threadArr=new Thread[10];
        for(int i=0;i<10;i++){
            threadArr[i]=new Thread(runnable);
        }
        for(int i=0;i<10;i++){
            threadArr[i].start();
        }
    }
}
結果：

執行緒Thread-0運行了！
ThreadName=Thread-0獲得鎖定！
執行緒Thread-8運行了！
執行緒Thread-2運行了！
ThreadName=Thread-8獲得鎖定！
ThreadName=Thread-2獲得鎖定！
執行緒Thread-1運行了！
執行緒Thread-3運行了！
執行緒Thread-7運行了！
執行緒Thread-4運行了！
執行緒Thread-5運行了！
ThreadName=Thread-1獲得鎖定！
ThreadName=Thread-3獲得鎖定！
執行緒Thread-9運行了！
執行緒Thread-6運行了！
ThreadName=Thread-7獲得鎖定！
ThreadName=Thread-4獲得鎖定！
ThreadName=Thread-5獲得鎖定！
ThreadName=Thread-9獲得鎖定！
ThreadName=Thread-6獲得鎖定！

解釋：檢視結果，發現也不是完全呈有序狀態，所以說公平鎖 "基本" 呈有序狀態。也就是說基本公平吧。

對於非公平鎖，只要在Test中寫Service service=new Service(false);測試發現基本上是亂序的，也就是說基本不公平吧。

    1.6常用方法介紹：

       <1>方法int getHoldCount();的作用是查詢當前執行緒保持此鎖定的個數，也就是表示呼叫lock();方法的次數。

public class Service {
	private ReentrantLock lock=new ReentrantLock();
	public void toService1(){
		try{
			lock.lock();
			System.out.println("toService1 getHoldCount="+lock.getHoldCount());
			toService2();
		}finally{
			lock.unlock();
		}
	}
	
	public void toService2(){
		try{
			lock.lock();
			System.out.println("toService2 getHoldCount="+lock.getHoldCount());
		}finally{
			lock.unlock();
		}
	}
}

public class Test {
    public static void main(String[] args) {
        Service service=new Service();
        service.toService1();
    }
} 
結果： toService1 getHoldCount=1

toService2 getHoldCount=2

      <2>方法int getQueueLength();的作用是返回正等待獲取此鎖定的執行緒估計數。通過英文名叫獲得佇列的長度，我在上一篇多執行緒通訊的博文中提到了那個阻塞佇列，如果當前執行緒等待了，就是被wait了，那麼就會進入阻塞佇列，而這個方法正是獲取這個阻塞佇列的長度，獲取佇列中有多少個正在等待的執行緒。

      <3>方法int getWaitQueueLength(Condition condition);作用就是返回等待與此鎖定相關的給定條件Condition的執行緒估計數。假如我有3個執行緒，都執行了同一個Condition物件的await();方法，而呼叫此方法就會返回3。

      <4>方法boolean hasQueuedThread();方法作用是查詢是否有執行緒正在等待獲取此鎖定。

      <5>方法boolean hasQueuedThread(Thread thread);方法的作用是查詢指定執行緒是否正在等待獲取此鎖定。

      <6>方法boolean hasWaiters(Condition condition);的作用是查詢是否有執行緒正在等待與此鎖定有關的condition條件。

      <7>方法boolean isFair();的作用是判斷是不是公平鎖。

      <8>方法boolean isHeldByCurrentThread()的作用是查詢當前執行緒是否保持鎖定，就是當前執行緒是否在new Lock().lock與

new Lock().unlock();之間。

      <9>方法boolean isLock();作用是查詢此鎖定是否由任意執行緒保持。

      <10>方法 void lockInterruptibly();的作用是如果當前執行緒未被中斷，則獲取鎖定，如果已經被中斷則出現異常。

      <11>方法 boolean tryLock();作用僅在呼叫時鎖定未被另一個執行緒保持的情況下，才獲取該鎖定。

public class Service {
	private ReentrantLock lock=new ReentrantLock();
	public void waitMethod(){
		if(lock.tryLock()){
			System.out.println(Thread.currentThread().getName()+"獲得鎖！");
		}else{
			System.out.println(Thread.currentThread().getName()+"未獲得鎖！");
		}
	}
}

public class Test {
    public static void main(String[] args) {
        final Service service=new Service();
        Runnable runnable=new Runnable(){
            @Override
            public void run() {
                // TODO Auto-generated method stub
                service.waitMethod();
            }    
        };
        Thread threadA=new Thread(runnable);
        threadA.setName("A");
        threadA.start();
        Thread threadB=new Thread(runnable);
        threadB.setName("B");
        threadB.start();
    }
}
結果：

A獲得鎖！
B未獲得鎖！

      <12>boolean tryLock(long timeout,TimeUnit unit);作用是如果鎖定在給定等待時間內沒有被另一個執行緒保持，且當前執行緒未被中斷，則獲取該鎖定。

      <13>awaitUtil();方法：作用是造成當前執行緒在接到訊號之前，被中斷、或到達指定最後期限之前一直處於等待狀態。

   1.7Condition的執行順序

     原來我們都是Lock物件可以建立1個Condition，將不同執行緒物件註冊在指定的Condition中，這樣其實對於執行緒的規劃很不靈活。我們可以通過Lock物件建立多個Condition，然後再去對執行緒規劃，如改變執行順序就很方便。

public class Test {
	//由於這個標誌位作為執行緒之間是否等待的條件，所以執行緒間應當是可見的，才用volatile關鍵字修飾。
	private volatile static int nextThread=1;
	private static ReentrantLock lock=new ReentrantLock();
	final private static Condition conditionA=lock.newCondition();
	final private static Condition conditionB=lock.newCondition();
	final private static Condition conditionC=lock.newCondition();
	public static void main(String[] args) {
		Thread threadA=new Thread(){
			@Override
			public void run() {
				try{
					lock.lock();
					while(nextThread !=1){
						conditionA.await();
					}
					for(int i=0;i<3;i++){
						System.out.println("ThreadA"+(i+1));
					}
					nextThread=2;
					conditionB.signalAll();
				}catch(InterruptedException e){
					e.printStackTrace();
				}finally{
					lock.unlock();
				}
			}	
		};
		
		Thread threadB=new Thread(){
			@Override
			public void run() {
				try{
					lock.lock();
					while(nextThread !=2){
						conditionB.await();
					}
					for(int i=0;i<3;i++){
						System.out.println("ThreadB"+(i+1));
					}
					nextThread=3;
					conditionC.signalAll();
				}catch(InterruptedException e){
					e.printStackTrace();
				}finally{
					lock.unlock();
				}
			}	
		};
		
		Thread threadC=new Thread(){
			@Override
			public void run() {
				try{
					lock.lock();
					while(nextThread !=3){
						conditionC.await();
					}
					for(int i=0;i<3;i++){
						System.out.println("ThreadC"+(i+1));
					}
					nextThread=1;
					conditionA.signalAll();
				}catch(InterruptedException e){
					e.printStackTrace();
				}finally{
					lock.unlock();
				}
			}
		};
		Thread[] aArr=new Thread[2];
		Thread[] bArr=new Thread[2];
		Thread[] cArr=new Thread[2];
		for(int i=0;i<2;i++){
			aArr[i]=new Thread(threadA);
			bArr[i]=new Thread(threadB);
			cArr[i]=new Thread(threadC);
			aArr[i].start();
			bArr[i].start();
			cArr[i].start();
		}
	}
}
結果：

ThreadA1
ThreadA2
ThreadA3
ThreadB1
ThreadB2
ThreadB3
ThreadC1
ThreadC2
ThreadC3
ThreadA1
ThreadA2
ThreadA3
ThreadB1
ThreadB2
ThreadB3
ThreadC1
ThreadC2
ThreadC3

2.ReentrantReadWriteLock類的使用

ReentrantLock實現了互斥排他的效果了。意思就是同一時間只有一個執行緒在執行ReentrantLock.lock();方法。效率不高。JDK因此提供了一個ReentrantReadWriteLock類來提升效率。

搞讀寫鎖就關鍵這幾句話：讀操作的鎖叫共享鎖，寫操作的鎖叫排他鎖。就是遇見寫鎖就需互斥。那麼以此可得出讀讀共享，寫寫互斥，讀寫互斥，寫讀互斥。

   2.1讀讀共享

public class Service {
	private ReentrantReadWriteLock lock=new ReentrantReadWriteLock();
	public void read(){
		try{
			try{
				lock.readLock().lock();
				System.out.println("獲取讀鎖"+Thread.currentThread().getName()+", "+System.currentTimeMillis());
				Thread.sleep(10000);
			}finally{
				lock.readLock().unlock();
			}
		}catch(InterruptedException e){
			e.printStackTrace();
		}	
	}
}

public class ThreadA extends Thread{
    private Service service;
    public ThreadA(Service service) {
        super();
        this.service = service;
    }
    @Override
    public void run() {
        service.read();
    }
}

public class ThreadB extends Thread{
    private Service service;
    public ThreadB(Service service) {
        super();
        this.service = service;
    }
    @Override
    public void run() {
        service.read();
    }
}


public class Test {
    public static void main(String[] args) {
        Service service=new Service();
        ThreadA a=new ThreadA(service);
        a.setName("A");
        ThreadB b=new ThreadB(service);
        b.setName("B");
        a.start();
        b.start();
    }
}
結果：

獲取讀鎖A, 1474902942515
獲取讀鎖B, 1474902942515

解釋：由程式可以看出執行緒進行讀操作，是同時進入lock();的，不存在互斥，就更沒什麼同步了。這樣減少了等待的時間，提高的執行的效率。所以說是讀讀共享。

   2.2寫寫互斥

     service中提供的是寫方法，然後執行緒呼叫寫方法，其他的都和上面是一樣測試。

public void write(){
		try{
			try{
				lock.writeLock().lock();
				System.out.println("獲取寫鎖"+Thread.currentThread().getName()+", "+System.currentTimeMillis());
				Thread.sleep(10000);
			}finally{
				lock.writeLock().unlock();
			}
		}catch(InterruptedException e){
			e.printStackTrace();
		}
	}
結果：

獲取寫鎖A, 1474903347768
獲取寫鎖B, 1474903357769

解釋：通過程式結果可以看出來，執行緒A獲取寫鎖，然後執行程式碼睡眠10秒後，才釋放鎖。然後執行緒B才獲取鎖，然後睡眠10秒，釋放鎖。意思就是寫鎖同一時間只允許一個執行緒執行lock();方法後面的程式碼。體現了寫鎖是互斥的。

   2.3寫讀互斥

public class Service {
	private ReentrantReadWriteLock lock=new ReentrantReadWriteLock();
	public void read(){
		try{
			try{
				lock.readLock().lock();
				System.out.println("獲取讀鎖"+Thread.currentThread().getName()+", "+System.currentTimeMillis());
				Thread.sleep(10000);
			}finally{
				lock.readLock().unlock();
			}
		}catch(InterruptedException e){
			e.printStackTrace();
		}	
	}
	
	public void write(){
		try{
			try{
				lock.writeLock().lock();
				System.out.println("獲取寫鎖"+Thread.currentThread().getName()+", "+System.currentTimeMillis());
				Thread.sleep(10000);
			}finally{
				lock.writeLock().unlock();
			}
		}catch(InterruptedException e){
			e.printStackTrace();
		}
	}
}

public class ThreadA extends Thread{
    private Service service;
    public ThreadA(Service service) {
        super();
        this.service = service;
    }
    @Override
    public void run() {
        service.write();
    }
}

public class ThreadB extends Thread{
    private Service service;
    public ThreadB(Service service) {
        super();
        this.service = service;
    }
    @Override
    public void run() {
        service.read();
    }
}

public class Test {
    public static void main(String[] args) {
        Service service=new Service();
        ThreadA a=new ThreadA(service);
        a.setName("A");
        ThreadB b=new ThreadB(service);
        b.setName("B");
        a.start();
        b.start();
    }
} 
結果：

獲取寫鎖A, 1474903606138
獲取讀鎖B, 1474903616145

解釋：執行緒A先獲得寫鎖，然後睡眠10秒，釋放鎖。然後執行緒B才去獲得讀鎖，然後睡眠10秒，釋放鎖。可以看出來寫鎖的時候，讀鎖是不可獲取鎖的。所以說讀寫是互斥的。也證明了之前總結的，只要見到寫鎖就是互斥的。

   2.4讀寫互斥

     其他的都不變，就是先寫再讀，程式還是上面的。只是Test中先寫執行緒，然後再讀執行緒。

public class Test {
    public static void main(String[] args) throws InterruptedException {
        Service service=new Service();
        ThreadB b=new ThreadB(service);
        b.setName("B");
        b.start();
        Thread.sleep(1000);
        ThreadA a=new ThreadA(service);
        a.setName("A");
        a.start();
    }
}
結果：

獲取讀鎖B, 1474904025583
獲取寫鎖A, 1474904035586

解釋：從程式結果也看出來了讀寫也是互斥的。

相關推薦

java多執行緒之Lock類的使用

1.ReentrantLock類的使用    1.1ReentrantLock實現執行緒間同步 public class MyService { private Lock lock=new ReentrantLock(); public void service(){

java多執行緒之Lock--顯式鎖

Lock與Synchronized簡介 Synchornized相信大家用的已經比較熟悉了，這裡我就不介紹它的用法了 Synchronized被稱為同步鎖或者是隱式鎖，隱式鎖與顯式鎖區別在於，隱式鎖的獲取和釋放都需要出現在一個塊結構中，而且是有順序的，獲取鎖的順序和釋放鎖的順序必須相反，就是說，

Java多執行緒之 Lock介面和ReentrantLock的使用

                在多執行緒開發中，除了synchronized這個關鍵字外，我們還能通過Lock介面來實現這種效果。通過Lock介面來實現這種多執行緒加鎖效果的好處是非常的靈活，我們不在需要對整個函式加鎖，而且可以很方便的把他放在我們函式的任何一個地方，非常的稱心，而且從效率上來說，使用Loc

JAVA多執行緒之Lock的使用

來源：http://blog.csdn.net/huang_xw/article/details/7090177 package com.fei; import java.util.concurrent.ExecutorService; import java.util.c

java 多執行緒之利用Thread類建立執行緒（Day02）

前言：在一個程式中，如果一次只完成一件事情，很容易實現，但現實生活中很多事情都是同時進行的，所以在java中為了模擬這種狀態，引入了執行緒機制，簡單的說，當程式同時完成很多事情時，就是所謂的多執行緒。 實現執行緒的兩種方式：一是通過繼承Thread類來建立執行緒，另一種方法

java多執行緒之同步鎖（Lock）

      從Java5開始，提供了Lock， Lock提供了比synchronized方法和synchronized程式碼塊更廣泛的鎖定操作，Lock可以實現更靈活的結構，並且支援多個相關的Condition物件(物件監視器)。       Lock是控制多個執行緒對共享

Java多執行緒之併發工具類

一、總論：在JDK中提供了幾種併發工具類 1）CountDownLatch（同步倒數計數器：等待多執行緒（或者多步驟）完成） 2）CyclicBarrier（迴圈屏障：同步屏障） 3）Semaphore(訊號量：控制併發程序數) 主要參考資料

java多執行緒之synchronized與lock、wait與notify

class Res { public String name; public String sex; public Boolean flag = false; public Lock lock = new ReentrantLock(); Condition condition = lock.new

Java多執行緒同步工具類之CountDownLatch

在過去我們實現多執行緒同步的程式碼中，往往使用join()、wait()、notiyAll()等執行緒間通訊的方式，隨著JUC包的不斷的完善，java為我們提供了豐富同步工具類，官方也鼓勵我們使用工具類來實現多執行緒的同步，今天我們就對其中CountDownLatch類的使用與底層實現進行分析與總結。 一、

Java多執行緒同步工具類之CyclicBarrier

一、CyclicBarrier使用 CyclicBarrier從字面上可以直接理解為執行緒執行的屏障，它可以讓一組執行緒執行到一個共同的屏障點時被阻塞，直到最後一個執行緒執行到指定位置，你設定的執行執行緒就會觸發執行；同時CyclicBarrier相比與CountDownLatch，它是可以被重置的；下面我

Java多執行緒之原子操作類

在併發程式設計中很容易出現併發安全問題，最簡單的例子就是多執行緒更新變數i=1，多個執行緒執行i++操作，就有可能獲取不到正確的值，而這個問題，最常用的方法是通過Synchronized進行控制來達到執行緒安全的目的。但是由於synchronized是採用的是悲觀鎖策略，並不是特別高效的一種解決方案。實際上，

Java多執行緒之join()方法

概要 本章，會對Thread中join()方法進行介紹。涉及到的內容包括： 1. join()介紹 2. join()原始碼分析(基於JDK1.7.0_40) 3. join()示例 來源：http://www.cnblogs.com/skywang12345/p/34792

白話理解java多執行緒之join()方法

join字面意思是加入,我理解為插隊. 舉例:媽媽在炒菜,發現沒喲醬油了,讓兒子去打醬油,兒子打完醬油,媽媽炒完菜,全家一起吃 package cn.yh.thread01; /** * * 打醬油的例子 */ public class Demo03 { public stat

細說Java 多執行緒之記憶體可見性

前言： 討論學習Java中的記憶體可見性、Java記憶體模型、指令重排序、as-if-serial語義等多執行緒中偏向底層的一些知識，以及synchronized和volatile實現記憶體可見性的原理和方法。 1、可見性介紹 可見性：一個執行緒對共用變數值的修改，能夠及時地被其他執行緒

java多執行緒之 執行緒協作

也是網上看的一道題目：關於假如有Thread1、Thread2、Thread3、Thread4四條執行緒分別統計C、D、E、F四個盤的大小，所有執行緒都統計完畢交給Thread5執行緒去做彙總，應當如何實現？ 蒐集整理了網上朋友提供的方法，主要有： 1. 多執行緒都是Thread或

java多執行緒之鎖機制二

網上看到一個題目，題目是這樣：Java多執行緒，啟動四個執行緒，兩個執行加一，另外兩個執行減一。 針對該問題寫了一個程式，測試通過，如下： class Sync { static int count = 0; public void add() {

java多執行緒之鎖機制一

網上看了一篇關於java synchronized關鍵字使用的很好的文章，現將其簡要總結一下，加深理解。 先總結兩個規則： synchronized鎖住的是括號裡的物件，而不是程式碼。對於非static的synchronized方法，鎖的就是物件本身也就是this。 多個執行緒

java多執行緒之Phaser

java多執行緒技術提供了Phaser工具類，Phaser表示“階段器”，用來解決控制多個執行緒分階段共同完成任務的情景問題。其作用相比CountDownLatch和CyclicBarrier更加靈活，例如有這樣的一個題目：5個學生一起參加考試，一共有三道題，要求所有學生到齊才能開始考試，全部同學都

多執行緒之Lock與synchronized比較及使用

   第一：先比較兩者的區別： 類別 synchronized

Java多執行緒之——ThreadLocal

ThreadLocal是什麼：每一個ThreadLocal能夠放一個執行緒級別的變數，也就是說，每一個執行緒有獨自的變數，互不干擾。以此達到執行緒安全的目的，並且一定會安全。 實現原理： 要了解實現原理，我們先看set方法 public void set(T value) { T