Java學習打卡：第十二天

內容導航

Java學習打卡：第十二天
- 內容管理
- - 前言（分享）
  - 界面編程實體(簡單計算器)
  - - 程式撰寫提示
    - 程式代碼（注解詳細）
    - 監聽類
    - - 配接器
  - 多執行緒
  - - 行程
    - 執行緒
    - 如何實作多執行緒
    - - extends Thread 實體分析
      - 實作Runnable介面方式
      - 如何保證執行緒安全
      - 執行緒同步synchronized

Java養成計劃（打卡第12天)

內容管理

前言（分享）

Hello! 我是C風，轉眼我們就將面向物件要學完了，但是對于JAVA SE 基礎還有幾個重要的點：反射機制，多執行緒和網路編程；這幾個我接下來就會分享，當講框架學習完之后，我會繼續再過一遍基礎，這一遍將更加扎實，每一個模塊就會以代碼居多，因為基礎的知識已經過了一遍，當將Java SE過完之后，也許就10月中旬了，之后就會寫幾個專案，比如簡易聊天室和文字游戲，還會做一個倉儲管理，當然會結合界面編程，實作簡單的與用戶互動

界面編程實體(簡單計算器)

我們之前已經大概了解過界面編程的基礎知識，接下來就分享一個題目，兩數之和--------是不是覺得很簡單，當然簡單，只是我們現在要提供一個界面與用戶互動了

先介紹一下基本的監聽器和事件

ActionEvent and ActionListener 事件所在的包就是Java.awt.event
- 監聽器的型別：interface ActionListener ;--------所有行為類事件的監聽器都要實作ActionListener介面，在ActionListener中只定義了一個actionPerformed()方法，對于每一個注冊了這個監聽器的組件，只要發生了行為類事件（比如按鈕按下）就會呼叫該方法來相應該事件

public interface ActionListener{
    public void actionPerformed(ActionEvent e);//必須要實作該方法，方法體
}

可能觸發事件用到的組件有JRadioButton(單選按鈕) JButton(按鈕) JTextFiled(文本框)

首先按照之前的講解我們首先應該創建一個頂級組件來繼承這個JFrame，當然中級容器JPanel也可以，之后在類中設定我們的基本的組件

程式撰寫提示

我們這里設定三個面板，面板的布局是BorderLayout，西面板設定提示資訊，面板按照網格布局GridLayout；提示資訊為3行1列；中面板設定文本框，文本框colum設定為10；東面板為按鈕面板，上面有兩個按鈕，加法和減法；之后我們設定一個監聽器，當監聽器Action識別為+我們進行加法，并將結果顯示到AnswerLabel上；這里我們用as捕捉例外，防止越界，將錯誤資訊也給AnswerLabel.這里我們使用一個內部類，因為屬性是私有的，

監聽器我們一般寫成內部類，因為我們只是在監聽的時候才會使用到這個類，訪問外部類的私有屬性比較方便

程式代碼（注解詳細）

package Calculator;

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;

