java多執行緒：執行緒同步synchronized（不同步的問題、佇列與鎖），死鎖的產生和解決
阿新 • • 發佈：2020-08-18
# 0、不同步的問題
併發的執行緒不安全問題：
多個執行緒同時操作同一個物件，如果控制不好，就會產生問題，叫做執行緒不安全。
我們來看三個比較經典的案例來說明**執行緒不安全的問題**。
## 0.1 訂票問題
例如前面說過的黃牛訂票問題，可能出現負數或相同。
[執行緒建立方式&&黃牛訂票模擬](https://www.cnblogs.com/lifegoeson/p/13491735.html)
## 0.2 銀行取錢
再來看一個取錢的例子：
```java
/*
模擬一個賬戶
*/
class Account{
int money;
String name;
public Account(int money, String name) {
this.money = money;
this.name = name;
}
}
/*
模擬取款機,方便設定名字，繼承Thread而不是實現Runnable
*/
class Drawing extends Thread{
Account account;
int outMoney;//取出去了多少錢
int outTotal;//總共取到了多少錢
public Drawing(Account account, int outMoney,String name) {
super(name);
this.account = account;
this.outMoney = outMoney;
}
@Override
public void run() {
account.money -= outMoney;
outTotal += outMoney;
System.out.println(this.getName() + "---賬戶餘額為：" + account.money);
System.out.println(this.getName() + "---總共取到了：" + outTotal);
}
}
```
然後我們寫個客戶端呼叫一下，假設兩個人同時取錢，操作同一個賬戶
```java
public class Checkout {
public static void main(String[] args) {
Account account = new Account(200000,"禮金");
Drawing you = new Drawing(account,8000,"你");
Drawing wife = new Drawing(account,300000,"你老婆");
you.start();
wife.start();
}
}
```
執行起來，問題就會出現。
每次的結果都不一樣，而且，這樣肯定會**把錢取成負數**，顯然這是非法的（嘻嘻），首先邏輯上需要修改，當錢少於 0 了就應該退出，並且不能繼續取錢的動作了。按照這個思路，加上一個判斷呢？
```java
if (account.money < outMoney){
System.out.println("餘額不足");
return;
}
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
```
可是即便是這樣，發現還是會出現結果為負的情況，**無法保證執行緒安全**。
## 0.3 數字遞增
還有一個經典的例子，那就是對於直接計算迭代過慢，而轉為多執行緒。
一個數字 num ，開闢一萬個執行緒對他做 ++ 操作，看結果會是多少。
```java
public class AddSum {
private static int num = 0;
public static void main(String[] args) {
for (int i=0; i<=10000; i++){
new Thread(()->{
num++;
}).start();
}
System.out.println(num);
}
}
```
每次運算的結果都不一樣，一樣的是，結果永遠 < 10000 。
或者用給 list 裡新增數字來測試：
```java
List list = new ArrayList<>();
for (int i=0; i<10000; i++){
new Thread(()->{
list.add(Thread.currentThread().getName());
}).start();
}
System.out.println(list.size());
```
一樣的結果。
**執行緒不安全的問題如何解決呢**?
list = new ArrayList<>();
for (int i=0; i<10000; i++){
new Thread(()->{
synchronized (list){
list.add(Thread.currentThread().getName());
}
}).start();
}
Thread.sleep(2000);
System.out.println(list.size());
```
main方法，下面的print語句，這些都是執行緒，所以可能上面還沒有操作的時候，就已經輸出了，為了方便觀察，我們在最後輸出之前先讓main執行緒休眠一會，再看裡面add的結果是否正確。
list1 = new CopyOnWriteArrayList<>();
for (int i=0; i<10000; i++){
new Thread(()->{
list1.add(Thread.currentThread().getName());
}).start();
}
Thread.sleep(2000);
System.out.println(list1.size());
```
## 2.3 問題
synchronized 塊太小，可能鎖不住，安全性又不行了，鎖的方法太大，又效率會降低，所以要很注意**控制範圍**。
而且，還有類似於 單例模式 裡 Double-Check 寫法針對的問題，有時候一重鎖性質不夠，兩重鎖仍然不夠保證安全。
# 三、執行緒同步問題應用示例
## 3.1 快樂影院
電影院買票。
```java
/**
* 快樂影院
*/
public class HappyCinema {
public static void main(String[] args) {
Cinema cinema = new Cinema(20, "萬達");
new Thread(new Customer(cinema,2)).start();
new Thread(new Customer(cinema,1)).start();
}
}
/**
* 電影院，提供訂票方法
*/
class Cinema{
int available;
String name;
public Cinema(int available, String name) {
this.available = available;
this.name = name;
}
//提供購票方法
public boolean bookTickets(int seats){
System.out.println("可用位置為："+available);
if (seats > available){
return false;
}
available -= seats;
return true;
}
}
/**
* 顧客，有多個顧客，模仿多執行緒
*/
class Customer implements Runnable{
Cinema cinema;
int seats;
//顧客建立的時候帶上要預定的作為+訂哪個影院
public Customer(Cinema cinema, int seats) {
this.cinema = cinema;
this.seats = seats;
}
@Override
public void run() {
boolean flag = cinema.bookTickets(seats);
if (flag){
System.out.println("出票成功,"+Thread.currentThread().getName()+"買了 "+seats+" 張票");
}else{
System.out.println("出票失敗,"+Thread.currentThread().getName()+"買票，但位置不足 ");
}
}
}
```
對於一個電影院的票：available 資源來說，多個執行緒訪問，是需要同步的，否則就會出現不安全的問題。
解決：
```java
@Override
public void run() {
synchronized (cinema){
//。。。
}
}
}
```
## 3.2 快樂影院進階
影院票的時候不是簡單計數，是可以選座位的，我們修改程式碼，具體到某一個座位號的預定。
將 int 座位數目改成 List，那麼購票方法改動如下：
```java
public boolean bookTickets(List seats){
System.out.println("可用位置為：" + available);
List copy = new ArrayList<>(available);
//相減
copy.removeAll(seats);
//判斷改變後
if (available.size() != copy.size() + seats.size() ){
return false;
}
available = copy;
return true;
}
```
其他地方只需要做簡單的修改，在呼叫的時候傳入一個構造好的 list 即可，這個時候再來看：
