Java基礎day20

• Java基礎day20-多線程
• 1.實現多線程
• • 1.1進程和線程
  • 1.2實現多線程方式一：繼承Thread類
  • 1.3設置和獲取線程名稱
  • 1.4線程優先級
  • 1.5線程控制
  • 1.6線程的生命周期
  • 1.7實現多線程方式二：實現Runnable接口
• 2.線程同步
• • 2.1賣票
  • 2.2賣票案例的問題
  • 2.3同步代碼塊解決數據安全問題
  • 2.4同步方法解決數據安全問題
  • 2.5線程安全的類
  • 2.6Lock鎖
• 3.生產者消費者
• • 3.1生產者和消費者模式概述
  • 3.2生產者和消費者案例

Java基礎day20-多線程

1.實現多線程

1.1進程和線程

• 進程：是正在運行的程序
  是系統進行資源分配和調用的獨立單位
  每一個進程都有它自己的內存空間和系統資源
• 線程：是進程中的單個順序控制流，是一條執行路徑
  單線程：一個進程如果只有一條執行路徑，則稱為單線程程序
  多線程：一個進程如果有多條執行路徑，則稱為多線程程序

1.2實現多線程方式一：繼承Thread類

• 方法介紹

方法名說明

void run()	在線程開啟后，此方法將被調用執行
void start()	使此線程開始執行，Java虛擬機會調用run方法()

• 實現步驟
  定義一個類MyThread繼承Thread類 在MyThread類中重寫run()方法
  創建MyThread類的對象
  啟動線程

• 代碼演示

//線程定義 public class myThread extends Thread{@Overridepublic void run() {for (int i=0;i<100;i++){System.out.println(i);}} } //測試類 public class test1 {public static void main(String[] args) {myThread m1 = new myThread();myThread m2 = new myThread();// m1.run(); // m2.run();//void start() 導致此線程開始執行; Java虛擬機調用此線程的run方法m1.start();m2.start();} }

• 兩個小問題
  為什么要重寫run()方法？
  ? 因為run()是用來封裝被線程執行的代碼
  run()方法和start()方法的區別？
  ?run()：封裝線程執行的代碼，直接調用，相當于普通方法的調用
  ?start()：啟動線程；然后由JVM調用此線程的run()方法

1.3設置和獲取線程名稱

• 方法介紹

方法名說明

void setName(String name)	將此線程的名稱更改為等于參數name
String getName()	返回此線程的名稱
Thread currentThread()	返回對當前正在執行的線程對象的引用

• 代碼演示

