2. 程式人生 > >多執行緒之建立執行緒的兩種方式

多執行緒之建立執行緒的兩種方式

阿新 • • 發佈：2018-12-26

彩蛋：

朕是小白，朕近段時間準備學一下有關執行緒方面的知識。（下面寫的東西是我對執行緒的一些理解）

今天是2018年5月28號，朕準備每天更新一篇部落格來激勵自己一直學習，不要間斷，畢竟是位又懶自制力又差的傢伙，哈哈哈！

言歸正傳，今晚準備詳細記錄一下執行緒建立的兩種方式以及這兩種方式的優缺點及適應的情況等等。

多程序：。。。

多執行緒：在一個應用程式中，有多個順序流同時執行。（執行緒：順序執行的程式碼）

建立執行緒有兩種方式：

一，（目標類來）繼承Thread類，重寫run方法來建立自己的執行緒。呼叫start函式就開始執行執行緒程式碼昂發啦！

從Thread類派生一個子類，並建立子類的物件。

子類應該重寫Thread類的run方法，寫入需要在新執行緒中執行的語句段。

呼叫start方法來啟動新執行緒，自動進入run方法。


舉例：在新執行緒中實現計算某個整數的階乘的過程：

package multi_thread;

public class FactorialThreadTester {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		System.out.println("main thread starts");
		FactorialThread thread = new FactorialThread(10);
		thread.start();
		System.out.println("main thread ends");
	}
}

class FactorialThread extends Thread{
	private int num;
	public FactorialThread(int num) {
		this.num = num;
	}
	public void run() {
		int i = num;
		int result = 1;
		System.out.println("new thread started");
		while(i>0) {
			result*=i;
			i--;
		}
		System.out.println("The factorial of "+num+" is "+result);
		System.out.println("new thread ends");
	}
}

執行結果：

備註：factorial（階乘）
main thread starts
main thread ends
new thread started
The factorial of 10 is 3628800
new thread ends

注：這裡之所以要另外寫一個主執行緒（public static void main（String[] args））是為了想說明建立的新執行緒並不是start（）後就立即執行的。它其實也需要CPU來進行排程，輪到它了它才會被執行。通過執行結果我們可以看出。

通過繼承Thread類來建立執行緒大致流程就是上面這樣。

下面我想補充一些個人感覺很有用的知識（如果急著看另一種建立執行緒的方式，請往下翻~~~）：

Thread類常用的API方法，整理如下：

名稱說明
public Thread()構造一個新的執行緒物件（Thread類的建構函式），預設名為Thread-n，n是從0開始遞增的整數
public Thread(Runnable target)構造一個新的執行緒物件，以一個實現Runnable介面的類的物件為引數，預設名為Thread-n，n是從0開始遞增的整數（哈哈哈，從此處建構函式可以看出建立執行緒的兩種不同方式，處處點題，我真機智！）
public Thread(String name)構造一個執行緒物件，並同時指定執行緒名
public static Thread currentThread()返回一個當前正在執行的執行緒物件
public static void yield()使當前執行緒物件暫停，允許別的執行緒開始執行（注：yield：屈服）
public static void sleep(long millis)使當前執行緒暫停執行指定毫秒數，但此執行緒並不失去已獲得的鎖
public void start()啟動執行緒，JVM將呼叫此執行緒的run方法，結果是將同時執行兩個執行緒，當前執行緒和執行run方法的執行緒
public void run()Thread的子類應該重寫此方法，內容應為該執行緒應執行的任務
public final void stop()停止執行緒執行，釋放該執行緒佔用的物件鎖
public void interrupt()中斷此執行緒
public final void join()如果啟動了執行緒A，呼叫join方法將等待執行緒A死亡才能繼續執行當前執行緒
public final void join(long millis)如果此前啟動了執行緒A，呼叫join方法將等待指定毫秒數或執行緒A死亡才能繼續執行當前執行緒
設定執行緒優先順序
public final void setPriority( int newPriority)設定執行緒優先順序
public final void setDaemon(Boolean on)設定是否為後臺執行緒，如果當前執行執行緒均為後臺執行緒則JVM停止執行。這個方法必須在start()方法前使用（注：daemon：後臺程式）
public final void checkAccess()判斷當前執行緒是否有權力修改呼叫此方法的執行緒
public void setName(String name)更改本執行緒的名稱為指定引數
public final boolean isAlive()測試執行緒是否處於活動狀態，如果執行緒被啟動並且沒有死亡則返回true

