synchronized是Java中的關鍵字，是一種同步鎖。它修飾的對象有以下幾種：

修飾一個代碼塊，被修飾的代碼塊稱為同步語句塊，其作用的范圍是大括號{}括起來的代碼，作用的對象是調用這個代碼塊的對象；

修飾一個方法，被修飾的方法稱為同步方法，其作用的范圍是整個方法，作用的對象是調用這個方法的對象；

修改一個靜態(tài)的方法，其作用的范圍是整個靜態(tài)方法，作用的對象是這個類的所有對象；

修改一個類，其作用的范圍是synchronized后面括號括起來的部分，作用主的對象是這個類的所有對象。
———————————————————————————————————————
修飾一個代碼塊
a、一個線程訪問一個對象中的synchronized(this)同步代碼塊時，其他試圖訪問該對象的線程將被阻塞.

/*** @author shuliangzhao* @Title: SyncThread* @ProjectName design-parent* @Description: TODO* @date 2019/6/17 23:25*/ public class SyncThread implements Runnable {private static int count;public SyncThread() {count = 0;}@Overridepublic void run() {synchronized (this) {try {for (int i = 0;i<5;i++) {System.out.println(Thread.currentThread().getName() + ":" + (count++));}Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}}}public static void main(String[] args) {SyncThread syncThread = new SyncThread();Thread thread = new Thread(syncThread,"Thread1");Thread thread1 = new Thread(syncThread,"Thread2");thread.start();thread1.start();} }

運行結果

Thread1:0 Thread1:1 Thread1:2 Thread1:3 Thread1:4 Thread2:5 Thread2:6 Thread2:7 Thread2:8 Thread2:9

當兩個并發(fā)線程(thread1和thread2)訪問同一個對象(syncThread)中的synchronized代碼塊時，在同一時刻只能有一個線程得到執(zhí)行，另一個線程受阻塞，必須等待當前線程執(zhí)行完這個代碼塊以后才能執(zhí)行該代碼塊。Thread1和thread2是互斥的，因為在執(zhí)行synchronized代碼塊時會鎖定當前的對象，只有執(zhí)行完該代碼塊才能釋放該對象鎖，下一個線程才能執(zhí)行并鎖定該對象。

把SyncThread的調用稍微改一下：

Thread thread = new Thread(new SyncThread(),"Thread1");Thread thread1 = new Thread(new SyncThread(),"Thread2");thread.start();thread1.start();

運行結果

Thread2:0 Thread1:0 Thread1:2 Thread1:3 Thread2:1 Thread2:5 Thread1:4 Thread2:6 Thread1:7 Thread2:8

這時相當于創(chuàng)建了兩個SyncThread的對象syncThread1和syncThread2，線程thread1執(zhí)行的是syncThread1對象中的synchronized代碼(run)，而線程thread2執(zhí)行的是syncThread2對象中的synchronized代碼(run)；我們知道synchronized鎖定的是對象，這時會有兩把鎖分別鎖定syncThread1對象和syncThread2對象，而這兩把鎖是互不干擾的，不形成互斥，所以兩個線程可以同時執(zhí)行。
b、當一個線程訪問對象的一個synchronized(this)同步代碼塊時，另一個線程仍然可以訪問該對象中的非synchronized(this)同步代碼塊

/*** @author shuliangzhao* @Title: SyncThread1* @ProjectName design-parent* @Description: TODO* @date 2019/6/17 23:53*/ public class CountThread implements Runnable{private static int count;public CountThread() {count = 0;}public void count() {synchronized(this) {for (int i = 0; i < 5; i ++) {try {System.out.println(Thread.currentThread().getName() + ":" + (count++));Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}}}}public void print() {for (int i = 0; i < 5; i ++) {try {System.out.println(Thread.currentThread().getName() + ":count:" + (count));Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}}}@Overridepublic void run() {String threadName = Thread.currentThread().getName();if (threadName.equals("A")) {count();} else if (threadName.equals("B")) {print();}}public static void main(String[] args) {CountThread countThread = new CountThread();Thread thread1 = new Thread(countThread, "A");Thread thread2 = new Thread(countThread, "B");thread1.start();thread2.start();} }

上面代碼中count是一個synchronized的，print是非synchronized的。從上面的結果中可以看出一個線程訪問一個對象的synchronized代碼塊時，別的線程可以訪問該對象的非synchronized代碼塊而不受阻塞。
c、指定要給某個對象加鎖

