導航

線程同步

并發：同一個對象被多個線程同時操作

• 一個線程持有鎖會導致其他所有需要此鎖的線程掛起

• 在多線程競爭下，加鎖，釋放鎖會導致比較多的上下文切換和調度延時，引起性能問題

• 如果一個優先級高的線程等待一個優先級低的線程釋放鎖，會導致優先級倒置，引起性能問題

同步方法

• 方法里面需要修改的內容才需要鎖

  package com.Spp.syn;
  ?
  // 不安全的買票
  public class UnSafeBuyTicket {
      public static void main(String[] args) {
          BuyTicket station = new BuyTicket();
          new Thread(station,"你").start();
          new Thread(station,"我").start();
          new Thread(station,"他").start();
      }
  }
  ?
  class BuyTicket implements Runnable{// 涉及多個線程操作同一個對象
      private int ticketNumbers = 10;
      boolean flag = true;// 外部停止方式
      @Override
      public void run() {
          while (flag){
              try {
                  Buy();
              } catch (InterruptedException e) {
                  e.printStackTrace();
              }
          }
      }
      //synchronized 同步方法，鎖的是this
      private synchronized void Buy() throws InterruptedException {
          // 判斷是否有票
          if(ticketNumbers <= 0){
              flag = false;
              return;
          }
          // 模擬延時
          Thread.sleep(100);
          // 買票
          System.out.println(Thread.currentThread().getName()+"拿到了第"+ticketNumbers--+"張票");
      }
  }

   

同步塊：

• synchronized(Obj){}

• Obj稱之為同步監視器

  • Obj可以是任何對象，推薦使用共享資源作為同步監視器

  • 同步方法中無需指定同步監視器，同步方法的同步監視器及時this，就是這個對象本身，或者是class

• 同步監視器的執行過程

  1. 第一個線程訪問，鎖定同步監視器，執行其中代碼

  2. 第二個線程訪問，發現同步監視器被鎖定，無法訪問

  3. 第一個線程訪問完畢，解鎖同步監視器

  4. 第二個線程訪問，發現同步監視器沒有鎖，然后鎖定并訪問

package com.Spp.syn;
?
public class UnSafeBank {
    public static void main(String[] args) {
        Account account = new Account(3600,"備用金");
        Drawing dra1 = new Drawing(account,280,"dra1");
        Drawing dra2 = new Drawing(account,100,"dra2");
        dra1.start();
        dra2.start();
    }
}
?
// 賬戶
class Account {
    int money;
    String name;
?
    public Account(int money, String name) {
        this.money = money;
        this.name = name;
    }
}
?
//銀行：模擬取款
class Drawing extends Thread {// 不涉及多個線程操作同一個對象
    Account account;
    // 要取的錢
    int takeMoney;
    // 現在手里有多少錢
    int nowMoney;
    public Drawing( Account account,int takeMoney,String name){
        super(name);
        this.account = account;
        this.takeMoney = takeMoney;
    }
?
    @Override
    public void run() {// 取錢
        //鎖的對象就是變化的量，需要增刪改查的對象
        synchronized (account){
            // 判斷錢夠不夠
            if(account.money-takeMoney<0){
                System.out.println(Thread.currentThread().getName()+"錢不夠,取不了這么多");
                return;
            }
            try {
                sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            account.money = account.money-takeMoney;
            nowMoney = nowMoney+takeMoney;
            System.out.println(account.name+"余額為"+account.money);
            //Thread.currentThread().getName() = this.getName()
            System.out.println(this.getName()+"手里的錢為"+nowMoney);
        }
        }
?
}

死鎖

執行卡死

package com.kuang.ThreadLesson;
?
public class DeadLock {
    public static void main(String[] args) {
        MakeUp g1 = new MakeUp(0,"11");
        MakeUp g2 = new MakeUp(1,"22");
        g1.start();
        g2.start();
    }
}
//口紅
class LipStick{
?
}
//鏡子
class Mirror{
?
}
?
class MakeUp extends Thread{
    // 需要的資源只有一份，用static來保證只有一份
    static LipStick lipStick = new LipStick();
    static Mirror mirror = new Mirror();
    int choice;// 選擇
    String name;// 使用的人
    MakeUp(int choice,String name){
        this.choice = choice;
        this.name = name;
    }
    @Override
    public void run() {
        try {
            makeup();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    private void makeup() throws InterruptedException {
        if(choice == 0){
            synchronized (lipStick){
                System.out.println(this.name+"獲得口紅的鎖");
                Thread.sleep(100);
                synchronized (mirror){
                    System.out.println(this.name+"獲得鏡子的鎖");
                }
            }
?
        }else{
            synchronized (mirror){
                System.out.println(this.name+"獲得鏡子的鎖");
                Thread.sleep(200);
                synchronized (lipStick){
                    System.out.println(this.name+"獲得口紅的鎖");
                }
            }
?
        }
    }
}

順利執行

 private void makeup() throws InterruptedException {
        if(choice == 0){
            synchronized (lipStick){
                System.out.println(this.name+"獲得口紅的鎖");
                Thread.sleep(100);
            }
            synchronized (mirror){
                System.out.println(this.name+"獲得鏡子的鎖");
            }
        }else{
            synchronized (mirror){
                System.out.println(this.name+"獲得鏡子的鎖");
                Thread.sleep(200);
            }
            synchronized (lipStick){
                System.out.println(this.name+"獲得口紅的鎖");
            }
        }
    }

Lock(鎖)

ReentrantLock：可重入鎖

ReentrantLock類實現Lock鎖

package com.kuang.ThreadLesson;
import java.util.concurrent.locks.ReentrantLock;
public class TestLock {
    public static void main(String[] args) {
        BuyTicket buyTicket = new BuyTicket();
        new Thread(buyTicket).start();
        new Thread(buyTicket).start();
        new Thread(buyTicket).start();
    }
}
?
class BuyTicket implements Runnable{
    int ticketNumbers = 10;
    //定義Lock鎖
    private final ReentrantLock lock = new ReentrantLock();
?
    @Override
    public void run() {
        while (true) {
            try {
                lock.lock();//加鎖
                if (ticketNumbers > 0) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(ticketNumbers--);
                }
            } finally {
                lock.unlock();//解鎖
            }
        }
    }
}

synchronized 與Lock的對比

• Lock是顯示鎖（手動開啟和關閉），synchronized是隱式鎖，出了作用域自動釋放

• Lock只有代碼塊鎖，synchronized有代碼塊鎖和方法鎖

• 使用Lock鎖，JVM將花費較少的時間來調度線程，性能更好。并且具有更好的擴展性（提供更多的子類）

• 優先使用順序：Lock > 同步代碼塊 > 同步方法