二，寫一個類來實現Runnable介面，在初始化一個Thread類或者Thread子類的執行緒物件的時候 ，把該類的物件作為引數傳遞給那個執行緒物件。（其中由該類提供run方法）。

Runnable介面：只有一個run()方法

以實現Runnable介面的類的物件為引數建立新的執行緒


還是舉這個例子：在新執行緒中實現計算某個整數的階乘的過程：

package multi_thread;

public class FactorialThreadTest_Runnable {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		System.out.println("main thread starts");
		FactorialThreadRunnable t = new FactorialThreadRunnable(10);
		new Thread(t).start();
		System.out.println("new thread started, main thread ends");
	}
}

class FactorialThreadRunnable implements Runnable{
	private int num;
	public FactorialThreadRunnable(int num) {
		this.num = num;
	}
	public void run() {
		int i = num;
		int result = 1;
		while(i>0) {
			result*=i;
			i--;
		}
		System.out.println("The factorial of "+num+" is "+result);
		System.out.println("new thread ends");
	}
}

執行結果：

main thread starts
new thread started, main thread ends
The factorial of 10 is 3628800
new thread ends


再舉一個使用Runnable介面實現上面多執行緒的例子：

package multi_thread;

public class ThreadSleepTester_Runnable {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		TestThread_Runnable thread1 = new TestThread_Runnable();
		TestThread_Runnable thread2 = new TestThread_Runnable();
		TestThread_Runnable thread3 = new TestThread_Runnable();
		System.out.println("Starting threads");
		new Thread(thread1,"Thread1").start();
		new Thread(thread2,"Thread2").start();
		new Thread(thread3,"Thread3").start();
		System.out.println("Threads started,main ends");
	}

}

class TestThread_Runnable implements Runnable{
	private int sleepTime;
	public TestThread_Runnable() {
		sleepTime=(int)(Math.random()*6000);
	}
	public void run() {
		try {
			System.out.println(Thread.currentThread().getName()+" going to sleep for "+sleepTime);
			Thread.sleep(sleepTime);
		}
		catch(InterruptedException e){};
		System.out.println(Thread.currentThread().getName()+" finished");
	}
}

執行結果：

Starting threads
Threads started,main ends
Thread1 going to sleep for 5924
Thread3 going to sleep for 2385
Thread2 going to sleep for 2112
Thread2 finished
Thread3 finished
Thread1 finished

通過實現Runnable介面來建立執行緒大致流程就是上面這樣。

接下來我們要思考一個問題：建立執行緒的兩種方式各有其優缺點：

直接繼承Thread類：

優點：編寫簡單，直接繼承，重寫run方法。

缺點：由於Java的單繼承機制，不能再繼承其他類了

使用Runnable介面：

優點有兩個：一，可以繼承其他類。Java不支援多繼承，如果已經繼承了某個基類，便需要實現Runnable介面來生成多執行緒。

二，可以將CPU，程式碼和資料分開，形成清晰的模型，便於多個執行緒共享資源。

其他的優缺點應該很好理解，但對於第二個（二，可以將CPU，程式碼和資料分開，形成清晰的模型，便於多個執行緒共享資源）優點，還是舉個例子來說明比較好！

通過實現Runnable介面為啥多個執行緒就可以共享資料等資源呢？？？

package multi_thread;

public class ShareTargetTester {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		TestThread_Runnable thread = new TestThread_Runnable();
		System.out.println("Starting threads");
		new Thread(thread,"Thread1").start();
		new Thread(thread,"Thread2").start();
		new Thread(thread,"Thread3").start();
		System.out.println("Threads started,main ends");
	}

}
class TestThread_Runnable implements Runnable{
	private int sleepTime;
	public TestThread_Runnable() {
		sleepTime=(int)(Math.random()*6000);
	}
	public void run() {
		try {
			System.out.println(Thread.currentThread().getName()+" going to sleep for "+sleepTime);
			Thread.sleep(sleepTime);
		}
		catch(InterruptedException e){};
		System.out.println(Thread.currentThread().getName()+" finished");
	}
}