/*** @author shuliangzhao* @Title: Account* @ProjectName design-parent* @Description: TODO* @date 2019/6/18 0:04*/ public class Account {String name;float amount;public Account(String name, float amount) {this.name = name;this.amount = amount;}//存錢public void deposit(float amt) {amount += amt;try {Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}}//取錢public void withdraw(float amt) {amount -= amt;try {Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}}public float getBalance() {return amount;} }/*** 賬戶操作類*/ class AccountOperator implements Runnable{private Account account;public AccountOperator(Account account) {this.account = account;}public void run() {synchronized (account) {account.deposit(500);account.withdraw(500);System.out.println(Thread.currentThread().getName() + ":" + account.getBalance());}}public static void main(String[] args) {Account account = new Account("zhang san", 10000.0f);AccountOperator accountOperator = new AccountOperator(account);final int THREAD_NUM = 5;Thread threads[] = new Thread[THREAD_NUM];for (int i = 0; i < THREAD_NUM; i ++) {threads[i] = new Thread(accountOperator, "Thread" + i);threads[i].start();}} }

運行結果

Thread0:10000.0 Thread4:10000.0 Thread3:10000.0 Thread2:10000.0 Thread1:10000.0

在AccountOperator 類中的run方法里，我們用synchronized 給account對象加了鎖。這時，當一個線程訪問account對象時，其他試圖訪問account對象的線程將會阻塞，直到該線程訪問account對象結束。也就是說誰拿到那個鎖誰就可以運行它所控制的那段代碼。
當有一個明確的對象作為鎖時，就可以用類似下面這樣的方式寫程序。

public void method3(SomeObject obj) {//obj 鎖定的對象synchronized(obj){// todo} }

當沒有明確的對象作為鎖，只是想讓一段代碼同步時，可以創(chuàng)建一個特殊的對象來充當鎖

private byte[] lock = new byte[0]; // 特殊的instance變量public void method(){synchronized(lock) {// todo 同步代碼塊}}public void run() {}

說明：零長度的byte數(shù)組對象創(chuàng)建起來將比任何對象都經濟――查看編譯后的字節(jié)碼：生成零長度的byte[]對象只需3條操作碼，而Object lock = new Object()則需要7行操作碼。

修飾一個方法

Synchronized修飾一個方法很簡單，就是在方法的前面加synchronized，public synchronized void method(){//todo}; synchronized修飾方法和修飾一個代碼塊類似，只是作用范圍不一樣，修飾代碼塊是大括號括起來的范圍，而修飾方法范圍是整個函數(shù)。

public synchronized void run() {for (int i = 0; i < 5; i ++) {try {System.out.println(Thread.currentThread().getName() + ":" + (count++));Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}} }

Synchronized作用于整個方法的寫法。
寫法一：

public synchronized void method() {// todo }

寫法二：

public void method() {synchronized(this) {// todo} }

在用synchronized修飾方法時要注意以下幾點：

synchronized關鍵字不能繼承。
雖然可以使用synchronized來定義方法，但synchronized并不屬于方法定義的一部分，因此，synchronized關鍵字不能被繼承。如果在父類中的某個方法使用了synchronized關鍵字，而在子類中覆蓋了這個方法，在子類中的這個方法默認情況下并不是同步的，而必須顯式地在子類的這個方法中加上synchronized關鍵字才可以。當然，還可以在子類方法中調用父類中相應的方法，這樣雖然子類中的方法不是同步的，但子類調用了父類的同步方法，因此，子類的方法也就相當于同步了。這兩種方式的例子代碼如下：
在子類方法中加上synchronized關鍵字

class Parent {public synchronized void method() { } } class Child extends Parent {public synchronized void method() { } }

在子類方法中調用父類的同步方法

class Parent {public synchronized void method() { } } class Child extends Parent {public void method() { super.method(); } }

在定義接口方法時不能使用synchronized關鍵字。
構造方法不能使用synchronized關鍵字，但可以使用synchronized代碼塊來進行同步

修飾一個靜態(tài)的方法

我們知道靜態(tài)方法是屬于類的而不屬于對象的。同樣的，synchronized修飾的靜態(tài)方法鎖定的是這個類的所有對象，把SyncThread改造下：

/*** @author shuliangzhao* @Title: SyncThread* @ProjectName design-parent* @Description: TODO* @date 2019/6/17 23:25*/ public class SyncThread implements Runnable {private static int count;public SyncThread() {count = 0;}public static void testSync() {try {for (int i = 0;i<5;i++) {System.out.println(Thread.currentThread().getName() + ":" + (count++));}Thread.sleep(2000);} catch (InterruptedException e) {e.printStackTrace();}}@Overridepublic synchronized void run() {testSync();}public static void main(String[] args) {SyncThread syncThread = new SyncThread();Thread thread = new Thread(new SyncThread(),"Thread1");Thread thread1 = new Thread(new SyncThread(),"Thread2");thread.start();thread1.start();} }

運行結果

Thread1:0 Thread1:1 Thread1:2 Thread1:3 Thread1:4 Thread2:0 Thread2:5 Thread2:6 Thread2:7 Thread2:8

syncThread1和syncThread2是SyncThread的兩個對象，但在thread1和thread2并發(fā)執(zhí)行時卻保持了線程同步。這是因為run中調用了靜態(tài)方法method，而靜態(tài)方法是屬于類的，所以syncThread1和syncThread2相當于用了同一把鎖。

修飾一個類

用法

class ClassName {public void method() {synchronized(ClassName.class) {// todo}} } public class SyncThread implements Runnable {private static int count;public SyncThread() {count = 0;}public static void testSync() {synchronized (SyncThread.class) {try {for (int i = 0;i<5;i++) {System.out.println(Thread.currentThread().getName() + ":" + (count++));}Thread.sleep(2000);} catch (InterruptedException e) {e.printStackTrace();}}}@Overridepublic synchronized void run() {testSync();}public static void main(String[] args) {SyncThread syncThread = new SyncThread();Thread thread = new Thread(new SyncThread(),"Thread1");Thread thread1 = new Thread(new SyncThread(),"Thread2");thread.start();thread1.start();} }

運行結果

Thread1:0 Thread1:1 Thread1:2 Thread1:3 Thread1:4 Thread2:5 Thread2:6 Thread2:7 Thread2:8 Thread2:9

A. 無論synchronized關鍵字加在方法上還是對象上，如果它作用的對象是非靜態(tài)的，則它取得的鎖是對象；如果synchronized作用的對象是一個靜態(tài)方法或一個類，則它取得的鎖是對類，該類所有的對象同一把鎖。
B. 每個對象只有一個鎖（lock）與之相關聯(lián)，誰拿到這個鎖誰就可以運行它所控制的那段代碼。
C. 實現(xiàn)同步是要很大的系統(tǒng)開銷作為代價的，甚至可能造成死鎖，所以盡量避免無謂的同步控制。

總結

以上是生活随笔為你收集整理的Java线程之Synchronized用法的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。