|-目錄
|??同步鎖
??-|同步鎖使用范圍
??-|對象鎖與靜態(tài)鎖
??-|死鎖
|??volatile實現’內存共享’
-synchronized同步鎖
?1.同步鎖使用范圍
??同步鎖使用場景：多個線程對同一個對象中的實例變量進行并發(fā)訪問拓挥。
??方法體中聲明的局部變量不需要同步處理写烤。
public class ThreadPrivateNumDemo {
public static void main(String[] args) {
final PrintPrivateNum privateNum = new PrintPrivateNum();
Thread thread_1 = new Thread("thread_1") {
public void run() {
privateNum.printNum(Thread.currentThread().getName());
};
};
Thread thread_2 = new Thread("thread_2") {
@Override
public void run() {
privateNum.printNum(Thread.currentThread().getName());
}
};
thread_1.start();
thread_2.start();
}
}
class PrintPrivateNum {
public void printNum(String name) {
int num = 0; // 局部變量不需要同步鎖
if ("thread_1".equals(name)) {
num += 300;
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
if ("thread_2".equals(name)) {
num -= 100;
}
System.out.println(Thread.currentThread().getName() + ",Num:" + num);
}
}
圖1-1 同步鎖[安全的局部變量]
??從【圖 1-1】可以驗證
安全的局部變量這句話帆疟，兩個線程同時操作num變量份氧，結果都是正常的。
class PrintPrivateNum {
private int num = 0; // 全局變量需要同步
圖1-2 同步鎖[實例變量]
??將num局部變量改為全局變量刷袍，可以看出結果與想要的不太一樣，我們想要的結果或許是thread_2,Num:300 thread_1,Num:200或thread_1,Num:-100 thread_2,Num:200,不會是【圖1-2】中的結果，【圖1-2】結果產生的原因是：thread_2修改Num=300后sleep酌伊，此時thread_1也同時進來修改了Num= 300 -100，故打印時Num已經變成了200缀踪。防止上述情況出現一般在方法聲明加上synchronized關鍵字居砖。
public synchronized void printNum(String name)
圖1-3 同步鎖[實例變量]
??使用了synchronized 關鍵字則結果始終是【圖1-3】，
原理說明：synchronized 關鍵字在方法聲明中使用時驴娃，是起到鎖的這樣一個作用奏候，作用：每次有且只有一個線程執(zhí)行該方法的方法體。?2.對象鎖與靜態(tài)鎖
??使用對象鎖分為：synchronized(this)鎖唇敞，synchronized(非this對象)鎖鼻由。synchronized(this)鎖與synchronized關鍵字在方法聲明是一樣的作用，
優(yōu)點都是解決多線程同步問題厚棵。synchronized(非this對象)蕉世，對比與synchronized(this)的優(yōu)點：提高多個方法同步的效率問題。
public class ThreadSynchronizedDemo {
public static void main(String[] args) throws InterruptedException {
final ThreadSynchronizedObject object = new ThreadSynchronizedObject();
Thread thread_1 = new Thread("thread_1") {
public void run() {
try{
object.threadMethodA();
} catch (InterruptedException e) {
e.printStackTrace();
}
};
};
Thread thread_2 = new Thread("thread_2") {
public void run() {
try{
object.threadMethodB();
} catch (InterruptedException e) {
e.printStackTrace();
}
};
};
thread_1.start();
thread_2.start();
Thread.sleep(3000);
long start_time = (ThreadSynchronizedTimeUtils.mMethodAIntoTime - ThreadSynchronizedTimeUtils.mMethodBIntoTime) > 0 ? ThreadSynchronizedTimeUtils.mMethodAIntoTime
: ThreadSynchronizedTimeUtils.mMethodBIntoTime;
long end_time = (ThreadSynchronizedTimeUtils.mMethodAOutTime - ThreadSynchronizedTimeUtils.mMethodBOutTime) > 0 ? ThreadSynchronizedTimeUtils.mMethodAOutTime
: ThreadSynchronizedTimeUtils.mMethodBOutTime;
System.out.println("總耗時:" + (end_time - start_time));
}
}
class ThreadSynchronizedObject {
public synchronized void threadMethodA() throws InterruptedException {
ThreadSynchronizedTimeUtils.setMethodAIntoTime();
System.out.println(Thread.currentThread().getName() + ",進入threadMethodA");
Thread.sleep(1000); ///<模擬方法請求耗時
System.out.println(Thread.currentThread().getName() + ",退出threadMethodA");
ThreadSynchronizedTimeUtils.setMethodAOutTime();
}
public void threadMethodB() throws InterruptedException {
synchronized (this) {
ThreadSynchronizedTimeUtils.setMethodBIntoTime();
System.out.println(Thread.currentThread().getName() + ",進入threadMethodB");
Thread.sleep(1000);
System.out.println(Thread.currentThread().getName() + ",退出threadMethodB");
ThreadSynchronizedTimeUtils.setMethodBOutTime();
}
}
}
class ThreadSynchronizedTimeUtils {
public static long mMethodAIntoTime;
public static long mMethodAOutTime;
public static long mMethodBIntoTime;
public static long mMethodBOutTime;
public static void setMethodAIntoTime() {
mMethodAIntoTime = System.currentTimeMillis();
}
public static void setMethodAOutTime() {
mMethodAOutTime = System.currentTimeMillis();
}
public static void setMethodBIntoTime() {
mMethodBIntoTime = System.currentTimeMillis();
}
public static void setMethodBOutTime() {
mMethodBOutTime = System.currentTimeMillis();
}
}
圖1-4 對象鎖
??從上面代碼以及結果可以得出兩個結論：
??1)synchronized關鍵字與synchronized(this)是同一把鎖(this對象)因為兩個線程方法進入與退出始終是成對出現婆硬。
??2)synchronized(this)鎖使多線程同步執(zhí)行方法體中的內容狠轻。
?這里有一個奇怪的現象出現，將main線程sleep(3000)放到獲取end_time后打印start_time與end_time始終為0彬犯；【莫非是內存釋放了向楼？】
class ThreadSynchronizedObject {
private Object object = new Object();
public synchronized void threadMethodA() throws InterruptedException {
ThreadSynchronizedTimeUtils.setMethodAIntoTime();
System.out.println(Thread.currentThread().getName() + ",進入threadMethodA");
Thread.sleep(1000); ///<模擬方法請求耗時
System.out.println(Thread.currentThread().getName() + ",退出threadMethodA");
ThreadSynchronizedTimeUtils.setMethodAOutTime();
}
public void threadMethodB() throws InterruptedException {
synchronized (object) {
ThreadSynchronizedTimeUtils.setMethodBIntoTime();
System.out.println(Thread.currentThread().getName() + ",進入threadMethodB");
Thread.sleep(1000);
System.out.println(Thread.currentThread().getName() + ",退出threadMethodB");
ThreadSynchronizedTimeUtils.setMethodBOutTime();
}
}
}
圖1-5 對象鎖.jpg
??將
ThreadSynchronizedObject 類threadMethodB改為synchronized (非this)鎖，效率如【圖1-5】提升了一倍谐区，故synchronized(非this)鎖適用于各個實例方法都需要同步操作時湖蜕。??靜態(tài)鎖：
應用在static靜態(tài)方法上，鎖為當前*.java文件的Class類宋列。
public class ThreadSynchronizedStaticDemo {
public static void main(String[] args) {
Thread thread_1 = new Thread("thread_1"){
public void run() {
synchronizedStaticService.methodA();
};
};
Thread thread_2 = new Thread("thread_2") {
public void run() {
synchronizedStaticService.methodB();
};
};
thread_1.start();
thread_2.start();
}
}
class synchronizedStaticService {
public static synchronized void methodA() {
try{
System.out.println("" + Thread.currentThread().getName() + ",開始methodA()!");
Thread.sleep(1000);
System.out.println("" + Thread.currentThread().getName() + ",退出methodA()!");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public static void methodB() {
synchronized(synchronizedStaticService.class) {
try{
System.out.println("" + Thread.currentThread().getName() + ",開始methodB()!");
Thread.sleep(1000);
System.out.println("" + Thread.currentThread().getName() + ",退出methodB()!");
} catch(InterruptedException e) {
e.printStackTrace();
}
}
}
}
圖1-6 靜態(tài)鎖
??從【圖1-6】看出methodA與methodB兩個方法都是按照順序執(zhí)行完成昭抒，可見靜態(tài)方法中synchronized關鍵字與synchronized(當前類.class)代碼塊作用一樣。
?3.死鎖
??出現死鎖的情形：
兩個或多個線程處于永久等待狀態(tài)炼杖，每個線程都等待其他線程釋放所持有的資源（鎖）灭返。
public class ThreadDealDemo {
public static void main(String[] args) {
final DealService dealService = new DealService();
Thread thread_1 = new Thread("thread_1") {
public void run() {
dealService.methodA();
};
};
Thread thread_2 = new Thread("thread_2") {
public void run() {
dealService.methodB();
};
};
thread_1.start();
thread_2.start();
}
}
class DealService {
private Object lock1 = new Object();
private Object lock2 = new Object();
public void methodA() {
System.out.println("" + Thread.currentThread().getName() + ",等待獲取lock1");
synchronized (lock1) {
try {
System.out.println("" + Thread.currentThread().getName() + ",持有l(wèi)ock1");
Thread.sleep(2000);
System.out.println("" + Thread.currentThread().getName() + ",等待獲取lock2");
synchronized (lock2) {
System.out.println("" + Thread.currentThread().getName() + ",持有l(wèi)ock2");
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public void methodB() {
System.out.println("" + Thread.currentThread().getName() + ",等待獲取lock2");
synchronized (lock2) {
try {
System.out.println("" + Thread.currentThread().getName() + ",持有l(wèi)ock2");
Thread.sleep(2000);
System.out.println("" + Thread.currentThread().getName() + ",等待獲取lock1");
synchronized (lock1) {
System.out.println("" + Thread.currentThread().getName() + ",持有l(wèi)ock1");
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
圖1-7 死鎖
??從【圖1-7】結果來看，進程一直處于運行狀態(tài)坤邪，thread_1等待獲取thread_2所持有的lock_2熙含，thread_2等待獲取thread_1所持有的lock_1，這樣進程不借助外力的情況下艇纺，處于永久等待狀態(tài)旺隙。
圖1-8 死鎖
圖1-9 死鎖
圖1-10 死鎖
??可以使用Java JDK自帶工具jsp檢測進程中死鎖問題。
?
步驟：?
1)jsp查詢根據結果找出進程號滞乙；eg:上述工程進程名為ThreadDealDemo進程號為46580.?
2)jstrck -l 進程號獲取當前進程堆棧信息，找到deallock信息腌乡。可以如【1-10】有相應的死鎖堆棧信息或粮，方便找到死鎖對應點导饲。
-volatile實現’內存共享‘
??volatile作用：使變量在多個線程可見;
??volatile實現‘共享內存’的解釋：使用volatile讓原本‘私有堆棧’中的操作氯材，變成‘公共堆椩酰’中操作，這樣內存在每個線程中都可見了氢哮。
圖1-11 線程數據操作
public class ThreadVolatileDemo {
public static void main(String[] args) throws InterruptedException {
ThreadVolatileRunnable runnable = new ThreadVolatileRunnable();
Thread thread = new Thread(runnable, "thread_1");
thread.start();
Thread.sleep(1000);
runnable.setPrint(false);
}
}
class ThreadVolatileRunnable implements Runnable {
private boolean isPrint = true;
public void setPrint(boolean flag) {
this.isPrint = flag;
if(!flag)
System.out.println("" + Thread.currentThread().getName() + ",嘗試讓線程退出!");
}
public void run() {
int num =0;
while (isPrint) {
num++;
}
System.out.println("" + Thread.currentThread().getName() + ",停止運行!num:" + num);
}
}
圖1-11 volatile
private volatile boolean isPrint = true;
圖1-12 volatile
??當sleep 1s后嘗試停止線程袋毙，可從【圖1-11】看出程序開關一直顯示紅色[運行狀態(tài)]，停止不了冗尤。這也就是第一章http://www.reibang.com/p/d901b25e0d4a提到的听盖，停止不了的死循環(huán)線程現象。
將isPrint變量增加volatile關鍵字后結果如【圖1-12】程序正常退出裂七。
??這里要提示一個技術點皆看，如果將打印語句移到while循環(huán)里，同樣的操作線程也能停止背零。關鍵點在println方法中有Synchronized結構體腰吟，synchronized作用于結構體時，作用：1)同步徙瓶，2）讓成員變量變?yōu)槎嗑€程可見;
故當我們又想讓變量變?yōu)榭梢娒停忠絼tsynchronized滿足需求。
-總結
??這里主要介紹了synchronized對象鎖侦镇，靜態(tài)鎖使用方式場景灵疮，volatile實現內存共享功能。