執行結果：

Starting threads
Threads started,main ends
Thread1 going to sleep for 4422
Thread2 going to sleep for 4422
Thread3 going to sleep for 4422
Thread2 finished
Thread1 finished
Thread3 finished
Thread1、Thread2和Thread3同時結束。（你執行一下看看就知道啦！）

這裡為啥Thread1、Thread2和Thread3休眠時間是一樣的呢？好奇怪！（emmmm，寡人還是不故弄玄虛了。。。）

原因是：你建立3個新執行緒傳給Thread的引數是一毛一樣滴，所以那3個新執行緒就共享了一個物件裡的資料（sleepTime）啊，所以就是一樣的！

		TestThread_Runnable thread = new TestThread_Runnable();
		new Thread(thread,"Thread1").start();
		new Thread(thread,"Thread2").start();
		new Thread(thread,"Thread3").start();

扶朕起來，朕還可以再舉一個例子：

用三個執行緒模擬三個售票口，總共出售10張票。（注：這三個執行緒應該共享10張票的資料，因為總共就10張票，三個程序一起來銷售）

package multi_thread;

public class sellTicketsTester {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		sellTickets t = new sellTickets();
		new Thread(t,"Thread1").start();
		new Thread(t,"Thread2").start();
		new Thread(t,"Thread3").start();
		
	}
}

class sellTickets implements Runnable{
	private int tickets = 10;
	public void run() {
		while(tickets>0) {
			System.out.println(Thread.currentThread().getName()+" is selling ticket "+tickets--);
		}
	}
}

執行結果：

Thread1 is selling ticket 10
Thread3 is selling ticket 8
Thread2 is selling ticket 9
Thread3 is selling ticket 6
Thread3 is selling ticket 4
Thread3 is selling ticket 3
Thread3 is selling ticket 2
Thread3 is selling ticket 1
Thread1 is selling ticket 7
Thread2 is selling ticket 5

哈哈哈，看完執行結果你就明白我滴意思了吧！

在這個例子中，建立了3 個執行緒，每個執行緒呼叫的是同一個sellTickets物件t中的run（）方法，訪問的也是同一個物件t中的變數tickets。

但是，如果是通過建立Thread類的子類來模擬售票過程，再建立3個新執行緒，則每個執行緒都有各自的方法和變數，雖然方法是相同的，但確是各有10張票，結果就會是每個執行緒都賣出了10張票，總共賣出了30張票，與原意就不符了！！！

（個人感覺執行緒間的資料共享挺重要的，也挺有意思的）

我還想補充一下執行緒有關的其他知識：

一、執行緒休眠：（呼叫sleep方法）

比如之前寫的程式：

package multi_thread;

public class FactorialThreadTester {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		System.out.println("main thread starts");
		FactorialThread thread = new FactorialThread(10);
		thread.start();
		System.out.println("main thread ends");
	}
}

class FactorialThread extends Thread{
	private int num;
	public FactorialThread(int num) {
		this.num = num;
	}
	public void run() {
		int i = num;
		int result = 1;
		System.out.println("new thread started");
		while(i>0) {
			result*=i;
			i--;
		}
		System.out.println("The factorial of "+num+" is "+result);
		System.out.println("new thread ends");
	}
}

執行結果：

備註：factorial（階乘）
main thread starts
main thread ends
new thread started
The factorial of 10 is 3628800
new thread ends

現在我讓主執行緒休眠一毫秒，執行結果就會發生改變了哦，因為主執行緒休眠了一毫秒！

package multi_thread;

public class FactorialThreadTester {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		System.out.println("main thread starts");
		FactorialThread thread = new FactorialThread(10);
		thread.start();
		try { Thread.sleep(1);}
		catch(Exception e) {};
		System.out.println("main thread ends");
	}
}

class FactorialThread extends Thread{
	private int num;
	public FactorialThread(int num) {
		this.num = num;
	}
	public void run() {
		int i = num;
		int result = 1;
		System.out.println("new thread started");
		while(i>0) {
			result*=i;
			i--;
		}
		System.out.println("The factorial of "+num+" is "+result);
		System.out.println("new thread ends");
	}
}

與上一個程式不同的是我只添加了紅色標記的語句，執行結果見下： 