@SuppressWarnings("serial")
public class Calculator extends JFrame{//JFrame在swing包中
	private JPanel leftPanel;
	private JPanel centerPanel;//私有屬性
	private JPanel buttonPanel;
	private JTextField input1TextField;
	private JTextField input2TextField;
	private JLabel answerLable;
	private JButton plusButton;
	private JButton minusButton;
	public static void main(String[] args) {
//		JFrame frame = new JFrame("加減法計算器");
//		frame.add(new Calculator());//這里已經是一個頂級容器了，所以我們這里不能將頂級容器放入容器，會報錯
		Calculator frame = new Calculator("簡單加減法計算器");//直接使用這個頂級容器,去查看JFrame的構造方法
		frame.setSize(600, 200);
		frame.setVisible(true);
	}
	public Calculator(String title) {
		super(title);//有參了
		setLayout(new BorderLayout());//java.awt布局管理；中級容器的布局
		leftPanel = new JPanel();//中級容器
		leftPanel.setLayout(new GridLayout(3,1));//每個面板的網格布局
		/**
		 * 接下來將提示語言放在左邊的網格化面板上
		 */
		JLabel inputOne = new JLabel("Input 1 :  ");//不可編輯
		JLabel inputTwo = new JLabel("Input 2 :  ");
		JLabel answer = new JLabel("Aswer : ");
		
		leftPanel.add(inputOne);
		leftPanel.add(inputTwo);
		leftPanel.add(answer);
		add(leftPanel,BorderLayout.WEST);//將面板放在西邊
		/**
		 * 放置中央面板網格
		 */
		centerPanel = new JPanel();
		centerPanel.setLayout( new GridLayout(3,1));
		input1TextField = new JTextField(10);
		input2TextField = new JTextField(10);//設定引數
		answerLable = new JLabel();//屬性都還沒有給物件
		centerPanel.add(input1TextField);
		centerPanel.add(input2TextField);
		centerPanel.add(answerLable);//不可編輯
		add(centerPanel,BorderLayout.CENTER);//將面板放在中央
		/**
		 * 將按鈕面板放在右邊
		 */
		buttonPanel = new JPanel();
		buttonPanel.setLayout(new GridLayout(2,1));//面板的網格布局
		plusButton = new JButton("+");
		minusButton = new JButton("-");
		buttonPanel.add(plusButton);
		buttonPanel.add(minusButton);
		add(buttonPanel,BorderLayout.EAST);//放在東邊
		/**
		 * 設定監聽器和事件
		 */
		ListenerOne listener = new ListenerOne();//創建監聽器，實作好了
		plusButton.addActionListener(listener);//點擊按鈕觸發事件
		minusButton.addActionListener(listener);
	}
	
	class ListenerOne implements ActionListener{//實作介面用implements
		//我們這里這個類只是輔助類
			@Override
			public void actionPerformed(ActionEvent e) {
				try {//監聽兩個按鈕
					@SuppressWarnings("removal")
					double d1 = new Double(input1TextField.getText()).doubleValue();
					@SuppressWarnings("removal")
					double d2 = new Double(input2TextField.getText()).doubleValue();
					if(e.getSource() == plusButton)
					{
						answerLable.setText(""+(d1+d2));
					}
					else {
						answerLable.setText(""+(d1-d2));//String型別
					}
				}catch(Exception as) {
					answerLable.setText(as.getMessage());//展示錯誤資訊
				}	
			}

		}
//內部類
}

運行結果是正常的（如下）如果代碼有疑惑的歡迎咨詢
在這里插入圖片描述

監聽類

大部分是通過繼承事件監聽器介面來處理事件的，但是繼承java介面必須實作出介面中所有的方法

但是有的介面中包含了大量的函式比如WindowsListener MouseListener FocusListener),如果實作所有函式是一件麻煩的事情，Java中就定義了相應介面的配接器來解決這種情況

配接器

配接器已經實作了介面中的所有方法，只要繼承配接器就可，并覆寫想要實作的方法即可，比如WindowListener WindowAdapter

多執行緒

行程

在了解多執行緒之前我們先來了解一下行程，什么是行程呢，行程就是我們的應用程式的執行實體，比如打卡PPT,那么行程就是這個WPS程式執行，而結束行程就是關閉程式的執行，運行的每一個應用程式都是行程，它有獨立的記憶體空間和系統資源；

執行緒

執行緒就是CPU調度和分派的基本單位，是行程中執行運算的最小單位，可完成一個獨立的順序控制流程，比如我們的eclipse是一個行程，那么其中我們撰寫的一個程式就是一個執行緒

隨便上段代碼

static int[] F = new int[201];
	public static void DFS(int n)
	{
		if(n < 3)
		{
			F[n] = 1;
			return;
		}
		DFS(n-1);
		DFS(n-2);
		F[n] = F[n-1] + F[n-2];
	}
	
	public static void main(String[] args) {
		int n;
		Scanner in = new Scanner(System.in);
		n = in.nextInt();
		DFS(n); // 先執行
		System.out.println(F[n]);
		System.out.println("echo"); //后執行
	}

這段代碼我們知道，一定是先執行這里的DFS，之后才會執行我們的列印陳述句echo；那我們可不可以同時執行這兩個代碼塊呢，我們在計算機中可以同時開多個行程，比如打開瀏覽器的同時打開eclipse；但是這里這段程式是做不到這點的，因為這段程式是單執行緒的

