Java 多線程的同步代碼塊詳解
火車站搶票問題
由于現(xiàn)實中買票也不會是零延遲的，為了真實性加入了延遲機制，也就是線程休眠語句
package test.MyThread.ticketDemo;
public class RunnableThread implements Runnable{
private int ticket = 100;
@Override
public void run(){
while(true){
if(ticket>0){
try {
Thread.sleep(100); //語句一
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"正在出售第 "+ticket+" 張票"); //語句二
ticket--; //語句三
}
}
}
}
package test.MyThread.ticketDemo;
public class ticketDemo1 {
public static void main(String[] args) {
RunnableThread r1 = new RunnableThread();
Thread t1 = new Thread(r1,"窗口一");
Thread t2 = new Thread(r1,"窗口二");
Thread t3 = new Thread(r1,"窗口三");
t1.start();
t2.start();
t3.start();
}
}
但是結(jié)果和我們想象中的不一樣，三個窗口賣出了同樣的票
這是因為，CPU的操作具有原子性，單獨執(zhí)行一條指令或者說語句，在執(zhí)行完畢前不會被中斷。
三個線程被啟動后，都會處于就緒狀態(tài)，然后開始搶奪CPU執(zhí)行語句。
1.語句一：Thread.sleep(100);
2.語句二： System.out.println(Thread.currentThread().getName()+“正在出售第 “+ticket+” 張票”);
3.語句三： ticket–;
我將程序中需要執(zhí)行的三條主要語句列了出來
三條線程中，加入線程一先搶到了CPU，這時就會開始執(zhí)行語句，也就是至少會完成一條語句一，然后進入休眠。
注：如果語句一不是休眠語句，而是別的語句，那么線程一就可以繼續(xù)往下執(zhí)行，因為原子性，正在執(zhí)行的語句不會被打斷，所以只會在一條語句結(jié)束，下一條語句未開始時，被搶走CPU或者中斷，導致線程退出運行狀態(tài)，轉(zhuǎn)為就緒或者阻塞狀態(tài)。所以線程一可以一次性完成多條語句，也有可能剛完成一條語句就被搶走了CPU。
接著，線程二，線程三也搶到了CPU，也開始執(zhí)行語句一，然后也進入休眠狀態(tài)。之后線程一二三從休眠中醒來，開始爭搶CPU完成語句二，但是三者都在完成語句三之前被搶走了CPU，導致一直沒有執(zhí)行ticket–語句，ticket也就沒有減少，因此三條線程一共打印三條輸出語句，里面的ticket都是相同。
然后三條線程又開始爭搶CPU來完成語句三，一個線程讓ticket減一，三個線程減少三張票。完成語句三后，又開始新的循環(huán)，三個線程開始爭搶CPU完成語句一。
因此，看到的結(jié)果會是，三條語句的ticket都相同，然后ticket突然減三，接著又輸出三條ticket相同的輸出語句。
那么，該如何解決這種情況呢？
這種延遲賣票的問題被稱為線程安全問題，要發(fā)生線程安全問題需要滿足三個條件（任何一共條件不滿足都不會造成線程安全問題）：
1.是否存在多線程環(huán)境
2.是否存在共享數(shù)據(jù)/共享變量
3.是否有多條語句操作著共享數(shù)據(jù)/共享變量
火車站延遲賣票問題滿足這三個條件，因此造成了線程安全問題，而前兩條都不可避免，那么就可以著手于破壞掉第三個條件，讓線程安全問題不成立。
思路是將多條語句包裝成一個同步代碼塊，當某個線程執(zhí)行這個同步代碼塊的時候，就跟原子性一樣，其他的線程不能搶占CPU，只能等這個同步代碼塊執(zhí)行完畢。
解決辦法：
1.synchronized —— 自動鎖
2.lock —— 手動鎖
synchronized
synchronized(對象){
//可能會發(fā)生線程安全問題的代碼
}
//這里的對象可以是任意對象，我們可以用 Object obj = new Object()里面的obj放入括號中
使用synchronized的條件：
1.必須有兩個或兩個以上的線程同一時間只有一個線程能夠執(zhí)行同步代碼塊多個線程想要同步時，必須共用同一把鎖
synchronized(對象)括號里面的對象就是一把鎖
使用synchronized的過程：
1.只有搶到鎖的線程才可以執(zhí)行同步代碼塊，其余的線程即使搶到了CPU執(zhí)行權(quán)，也只能等待，等待鎖的釋放。
2.代碼執(zhí)行完畢或者程序拋出異常都會釋放鎖，然后還未執(zhí)行同步代碼塊的線程爭搶鎖，誰搶到誰就能運行同步代碼塊。
同步代碼塊
因此，修改后的代碼為：
package test.MyThread.ticketDemo;
public class RunnableThread implements Runnable{
private int ticket = 100;
Object obj = new Object();
@Override
public void run(){
while(true){
synchronized (obj) {
if (ticket > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "正在出售第 " + ticket + " 張票");
ticket--;
}
}
}
}
}
package test.MyThread.ticketDemo;
public class ticketDemo1 {
public static void main(String[] args) {
//這里沒有改動，只是在上一個代碼中加了一把鎖
RunnableThread r1 = new RunnableThread();
Thread t1 = new Thread(r1,"窗口一");
Thread t2 = new Thread(r1,"窗口二");
Thread t3 = new Thread(r1,"窗口三");
t1.start();
t2.start();
t3.start();
}
}
可以看出來結(jié)果符合我們的預期，是正確的
現(xiàn)在又有了新的問題，那就是如果我在構(gòu)造線程的RunnableThread類里面加入方法呢？同步代碼塊里面出現(xiàn)方法時，我們應(yīng)該怎么“上鎖”呢？
同步方法（this鎖）
同步方法，在public的后面加上synchronized關(guān)鍵字
package test.MyThread.ticketDemo;
public class RunnableThread1 implements Runnable{
private int ticket = 100;
Object obj = new Object();
public boolean flag = true;
@Override
public void run(){
if(flag==true){
while(ticket>0){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
SellTicket1();
}
}
}
//同步方法，在public的后面加上synchronized關(guān)鍵字
public synchronized void SellTicket1(){
if(ticket>0){
System.out.println(Thread.currentThread().getName()+"正在出售第 "+ticket+" 張票");
ticket--;
}
}
}
package test.MyThread.ticketDemo;
public class ticketDemo2 {
public static void main(String[] args) throws InterruptedException {
RunnableThread1 r = new RunnableThread1();
Thread t1 = new Thread(r,"窗口一");
Thread t2 = new Thread(r,"窗口二");
t1.start();
t2.start();
}
}
this鎖
先來看看，如果有兩條路徑，一條路徑是使用同步代碼塊，但是對象是obj，另一條路徑是使用同步方法
package test.MyThread.ticketDemo;
public class TicketWindow2 implements Runnable{
//定義100張票
private static int tickets = 100;
Object obj = new Object();
int i =0;
@Override
public void run() {
while (true){
if(i%2==0){
synchronized (obj){
if(tickets>0){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+" 正在出售第 "+(tickets--)+" 張票");
}
}
}else {
sellTicket();
}
i++;
}
}
public synchronized void sellTicket(){
if(tickets>0){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+" 正在出售第 "+(tickets--)+" 張票");
}
}
}
結(jié)果出錯，說明同步方法的用的對象鎖不能是任意的對象，不同的線程應(yīng)該用相同的鎖。同步方法是屬于對象，而在這個類里面調(diào)用方法的是this對象，也就是this.sellTicket()，因此把this提取出來作為對象鎖中的對象。這樣多個線程都用的是this鎖
package test.MyThread.ticketDemo;
public class TicketWindow2 implements Runnable{
//定義100張票
private static int tickets = 100;
Object obj = new Object();
int i =0;
@Override
public void run() {
while (true){
if(i%2==0){
synchronized (this){
if(tickets>0){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+" 正在出售第 "+(tickets--)+" 張票");
}
}
}else {
sellTicket();
}
i++;
}
}
public synchronized void sellTicket(){
if(tickets>0){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+" 正在出售第 "+(tickets--)+" 張票");
}
}
}
修改完成后再運行代碼，發(fā)現(xiàn)沒有錯誤
注：
1.一個線程使用同步方法，另一個線程使用同步代碼塊this鎖，可以實現(xiàn)同步
2.一個線程使用同步方法，另一個線程使用同步代碼塊，但是不是this鎖。這種情況不能實現(xiàn)同步。
靜態(tài)同步方法
同步方法的鎖對象是this，
靜態(tài)同步方法的鎖對象是：這個靜態(tài)同步方法所屬的類的字節(jié)碼文件
下面代碼挺長的，但其實就修改了上面同步方法的代碼的兩處地方
1.public synchronized void sellTicket(){}改為
public synchronized static void sellTicket(){}
2.synchronized (this){}改為synchronized (TicketWindow2.class){}
package test.MyThread.ticketDemo;
public class TicketWindow2 implements Runnable{
//定義100張票
private static int tickets = 100;
Object obj = new Object();
int i =0;
@Override
public void run() {
while (true){
if(i%2==0){
synchronized (TicketWindow2.class){
if(tickets>0){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+" 正在出售第 "+(tickets--)+" 張票");
}
}
}else {
sellTicket();
}
i++;
}
}
public synchronized static void sellTicket(){
if(tickets>0){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+" 正在出售第 "+(tickets--)+" 張票");
}
}
}
main()方法里面創(chuàng)建進程和啟動進程的代碼，和上面同步方法里面的代碼相同
結(jié)果也和上面的一樣，都不再列出來了
死鎖問題
package test.MyThread.ticketDemo;
//兩個不同的鎖對象
public class LockObject {
public static final Object lock1 = new Object();
public static final Object lock2 = new Object();
}
package test.MyThread.ticketDemo;
public class DieLockThread extends Thread{
public boolean flag;
public DieLockThread(boolean flag){
this.flag = flag;
}
@Override
public void run() {
if(flag){
synchronized(LockObject.lock1){
System.out.println("lock1");
synchronized(LockObject.lock2){
System.out.println("lock2");
}
}
}else{
synchronized(LockObject.lock2){
System.out.println("lock2");
synchronized(LockObject.lock1){
System.out.println("lock1");
}
}
}
}
}
package test.MyThread.ticketDemo;
public class DieLockDemo {
public static void main(String[] args) {
DieLockThread d1 = new DieLockThread(true);
DieLockThread d2 = new DieLockThread(false);
d1.start();
d2.start();
}
}
程序會卡在這一步，不能進行下一步也不能停止
利用有參構(gòu)造，構(gòu)造出來的線程d1應(yīng)該是先獲得鎖對象LockObject.lock1然后執(zhí)行打印語句。接著獲取鎖對象LockObject.lock2，然后打印lock2。
但是這里因為線程d2是先獲取的鎖對象LockObject.lock2，并占據(jù)這個鎖對象，然后想獲得鎖對象LockObject.lock1，但LockObject.lock1此時被線程d1占據(jù)著
兩個線程都在等待對方釋放鎖對象，然后進行下一步，但是兩者都不釋放，導致程序卡死在這里。這就造成了死鎖。
lock
package test.MyThread.ticketDemo;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class LockThread implements Runnable{
private int ticket = 100;
Lock lock = new ReentrantLock();
@Override
public void run(){
while(ticket>0){
try{
lock.lock();
if(ticket>0){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " 正在出售第 " + (ticket--) + " 張票");
}
}finally {
lock.unlock();
}
}
}
}
package test.MyThread.ticketDemo;
public class LockDemo {
public static void main(String[] args) {
LockThread lt = new LockThread();
Thread t1 = new Thread(lt,"窗口一");
Thread t2 = new Thread(lt,"窗口二");
Thread t3 = new Thread(lt,"窗口三");
t1.start();
t2.start();
t3.start();
}
}
結(jié)果正確
總結(jié)
本篇文章就到這里了，希望能夠給你帶來幫助，也希望您能夠多多關(guān)注腳本之家的更多內(nèi)容！
相關(guān)文章
springboot多項目結(jié)構(gòu)實現(xiàn)
本文主要介紹了springboot多項目結(jié)構(gòu)實現(xiàn)，文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值，需要的朋友們下面隨著小編來一起學習學習吧2023-01-01
mybatis使用foreach查詢不出結(jié)果也不報錯的問題
這篇文章主要介紹了mybatis使用foreach查詢不出結(jié)果也不報錯的問題，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教2022-03-03
這篇文章主要介紹了Mybatis與Ibatis的區(qū)別,需要的朋友可以參考下2016-05-05
SpringMVC使用hibernate-validator進行參數(shù)校驗最佳實踐記錄
這篇文章主要介紹了SpringMVC使用hibernate-validator進行參數(shù)校驗最佳實踐,本文通過實例代碼給大家介紹的非常詳細，對大家的學習或工作具有一定的參考借鑒價值，需要的朋友可以參考下2021-05-05
ean在Spring和SpringMVC中無所不在，將這個概念內(nèi)化很重要，所以下面這篇文章主要給大家介紹了關(guān)于Spring學習筆記之bean基礎(chǔ)的相關(guān)資料，文中通過示例代碼介紹的非常詳解，需要的朋友可以參考下。2017-12-12
Java之多個線程順序循環(huán)執(zhí)行的幾種實現(xiàn)
這篇文章主要介紹了Java之多個線程順序循環(huán)執(zhí)行的幾種實現(xiàn)方式,具有很好的參考價值,希望對大家有所幫助,如有錯誤或未考慮完全的地方,望不吝賜教2023-09-09
這篇文章主要介紹了java瀏覽器文件打包下載過程解析,文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值,需要的朋友可以參考下2019-10-10
Spring的核心功能有三點IOC、DI、AOP，IOC則是基礎(chǔ)，也是Spring功能的最核心的點之一。今天一起來總結(jié)下Spring中Bean是怎么被創(chuàng)建出來的2023-03-03
這篇文章主要介紹了IDEA 前進 后退 添加到工具欄的操作，具有很好的參考價值，希望對大家有所幫助。一起跟隨小編過來看看吧2021-02-02
Java Swing JToggleButton開關(guān)按鈕的實現(xiàn)
這篇文章主要介紹了Java Swing JToggleButton開關(guān)按鈕的實現(xiàn)，文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值，需要的朋友們下面隨著小編來一起學習學習吧2019-12-12