深入了解Java中Synchronized的各種使用方法
在Java當中synchronized通常是用來標記一個方法或者代碼塊。在Java當中被synchronized標記的代碼或者方法在同一個時刻只能夠有一個線程執(zhí)行被synchronized修飾的方法或者代碼塊。因此被synchronized修飾的方法或者代碼塊不會出現(xiàn)數(shù)據(jù)競爭的情況，也就是說被synchronized修飾的代碼塊是并發(fā)安全的。
Synchronized關鍵字
synchronized關鍵字通常使用在下面四個地方：
- synchronized修飾實例方法。
- synchronized修飾靜態(tài)方法。
- synchronized修飾實例方法的代碼塊。
- synchronized修飾靜態(tài)方法的代碼塊。
在實際情況當中我們需要仔細分析我們的需求選擇合適的使用synchronized方法，在保證程序正確的情況下提升程序執(zhí)行的效率。
Synchronized修飾實例方法
下面是一個用Synchronized修飾實例方法的代碼示例：
public class SyncDemo {
private int count;
public synchronized void add() {
count++;
}
public static void main(String[] args) throws InterruptedException {
SyncDemo syncDemo = new SyncDemo();
Thread t1 = new Thread(() -> {
for (int i = 0; i < 10000; i++) {
syncDemo.add();
}
});
Thread t2 = new Thread(() -> {
for (int i = 0; i < 10000; i++) {
syncDemo.add();
}
});
t1.start();
t2.start();
t1.join(); // 阻塞住線程等待線程 t1 執(zhí)行完成
t2.join(); // 阻塞住線程等待線程 t2 執(zhí)行完成
System.out.println(syncDemo.count);// 輸出結果為 20000
}
}
在上面的代碼當中的add方法只有一個簡單的count++操作，因為這個方法是使用synchronized修飾的因此每一個時刻只能有一個線程執(zhí)行add方法，因此上面打印的結果是20000。如果add方法沒有使用synchronized修飾的話，那么線程t1和線程t2就可以同時執(zhí)行add方法，這可能會導致最終count的結果小于20000，因為count++操作不具備原子性。
上面的分析還是比較明確的，但是我們還需要知道的是synchronized修飾的add方法一個時刻只能有一個線程執(zhí)行的意思是對于一個SyncDemo類的對象來說一個時刻只能有一個線程進入。比如現(xiàn)在有兩個SyncDemo的對象s1和s2，一個時刻只能有一個線程進行s1的add方法，一個時刻只能有一個線程進入s2的add方法，但是同一個時刻可以有兩個不同的線程執(zhí)行s1和s2的add方法，也就說s1的add方法和s2的add是沒有關系的，一個線程進入s1的add方法并不會阻止另外的線程進入s2的add方法，也就是說synchronized在修飾一個非靜態(tài)方法的時候“鎖”住的只是一個實例對象，并不會“鎖”住其它的對象。其實這也很容易理解，一個實例對象是一個獨立的個體別的對象不會影響他，他也不會影響別的對象。
Synchronized修飾靜態(tài)方法
Synchronized修飾靜態(tài)方法：
public class SyncDemo {
private static int count;
public static synchronized void add() {
count++; // 注意 count 也要用 static 修飾 否則編譯通過不了
}
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(() -> {
for (int i = 0; i < 10000; i++) {
SyncDemo.add();
}
});
Thread t2 = new Thread(() -> {
for (int i = 0; i < 10000; i++) {
SyncDemo.add();
}
});
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println(SyncDemo.count); // 輸出結果為 20000
}
}
上面的代碼最終輸出的結果也是20000，但是與前一個程序不同的是。這里的add方法用static修飾的，在這種情況下真正的只能有一個線程進入到add代碼塊，因為用static修飾的話是所有對象公共的，因此和前面的那種情況不同，不存在兩個不同的線程同一時刻執(zhí)行add方法。
你仔細想想如果能夠讓兩個不同的線程執(zhí)行add代碼塊，那么count++的執(zhí)行就不是原子的了。那為什么沒有用static修飾的代碼為什么可以呢？因為當沒有用static修飾時，每一個對象的count都是不同的，內存地址不一樣，因此在這種情況下count++這個操作仍然是原子的！
Sychronized修飾多個方法
synchronized修飾多個方法示例：
public class AddMinus {
public static int ans;
public static synchronized void add() {
ans++;
}
public static synchronized void minus() {
ans--;
}
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(() -> {
for (int i = 0; i < 10000; i++) {
AddMinus.add();
}
});
Thread t2 = new Thread(() -> {
for (int i = 0; i < 10000; i++) {
AddMinus.minus();
}
});
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println(AddMinus.ans); // 輸出結果為 0
}
}
在上面的代碼當中我們用synchronized修飾了兩個方法，add和minus。這意味著在同一個時刻這兩個函數(shù)只能夠有一個被一個線程執(zhí)行，也正是因為add和minus函數(shù)在同一個時刻只能有一個函數(shù)被一個線程執(zhí)行，這才會導致ans最終輸出的結果等于0。
對于一個實例對象來說：
public class AddMinus {
public int ans;
public synchronized void add() {
ans++;
}
public synchronized void minus() {
ans--;
}
public static void main(String[] args) throws InterruptedException {
AddMinus addMinus = new AddMinus();
Thread t1 = new Thread(() -> {
for (int i = 0; i < 10000; i++) {
addMinus.add();
}
});
Thread t2 = new Thread(() -> {
for (int i = 0; i < 10000; i++) {
addMinus.minus();
}
});
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println(addMinus.ans);
}
}
上面的代碼沒有使用static關鍵字，因此我們需要new出一個實例對象才能夠調用add和minus方法，但是同樣對于AddMinus的實例對象來說同一個時刻只能有一個線程在執(zhí)行add或者minus方法，因此上面代碼的輸出同樣是0。
Synchronized修飾實例方法代碼塊
Synchronized修飾實例方法代碼塊
public class CodeBlock {
private int count;
public void add() {
System.out.println("進入了 add 方法");
synchronized (this) {
count++;
}
}
public void minus() {
System.out.println("進入了 minus 方法");
synchronized (this) {
count--;
}
}
public static void main(String[] args) throws InterruptedException {
CodeBlock codeBlock = new CodeBlock();
Thread t1 = new Thread(() -> {
for (int i = 0; i < 10000; i++) {
codeBlock.add();
}
});
Thread t2 = new Thread(() -> {
for (int i = 0; i < 10000; i++) {
codeBlock.minus();
}
});
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println(codeBlock.count); // 輸出結果為 0
}
}
有時候我們并不需要用synchronized去修飾代碼塊，因為這樣并發(fā)度就比較低了，一個方法一個時刻只能有一個線程在執(zhí)行。因此我們可以選擇用synchronized去修飾代碼塊，只讓某個代碼塊一個時刻只能有一個線程執(zhí)行，除了這個代碼塊之外的代碼還是可以并行的。
比如上面的代碼當中add和minus方法沒有使用synchronized進行修飾，因此一個時刻可以有多個線程執(zhí)行這個兩個方法。在上面的synchronized代碼塊當中我們使用了this對象作為鎖對象，只有拿到這個鎖對象的線程才能夠進入代碼塊執(zhí)行，而在同一個時刻只能有一個線程能夠獲得鎖對象。也就是說add函數(shù)和minus函數(shù)用synchronized修飾的兩個代碼塊同一個時刻只能有一個代碼塊的代碼能夠被一個線程執(zhí)行，因此上面的結果同樣是0。
這里說的鎖對象是this也就CodeBlock類的一個實例對象，因為它鎖住的是一個實例對象，因此當實例對象不一樣的時候他們之間是沒有關系的，也就是說不同實例用synchronized修飾的代碼塊是沒有關系的，他們之間是可以并發(fā)的。
Synchronized修飾靜態(tài)代碼塊
public class CodeBlock {
private static int count;
public static void add() {
System.out.println("進入了 add 方法");
synchronized (CodeBlock.class) {
count++;
}
}
public static void minus() {
System.out.println("進入了 minus 方法");
synchronized (CodeBlock.class) {
count--;
}
}
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(() -> {
for (int i = 0; i < 10000; i++) {
CodeBlock.add();
}
});
Thread t2 = new Thread(() -> {
for (int i = 0; i < 10000; i++) {
CodeBlock.minus();
}
});
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println(CodeBlock.count);
}
}
上面的代碼是使用synchronized修飾靜態(tài)代碼塊，上面代碼的鎖對象是CodeBlock.class，這個時候他不再是鎖住一個對象了，而是一個類了，這個時候的并發(fā)度就變小了，上一份代碼當鎖對象是CodeBlock的實例對象時并發(fā)度更大一些，因為當鎖對象是實例對象的時候，只有實例對象內部是不能夠并發(fā)的，實例之間是可以并發(fā)的。但是當鎖對象是CodeBlock.class的時候，實例對象之間時不能夠并發(fā)的，因為這個時候的鎖對象是一個類。
應該用什么對象作為鎖對象
在前面的代碼當中我們分別使用了實例對象和類的class對象作為鎖對象，事實上你可以使用任何對象作為鎖對象，但是不推薦使用字符串和基本類型的包裝類作為鎖對象，這是因為字符串對象和基本類型的包裝對象會有緩存的問題。字符串有字符串常量池，整數(shù)有小整數(shù)池。因此在使用這些對象的時候他們可能最終都指向同一個對象，因為指向的都是同一個對象，線程獲得鎖對象的難度就會增加，程序的并發(fā)度就會降低。
比如在下面的示例代碼當中就是由于鎖對象是同一個對象而導致并發(fā)度下降：
import java.util.concurrent.TimeUnit;
public class Test {
public void testFunction() throws InterruptedException {
synchronized ("HELLO WORLD") {
System.out.println(Thread.currentThread().getName() + "\tI am in synchronized code block");
TimeUnit.SECONDS.sleep(5);
}
}
public static void main(String[] args) {
Test t1 = new Test();
Test t2 = new Test();
Thread thread1 = new Thread(() -> {
try {
t1.testFunction();
} catch (InterruptedException e) {
e.printStackTrace();
}
});
Thread thread2 = new Thread(() -> {
try {
t2.testFunction();
} catch (InterruptedException e) {
e.printStackTrace();
}
});
thread1.start();
thread2.start();
}
}
在上面的代碼當中我們使用兩個不同的線程執(zhí)行兩個不同的對象內部的testFunction函數(shù)，按道理來說這兩個線程是可以同時執(zhí)行的，因為執(zhí)行的是兩個不同的實例對象的同步代碼塊。但是上面代碼的執(zhí)行首先一個線程會進入同步代碼塊然后打印輸出，等待5秒之后，這個線程退出同步代碼塊另外一個線程才會再進入同步代碼塊，這就說明了兩個線程不是同時執(zhí)行的，其中一個線程需要等待另外一個線程執(zhí)行完成才執(zhí)行。這正是因為兩個Test對象當中使用的"HELLO WORLD"字符串在內存當中是同一個對象，是存儲在字符串常量池中的對象，這才導致了鎖對象的競爭。
下面的代碼執(zhí)行的結果也是一樣的，一個線程需要等待另外一個線程執(zhí)行完成才能夠繼續(xù)執(zhí)行，這是因為在Java當中如果整數(shù)數(shù)據(jù)在[-128, 127]之間的話使用的是小整數(shù)池當中的對象，使用的也是同一個對象，這樣可以減少頻繁的內存申請和回收，對內存更加友好。
import java.util.concurrent.TimeUnit;
public class Test {
public void testFunction() throws InterruptedException {
synchronized (Integer.valueOf(1)) {
System.out.println(Thread.currentThread().getName() + "\tI am in synchronized code block");
TimeUnit.SECONDS.sleep(5);
}
}
public static void main(String[] args) {
Test t1 = new Test();
Test t2 = new Test();
Thread thread1 = new Thread(() -> {
try {
t1.testFunction();
} catch (InterruptedException e) {
e.printStackTrace();
}
});
Thread thread2 = new Thread(() -> {
try {
t2.testFunction();
} catch (InterruptedException e) {
e.printStackTrace();
}
});
thread1.start();
thread2.start();
}
}
Synchronized與可見性和重排序
可見性
當一個線程進入到synchronized同步代碼塊的時候，將會刷新所有對該線程的可見的變量，也就是說如果其他線程修改了某個變量，而且線程需要在Synchronized代碼塊當中使用，那就會重新刷新這個變量到內存當中，保證這個變量對于執(zhí)行同步代碼塊的線程是可見的。
當一個線程從同步代碼塊退出的時候，也會將線程的工作內存同步到內存當中，保證在同步代碼塊當中修改的變量對其他線程可見。
重排序
Java編譯器和JVM當發(fā)現(xiàn)能夠讓程序執(zhí)行的更快的時候是可能對程序的指令進行重排序處理的，也就是通過調換程序指令執(zhí)行的順序讓程序執(zhí)行的更快。
但是重排序很可能讓并發(fā)程序產(chǎn)生問題，比如說當一個在synchronized代碼塊當中的寫操作被重排序到synchronized同步代碼塊外部了這顯然是有問題的。
在JVM的實現(xiàn)當中是不允許synchronized代碼塊內部的指令和他前面和后面的指令進行重排序的，但是在synchronized內部的指令是可能與synchronized內部的指令進行重排序的，比較著名的就是DCL單例模式，他就是在synchronized代碼塊當中存在重排序的，如果你對DCL單例模式還不是很熟悉，你可以閱讀這篇文章的DCL單例模式部分。
總結
在本篇文章當中主要介紹了各種synchronized的使用方法，總結如下：
Synchronized修飾實例方法，這種情況不同的對象之間是可以并發(fā)的。
Synchronized修飾實例方法，這種情況下不同的對象是不能并發(fā)的，但是不同的類之間可以進行并發(fā)。
Sychronized修飾多個方法，這多個方法在統(tǒng)一時刻只能有一個方法被執(zhí)行，而且只能有一個線程能夠執(zhí)行。
Synchronized修飾實例方法代碼塊，同一個時刻只能有一個線程執(zhí)行代碼塊。
Synchronized修飾靜態(tài)代碼塊，同一個時刻只能有一個線程執(zhí)行這個代碼塊，而且不同的對象之間不能夠進行并發(fā)。
應該用什么對象作為鎖對象，建議不要使用字符串和基本類型的包裝類作為鎖對象，因為Java對這些進行優(yōu)化，很可能多個對象使用的是同一個鎖對象，這會大大降低程序的并發(fā)度。
程序在進入和離開Synchronized代碼塊的時候都會將線程的工作內存刷新到內存當中，以保證數(shù)據(jù)的可見性，這一點和volatile關鍵字很像，同時Synchronized代碼塊中的指令不會和Synchronized代碼塊之間和之后的指令進行重排序，但是Synchronized代碼塊內部可能進行重排序。
以上就是深入了解Java中Synchronized的各種使用方法的詳細內容，更多關于Java Synchronized用法的資料請關注腳本之家其它相關文章！
相關文章
啟動Tomcat報錯Unsupported major.minor version xxx的解決方法
這篇文章主要為大家詳細介紹了啟動Tomcat報錯Unsupported major.minor version xxx的解決方法，具有一定的參考價值，感興趣的小伙伴們可以參考一下2017-11-11
這篇文章主要為大家介紹了Java?this關鍵字的使用，具有一定的參考價值，感興趣的小伙伴們可以參考一下，希望能夠給你帶來幫助2022-01-01
這篇文章主要介紹了詳解Java如何獲取文件編碼格式，具有一定的參考價值，感興趣的小伙伴們可以參考一下。2017-01-01
很多朋友不清楚在Servlet中怎么上傳文件，談到這個問題，首先需要我們掌握開發(fā)servlet的步驟，本文通過實例代碼給大家介紹的非常詳細，對大家的學習或工作具有一定的參考借鑒價值，需要的朋友參考下吧2021-05-05
這篇文章主要為大家詳細介紹了springboot集成ftp實現(xiàn)文件上傳，文中示例代碼介紹的非常詳細，具有一定的參考價值，感興趣的小伙伴們可以參考一下2021-05-05
spring事務Propagation及其實現(xiàn)原理詳解
這篇文章主要介紹了spring事務Propagation及其實現(xiàn)原理詳解，分享了相關代碼示例，小編覺得還是挺不錯的，具有一定借鑒價值，需要的朋友可以參考下2018-02-02
Java中PriorityQueue實現(xiàn)最小堆和最大堆的用法
很多時候都會遇到PriorityQueue，本文主要介紹了Java中PriorityQueue實現(xiàn)最小堆和最大堆的用法，具有一定的參考價值，感興趣的小伙伴們可以參考一下2021-06-06
這篇文章主要介紹了Spring Cloud中Eureka開啟密碼認證的實例，小編覺得挺不錯的，現(xiàn)在分享給大家，也給大家做個參考。一起跟隨小編過來看看吧2018-05-05
這篇文章主要介紹了spring 自定義讓@Value被解析到，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教2021-09-09
MyBatisPlus（簡稱MP）是基于MyBatis框架基礎上開發(fā)的增強型工具，旨在簡化開發(fā)、提高效率。本文將為大家詳細介紹一下MyBatisPlus是使用，需要的可以參考一下2022-07-07