我們目前所寫的程式都是單執行緒的，就是只能從上到下依次執行，當然不能亂用goto陳述句的，那我們如果要同時執行這些入局要怎么做呢，那就要使用到我們的多執行緒的方式

如何實作多執行緒

在Java里面要實作多執行緒有兩種方式，一種就是讓我們想要實作多執行緒的類去繼承我們的執行緒類Thread，這個詞很常見啊

Exception in thread "main"

比如這就是我們很常見的報錯，就是指執行緒main中存在例外（例外），我們繼承這個類之后重寫里面的run();之后我們在mian執行緒中new一個物件時就開辟了新的執行緒，這個時候我們就object.start()就可以讓多個執行緒執行，只是還是需要系統的CPU來分配我們執行緒的執行時間

package Luogu;

import java.util.Scanner;

public class Luogu extends Thread{
	
	static int[] F = new int[201];
	
	@Override
	public void run() {//這是新執行緒
		for(int i = 1;i <= 10;i++)
		{
			System.out.println("hi ,how are you")
		}
	}
	
	public static void DFS(int n)
	{//計算斐波拉契數列
		if(n < 3)
		{
			F[n] = 1;
			return;
		}
		DFS(n-1);
		DFS(n-2);
		F[n] = F[n-1] + F[n-2];
	}
	
	public static void main(String[] args) {
		int n;
		Scanner in = new Scanner(System.in);
		n = in.nextInt();
		Luogu luo = new Luogu();//呼叫實體方法，只是處于可執行狀態，就是準備好執行
		luo.start();//啟動新執行緒，但是這不意味著馬上就去執行這個執行緒，需要CPU來分配執行時間
		DFS(n);//是按照時間執行來分配的
		System.out.println(F[n]);
		System.out.println("echo");
	}
}//這里就有兩個執行緒，一個就是main執行緒，第二個就是新定義物件對應0號執行緒，這里執行緒之間是互相不影響的，一個報錯，另外的還是可以正常執行

進入mian方法時，就會啟動mian 執行緒，進入創建物件后，再start就啟動了新執行緒，這里的啟動不是說就執行了，還是CPU來分配執行緒的執行時間，執行緒之間是互相不影響的，我故意在run中陳述句出現語法錯誤，之后運行

10
55
echo
Exception in thread “Thread-0” java.lang.Error: Unresolved compilation problem:
Syntax error, insert “;” to complete BlockStatements
at Luogu.Luogu.run(Luogu.java:13)

這里的main執行緒還是正常執行，只是Thrad-0報錯了，不能執行

執行緒的執行是CPU分配的，不一定一直都main執行緒先執行

12
144
hi ,how are you
hi ,how are you
hi ,how are you
hi ,how are you
hi ,how are you
hi ,how are you
hi ,how are you
hi ,how are you
hi ,how are you
hi ,how are you

這里是main執行緒先執行，我們再改一改資料試一試

20
hi ,how are you
hi ,how are you
hi ,how are you
hi ,how are you
hi ,how are you
hi ,how are you
hi ,how are you
hi ,how are you
hi ,how are you
hi ,how are you
6765

這次又是run新執行緒先執行了，因為CPU判斷執行主執行緒的時間相較run執行緒時間長很多，所以就選擇讓新執行緒先執行了

CPU就可能將執行權限交給不同的執行緒，這都是CPU決定的，

extends Thread 實體分析

那我們這種開辟執行緒的方法就是我們定義run之后然后創建四個物件，因為new就是開辟一個執行緒，那我們現在來模擬一下賣票的小程式，我們單執行緒就是只開辟一個視窗進行賣票，效率太低了，那我們現在就開辟四個視窗賣票

這里可以得到執行緒名稱 Thread.currentThread().getName(); 還有就是要啟動每一個執行緒，必須要start();

package Luogu;

public class SellTicket extends Thread{
	private int ticket = 10;
	@Override
	public void run() {
		while(ticket > 0)
		{//得到執行緒的名稱
			System.out.println(Thread.currentThread().getName()+"號視窗"+"賣出第"+ ticket-- +"張票");
		}
	}
	public static void main(String[] args) {
		SellTicket window1 = new SellTicket();
		SellTicket window2 = new SellTicket();
		SellTicket window3 = new SellTicket();
		SellTicket window4 = new SellTicket();
		window1.start();//不寫這個就沒有啟動執行緒
		window2.start();
		window3.start();
		window4.start();//表示啟動執行緒，一般第一個是0號執行緒，之后就是1號
	}
}

