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

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

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

如下實例，在沒有使用synchronized的情況下，多個線程訪問共享代碼區(qū)域時，可能會出現(xiàn)與預(yù)想中不同的結(jié)果。

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(); }}

可能會輸出如下結(jié)果：

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

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

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

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

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

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

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.同步方法，修飾靜態(tài)方法

鎖的對象是當前類的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.同步方法和同步代碼塊的區(qū)別

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

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

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

內(nèi)置鎖的可重入性

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

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

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

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

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方法}基于內(nèi)置鎖的等待和喚醒

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

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

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

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

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

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

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

public class Apple { //蘋果數(shù)量 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(); }}

/** * 生產(chǎn)者，買蘋果 */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(); }}

輸出結(jié)果：

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

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