synchronized在JDK5.0的早期版本中是重量級鎖，效率很低，但從JDK6.0開始，JDK在關鍵字synchronized上做了大量的優化，如偏向鎖、輕量級鎖等，使它的效率有了很大的提升。

synchronized的作用是實現線程間的同步，當多個線程都需要訪問共享代碼區域時，對共享代碼區域進行加鎖，使得每一次只能有一個線程訪問共享代碼區域，從而保證線程間的安全性。

因為沒有顯式的加鎖和解鎖過程，所以稱之為隱式鎖，也叫作內置鎖、監視器鎖。

如下實例，在沒有使用synchronized的情況下，多個線程訪問共享代碼區域時，可能會出現與預想中不同的結果。

public class Apple implements Runnable { private int appleCount = 5; @Override public void run() { eatApple(); } public void eatApple(){ appleCount--; System.out.println(Thread.currentThread().getName() + '吃了一個蘋果，還剩' + appleCount + '個蘋果'); } public static void main(String[] args) { Apple apple = new Apple(); Thread t1 = new Thread(apple, '小強'); Thread t2 = new Thread(apple, '小明'); Thread t3 = new Thread(apple, '小花'); Thread t4 = new Thread(apple, '小紅'); Thread t5 = new Thread(apple, '小黑'); t1.start(); t2.start(); t3.start(); t4.start(); t5.start(); }}

可能會輸出如下結果：

小強吃了一個蘋果，還剩3個蘋果小黑吃了一個蘋果，還剩3個蘋果小明吃了一個蘋果，還剩2個蘋果小花吃了一個蘋果，還剩1個蘋果小紅吃了一個蘋果，還剩0個蘋果

輸出結果異常的原因是eatApple方法里操作不是原子的，如當A線程完成appleCount的賦值，還沒有輸出，B線程獲取到appleCount的最新值，并完成賦值操作，然后A和B同時輸出。（A，B線程分別對應小黑、小強）

如果改下eatApple方法如下，還會不會有線程安全問題呢？

public void eatApple(){System.out.println(Thread.currentThread().getName() + '吃了一個蘋果，還剩' + --appleCount + '個蘋果');}

還是會有的，因為--appleCount不是原子操作，--appleCount可以用另外一種寫法表示：appleCount = appleCount - 1，還是有可能會出現以上的異常輸出結果。

synchronized分為同步方法和同步代碼塊兩種用法，當每個線程訪問同步方法或同步代碼塊區域時，首先需要獲得對象的鎖，搶到鎖的線程可以繼續執行，搶不到鎖的線程則阻塞，等待搶到鎖的線程執行完成后釋放鎖。

1.同步代碼塊

鎖的對象是object：