這里的運行結果是這樣的

Thread-1號視窗賣出第10張票
Thread-0號視窗賣出第10張票
Thread-3號視窗賣出第10張票
Thread-2號視窗賣出第10張票
Thread-2號視窗賣出第9張票
Thread-3號視窗賣出第9張票
Thread-0號視窗賣出第9張票
Thread-0號視窗賣出第8張票
Thread-1號視窗賣出第9張票
Thread-0號視窗賣出第7張票
Thread-3號視窗賣出第8張票
Thread-2號視窗賣出第8張票
Thread-3號視窗賣出第7張票
Thread-0號視窗賣出第6張票
Thread-1號視窗賣出第8張票
Thread-0號視窗賣出第5張票
Thread-3號視窗賣出第6張票
Thread-2號視窗賣出第7張票
Thread-3號視窗賣出第5張票
Thread-0號視窗賣出第4張票
Thread-1號視窗賣出第7張票
Thread-0號視窗賣出第3張票
Thread-3號視窗賣出第4張票
Thread-2號視窗賣出第6張票
Thread-3號視窗賣出第3張票
Thread-0號視窗賣出第2張票
Thread-1號視窗賣出第6張票
Thread-3號視窗賣出第2張票
Thread-2號視窗賣出第5張票
Thread-2號視窗賣出第4張票
Thread-2號視窗賣出第3張票
Thread-2號視窗賣出第2張票
Thread-2號視窗賣出第1張票
Thread-3號視窗賣出第1張票
Thread-0號視窗賣出第1張票
Thread-1號視窗賣出第5張票
Thread-1號視窗賣出第4張票
Thread-1號視窗賣出第3張票
Thread-1號視窗賣出第2張票
Thread-1號視窗賣出第1張票

這好像和我們想象的不一樣，就是我們其實賣了40張票，但是我們也確實發現不同的執行緒在同時執行

這里為什么會出現40張票呢，那是因為我們這里的票是成員變數，然后我們開辟執行緒靠的是創建物件，所以每個物件就都具備了這個屬性，就是每個執行緒視窗之前都有10張票，那我們這么解決這個問題，就是共享資訊呢

我們還是先總結一下擴展Thread方式的缺點

就是每個執行緒都具有自己的私有的屬性，就是屬性不共享，這是由物件不同導致的
我們要通過繼承的方式，那該類就不能去繼承其他的類了，因為Java是單繼承，這會讓我們的程式不能繼承其他的類，有很多就局限了

那就要引出另外一種方式了

實作Runnable介面方式

這和上面的方式沒有太大的區別，只是這個是實作介面而已

public class SellTicket implements Runnable{};

就這樣就實作了介面，我們之后就重寫里面的run方法就好了

只是現在我們實作多執行緒就和第一種有點區別了

我們知道上一種方式是這樣

extends Thread
    
SellTicket s1 = new SellTicket();
SellTicket s2 = new SellTicket();
s1.start();
s2.start();

也就是創建多個物件，每個物件都是一個執行緒，而現在我們就只需要創建一個物件，然后創建多個Thread物件，在構造方法中傳入我們上面創建的一個物件就可以了，這樣就可以只有一個屬性了，

implements Runnable
    
SellTicket s = new SellTicket();
Thread t1 = new Thread(s);
Thread t2 = new Thread(s);
t1.start();
t2.start();

但是我們還是要使用start()來啟動我們的執行緒，我們在企業開發中常使用的還是這種方式

package Luogu;

//public class SellTicket extends Thread{
public class SellTicket implements Runnable{
	private int ticket = 10;
	@Override
	public void run() {
		while(ticket > 0)
		{
			System.out.println(Thread.currentThread().getName()+"號視窗"+"賣出第"+ ticket-- +"張票");
		}
	}
	public static void main(String[] args) {
		SellTicket s = new SellTicket();
		Thread thread1 = new Thread(s);
		Thread thread2 = new Thread(s);
		Thread thread3 = new Thread(s);
		Thread thread4 = new Thread(s);
		thread1.start();
		thread2.start();
		thread3.start();
		thread4.start();
	}
}

