JAVA多線程編程實例分析

今天小編給大家分享一下JAVA多線程編程實例分析的相關知識點，內容詳細，邏輯清晰，相信大部分人都還太了解這方面的知識，所以分享這篇文章給大家參考一下，希望大家閱讀完這篇文章后有所收獲，下面我們一起來了解一下吧。

1.三個售票窗口同時出售20張票

程序分析： (1)票數要使用同一個靜態值 (2)為保證不會出現賣出同一個票數，要 java 多線程同步鎖。 設計思路： (1)創建一個站臺類Station，繼承 Thread，重寫 run方法，在 run 方法里面執行售票操作！售票要使用同步鎖：即有一個站臺賣這張票時，其他站臺要等這張票賣完！ (2)創建主方法調用類

（一）創建一個站臺類，繼承 Thread

package com.xykj.threadStation;
public class Station extends Thread {
    // 通過構造方法給線程名字賦值
    public Station(String name) {
       super(name);// 給線程名字賦值
    }
    // 為了保持票數的一致，票數要靜態
    static int tick = 20;    
    // 創建一個靜態鑰匙
    static Object ob = "aa";//值是任意的
    // 重寫run方法，實現買票操作
    @Override
    public void run() {
      while (tick > 0) {
          synchronized (ob) {// 這個很重要，必須使用一個鎖，
          // 進去的人會把鑰匙拿在手上，出來后才把鑰匙拿讓出來
          if (tick > 0) {
            System.out.println(getName() + "賣出了第" + tick + "張票");
            tick--;
          } else {
            System.out.println("票賣完了");
          }
        }
        try {
            sleep(1000)；//休息一秒
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
      }
  }
}

（二）創建主方法調用類

package com.xykj.threadStation;
public class MainClass {
  /**
  * java多線程同步鎖的使用
   * 示例：三個售票窗口同時出售10張票
   * */
  public static void main(String[] args) {
      //實例化站臺對象，并為每一個站臺取名字
     Station station1=new Station("窗口1");
     Station station2=new Station("窗口2");
     Station station3=new Station("窗口3");
    // 讓每一個站臺對象各自開始工作
     station1.start();
     station2.start();
     station3.start();
  }
}

程序運行結果：

窗口1賣出了第20張票
窗口2賣出了第19張票
窗口3賣出了第18張票
窗口3賣出了第17張票
窗口1賣出了第16張票
窗口2賣出了第15張票
窗口3賣出了第14張票
窗口1賣出了第13張票
窗口2賣出了第12張票
窗口2賣出了第11張票
窗口1賣出了第10張票
窗口3賣出了第9張票
窗口3賣出了第8張票
窗口1賣出了第7張票
窗口2賣出了第6張票
窗口3賣出了第5張票
窗口1賣出了第4張票
窗口2賣出了第3張票
窗口3賣出了第2張票
窗口1賣出了第1張票
票賣完了

可以看到票數是不會有錯的！

2.兩個人AB通過一個賬戶A在柜臺取錢和B在ATM機取錢！

程序分析：

錢的數量要設置成一個靜態的變量，兩個人要取的同一個對象值。 （一）創建一個 Bank 類

package com.thread.demo.demo2;
import java.util.Objects;
public class Bank {
    // 假設一個賬戶有1000塊錢  
    static double money = 1000;
    // 柜臺Counter取錢的方法  
    private void Counter(double money) {
        Bank.money -= money;
        System.out.println("柜臺取錢" + money + "元，還剩" + Bank.money + "元！");
    }
    // ATM取錢的方法  
    private void ATM(double money) {
        Bank.money -= money;
        System.out.println("ATM取錢" + money + "元，還剩" + Bank.money + "元！");
    }
    //提供一個對外取款途徑，防止直接調取方法同時取款時，并發余額顯示錯誤
    public synchronized void outMoney(double money, String mode) throws Exception{
        if(money > Bank.money){
            //校驗余額是否充足
            throw new Exception("取款金額"+money+",余額只剩"+Bank.money+"，取款失敗");
        }
        if(Objects.equals(mode, "ATM")){
            ATM(money);
        } else {
            Counter(money);
        }
    }
}

（二）創建一個 PersonA 類

package com.thread.demo.demo2;
public class PersonA extends Thread {
    Bank bank;
    String mode;
    public PersonA(Bank bank, String mode) {
        this.mode = mode;
        this.bank = bank;
    }
        while(bank.money >= 100){
            try {
                bank.outMoney(100, mode);
            } catch (Exception e1) {
                // TODO Auto-generated catch block
                e1.printStackTrace();
            }
            try {
                sleep(100);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
}

（三）創建一個 PersonB 類

package com.thread.demo.demo2;
public class PersonB extends Thread {
    Bank bank;
    String mode;
    public PersonB(Bank bank, String mode) {
        this.bank = bank;
        this.mode = mode;
    }
    public void run() {
        while (bank.money >= 200) {
            try {
                bank.outMoney(200, mode);
            } catch (Exception e1) {
                // TODO Auto-generated catch block
                e1.printStackTrace();
            }
            try {
                sleep(100);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
}

（四）創建主方法的調用類

package com.thread.demo.demo2;
/**
 * 兩個人AB通過一個賬戶A在柜臺取錢和B在ATM機取錢
 * */
public class MainClass {
    public static void main(String[] args) {
        Bank bank = new Bank();
        // 實例化兩個人，傳入同一個銀行的對象
        PersonA a = new PersonA(bank, "Counter");
        PersonB b = new PersonB(bank, "ATM");
        a.start();
        b.start();
    }
}

可以看到取完就停止運行了。

3.龜兔賽跑問題

龜兔賽跑：2000米
要求：
 (1)兔子每 0.1 秒 5 米的速度，每跑20米休息1秒;
 (2)烏龜每 0.1 秒跑 2 米，不休息；
 (3)其中一個跑到終點后另一個不跑了！
程序設計思路：
 (1)創建一個 Animal 動物類，繼承Thread，編寫一個 running 抽象方法，重寫 run 方法，把 running 方法在 run 方法里面調用。
 (2)創建 Rabbit 兔子類和 Tortoise 烏龜類，繼承動物類
 (3)兩個子類重寫 running 方法
 (4)本題的第3個要求涉及到線程回調。需要在動物類創建一個回調接口，創建一個回調對象。

（一）創建 Animal 動物類

package com.thread.demo.demo3;
public abstract class Animal extends Thread {
    public int length = 2000;// 比賽長度
    public abstract void runing();
    @Override
    public void run() {
        super.run();
        while (length > 0) {
            runing();
        }
    }
    // 在需要回調數據的地方（兩個子類需要），聲明一個接口
    public static interface Calltoback {
        public void win();
    }
    // 2.創建接口對象
    public Calltoback calltoback;
}

（二）創建 Rabbit 兔子類

package com.thread.demo.demo3;
public class Rabbit extends Animal {
    public Rabbit() {
        setName("兔子");
    }
    @Override
    public void runing() {
        //兔子速度
        int dis = 5;
        length -= dis;
        System.out.println("兔子跑了" + dis + "米，距離終點還有" + length + "米");
        if (length <= 0) {
            length = 0;
            System.out.println("兔子獲得了勝利");
            // 給回調對象賦值，讓烏龜不要再跑了
            if (calltoback != null) {
                calltoback.win();
            }
        }
        try {
            if ((2000 - length) % 20 == 0) {    // 每20米休息一次,休息時間是1秒
                sleep(1000);
            } else {                //沒0.1秒跑5米
                sleep(100);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

（三）創建 Tortoise 烏龜類

package com.thread.demo.demo3;
public class Tortoise extends Animal {
    public Tortoise() {
        setName("烏龜");// Thread的方法，給線程賦值名字
    }
    // 重寫running方法，編寫烏龜的奔跑操作
    @Override
    public void runing() {
        // 烏龜速度
        int dis = 2;
        length -= dis;
        System.out.println("烏龜跑了" + dis + "米，距離終點還有" + length + "米");
        if (length <= 0) {
            length = 0;
            System.out.println("烏龜獲得了勝利");
            // 讓兔子不要在跑了
            if (calltoback != null) {
                calltoback.win();
            }
        }
        try {
            sleep(100);                     //沒0.1秒跑2米
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

（四）創建一個讓動物線程停止的類，這里要實現回調接口

package com.thread.demo.demo3;
import com.thread.demo.demo3.Animal.Calltoback;
public class LetOneStop implements Calltoback {
    // 動物對象
    Animal an;
    // 獲取動物對象，可以傳入兔子或烏龜的實例
    public LetOneStop(Animal an) {
        this.an = an;
    }
    // 讓動物的線程停止
    @Override
    public void win() {
        // 線程停止
        an.stop();
    }
}

（五）創建一個主方法調用類

package com.thread.demo.demo3;
public class MainClass {
    /**
     * 龜兔賽跑：2000米
     */
    public static void main(String[] args) {
        // 實例化烏龜和兔子
        Tortoise tortoise = new Tortoise();
        Rabbit rabbit = new Rabbit();
        // 回調方法的使用，誰先調用calltoback方法，另一個就不跑了
        LetOneStop letOneStop1 = new LetOneStop(tortoise);
        // 讓兔子的回調方法里面存在烏龜對象的值，可以把烏龜stop
        rabbit.calltoback = letOneStop1;
        LetOneStop letOneStop2 = new LetOneStop(rabbit);
        // 讓烏龜的回調方法里面存在兔子對象的值，可以把兔子stop
        tortoise.calltoback = letOneStop2;
        // 開始跑
        tortoise.start();
        rabbit.start();
    }
}

以上就是“JAVA多線程編程實例分析”這篇文章的所有內容，感謝各位的閱讀！相信大家閱讀完這篇文章都有很大的收獲，小編每天都會為大家更新不同的知識，如果還想學習更多的知識，請關注億速云行業資訊頻道。