public class test2 {public static void main(String[] args) {myThread my1 = new myThread();myThread my2 = new myThread();//void setName(String name)：將此線程的名稱更改為等于參數 namemy1.setName("高鐵");my2.setName("飛機");//Thread(String name) // myThread my1 = new myThread("高鐵"); // myThread my2 = new myThread("飛機");my1.start();my2.start();//static Thread currentThread() 返回對當前正在執行的線程對象的引用System.out.println(Thread.currentThread().getName());} }

1.4線程優先級

• 線程調度
  兩種調度方式
  ? 分時調度模型：所有線程輪流使用 CPU 的使用權，平均分配每個線程占用 CPU 的時間片
  ? 搶占式調度模型：優先讓優先級高的線程使用 CPU，如果線程的優先級相同，那么會隨機選擇一個，優先級高的線程獲取的 CPU 時間片相對多一些
  Java使用的是搶占式調度模型
  隨機性
  假如計算機只有一個 CPU，那么 CPU 在某一個時刻只能執行一條指令，線程只有得到CPU時間片，也就是使用權，才可以執行指令。所以說多線程程序的執行是有隨機性，因為誰搶到CPU的使用權是不一定的優先級相關方法

方法名說明

final int getPriority()	返回此線程的優先級
final void setPriority(int newPriority)	更改此線程的優先級 線程默認優先級是5；線程優先級的范圍是：1-10

public class ThreadPriority extends Thread{@Overridepublic void run() {for (int i = 0;i<100;i++){System.out.println(getName()+":"+i);}} }public class test3 {public static void main(String[] args) {ThreadPriority tp1 = new ThreadPriority();ThreadPriority tp2 = new ThreadPriority();ThreadPriority tp3 = new ThreadPriority();tp1.setName("高鐵");tp2.setName("飛機");tp3.setName("汽車");//public final int getPriority()：返回此線程的優先級System.out.println(tp1.getPriority());// 5System.out.println(tp2.getPriority());// 5System.out.println(tp3.getPriority()); //5//public final void setPriority(int newPriority)：更改此線程的優先級// tp1.setPriority(10000); //IllegalArgumentExceptionSystem.out.println(Thread.MAX_PRIORITY); //10System.out.println(Thread.MIN_PRIORITY); //1System.out.println(Thread.NORM_PRIORITY); //5//設置正確的優先級tp1.setPriority(5);tp2.setPriority(10);tp3.setPriority(1);tp1.start();tp2.start();tp3.start();} }

1.5線程控制

• 相關方法

方法名說明

static void sleep(long millis)	使當前正在執行的線程停留（暫停執行）指定的毫秒數
void join()	等待這個線程死亡
void setDaemon(boolean on)	將此線程標記為守護線程，當運行的線程都是守護線程時，Java虛擬機將退出

• 代碼演示

//sleep演示 public class ThreadSleep extends Thread {@Overridepublic void run() {for (int i = 0; i < 100; i++) {System.out.println(getName() + ":" + i);try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}} } //測試類 public class test4 {public static void main(String[] args) {ThreadSleep ts1 = new ThreadSleep();ThreadSleep ts2 = new ThreadSleep();ThreadSleep ts3 = new ThreadSleep();ts1.setName("曹操");ts2.setName("劉備");ts3.setName("孫權");ts1.start();ts2.start();ts3.start();} } //Join演示： public class ThreadJoin extends Thread{@Overridepublic void run() {for (int i = 0; i < 100; i++) {System.out.println(getName() + ":" + i);}} } public class test5 {public static void main(String[] args) {ThreadJoin tj1 = new ThreadJoin();ThreadJoin tj2 = new ThreadJoin();ThreadJoin tj3 = new ThreadJoin();tj1.setName("康熙");tj2.setName("四阿哥");tj3.setName("六阿哥");tj1.start();try {tj1.join();} catch (InterruptedException e) {e.printStackTrace();}tj2.start();tj3.start();} }//Daemon演示： public class ThreadDaemon extends Thread{@Overridepublic void run() {for (int i = 0; i < 100; i++) {System.out.println(getName() + ":" + i);}} } public class test6 {public static void main(String[] args) {ThreadDaemon td1 = new ThreadDaemon();ThreadDaemon td2 = new ThreadDaemon();td1.setName("張飛");td2.setName("關羽");//設置主線程為劉備Thread.currentThread().setName("劉備");//設置守護線程td1.setDaemon(true);td2.setDaemon(true);td1.start();td2.start();for (int i = 0; i < 10; i++) {System.out.println(Thread.currentThread().getName() + ":" + i);}} }

1.6線程的生命周期

線程一共有五種狀態，線程在各種狀態之間轉換。

1.7實現多線程方式二：實現Runnable接口

Thread構造方法

方法名說明

Thread(Runnable target)	分配一個新的Thread對象
Thread(Runnable target, String name)	分配一個新的Thread對象

• 實現步驟
  定義一個類MyRunnable實現Runnable接口
  在MyRunnable類中重寫run()方法
  創建MyRunnable類的對象
  創建Thread類的對象，把MyRunnable對象作為構造方法的參數
  啟動線程
• 代碼演示

public class MyRunnable implements Runnable {@Overridepublic void run() {for (int i = 0; i < 100; i++){System.out.println(Thread.currentThread().getName()+":"+i);}} } public class test7 {public static void main(String[] args) {//創建MyRunnable類的對象MyRunnable my = new MyRunnable();//創建Thread類的對象，把MyRunnable對象作為構造方法的參數// Thread(Runnable target) // Thread t1 = new Thread(my); // Thread t2 = new Thread(my);//Thread(Runnable target, String name)Thread t1 = new Thread(my,"高鐵");Thread t2 = new Thread(my,"飛機");//啟動線程t1.start();t2.start();} }

• 多線程的實現方案有兩種
  繼承Thread類
  實現Runnable接口
• 相比繼承Thread類，實現Runnable接口的好處
  避免了Java單繼承的局限性
  適合多個相同程序的代碼去處理同一個資源的情況，把線程和程序的代碼、數據有效分離，較好的體現
  了面向對象的設計思想

2.線程同步

2.1賣票

• 案例需求
  某電影院目前正在上映國產大片，共有100張票，而它有3個窗口賣票，請設計一個程序模擬該電影院賣票
• 實現步驟
  • 定義一個類SellTicket實現Runnable接口，里面定義一個成員變量：private int tickets = 100;
  • 在SellTicket類中重寫run()方法實現賣票，代碼步驟如下
  • 判斷票數大于0，就賣票，并告知是哪個窗口賣的
  • 賣了票之后，總票數要減1
  • 票沒有了，也可能有人來問，所以這里用死循環讓賣票的動作一直執行
  • 定義一個測試類SellTicketDemo，里面有main方法，代碼步驟如下
  • 創建SellTicket類的對象
  • 創建三個Thread類的對象，把SellTicket對象作為構造方法的參數，并給出對應的窗口名稱
  • 啟動線程
• 代碼實現

public class SellTicket implements Runnable {private int tickets = 100;@Overridepublic void run() {while (true){if (tickets>0){System.out.println(Thread.currentThread().getName()+"正在出售第"+tickets+"張票");tickets--;}}} }public class test1 {public static void main(String[] args) {//創建SellTicket類的對象SellTicket st = new SellTicket();//創建三個Thread類的對象，把SellTicket對象作為構造方法的參數，并給出對應的窗口名稱Thread t1 = new Thread(st,"窗口1");Thread t2 = new Thread(st,"窗口2");Thread t3 = new Thread(st,"窗口3");//啟動線程t1.start();t2.start();t3.start();} }

2.2賣票案例的問題

• 賣票出現了問題
  相同的票出現了多次
  出現了負數的票
• 問題產生原因
  線程執行的隨機性導致的

//解決票數為復數的問題，但是仍會出現重復 public class SellTicket implements Runnable {private int tickets = 100;@Overridepublic void run() {while (true){if (tickets>0){try {Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName()+"正在出售第"+tickets+"張票");tickets--;}}} }

2.3同步代碼塊解決數據安全問題

• 安全問題出現的條件
  是多線程環境
  有共享數據
  有多條語句操作共享數據
• 如何解決多線程安全問題呢?
  基本思想：讓程序沒有安全問題的環境
• 怎么實現呢?
  把多條語句操作共享數據的代碼給鎖起來，讓任意時刻只能有一個線程執行即可
  Java提供了同步代碼塊的方式來解決
• 同步代碼塊格式:

synchronized(任意對象) { 多條語句操作共享數據的代碼 }

synchronized(任意對象)：就相當于給代碼加鎖了，任意對象就可以看成是一把鎖

• 同步的好處和弊端
  好處：解決了多線程的數據安全問題
  弊端：當線程很多時，因為每個線程都會去判斷同步上的鎖，這是很耗費資源的，無形中會降低程序的運行效率
• 代碼演示

public class SellTicket implements Runnable {private int tickets = 100;private Object obj = new Object();@Overridepublic void run() {while (true) {//tickets = 100;// t1,t2,t3// 假設t1搶到了CPU的執行權// 假設t2搶到了CPU的執行權synchronized (obj) {//t1進來后，就會把這段代碼給鎖起來if (tickets > 0) {try {Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "張票");tickets--;}}}} }public class test1 {public static void main(String[] args) {//創建SellTicket類的對象SellTicket st = new SellTicket();//創建三個Thread類的對象，把SellTicket對象作為構造方法的參數，并給出對應的窗口名稱Thread t1 = new Thread(st,"窗口1");Thread t2 = new Thread(st,"窗口2");Thread t3 = new Thread(st,"窗口3");//啟動線程t1.start();t2.start();t3.start();} }

2.4同步方法解決數據安全問題

• 同步方法的格式
  同步方法：就是把synchronized關鍵字加到方法上

修飾符 synchronized 返回值類型 方法名(方法參數) { 方法體； }

同步方法的鎖對象是什么呢?
this

• 靜態同步方法
  同步靜態方法：就是把synchronized關鍵字加到靜態方法上

修飾符 static synchronized 返回值類型 方法名(方法參數) { 方法體； }

同步靜態方法的鎖對象是什么呢?
類名.class

• 代碼演示

public class SellTicket implements Runnable {private static int tickets = 100;private int x = 0;@Overridepublic void run() {while (true){sellTicket();}}//同步方法 // private synchronized void sellTicket() { // if (tickets > 0){ // try { // Thread.sleep(100); // } catch (InterruptedException e) { // e.printStackTrace(); // } // System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "張票"); // tickets--; // } // }// 靜態同步方法private static synchronized void sellTicket() {if (tickets > 0) {try {Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "張票");tickets--;}} }public class test1 {public static void main(String[] args) {//創建SellTicket類的對象SellTicket st = new SellTicket();//創建三個Thread類的對象，把SellTicket對象作為構造方法的參數，并給出對應的窗口名稱Thread t1 = new Thread(st,"窗口1");Thread t2 = new Thread(st,"窗口2");Thread t3 = new Thread(st,"窗口3");//啟動線程t1.start();t2.start();t3.start();} }

2.5線程安全的類

• StringBuffer
  • 線程安全，可變的字符序列
  • 從版本JDK 5開始，被StringBuilder 替代。 通常應該使用StringBuilder類，因為它支持所有相同的操作，但它更快，因為它不執行同步
• Vector
  • 從Java 2平臺v1.2開始，該類改進了List接口，使其成為Java Collections Framework的成員。 與新的集
  • 合實現不同， Vector被同步。 如果不需要線程安全的實現，建議使用ArrayList代替Vector
• Hashtable
  • 該類實現了一個哈希表，它將鍵映射到值。 任何非null對象都可以用作鍵或者值
  • 從Java 2平臺v1.2開始，該類進行了改進，實現了Map接口，使其成為Java Collections Framework的成員。 與新的集合實現不同， Hashtable被同步。 如果不需要線程安全的實現，建議使用HashMap代替Hashtable

2.6Lock鎖

雖然我們可以理解同步代碼塊和同步方法的鎖對象問題，但是我們并沒有直接看到在哪里加上了鎖，在哪里釋放了鎖，為了更清晰的表達如何加鎖和釋放鎖，JDK5以后提供了一個新的鎖對象LockLock是接口不能直接實例化，這里采用它的實現類ReentrantLock來實例化

• ReentrantLock構造方法

方法名說明

ReentrantLock()	創建一個ReentrantLock的實例

• 加鎖解鎖方法

方法名說明

void lock()	獲得鎖
void unlock()	釋放鎖

• 代碼演示

//賣票方法 import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock;public class SellTicket implements Runnable{private int tickets = 100;private Lock lock = new ReentrantLock();@Overridepublic void run() {while (true){try {lock.lock();if (tickets>0){try {Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "張票");tickets--;}} finally {lock.unlock();}}} } //測試類 public class test1 {public static void main(String[] args) {SellTicket st = new SellTicket();Thread t1 = new Thread(st, "窗口1");Thread t2 = new Thread(st, "窗口2");Thread t3 = new Thread(st, "窗口3");t1.start();t2.start();t3.start();} }

3.生產者消費者

3.1生產者和消費者模式概述

• 概述
  生產者消費者模式是一個十分經典的多線程協作的模式，弄懂生產者消費者問題能夠讓我們對多線程編程的理解更加深刻。
  所謂生產者消費者問題，實際上主要是包含了兩類線程：
  一類是生產者線程用于生產數據
  一類是消費者線程用于消費數據
  為了解耦生產者和消費者的關系，通常會采用共享的數據區域，就像是一個倉庫
  生產者生產數據之后直接放置在共享數據區中，并不需要關心消費者的行為
  消費者只需要從共享數據區中去獲取數據，并不需要關心生產者的行為
  
• Object類的等待和喚醒方法

方法名說明

void wait()	導致當前線程等待，直到另一個線程調用該對象的 notify()方法或 notifyAll()方法
void notify()	喚醒正在等待對象監視器的單個線程
void notifyAll()	喚醒正在等待對象監視器的所有線程

3.2生產者和消費者案例

• 案例需求
  生產者消費者案例中包含的類：
  奶箱類(Box)：定義一個成員變量，表示第x瓶奶，提供存儲牛奶和獲取牛奶的操作
  生產者類(Producer)：實現Runnable接口，重寫run()方法，調用存儲牛奶的操作
  消費者類(Customer)：實現Runnable接口，重寫run()方法，調用獲取牛奶的操作
  測試類(BoxDemo)：里面有main方法，main方法中的代碼步驟如下
  ①創建奶箱對象，這是共享數據區域
  ②創建消費者創建生產者對象，把奶箱對象作為構造方法參數傳遞，因為在這個類中要調用存儲牛奶的操作
  ③對象，把奶箱對象作為構造方法參數傳遞，因為在這個類中要調用獲取牛奶的操作
  ④創建2個線程對象，分別把生產者對象和消費者對象作為構造方法參數傳遞
  ⑤啟動線程
• 代碼實現

public class Box {//定義一個成員變量，表示第x瓶奶private int milk;//定義一個成員變量，表示奶箱的狀態private boolean state = false;//提供存儲牛奶和獲取牛奶的操作public synchronized void put(int milk) {//如果有牛奶，等待消費if (state){try {wait();} catch (InterruptedException e) {e.printStackTrace();}}//如果沒有牛奶，就生產牛奶this.milk = milk;System.out.println("送奶工將第" + this.milk + "瓶奶放入奶箱");//生產完畢之后，修改奶箱狀態state = true;//喚醒其他等待的線程notifyAll();}public synchronized void get() {//如果沒有牛奶，等待生產if(!state) {try {wait();} catch (InterruptedException e) {e.printStackTrace();}}//如果有牛奶，就消費牛奶System.out.println("用戶拿到第" + this.milk + "瓶奶");//消費完畢之后，修改奶箱狀態state = false;//喚醒其他等待的線程notifyAll();} }public class Producer implements Runnable {private Box b;public Producer() {}public Producer(Box b) {this.b = b;}@Overridepublic void run() {for (int i = 1; i <= 30; i++) {b.put(i);}} }public class Customer implements Runnable{private Box b;public Customer(Box b) {this.b = b;}@Overridepublic void run() {while (true){b.get();}} }public class test {public static void main(String[] args) {//創建奶箱對象，這是共享數據區域Box b = new Box();//創建生產者對象，把奶箱對象作為構造方法參數傳遞，因為在這個類中要調用存儲牛奶的操作Producer p = new Producer(b);// 創建消費者對象，把奶箱對象作為構造方法參數傳遞，因為在這個類中要調用獲取牛奶的操作Customer c = new Customer(b);//創建2個線程對象，分別把生產者對象和消費者對象作為構造方法參數傳遞Thread t1 = new Thread(p);Thread t2 = new Thread(c);//啟動線程t1.start();t2.start();} }

總結

以上是生活随笔為你收集整理的Java基础day20的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。