運行結果是可能變化的，但是這次賣票的總數就是10了

Thread-1號視窗賣出第10張票
Thread-3號視窗賣出第7張票
Thread-0號視窗賣出第9張票
Thread-2號視窗賣出第8張票
Thread-0號視窗賣出第4張票
Thread-3號視窗賣出第5張票
Thread-3號視窗賣出第1張票
Thread-1號視窗賣出第6張票
Thread-0號視窗賣出第2張票
Thread-2號視窗賣出第3張票

每次運行的結果都不一樣，那是因為CPU分配的運行權力每次都不一樣，就是說有一種執行的機會，比如我們的執行緒0在列印陳述句的時候，突然CPU將執行權給了另外的執行緒就會出現重復賣票的可能，多模擬幾次就可以發現，這就是CPU隨時切換執行權導致的

就是比如執行緒0執行賣第10張票，還沒有執行完陳述句，突然CPU切換到了執行緒2，這個時候系統判斷還是有10張票，然后就還是賣第10張票，就出現了問題，就出現了資料不安全的例外

如何保證執行緒安全

這里我們想要保證執行緒安全，就必須讓一個執行緒還沒有執行完的時候，其他的執行緒不要執行

執行緒同步synchronized

那我們就要使用執行緒同步來實作這個這個功能，我們就使用關鍵字synchronized來對需要處理的片段上🔒，注意這里synchronized里面可以傳入任何一個物件就可以保證上🔒

while(ticket > 0)
		{
			synchronized(obj)//加上一個同步鎖
			{
				System.out.println(Thread.currentThread().getName()+"號視窗"+"賣出第"+ ticket-- +"張票");
			}
		}

這樣之后，就不會再出現重復賣票的行為，但是出現了新的問題就是一直只有一個執行緒執行完才會其他執行緒，并且會出現負數

Thread-0號視窗賣出第10張票
Thread-0號視窗賣出第9張票
Thread-0號視窗賣出第8張票
Thread-0號視窗賣出第7張票
Thread-0號視窗賣出第6張票
Thread-0號視窗賣出第5張票
Thread-0號視窗賣出第4張票
Thread-0號視窗賣出第3張票
Thread-0號視窗賣出第2張票
Thread-0號視窗賣出第1張票
Thread-3號視窗賣出第0張票
Thread-2號視窗賣出第-1張票
Thread-1號視窗賣出第-2張票

這里就是當還剩1張票的時候，還沒有執行同步代碼塊時，機會給了3號執行緒，同時又給了1執行緒和2號執行緒，還是存在問題，這個時候我們就在同步鎖里面再加上一個判斷陳述句，只有里面滿足才執行

synchronized(obj)//加上一個同步鎖
			{
    			if(ticket > 0)
                {
					System.out.println(Thread.currentThread().getName()+"號視窗"+"賣出第"+ ticket-- +"張票");
                }
			}

這樣就不會出現負數的行為了，就只有0號執行緒執行完才會去執行其余執行緒

Thread-0號視窗賣出第10張票
Thread-0號視窗賣出第9張票
Thread-0號視窗賣出第8張票
Thread-0號視窗賣出第7張票
Thread-0號視窗賣出第6張票
Thread-0號視窗賣出第5張票
Thread-0號視窗賣出第4張票
Thread-0號視窗賣出第3張票
Thread-0號視窗賣出第2張票
Thread-0號視窗賣出第1張票

這樣我們就不會出現負數了，你可能疑惑這里又只有一個執行緒執行了，那是這種情況而已，還有就是資料不夠大，當你切換之后我們就可以發現時幾個執行緒都在執行

好了~~~今天的分析結束了，我們主要分享了一個界面編程的案例，那就是做一個界面的計算器，要實作用戶互動，之后我們又通過售票的方式來講解我們的多執行緒知識~

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/301942.html

標籤：java

上一篇：純手寫超詳細講解Spring JdbcTemplate&宣告式事務

下一篇：Java學習 -- 繼承性

界面編程實戰分析------計算器實作用戶互動；多執行緒---售票視窗分析；一文帶你分析界面編程與多執行緒【Java養成】