public class Apple implements Runnable { private int appleCount = 5; private Object object = new Object(); @Override public void run() { eatApple(); } public void eatApple(){//同步代碼塊，此時鎖的對象是object synchronized (object) { appleCount--; System.out.println(Thread.currentThread().getName() + '吃了一個蘋果，還剩' + appleCount + '個蘋果'); } } //...省略main方法}

2.同步方法，修飾普通方法

鎖的對象是當前類的實例對象：

public class Apple implements Runnable { private int appleCount = 5; @Override public void run() { eatApple(); } public synchronized void eatApple() { appleCount--; System.out.println(Thread.currentThread().getName() + '吃了一個蘋果，還剩' + appleCount + '個蘋果'); } //...省略main方法}

等價于以下同步代碼塊的寫法：

public void eatApple() {synchronized (this) {appleCount--;System.out.println(Thread.currentThread().getName() + '吃了一個蘋果，還剩' + appleCount + '個蘋果');}}

3.同步方法，修飾靜態方法

鎖的對象是當前類的class對象：

public class Apple implements Runnable { private static int appleCount = 5; @Override public void run() { eatApple(); } public synchronized static void eatApple() { appleCount--; System.out.println(Thread.currentThread().getName() + '吃了一個蘋果，還剩' + appleCount + '個蘋果'); } //...省略main方法}

等價于以下同步代碼塊的寫法：

public static void eatApple() {synchronized (Apple.class) {appleCount--;System.out.println(Thread.currentThread().getName() + '吃了一個蘋果，還剩' + appleCount + '個蘋果');}}

4.同步方法和同步代碼塊的區別

a.同步方法鎖的對象是當前類的實例對象或者當前類的class對象，而同步代碼塊鎖的對象可以是任意對象。

b.同步方法是使用synchronized修飾方法，而同步代碼塊是使用synchronized修飾共享代碼區域。同步代碼塊相對于同步方法來說粒度更細，鎖的區域更小，一般鎖范圍越小效率就越高。如下情況顯然同步代碼塊更適用：

public static void eatApple() {//不需要同步的耗時操作1//...synchronized (Apple.class) {appleCount--;System.out.println(Thread.currentThread().getName() + '吃了一個蘋果，還剩' + appleCount + '個蘋果');}//不需要同步的耗時操作2//...}

內置鎖的可重入性

內置鎖的可重入性是指當某個線程試圖獲取一個它已經持有的鎖時，它總是可以獲取成功。如下：

public static void eatApple() {synchronized (Apple.class) {synchronized (Apple.class) {synchronized (Apple.class) {appleCount--;System.out.println(Thread.currentThread().getName() + '吃了一個蘋果，還剩' + appleCount + '個蘋果');}}}}

如果鎖不是可重入的，那么假如某線程持有了該鎖，然后又需要等待持有該鎖的線程釋放鎖，這不就造成死鎖了嗎？

synchronized不可以被繼承，如果子類中重寫后的方法需要實現同步，則需要手動添加synchronized關鍵字。

public class AppleParent { public synchronized void eatApple(){ }}public class Apple extends AppleParent implements Runnable { private int appleCount = 5; @Override public void run() { eatApple(); } @Override public void eatApple() { appleCount--; System.out.println(Thread.currentThread().getName() + '吃了一個蘋果，還剩' + appleCount + '個蘋果'); } //...省略main方法}基于內置鎖的等待和喚醒

基于內置鎖的等待和喚醒是使用Object類中的wait()和notify()或notifyAll()來實現的。這些方法的調用前提是已經持有對應的鎖，所以只能在同步方法或者同步代碼塊里調用。如果在沒有獲取到對應鎖的情況下調用則會拋出IllegalMonitorStateException異常。下面介紹下相關的幾個方法：

wait()：使當前線程無限期地等待，直到另一個線程調用notify()或notifyAll()。

wait(long timeout)：指定一個超時時間，超時時間過后線程將會被自動喚醒。線程也可以在超時時間之前被notify()或notifyAll()喚醒。注意，wait(0)等同于調用wait()。

wait(long timeout, int nanos)：類似于wait(long timeout)，主要區別是wait(long timeout, int nanos)提供了更高的精度。

notify()：隨機喚醒一個在相同鎖對象上等待的線程。

notifyAll()：喚醒所有在相同鎖對象上等待的線程。

一個簡單的等待喚醒實例：

public class Apple { //蘋果數量 private int appleCount = 0; /** * 買蘋果 */ public synchronized void getApple() { try { while (appleCount != 0) { wait(); } } catch (InterruptedException ex) { ex.printStackTrace(); } System.out.println(Thread.currentThread().getName() + '買了5個蘋果'); appleCount = 5; notify(); } /** * 吃蘋果 */ public synchronized void eatApple() { try { while (appleCount == 0) { wait(); } } catch (InterruptedException ex) { ex.printStackTrace(); } System.out.println(Thread.currentThread().getName() + '吃了1個蘋果'); appleCount--; notify(); }}

/** * 生產者，買蘋果 */public class Producer extends Thread{ private Apple apple; public Producer(Apple apple, String name){ super(name); this.apple = apple; } @Override public void run(){ while (true) apple.getApple(); }}/** * 消費者，吃蘋果 */public class Consumer extends Thread{ private Apple apple; public Consumer(Apple apple, String name){ super(name); this.apple = apple; } @Override public void run(){ while (true) apple.eatApple(); }}

public class Demo { public static void main(String[] args) { Apple apple = new Apple(); Producer producer = new Producer(apple,'小明'); Consumer consumer = new Consumer(apple, '小紅'); producer.start(); consumer.start(); }}

輸出結果：

小明買了5個蘋果小紅吃了1個蘋果小紅吃了1個蘋果小紅吃了1個蘋果小紅吃了1個蘋果小紅吃了1個蘋果小明買了5個蘋果小紅吃了1個蘋果 ......

到此這篇關于Java并發編程之內置鎖(synchronized)的文章就介紹到這了,更多相關Java內置鎖內容請搜索好吧啦網以前的文章或繼續瀏覽下面的相關文章希望大家以后多多支持好吧啦網！