main thread starts
new thread started
The factorial of 10 is 3628800
new thread ends
main thread ends

新執行緒結束後main執行緒才結束。

多個執行緒休眠的情況見下：

package multi_thread;

public class ThreadSleepTester {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		TestThread thread1 = new TestThread("Thread1");
		TestThread thread2 = new TestThread("Thread2");
		TestThread thread3 = new TestThread("Thread3");
		System.out.println("Starting threads");
		thread1.start();
		thread2.start();
		thread3.start();
		System.out.println("Threads started,main ends");
	}
}
	
	class TestThread extends Thread{
		private int sleepTime;
		public TestThread(String name) {
			super(name);
			sleepTime=(int)(Math.random()*6000);
		}
		public void run() {
			try {
				System.out.println(getName()+" going to sleep for "+sleepTime);
				Thread.sleep(sleepTime);
			}
			catch(InterruptedException e){};
			System.out.println(getName()+" finished");
		}
}

備註：Math.random()產生0~1之間的隨機數。

Thread.sleep(sleepTime)，其中sleepTime的單位是毫秒！

執行結果見下： 

Starting threads
Threads started,main ends
Thread1 going to sleep for 5492
Thread2 going to sleep for 1295
Thread3 going to sleep for 3126
Thread2 finished
Thread3 finished
Thread1 finished

由於執行緒1休眠時間最長，所以最後結束；執行緒2休眠時間最短，所以最先結束。

每次執行，都會隨機產生不同的休眠時間，所以其實每次執行的結果都不相同！

結尾也有彩蛋，嘻嘻：

eclipse變數名如何實現一改全改呢？（個人感覺還是很有用的小技巧）

雙擊選擇要改的變數名，右鍵下拉選單選擇refactor重構選項,選擇rename，然後就輸入自己需要改成的名字，回車，搞定！


相關推薦

Java Spark之建立RDD的兩種方式和操作RDD

首先看看思維導圖，我的spark是1.6.1版本，jdk是1.7版本  spark是什麼？  Spark是基於記憶體計算的大資料平行計算框架。Spark基於記憶體計算，提高了在大資料環境下資料處理的實時性，同時保證了高容錯性和高可伸縮性，允許使用者將Spark 部署在大量廉

Java接入Spark之建立RDD的兩種方式和操作RDD

首先看看思維導圖，我的spark是1.6.1版本，jdk是1.7版本 spark是什麼？ Spark是基於記憶體計算的大資料平行計算框架。Spark基於記憶體計算，提高了在大資料環境下資料處理的實時性，同時保證了高容錯性和高可伸縮性，允許使用者將Spar

多執行緒之建立執行緒的兩種方式

彩蛋：朕是小白，朕近段時間準備學一下有關執行緒方面的知識。（下面寫的東西是我對執行緒的一些理解）今天是2018年5月28號，朕準備每天更新一篇部落格來激勵自己一直學習，不要間斷，畢竟是位又懶自制力又差的傢伙，哈哈哈！言歸正傳，今晚準備詳細記錄一下執行緒建立的兩種方式以及這兩種

多執行緒之建立執行緒的方式之一：實現Callable介面（三）

對於多執行緒，大家並不陌生，對於如何建立執行緒也是輕車熟路，對於使用new thread和實現runable介面的方式，不再多說。這篇博文我們介紹第三種：實現Callable介面。 Callable介面 介面定義： @FunctionalInterface

java多執行緒之建立執行緒的三種方式優缺點

Java使用Thread類代表執行緒，所有的執行緒物件都必須是Thread類或其子類的例項。  一、繼承Thread類建立執行緒類  1.重寫run方法。該run（）方法的方法體就代表了執行緒需要完成的任務。  2.建立Thread子類的例項。  3.呼叫執行緒物件的st

java多執行緒之建立執行緒與死鎖

執行緒建立篇    java中的執行緒建立有多種方式，筆者(ymh)這裡分別根據執行緒執行完畢後是否有返回值討論執行緒建立的四種方式。 1、通過繼承Thread類重寫run方法(無返回值) 示例程式碼：

多執行緒實現內部類的兩種方式

