Java之戳中痛點 - （8）synchronized深度解析
阿新 • • 發佈：2019-08-30
概覽：
- 簡介：作用、地位、不控制併發的影響
- 用法：物件鎖和類鎖
- 多執行緒訪問同步方法的7種情況
- 性質：可重入、不可中斷
- 原理：加解鎖原理、可重入原理、可見性原理
- 缺陷：效率低、不夠靈活、無法預判是否成功獲取到鎖
- 如何選擇Lock或Synchronized
- 如何提高效能、JVM如何決定哪個執行緒獲取鎖
- 總結
後續會有程式碼演示，測試環境 JDK8、IDEA
一、簡介
1、作用
能夠保證在==同一時刻==最多隻有一個執行緒執行該程式碼，以保證併發安全的效果。
2、地位
- Synchronized是Java關鍵字，Java原生支援
- 最基本的互斥同步手段
- 併發程式設計的元老級別
3、不控制併發的影響
測試：兩個執行緒同時a++，猜一下結果
package cn.jsonshare.java.base.synchronizedtest; /** * 不使用synchronized,兩個執行緒同時a++ * * @author JSON * @date 2019-08-29 */ public class SynchronizedTest1 implements Runnable{ static SynchronizedTest1 st = new SynchronizedTest1(); static int a = 0; /** * 不使用synchronized,兩個執行緒同時a++ */ public static void main(String[] args) throws Exception{ Thread t1 = new Thread(st); Thread t2 = new Thread(st); t1.start(); t2.start(); t1.join(); t2.join(); System.out.println(a); } @Override public void run(){ for(int i=0; i<10000; i++){ a++; } } }
預期是20000，但多次執行的結果都小於20000
10108
11526
10736
...二、用法：物件鎖和類鎖
1、物件鎖
- 程式碼塊形式：手動指定鎖物件
- 方法鎖形式：synchronized修飾方法，鎖物件預設為this
package cn.jsonshare.java.base.synchronizedtest; /** * 物件鎖例項: 程式碼塊形式 * * @author JSON * @date 2019-08-29 */ public class SynchronizedTest2 implements Runnable{ static SynchronizedTest2 st = new SynchronizedTest2(); public static void main(String[] args) { Thread t1 = new Thread(st); Thread t2 = new Thread(st); t1.start(); t2.start(); while(t1.isAlive() || t2.isAlive()){ } System.out.println("run over"); } @Override public void run(){ synchronized (this){ System.out.println("開始執行:" + Thread.currentThread().getName()); try { // 模擬執行內容 Thread.sleep(3000); }catch (Exception e){ e.printStackTrace(); } System.out.println("執行結束:" + Thread.currentThread().getName()); } } }
package cn.jsonshare.java.base.synchronizedtest;
/**
* 物件鎖例項：synchronized方法
* @author JSON
* @date 2019-08-29
*/
public class SynchronizedTest3 implements Runnable{
static SynchronizedTest3 st = new SynchronizedTest3();
public static void main(String[] args) throws Exception{
Thread t1 = new Thread(st);
Thread t2 = new Thread(st);
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println("run over");
}
@Override
public void run(){
method();
}
public synchronized void method(){
System.out.println("開始執行:" + Thread.currentThread().getName());
try {
// 模擬執行內容
Thread.sleep(3000);
}catch (Exception e){
e.printStackTrace();
}
System.out.println("執行結束:" + Thread.currentThread().getName());
}
}
結果：
開始執行:Thread-0
執行結束:Thread-0
開始執行:Thread-1
執行結束:Thread-1
run over2、類鎖
==概念：Java類可能有多個物件，但只有一個Class物件==
==本質：所謂的類鎖，不過是Class物件的鎖而已==
==用法和效果：類鎖只能在同一時刻被一個物件擁有==
形式1：synchronized載入static方法上
形式2：synchronized(*.class)程式碼塊
package cn.jsonshare.java.base.synchronizedtest;
/**
* 類鎖：synchronized載入static方法上
*
* @author JSON
* @date 2019-08-29
*/
public class SynchronizedTest4 implements Runnable{
static SynchronizedTest4 st1 = new SynchronizedTest4();
static SynchronizedTest4 st2 = new SynchronizedTest4();
public static void main(String[] args) throws Exception{
Thread t1 = new Thread(st1);
Thread t2 = new Thread(st2);
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println("run over");
}
@Override
public void run(){
method();
}
public static synchronized void method(){
System.out.println("開始執行:" + Thread.currentThread().getName());
try {
// 模擬執行內容
Thread.sleep(3000);
}catch (Exception e){
e.printStackTrace();
}
System.out.println("執行結束:" + Thread.currentThread().getName());
}
}
package cn.jsonshare.java.base.synchronizedtest;
/**
* 類鎖：synchronized(*.class)程式碼塊
*
* @author JSON
* @date 2019-08-29
*/
public class SynchronizedTest5 implements Runnable{
static SynchronizedTest4 st1 = new SynchronizedTest4();
static SynchronizedTest4 st2 = new SynchronizedTest4();
public static void main(String[] args) throws Exception{
Thread t1 = new Thread(st1);
Thread t2 = new Thread(st2);
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println("run over");
}
@Override
public void run(){
method();
}
public void method(){
synchronized(SynchronizedTest5.class){
System.out.println("開始執行:" + Thread.currentThread().getName());
try {
// 模擬執行內容
Thread.sleep(3000);
}catch (Exception e){
e.printStackTrace();
}
System.out.println("執行結束:" + Thread.currentThread().getName());
}
}
}
結果：
開始執行:Thread-0
執行結束:Thread-0
開始執行:Thread-1
執行結束:Thread-1
run over三、多執行緒訪問同步方法的7種情況
- 兩個執行緒同時訪問一個物件的相同的synchronized方法
- 兩個執行緒同時訪問兩個物件的相同的synchronized方法
- 兩個執行緒同時訪問兩個物件的相同的static的synchronized方法
- 兩個執行緒同時訪問同一物件的synchronized方法與非synchronized方法
- 兩個執行緒訪問同一物件的不同的synchronized方法
- 兩個執行緒同時訪問同一物件的static的synchronized方法與非static的synchronized方法
- 方法丟擲異常後，會釋放鎖嗎
仔細看下面示例程式碼結果輸出的結果，注意輸出時間間隔，來預測結論
場景1：
package cn.jsonshare.java.base.synchronizedtest;
/**
* 兩個執行緒同時訪問一個物件的相同的synchronized方法
*
* @author JSON
* @date 2019-08-29
*/
public class SynchronizedScene1 implements Runnable{
static SynchronizedScene1 ss = new SynchronizedScene1();
public static void main(String[] args) throws Exception{
Thread t1 = new Thread(ss);
Thread t2 = new Thread(ss);
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println("run over");
}
@Override
public void run(){
method();
}
public synchronized void method(){
System.out.println("開始執行:" + Thread.currentThread().getName());
try {
// 模擬執行內容
Thread.sleep(3000);
}catch (Exception e){
e.printStackTrace();
}
System.out.println("執行結束:" + Thread.currentThread().getName());
}
}場景2：
package cn.jsonshare.java.base.synchronizedtest;
/**
* 兩個執行緒同時訪問兩個物件的相同的synchronized方法
*
* @author JSON
* @date 2019-08-29
*/
public class SynchronizedScene2 implements Runnable{
static SynchronizedScene2 ss1 = new SynchronizedScene2();
static SynchronizedScene2 ss2 = new SynchronizedScene2();
public static void main(String[] args) throws Exception{
Thread t1 = new Thread(ss1);
Thread t2 = new Thread(ss2);
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println("run over");
}
@Override
public void run(){
method();
}
public synchronized void method(){
System.out.println("開始執行:" + Thread.currentThread().getName());
try {
// 模擬執行內容
Thread.sleep(3000);
}catch (Exception e){
e.printStackTrace();
}
System.out.println("執行結束:" + Thread.currentThread().getName());
}
}場景3：
package cn.jsonshare.java.base.synchronizedtest;
/**
* 兩個執行緒同時訪問兩個物件的相同的static的synchronized方法
*
* @author JSON
* @date 2019-08-29
*/
public class SynchronizedScene3 implements Runnable{
static SynchronizedScene3 ss1 = new SynchronizedScene3();
static SynchronizedScene3 ss2 = new SynchronizedScene3();
public static void main(String[] args) throws Exception{
Thread t1 = new Thread(ss1);
Thread t2 = new Thread(ss2);
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println("run over");
}
@Override
public void run(){
method();
}
public synchronized static void method(){
System.out.println("開始執行:" + Thread.currentThread().getName());
try {
// 模擬執行內容
Thread.sleep(3000);
}catch (Exception e){
e.printStackTrace();
}
System.out.println("執行結束:" + Thread.currentThread().getName());
}
}場景4：
package cn.jsonshare.java.base.synchronizedtest;
/**
* 兩個執行緒同時訪問同一物件的synchronized方法與非synchronized方法
*
* @author JSON
* @date 2019-08-29
*/
public class SynchronizedScene4 implements Runnable{
static SynchronizedScene4 ss1 = new SynchronizedScene4();
public static void main(String[] args) throws Exception{
Thread t1 = new Thread(ss1);
Thread t2 = new Thread(ss1);
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println("run over");
}
@Override
public void run(){
// 模擬兩個執行緒同時訪問 synchronized方法與非synchronized方法
if(Thread.currentThread().getName().equals("Thread-0")){
method1();
}else{
method2();
}
}
public void method1(){
System.out.println("method1開始執行:" + Thread.currentThread().getName());
try {
// 模擬執行內容
Thread.sleep(3000);
}catch (Exception e){
e.printStackTrace();
}
System.out.println("method1執行結束:" + Thread.currentThread().getName());
}
public synchronized void method2(){
System.out.println("method2開始執行:" + Thread.currentThread().getName());
try {
// 模擬執行內容
Thread.sleep(3000);
}catch (Exception e){
e.printStackTrace();
}
System.out.println("method2執行結束:" + Thread.currentThread().getName());
}
}場景5：
package cn.jsonshare.java.base.synchronizedtest;
/**
* 兩個執行緒訪問同一物件的不同的synchronized方法
*
* @author JSON
* @date 2019-08-29
*/
public class SynchronizedScene5 implements Runnable{
static SynchronizedScene5 ss1 = new SynchronizedScene5();
public static void main(String[] args) throws Exception{
Thread t1 = new Thread(ss1);
Thread t2 = new Thread(ss1);
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println("run over");
}
@Override
public void run(){
// 模擬兩個執行緒同時訪問不同的synchronized方法
if(Thread.currentThread().getName().equals("Thread-0")){
method1();
}else{
method2();
}
}
public synchronized void method1(){
System.out.println("method1開始執行:" + Thread.currentThread().getName());
try {
// 模擬執行內容
Thread.sleep(3000);
}catch (Exception e){
e.printStackTrace();
}
System.out.println("method1執行結束:" + Thread.currentThread().getName());
}
public synchronized void method2(){
System.out.println("method2開始執行:" + Thread.currentThread().getName());
try {
// 模擬執行內容
Thread.sleep(3000);
}catch (Exception e){
e.printStackTrace();
}
System.out.println("method2執行結束:" + Thread.currentThread().getName());
}
}場景6：
package cn.jsonshare.java.base.synchronizedtest;
/**
* 兩個執行緒同時訪問同一物件的static的synchronized方法與非static的synchronized方法
*
* @author JSON
* @date 2019-08-29
*/
public class SynchronizedScene6 implements Runnable{
static SynchronizedScene6 ss1 = new SynchronizedScene6();
public static void main(String[] args) throws Exception{
Thread t1 = new Thread(ss1);
Thread t2 = new Thread(ss1);
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println("run over");
}
@Override
public void run(){
// 模擬兩個執行緒同時訪問static的synchronized方法與非static的synchronized方法
if(Thread.currentThread().getName().equals("Thread-0")){
method1();
}else{
method2();
}
}
public static synchronized void method1(){
System.out.println("method1開始執行:" + Thread.currentThread().getName());
try {
// 模擬執行內容
Thread.sleep(3000);
}catch (Exception e){
e.printStackTrace();
}
System.out.println("method1執行結束:" + Thread.currentThread().getName());
}
public synchronized void method2(){
System.out.println("method2開始執行:" + Thread.currentThread().getName());
try {
// 模擬執行內容
Thread.sleep(3000);
}catch (Exception e){
e.printStackTrace();
}
System.out.println("method2執行結束:" + Thread.currentThread().getName());
}
}場景7：
package cn.jsonshare.java.base.synchronizedtest;
/**
* 方法丟擲異常後，會釋放鎖嗎
*
* @author JSON
* @date 2019-08-29
*/
public class SynchronizedScene7 implements Runnable{
static SynchronizedScene7 ss1 = new SynchronizedScene7();
public static void main(String[] args) throws Exception{
Thread t1 = new Thread(ss1);
Thread t2 = new Thread(ss1);
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println("run over");
}
@Override
public void run(){
method1();
}
public synchronized void method1(){
System.out.println("method1開始執行:" + Thread.currentThread().getName());
try {
// 模擬執行內容
Thread.sleep(3000);
}catch (Exception e){
e.printStackTrace();
}
// 模擬異常
throw new RuntimeException();
//System.out.println("method1執行結束:" + Thread.currentThread().getName());
}
}總結：
1、兩個執行緒同時訪問一個物件的相同的synchronized方法
同一例項擁有同一把鎖，其他執行緒必然等待，順序執行2、兩個執行緒同時訪問兩個物件的相同的synchronized方法
不同的例項擁有的鎖是不同的，所以不影響，並行執行3、兩個執行緒同時訪問兩個物件的相同的static的synchronized方法
靜態同步方法，是類鎖，所有例項是同一把鎖，其他執行緒必然等待，順序執行4、兩個執行緒同時訪問同一物件的synchronized方法與非synchronized方法
非synchronized方法不受影響，並行執行5、兩個執行緒訪問同一物件的不同的synchronized方法
同一例項擁有同一把鎖，所以順序執行（說明：鎖的是this物件==同一把鎖）6、兩個執行緒同時訪問同一物件的static的synchronized方法與非static的synchronized方法
static同步方法是類鎖，非static是物件鎖，原理上是不同的鎖，所以不受影響，並行執行7、方法丟擲異常後，會釋放鎖嗎
會自動釋放鎖，這裡區別Lock，Lock需要顯示的釋放鎖3個核心思想：
1、一把鎖只能同時被一個執行緒獲取，沒有拿到鎖的執行緒必須等待（對應1、5的情景）
2、每個例項都對應有自己的一把鎖，不同的例項之間互不影響；
例外：鎖物件是*.class以及synchronized被static修飾的時候，所有物件共用同一把鎖（對應2、3、4、6情景）3、無論是方法正常執行完畢還是方法丟擲異常，都會釋放鎖（對應7情景）
補充：
問題：目前進入到被synchronized修飾的方法，這個方法裡邊呼叫了非synchronized方法，是執行緒安全的嗎？
package cn.jsonshare.java.base.synchronizedtest;
/**
* 目前進入到被synchronized修飾的方法，這個方法裡邊呼叫了非synchronized方法，是執行緒安全的嗎？
*
* @author JSON
* @date 2019-08-29
*/
public class SynchronizedScene8 {
public static void main(String[] args) {
new Thread(() -> {
method1();
}).start();
new Thread(() -> {
method1();
}).start();
}
public static synchronized void method1() {
method2();
}
private static void method2() {
System.out.println(Thread.currentThread().getName() + "進入非Synchronized方法");
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "結束非Synchronized方法");
}
}結論：這樣是執行緒安全的
四、性質
1、可重入
指的是同一執行緒的外層函式獲取鎖之後，內層函式可以直接再次獲取該鎖
Java典型的可重入鎖：synchronized、ReentrantLock
好處：避免死鎖，提升封裝性
粒度：執行緒而非呼叫
情況1：證明同一方法是可重入的
情況2：證明可重入不要求是同一方法
情況3：證明可重入不要求是同一類中的2、不可中斷
一旦這個鎖被別的執行緒獲取了，如果我現在想獲得，我只能選擇等待或者阻塞，直到別的執行緒釋放這個鎖，如果別的執行緒永遠不釋放鎖，那麼我只能永遠的等待下去。
相比之下，Lock類可以擁有中斷的能力，第一點：如果我覺得我等待的時間太長了，有權中斷現在已經獲取到鎖的執行緒執行；第二點：如果我覺得我等待的時間太長了不想再等了，也可以退出。
五、原理
1、加解鎖原理（現象、時機、深入JVM看位元組碼）
現象：每一個類的例項對應一把鎖，每一個synchronized方法都必須首先獲得呼叫該方法的類的例項的鎖，方能執行，否則就會阻塞，方法執行完成或者丟擲異常，鎖被釋放，被阻塞執行緒才能獲取到該鎖，執行。
獲取和釋放鎖的時機：內建鎖或監視器鎖
package cn.jsonshare.java.base.synchronizedtest;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* method1 等價於 method2
*
* @author JSON
* @date 2019-08-29
*/
public class SynchronizedToLock1 {
Lock lock = new ReentrantLock();
public synchronized void method1(){
System.out.println("執行method1");
}
public void method2(){
lock.lock();
try {
System.out.println("執行method2");
}catch (Exception e){
e.printStackTrace();
}finally {
lock.unlock();
}
}
public static void main(String[] args) {
SynchronizedToLock1 sl = new SynchronizedToLock1();
// method1 等價於 method2
sl.method1();
sl.method2();
}
}深入JVM看位元組碼：
...
monitorenter指令
...
monitorexit指令
...2、可重入原理（加鎖次數計數器）
JVM負責跟蹤物件被加鎖的次數
執行緒第一次給物件加鎖的時候，計數變為1，每當這個相同的執行緒在此物件上再次獲得鎖時，計數會遞增
每當任務離開時，計數遞減，當計數為0的時候，鎖被完全釋放
3、可見性原理（記憶體模型）
Java記憶體模型
執行緒A向執行緒B傳送資料的過程（JMM控制）
==synchronized關鍵字實現可見性：==
被synchronized修飾，那麼執行完成後，對物件所做的任何修改都要在釋放鎖之前，都要從執行緒記憶體寫入到主記憶體，所以主記憶體中的資料是最新的。
六、缺陷
1、效率低
1)、鎖的釋放情況少（執行緒執行完成或者異常情況釋放）
2)、試圖獲得鎖時不能設定超時（只能等待）
3)、不能中斷一個正在試圖獲得鎖的執行緒（不能中斷）
2、不夠靈活
加鎖和釋放的時機比較單一，每個鎖僅有單一的條件（某個物件），可能是不夠的
比如：讀寫鎖更靈活
3、無法預判是否成功獲取到鎖
七、常見問題
1、synchronized關鍵字注意點：
- 鎖物件不能為空
- 作用域不宜過大
- 避免死鎖
2、如何選擇Lock和synchronized關鍵字？
總結建議（優先避免出錯的原則）：
- 如果可以的話，儘量優先使用java.util.concurrent各種類（不需要考慮同步工作，不容易出錯）
- 優先使用synchronized，這樣可以減少編寫程式碼的量，從而可以減少出錯率
- 若用到Lock或Condition獨有的特性，才使用Lock或Condition
八、總結
一句話總結synchronized：
JVM會自動通過使用monitor來加鎖和解鎖，保證了同一時刻只有一個執行緒可以執行指定的程式碼，從而保證執行緒安全，同時具有可重入和不可中斷的特性