JAVA - 多線程 - 同步與死鎖

同步問題引出

問題概況：售票系統中只能售出5張票，有三個線程在刷票，每個線程刷票的次數是100次：

class MyThread implements Runnable {
	private int ticket = 5;
	public void run() {
		for(int i = 0; i < 100; i++) {
			if(ticket > 0) {
				try {
					Thread.sleep(300);
				} catch (Exception e) {
					e.printStackTrace();
				}
				System.out.println("賣票： ticket = " + ticket--);
			}
		}
	}
}

public class SyncDemo {
	public static void main(String[] args) {
		MyThread mt = new MyThread();
		Thread t1 = new Thread(mt);
		Thread t2 = new Thread(mt);
		Thread t3 = new Thread(mt);
		t1.start();
		t2.start();
		t3.start();
	}
}

程序運行的結果：

賣票： ticket = 4
賣票： ticket = 5
賣票： ticket = 4
賣票： ticket = 3
賣票： ticket = 2
賣票： ticket = 1
賣票： ticket = 0
賣票： ticket = -1

 

同步問題分析

總結操作代碼中對票數的操作如下：

1. 判斷票數是否大於0，大於0則表示還有票可以賣；
2. 如果票大於0，則將票賣出。

     但是，步驟一跟步驟二之間假如了延遲操作，那麼一個線程就有可能還沒有對票數進行減操作之前，其他縣城就已經將票數減少，就會出現負數的情況。前面已經提及過通過Runnable接口實現程序的多線程，可以在線程間共享類屬資源，則意味着類中的屬性將被多個線程共享，這樣就會造成一個問題，如果多個線程要操作同一資源就有可能出現資源同步的問題。

        所謂同步，就是指多個操作之間在同一個時間段內只能有一個線程進行，其他線程要等待次線程完成之後纔可以繼續執行。

       

       JAVA中實現同步的方法有兩種：

• 同步代碼塊

synchronized(同步對象) {
	需要同步的代碼；
}

• 同步方法

synchronized 方法返回值 方法名稱（參數列表）{
}

同步問題解決

使用同步代碼塊解決同步問題

class MyThread implements Runnable {
	private int ticket = 5;
	public void run() {
		for(int i = 0; i < 100; i++) {
			synchronized (this) {    // 同步代碼塊
				if(ticket > 0) {
					try {
						Thread.sleep(300);
					} catch (Exception e) {
						e.printStackTrace();
					}
					System.out.println("賣票： ticket = " + ticket--);
				}
			}
		}
	}
}

使用同步方法解決同步問題

class MyThread implements Runnable {
	private int ticket = 5;
	public void run() {
		for(int i = 0; i < 100; i++) {
			this.sale();
		}
	}
	public synchronized void sale() {
			if(ticket > 0) {
				try {
					Thread.sleep(300);
				} catch (Exception e) {
					e.printStackTrace();
				}
				System.out.println("賣票： ticket = " + ticket--);
			}
	}
}

死鎖問題

     同步可以保證資源共享操作的正確性，但是過多的同步有可能是導致死鎖的，造成程序的停滯。關於死鎖的概念，可以想象一下如下情景：

1. 張三想要李四的畫，李四想要張三的書；
2. 張三  -->  李四 : 你給我畫，我給你書；
3. 李四 -->  張三  : 你給我書，我給你畫；
4. 張三跟李四互不想讓，就造成了兩人一直乾等下去。

代碼的實現：

class Zhangsan {
	public void say() {
		System.out.println("張三  --> 李四 : 你給我畫，我給你書.");
	}
	public void get() {
		System.out.println("張三：得到了畫！");
	}
}

class Lisi {
	public void say() {
		System.out.println("李四 --> 張三  : 你給我書，我給你畫。");
	}
	public void get() {
		System.out.println("李四：得到了書！");
	}
}

public class ThreadDeadLock implements Runnable {
	
	private static Zhangsan zs = new Zhangsan();  //同步對象
	private static Lisi ls = new Lisi();          //同步對象
	
	private boolean flag = false;
	
	public void run() {
		if(flag) {                      // thA 執行的代碼
			synchronized (zs) {    //獲得"張三"同步鎖
				zs.say();
				try {
					Thread.sleep(500);
				} catch (Exception e) {
					e.printStackTrace();
				}
				synchronized (ls) { // 需獲得"李四"才能往下執行，此時"李四"被thB獲得，而thB釋放"李四"					           zs.get();  // 條件是獲得"張三"，因爲此時"張三"爲thA所有，造成了兩線程的死鎖
				}
			}
		} else {
			synchronized (ls) {   //thB 執行的代碼，獲得"李四"同步鎖
				ls.say();
				try {
					Thread.sleep(500);
				} catch (Exception e) {
					e.printStackTrace();
				}
				synchronized (zs) {
					ls.get();
				}
			}
		}
	}
	
	public static void main(String[] args) {
		ThreadDeadLock t1 = new ThreadDeadLock();
		ThreadDeadLock t2 = new ThreadDeadLock();
		t1.flag = true;
		t2.flag = false;
		Thread thA = new Thread(t1, "thA");
		Thread thB = new Thread(t2, "thB");
		
		System.out.println(thA.getName() + " flag is " + t1.flag);
		System.out.println(thB.getName() + " flag is " + t2.flag);
		
		thA.start();
		thB.start();
	}

}

 

運行結果

thA flag is true
thB flag is false
張三  --> 李四  : 你給我畫，我給你書。
李四  --> 張三  : 你給我書，我給你畫。

思考：

     如何修改以上程序來解決死鎖問題？

 

總結

     通過Runnable()接口來實現多線程程序，由於存在線程間資源間的共享問題，同步是用來解決不同線程對共享資源操作的完整性，但是過多的同步就有可能產生死鎖，應該要盡力避免程序死鎖的發生。

 

BR~

Jianwei Wang