Java中可以使用關鍵字synchronized進行線程同步控制，實現(xiàn)關鍵資源順序訪問，避免由于多線程并發(fā)執(zhí)行導致的數(shù)據(jù)不一致性等問題。synchronized的原理是對象監(jiān)視器（鎖），只有獲取到監(jiān)視器的線程才能繼續(xù)執(zhí)行，否則線程會等待獲取監(jiān)視器。Java中每個對象或者類都有一把鎖與之相關聯(lián)，對于對象來說，監(jiān)視的是這個對象的實例變量，對于類來說，監(jiān)視的是類變量（一個類本身是類Class的對象，所以與類關聯(lián)的鎖也是對象鎖）。synchronized關鍵字使用方式有兩種：synchronized方法和synchronized塊。這兩種監(jiān)視區(qū)域都和一個引入對象相關聯(lián)，當?shù)竭_這個監(jiān)視區(qū)域時，JVM就會鎖住這個引用對象，當離開時會釋放這個引用對象上的鎖（有異常退出時，JVM會釋放鎖）。對象鎖是JVM內部機制，只需要編寫同步方法或者同步塊即可，操作監(jiān)視區(qū)域時JVM會自動獲取鎖或者釋放鎖。
示例1
先來看第一個示例，在java中，同一個對象的臨界區(qū)，在同一時間只有一個允許被訪問（都是非靜態(tài)的synchronized方法）：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
package concurrency;public class Main8 { public static void main(String[] args) { Account account = new Account(); account.setBalance(1000); Company company = new Company(account); Thread companyThread = new Thread(company); Bank bank = new Bank(account); Thread bankThread = new Thread(bank); System.out.printf("Account : Initial Balance: %f\n", account.getBalance()); companyThread.start(); bankThread.start(); try { //join()方法等待這兩個線程運行完成 companyThread.join(); bankThread.join(); System.out.printf("Account : Final Balance: %f\n", account.getBalance()); } catch (InterruptedException e) { e.printStackTrace(); } }} |
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
|
/*帳戶*/class Account{ private double balance; /*將傳入的數(shù)據(jù)加到余額balance中*/ public synchronized void addAmount(double amount){ double tmp = balance; try { Thread.sleep(10); } catch (InterruptedException e) { e.printStackTrace(); } tmp += amount; balance = tmp; } /*將傳入的數(shù)據(jù)從余額balance中扣除*/ public synchronized void subtractAmount(double amount){ double tmp = balance; try { Thread.sleep(10); } catch (InterruptedException e) { e.printStackTrace(); } tmp -= amount; balance = tmp; } public double getBalance() { return balance; } public void setBalance(double balance) { this.balance = balance; }} |
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
/*銀行*/class Bank implements Runnable{ private Account account; public Bank(Account account){ this.account = account; } @Override public void run() { for (int i = 0; i < 100; i++) { account.subtractAmount(1000); } }} |
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
/*公司*/class Company implements Runnable{ private Account account; public Company(Account account){ this.account = account; } @Override public void run() { for (int i = 0; i < 100; i++) { account.addAmount(1000); } }} |
你已經(jīng)開發(fā)了一個銀行賬戶的模擬應用，它能夠對余額進行充值和扣除。這個程序通過調用100次addAmount()方法對帳戶進行充值，每次存入1000；然后通過調用100次subtractAmount()方法對帳戶余額進行扣除，每次扣除1000；我們期望帳戶的最終余額與起初余額相等，我們通過synchronized關鍵字實現(xiàn)了。
如果想查看共享數(shù)據(jù)的并發(fā)訪問問題，只需要將addAmount()和subtractAmount()方法聲明中的synchronized關鍵字刪除即可。在沒有synchronized關鍵字的情況下，打印出來的余額值并不一致。如果多次運行這個程序，你將獲取不同的結果。因為JVM并不保證線程的執(zhí)行順序，所以每次運行的時候，線程將以不同的順序讀取并且修改帳戶的余額，造成最終結果也是不一樣的。
一個對象的方法采用synchronized關鍵字進行聲明，只能被一個線程訪問。如果線程A正在執(zhí)行一個同步方法syncMethodA()，線程B要執(zhí)行這個對象的其他同步方法syncMethodB()，線程B將被阻塞直到線程A訪問完。但如果線程B訪問的是同一個類的不同對象，那么兩個線程都不會被阻塞。
示例2
演示同一個對象上的靜態(tài)synchronized方法與非靜態(tài)synchronized方法可以在同一時間點被多個線程訪問的問題，驗證一下。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
package concurrency;public class Main8 { public static void main(String[] args) { Account account = new Account(); account.setBalance(1000); Company company = new Company(account); Thread companyThread = new Thread(company); Bank bank = new Bank(account); Thread bankThread = new Thread(bank); System.out.printf("Account : Initial Balance: %f\n", account.getBalance()); companyThread.start(); bankThread.start(); try { //join()方法等待這兩個線程運行完成 companyThread.join(); bankThread.join(); System.out.printf("Account : Final Balance: %f\n", account.getBalance()); } catch (InterruptedException e) { e.printStackTrace(); } }} |
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
|
/*帳戶*/class Account{ /*這里改為靜態(tài)變量*/ private static double balance = 0; /*將傳入的數(shù)據(jù)加到余額balance中，注意是用static修飾過的*/ public static synchronized void addAmount(double amount){ double tmp = balance; try { Thread.sleep(10); } catch (InterruptedException e) { e.printStackTrace(); } tmp += amount; balance = tmp; } /*將傳入的數(shù)據(jù)從余額balance中扣除*/ public synchronized void subtractAmount(double amount){ double tmp = balance; try { Thread.sleep(10); } catch (InterruptedException e) { e.printStackTrace(); } tmp -= amount; balance = tmp; } public double getBalance() { return balance; } public void setBalance(double balance) { this.balance = balance; }} |
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
/*銀行*/class Bank implements Runnable{ private Account account; public Bank(Account account){ this.account = account; } @Override public void run() { for (int i = 0; i < 100; i++) { account.subtractAmount(1000); } }} |
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
/*公司*/class Company implements Runnable{ private Account account; public Company(Account account){ this.account = account; } @Override public void run() { for (int i = 0; i < 100; i++) { account.addAmount(1000); } }} |
我只是把上個例子中的，balance加了static關鍵字修改，addAmount()方法也可以static關鍵字修飾。執(zhí)行結果大家可以自己測試一下，每次執(zhí)行都是不一樣的結果！
一些總結：
- synchronized是通過軟件（JVM）實現(xiàn)的，簡單易用，即使在JDK5之后有了Lock，仍然被廣泛地使用。
- synchronized實際上是非公平的，新來的線程有可能立即獲得監(jiān)視器，而在等待區(qū)中等候已久的線程可能再次等待，不過這種搶占的方式可以預防饑餓。
- synchronized只有鎖只與一個條件（是否獲取鎖）相關聯(lián)，不靈活，后來Condition與Lock的結合解決了這個問題。
- 多線程競爭一個鎖時，其余未得到鎖的線程只能不停的嘗試獲得鎖，而不能中斷。高并發(fā)的情況下會導致性能下降。ReentrantLock的lockInterruptibly()方法可以優(yōu)先考慮響應中斷。 一個線程等待時間過長，它可以中斷自己，然后ReentrantLock響應這個中斷，不再讓這個線程繼續(xù)等待。有了這個機制，使用ReentrantLock時就不會像synchronized那樣產(chǎn)生死鎖了。