public static void main(String[] args) {// TODO Auto-generated method stub//第一種，繼承Thread類，來實現內部類new Thread(){@Overridepublic void run() {

springboot項目啟動成功後執行一段代碼的兩種方式

參數 註解 etime mman pac cycle net org 啟動 springboot項目啟動成功後執行一段代碼的兩種方式 實現ApplicationRunner接口 package com.lnjecit.lifecycle; import

Hibernate學習筆記（一）之——根據配置檔案自動建立表的兩種方式（註解方式和配置檔案方式）

環境準備：jdk  eclipse   hibernate、mysql jar包 專案截圖： Student是根據配置檔案建立表，Teacher是根據註解建立表 Student.java package com.java1234.model; publi

獲取Executor提交的併發執行的任務返回結果的兩種方式/ExecutorCompletionService使用

當我們通過Executor提交一組併發執行的任務，並且希望在每一個任務完成後能立即得到結果，有兩種方式可以採取： 方式一： 通過一個list來儲存一組future，然後在迴圈中輪訓這組future,直到每個future都已完成。如果我們不希望出現因為排在前面的任務阻

Spring系列之AOP實現的兩種方式

部分 靜態常量 cep value conf tar import enc ble AOP常用的實現方式有兩種，一種是采用聲明的方式來實現（基於XML），一種是采用註解的方式來實現（基於AspectJ）。 首先復習下AOP中一些比較重要的概念： Joinpoint（連接點）

python並發編程：多線程-開啟線程的兩種方式

utf-8 data NPU pre int thread pro reading class 一 threading模塊介紹 multiprocess模塊完全模仿了threading模塊的接口，二者在使用層面，有很大的相似性 二 開啟線程的兩種方式 方式一 f

建立資源的兩種方式

命令 vs 配置檔案 Kubernetes 支援兩種方式建立資源： 1. 用 kubectl 命令直接建立 kubectl run nginx-deployment --image=nginx:1.7.9 --replicas=2   在命令列中通過引數指定資源的屬性。 2.

spark建立DF的兩種方式

方式一：反射：(使用這種方式來建立DF是在你知道欄位具體有哪些) 1.建立一個SparkContext，然後再建立SQLContext 2.先建立RDD，對資料進行整理，然後關聯case class，將非結構化的資料轉換成結構化資料 3.顯示的呼叫toDF方法，將RDD轉換成DF（需要隱私轉

SpringBoot之——熱部署的兩種方式

一、熱部署 在專案開發過程中，常常會改動頁面資料或者修改資料結構，為了顯示改動效果，往往需要重啟應用檢視改變效果，其實就是重新編譯生成了新的 Class 檔案，這個檔案裡記錄著和程式碼等對應的各種資訊，然後 Class 檔案將被虛擬機器的 ClassLoader 載入。

建立String的兩種方式有什麼不同

1.String a=new String（"abc");    String b=new String（"abc"); 當使用String a=new String（"abc");時，雖然值是一樣的，但每次建立一個新的物件，每個物件的地址不同。 2.String b="a

程序的建立，建立程序的兩種方式

一：程序的建立      1，系統的初始化       2，一個程序在執行過程中開啟了子程序       3，使用者的互動式請求，而建立一個新程序（如雙擊qq）       4，一個批處理作業的初始化（只在大型機的批處理系統中應用）        關於程序的建立，UNIX和W

JAVA 建立程序的兩種方式

在Java中建立執行緒有兩種方式：繼承Thread類或者實現Runnable介面再重寫run()方法 那麼在Java中要如何建立程序呢？ 同樣也有兩種方法 通過ProcessBuilder.start()方法 先看程序類Process publ

DOS下建立連線的兩種方式

    在DOS中，有著兩種建立連結的方法：快捷方式和連結。    一、快捷方式    快捷方式應該是使用得比較多的了，它其實是一個字尾名為.lnk的檔案，其在BAT指令碼中建立的方式是通過VB來進行建立，具體程式碼如下：:CreateShortmshta VBScript:

java反射class的三種方式，反射建立物件的兩種方式

反射中，欲獲取一個類或者呼叫某個類的方法，首先要獲取到該類的 Class 物件。 1、獲取Class物件 在 Java API 中，提供了獲取 Class 類物件的三種方法： 第一種，使用 Class.forName 靜態方法。 前提：已明確類的全路徑名。 第二種，