深入探究Java多線程并發(fā)編程的要點
關(guān)鍵字synchronized
synchronized關(guān)鍵可以修飾函數(shù)、函數(shù)內(nèi)語句。無論它加上方法還是對象上，它取得的鎖都是對象，而不是把一段代碼或是函數(shù)當(dāng)作鎖。
1，當(dāng)兩個并發(fā)線程訪問同一個對象object中的這個synchronized(this)同步代碼塊時，一段時間只能有一個線程得到執(zhí)行，而另一個線程只有等當(dāng)前線程執(zhí)行完以后才能執(zhí)行這塊代碼。
2，當(dāng)一個線程訪問object中的一個synchronized(this)同步代碼塊時，其它線程仍可以訪問這個object中是其它非synchronized (this)代碼塊。
3，這里需要注意的是，當(dāng)一個線程訪問object的一個synchronized(this)代碼塊時，其它線程對這個object中其它synchronized (this)同步代碼塊的訪問將被阻塞。
4，以上所述也適用于其它的同步代碼塊，也就是說，當(dāng)一個線程訪問object的一個synchronized(this)同步代碼塊時，這個線程就獲得了object的對象鎖。而且每個對象（即類實例）對應(yīng)著一把鎖，每個synchronized(this)都必須獲得調(diào)用該代碼塊兒（可以函數(shù)，也可以是變量）的對象的鎖才能執(zhí)行，否則所屬線程阻塞，方法一旦執(zhí)行就會獨占該鎖，直到從方法返回時，也釋放這個鎖，重新進(jìn)入可執(zhí)行狀態(tài)。這種機(jī)制確保了同一時刻對于每一個對象，其所有聲明為synchronized的成員函數(shù)中至多只有一個處于可執(zhí)行狀態(tài)（因為至多只有一個線程可以獲取該對象的鎖），從而避免了類成員變量的訪問沖突。
synchronized方式的缺點：
由于synchronized鎖定的是調(diào)用這個同步方法的對象，也就是說，當(dāng)一個線程P1在不同的線程中執(zhí)行這個方法時，它們之間會形成互斥，從而達(dá)到同步的效果。但這里需要注意的是，這個對象所性的Class的另一個對象卻可以任意調(diào)用這個被加了synchronized關(guān)鍵字的方法。同步方法的實質(zhì)是將synchronized作用于object reference，對于拿到了P1對象鎖的線程才可以調(diào)用這個synchronized方法，而對于P2來說，P1與它毫不相干，程序也可能在這種情況下擺脫同步機(jī)制的控制，造成數(shù)據(jù)混亂。以下我們將對這種情況進(jìn)行詳細(xì)地說明：
首先我們先介紹synchronized關(guān)鍵字的兩種加鎖對象：對象和類——synchronized可以為資源加對象鎖或是類鎖，類鎖對這個類的所有對象（實例）均起作用，而對象鎖只是針對該類的一個指定的對象加鎖，這個類的其它對象仍然可以使用已經(jīng)對前一個對象加鎖的synchronized方法。
在這里我們主要討論的一個問題就是：“同一個類，不同實例調(diào)用同一個方法，會產(chǎn)生同步問題嗎？”
同步問題只和資源有關(guān)系，要看這個資源是不是靜態(tài)的。同一個靜態(tài)數(shù)據(jù)，你相同函數(shù)分屬不同線程同時對其進(jìn)行讀寫，CPU也不會產(chǎn)生錯誤，它會保證你代碼的執(zhí)行邏輯，而這個邏輯是否是你想要的，那就要看你需要什么樣的同步了。即便你兩個不同的代碼，在CPU的不同的兩個core里跑，同時寫一個內(nèi)存地址，Cache機(jī)制也會在L2里先鎖定一個。然后更新，再share給另一個core，也不會出錯，不然intel，amd就白養(yǎng)那么多人了。
因此，只要你沒有兩個代碼共享的同一個資源或變量，就不會出現(xiàn)數(shù)據(jù)不一致的情況。而且同一個類的不同對象的調(diào)用有完全不同的堆棧，它們之間完全不相干。
以下我們以一個售票過程舉例說明，在這里，我們的共享資源就是票的剩余張數(shù)。
package com.test;
public class ThreadSafeTest extends Thread implements Runnable {
private static int num = 1;
public ThreadSafeTest(String name) {
setName(name);
}
public void run() {
sell(getName());
}
private synchronized void sell(String name){
if (num > 0) {
System. out.println(name + ": 檢測票數(shù)大于0" );
System. out.println(name + ": \t正在收款（大約5秒完成）。。。" );
try {
Thread. sleep(5000);
System. out.println(name + ": \t打印票據(jù)，售票完成" );
num--;
printNumInfo();
} catch (InterruptedException e) {
e.printStackTrace();
}
} else {
System. out.println(name+": 沒有票了，停止售票" );
}
}
private static void printNumInfo() {
System. out.println("系統(tǒng)：當(dāng)前票數(shù)：" + num);
if (num < 0) {
System. out.println("警告：票數(shù)低于0，出現(xiàn)負(fù)數(shù)" );
}
}
public static void main(String args[]) {
try {
new ThreadSafeTest("售票員李XX" ).start();
Thread. sleep(2000);
new ThreadSafeTest("售票員王X" ).start();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
運行上述代碼，我們得到的輸出是：
售票員李XX: 檢測票數(shù)大于0 售票員李XX: 正在收款（大約5秒完成）。。。 售票員王X: 檢測票數(shù)大于0 售票員王X: 正在收款（大約5秒完成）。。。 售票員李XX: 打印票據(jù)，售票完成 系統(tǒng)：當(dāng)前票數(shù)：0 售票員王X: 打印票據(jù)，售票完成 系統(tǒng)：當(dāng)前票數(shù)：-1 警告：票數(shù)低于0，出現(xiàn)負(fù)數(shù)
根據(jù)輸出結(jié)果，我們可以發(fā)現(xiàn)，剩余票數(shù)為-1，出現(xiàn)了同步錯誤的問題。之所以出現(xiàn)這種情況的原因是，我們建立的兩個實例對象，對共享的靜態(tài)資源static int num = 1同時進(jìn)行了修改。那么我們將上面代碼中方框內(nèi)的修飾詞static去掉，然后再運行程序，可以得到：
售票員李XX: 檢測票數(shù)大于0 售票員李XX: 正在收款（大約5秒完成）。。。 售票員王X: 檢測票數(shù)大于0 售票員王X: 正在收款（大約5秒完成）。。。 售票員李XX: 打印票據(jù)，售票完成 系統(tǒng)：當(dāng)前票數(shù)：0 售票員王X: 打印票據(jù)，售票完成 系統(tǒng)：當(dāng)前票數(shù)：0
對程度修改之后，程序運行貌似沒有問題了，每個對象擁有各自不同的堆棧，分別獨立運行。但這樣卻違背了我們希望多線程同時對共享資源的處理（去static后，num就從共享資源變成了每個實例各自擁有的成員變量），這顯然不是我們想要的。
在以上兩種代碼中，采取的主要是對對象的鎖定。由于我之前談到的原因，當(dāng)一個類的兩個不同的實例對同一共享資源進(jìn)行修改時，CPU為了保證程序的邏輯會默認(rèn)這種做法，至于是不是想要的結(jié)果，這個只能由程序員自己來決定。因此，我們需要改變鎖的作用范圍，若作用對象只是實例，那么這種問題是無法避免的；只有當(dāng)鎖的作用范圍是整個類的時候，才可能排除同一個類的不同實例對共享資源同時修改的問題。
package com.test;
public class ThreadSafeTest extends Thread implements Runnable {
private static int num = 1;
public ThreadSafeTest(String name) {
setName(name);
}
public void run() {
sell(getName());
}
private synchronized static void sell(String name){
if (num > 0) {
System. out.println(name + ": 檢測票數(shù)大于0" );
System. out.println(name + ": \t正在收款（大約5秒完成）。。。" );
try {
Thread. sleep(5000);
System. out.println(name + ": \t打印票據(jù)，售票完成" );
num--;
printNumInfo();
} catch (InterruptedException e) {
e.printStackTrace();
}
} else {
System. out.println(name+": 沒有票了，停止售票" );
}
}
private static void printNumInfo() {
System. out.println("系統(tǒng)：當(dāng)前票數(shù)：" + num);
if (num < 0) {
System. out.println("警告：票數(shù)低于0，出現(xiàn)負(fù)數(shù)" );
}
}
public static void main(String args[]) {
try {
new ThreadSafeTest("售票員李XX" ).start();
Thread. sleep(2000);
new ThreadSafeTest("售票員王X" ).start();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
將程序做如上修改，可以得到運行結(jié)果：
售票員李XX: 檢測票數(shù)大于0 售票員李XX: 正在收款（大約5秒完成）。。。 售票員李XX: 打印票據(jù)，售票完成 系統(tǒng)：當(dāng)前票數(shù)：0 售票員王X: 沒有票了，停止售票
對sell()方法加上了static修飾符，這樣就將鎖的作用對象變成了類，當(dāng)該類的一個實例對共享變量進(jìn)行操作時將會阻塞這個類的其它實例對其的操作。從而得到我們?nèi)缙谙胍慕Y(jié)果。
總結(jié)：
1，synchronized關(guān)鍵字有兩種用法：synchronized方法和synchronized塊。
2，在Java中不單是類實例，每一個類也可以對應(yīng)一把鎖
在使用synchronized關(guān)鍵字時，有以下幾點兒需要注意：
1，synchronized關(guān)鍵字不能被繼承。雖然可以用synchronized來定義方法，但是synchronized卻并不屬于方法定義的一部分，所以synchronized關(guān)鍵字并不能被繼承。如果父類中的某個方法使用了synchronized關(guān)鍵字，而子類中也覆蓋了這個方法，默認(rèn)情況下子類中的這個方法并不是同步的，必須顯示的在子類的這個方法中加上synchronized關(guān)鍵字才可。當(dāng)然，也可以在子類中調(diào)用父類中相應(yīng)的方法，這樣雖然子類中的方法并不是同步的，但子類調(diào)用了父類中的同步方法，也就相當(dāng)子類方法也同步了。如，
在子類中加synchronized關(guān)鍵字：
class Parent {
public synchronized void method() { }
}
class Child extends Parent {
public synchronized void method () { }
}
調(diào)用父類方法：
class Parent {
public synchronized void method() { }
}
class Child extends Parent {
public void method() { super.method(); }
}
2，在接口方法定義時不能使用synchronized關(guān)鍵字。
3，構(gòu)造方法不能使用synchronized關(guān)鍵字，但可以使用synchronized塊來進(jìn)行同步。
4，synchronized位置可以自由放置，但是不能放置在方法的返回類型后面。
5，synchronized關(guān)鍵字不可以用來同步變量，如下面代碼是錯誤的：
public synchronized int n = 0; public static synchronized int n = 0;
6，雖然使用synchronized關(guān)鍵字是最安全的同步方法，但若是大量使用也會造成不必要的資源消耗以及性能損失。從表面上看synchronized鎖定的是一個方法，但實際上鎖定的卻是一個類，比如，對于兩個非靜態(tài)方法method1()和method2()都使用了synchronized關(guān)鍵字，在執(zhí)行其中的一個方法時，另一個方法是不能執(zhí)行的。靜態(tài)方法和非靜態(tài)方法情況類似。但是靜態(tài)方法和非靜態(tài)方法之間不會相互影響，見如下代碼：
public class MyThread1 extends Thread {
public String methodName ;
public static void method(String s) {
System. out .println(s);
while (true );
}
public synchronized void method1() {
method( "非靜態(tài)的method1方法" );
}
public synchronized void method2() {
method( "非靜態(tài)的method2方法" );
}
public static synchronized void method3() {
method( "靜態(tài)的method3方法" );
}
public static synchronized void method4() {
method( "靜態(tài)的method4方法" );
}
public void run() {
try {
getClass().getMethod( methodName ).invoke( this);
}
catch (Exception e) {
}
}
public static void main(String[] args) throws Exception {
MyThread1 myThread1 = new MyThread1();
for (int i = 1; i <= 4; i++) {
myThread1. methodName = "method" + String.valueOf (i);
new Thread(myThread1).start();
sleep(100);
}
}
}
運行結(jié)果為：
非靜態(tài)的method1方法 靜態(tài)的method3方法
從上面的運行結(jié)果可以看出，method2和method4在method1和method3運行完之前是不會運行的。因此，可以得出一個結(jié)論，如查在類中使用synchronized來定義非靜態(tài)方法，那么將影響這個類中的所有synchronized定義的非靜態(tài)方法；如果定義的靜態(tài)方法，那么將影響這個類中所有以synchronized定義的靜態(tài)方法。這有點兒像數(shù)據(jù)表中的表鎖，當(dāng)修改一條記錄時，系統(tǒng)就將整個表都鎖住了。因此，大量使用這種同步方法會使程序的性能大幅度地下降。
對共享資源的同步訪問更加安全的技巧：
1，定義private的instance變量+它的get方法，而不要定義public/protected的instance變量。如果將變量定義為public，對象可以在外界繞過同步方法的控制而直接取得它，并且改動它。這也是JavaBean的標(biāo)準(zhǔn)實現(xiàn)之一。
2，如果instance變量是一個對象，如數(shù)組或ArrayList等，那上述方法仍然不安全，因為當(dāng)外界通過get方法拿到這個instance對象的引用后，又將其指向另一個對象，那么這個private變量也就變了，豈不是很危險。這個時候就需要將get方法也加上synchronized同步，并且只返回這個private對象的clone()。這樣，調(diào)用端得到的就只是對象副本的一個引用了。
wait()與notify()獲取對象監(jiān)視器(鎖)的三種方式
在某個線程方法中對wait()和notify()的調(diào)用必須指定一個Object對象，而且該線程必須擁有該Object對象的monitor。而獲取對象monitor最簡單的辦法就是，在對象上使用synchronized關(guān)鍵字。當(dāng)調(diào)用wait()方法以后，該線程會釋放掉對象鎖，并進(jìn)入sleep狀態(tài)。而在其它線程調(diào)用notify()方法時，必須使用同一個Object對象，notify()方法調(diào)用成功后，所在這個對象上的相應(yīng)的等侍線程將被喚醒。
對于被一個對象鎖定的多個方法，在調(diào)用notify()方法時將會任選其中一個進(jìn)行喚醒，而notifyAll()則是將其所有等待線程喚醒。
package net.mindview.util;
import javax.swing.JFrame;
public class WaitAndNotify {
public static void main(String[] args) {
System. out.println("Hello World!" );
WaitAndNotifyJFrame frame = new WaitAndNotifyJFrame();
frame.setDefaultCloseOperation(JFrame. EXIT_ON_CLOSE);
// frame.show();
frame.setVisible( true);
}
}
@SuppressWarnings("serial" )
class WaitAndNotifyJFrame extends JFrame {
private WaitAndNotifyThread t ;
public WaitAndNotifyJFrame() {
setSize(300, 100);
setLocation(250, 250);
JPanel panel = new JPanel();
JButton start = new JButton(new AbstractAction("Start") {
public void actionPerformed(ActionEvent event) {
if (t == null) {
t = new WaitAndNotifyThread(WaitAndNotifyJFrame.this);
t.start();
} else if (t .isWait ) {
t. isWait = false ;
t.n();
// t.notify();
}
}
});
panel.add(start);
JButton pause = new JButton(new AbstractAction("Pause") {
public void actionPerformed(ActionEvent e) {
if (t != null) {
t. isWait = true ;
}
}
});
panel.add(pause);
JButton end = new JButton(new AbstractAction("End") {
public void actionPerformed(ActionEvent e) {
if (t != null) {
t.interrupt();
t = null;
}
}
});
panel.add(end);
getContentPane().add(panel);
}
}
@SuppressWarnings("unused" )
class WaitAndNotifyThread extends Thread {
public boolean isWait ;
private WaitAndNotifyJFrame control ;
private int count ;
public WaitAndNotifyThread(WaitAndNotifyJFrame f) {
control = f;
isWait = false ;
count = 0;
}
public void run() {
try {
while (true ) {
synchronized (this ) {
System. out.println("Count:" + count++);
sleep(100);
if (isWait )
wait();
}
}
} catch (Exception e) {
}
}
public void n() {
synchronized (this ) {
notify();
}
}
}
如上面例子方框中的代碼，若去掉同步代碼塊，執(zhí)行就會拋出java.lang.IllegalMonitorStateException異常。
查看JDK，我們可以看到，出現(xiàn)此異常的原因是當(dāng)前線程不是此對象監(jiān)視器的所有者。
此方法只應(yīng)由作為此對象監(jiān)視器的所有者的線程來調(diào)用，通過以下三種方法之一，可以使線程成為此對象監(jiān)視器的所有者：
1，通過執(zhí)行此對象的同步實例方法，如：
public synchronized void n() {
notify();
}
2，通過執(zhí)行在此對象上進(jìn)行同步的synchronized語句的正文，如：
public void n() {
synchronized (this ) {
notify();
}
}
3，對于Class類型的對象，可以通過執(zhí)行該類的同步靜態(tài)方法。
在調(diào)用靜態(tài)方法時，我們并不一定創(chuàng)建一個實例對象。因此，就不能使用this來同步靜態(tài)方法，所以必須使用Class對象來同步靜態(tài)方法，由于notify()方法不是靜態(tài)方法，所以我們無法將n()方法設(shè)置成靜態(tài)方法，所以采用另外一個例子加以說明：
public class SynchronizedStatic implements Runnable {
private static boolean flag = true;
//類對象同步方法一：
// 注意static修飾的同步方法，監(jiān)視器：SynchronizedStatic.class
private static synchronized void testSyncMethod() {
for (int i = 0; i < 100; i++) {
try {
Thread. sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System. out.println("testSyncMethod:" + i);
}
}
//類對象同步方法二：
private void testSyncBlock() {
// 顯示使用獲取class做為監(jiān)視器．它與static synchronized method隱式獲取class監(jiān)視器一樣．
synchronized (SynchronizedStatic. class) {
for (int i = 0; i < 100; i++) {
try {
Thread. sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System. out.println("testSyncBlock:" + i);
}
}
}
public void run() {
// flag是static的變量．所以，不同的線程會執(zhí)行不同的方法,只有這樣才能看到不同的鎖定效果．
if (flag ) {
flag = false ;
testSyncMethod();
} else {
flag = true ;
testSyncBlock();
}
}
public static void main(String[] args) {
ExecutorService exec = Executors. newFixedThreadPool(2);
SynchronizedStatic rt = new SynchronizedStatic();
SynchronizedStatic rt1 = new SynchronizedStatic();
exec.execute(rt);
exec.execute(rt1);
exec.shutdown();
}
}
以上代碼的運行結(jié)果是，讓兩個同步方法同時打印從0到99這100個數(shù)，其中方法一是一個靜態(tài)同步方法，它的作用域為類；方法二顯示的聲明了代碼塊的作用域是類。這兩個方法的異曲同工的。由于方法一和方法二的作用域同為類，所以它們兩個方法間是互斥的，也就是說，當(dāng)一個線程調(diào)用了這兩個方法中的一個，剩余沒有調(diào)用的方法也會對其它線程形成阻塞。因此，程序的運行結(jié)果會是：
testSyncMethod:0 testSyncMethod:1 ... ... testSyncMethod:99 testSyncBlock:0 ... ... testSyncBlock:99
但是，如果我們將方法二中的SynchronizedStatic. class替換成this的話，由于作用域的沒，這兩個方法就不會形成互斥，程序的輸出結(jié)果也會交替進(jìn)行，如下所示：
testSyncBlock:0 testSyncMethod:0 testSyncBlock:1 testSyncMethod:1 ... ... testSyncMethod:99 testSyncBlock:99
鎖(lock)的作用域有兩種，一種是類的對象，另一種的類本身。在以上代碼中給出了兩種使鎖的作用范圍為類的方法，這樣就可以使同一個類的不同對象之間也能完成同步。
總結(jié)以上，需要注意的有以下幾點：
1，wait()、notify()、notifyAll()都需要在擁有對象監(jiān)視器的前提下執(zhí)行，否則就會拋出java.lang.IllegalMonitorStateException異常。
2，多個線程可以同時在一個對象上等待。
3，notify()是隨機(jī)喚醒一個在對象上等待的線程，若沒有等待的線程，則什么也不做。
4，notify()喚醒的線程，并不是在notify()執(zhí)行以后就立即喚醒，而是在notify()線程釋放了對象監(jiān)視器之后才真正執(zhí)行被喚醒的線程。
5，Object的這些方法與Thread的sleep、interrupt方法相差還是很遠(yuǎn)的，不要混為一談。
相關(guān)文章
Java后臺批量生產(chǎn)echarts圖表并保存圖片
這篇文章主要介紹了Java后臺批量生產(chǎn)echarts圖表并保存圖片,文中通過示例代碼介紹的非常詳細(xì)，對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價值,需要的朋友可以參考下2020-05-05
這篇文章主要介紹了Java基礎(chǔ)之Filter的實例詳解的相關(guān)資料,需要的朋友可以參考下2017-07-07
這篇文章主要介紹了對Netty組件的基本介紹,Netty是基于Java NIO client-server的網(wǎng)絡(luò)應(yīng)用框架，使用Netty可以快速開發(fā)網(wǎng)絡(luò)應(yīng)用,本文涵蓋了netty開發(fā)中主要的組件的介紹,需要的朋友可以參考下2021-06-06
MyBatis代碼自動生成器Mybatis-Generator的使用詳解
本文詳細(xì)介紹如何在SpringBoot項目中使用MyBatis-Generator進(jìn)行代碼生成,包括配置文件的添加、POM依賴配置、運行配置等步驟,通過自動生成代碼,可以簡化MyBatis的繁瑣配置和SQL編寫,提高開發(fā)效率,注意要考慮MySQL版本兼容性,以及確保路徑配置正確2024-10-10
Java中線程組ThreadGroup與線程池的區(qū)別及示例
這篇文章主要介紹了Java中線程組與線程池的區(qū)別及示例,ThreadGroup是用來管理一組線程的，可以控制線程的執(zhí)行，查看線程的執(zhí)行狀態(tài)等操作，方便對于一組線程的統(tǒng)一管理,需要的朋友可以參考下2023-05-05
Day14基礎(chǔ)不牢地動山搖-Java基礎(chǔ)
這篇文章主要給大家介紹了關(guān)于Java中方法使用的相關(guān)資料,文中通過示例代碼介紹的非常詳細(xì),對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價值,需要的朋友們下面隨著小編來一起學(xué)習(xí)學(xué)習(xí)吧2021-08-08
這篇文章主要介紹了ActiveMQ整合Spring入門用法解析,文中通過示例代碼介紹的非常詳細(xì)，對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價值,需要的朋友可以參考下2020-10-10
這篇文章主要介紹了基于ComponentScan注解的掃描范圍及源碼解析,具有很好的參考價值,希望對大家有所幫助,如有錯誤或未考慮完全的地方,望不吝賜教2023-09-09
使用Mybatis的Batch?Insert?Support?實現(xiàn)批量插入
這篇文章主要介紹了使用Mybatis的Batch?Insert?Support?實現(xiàn)批量插入。具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教2022-07-07
SpringBoot實現(xiàn)監(jiān)控Actuator,關(guān)閉redis監(jiān)測
這篇文章主要介紹了SpringBoot實現(xiàn)監(jiān)控Actuator,關(guān)閉redis監(jiān)測，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教2021-11-11