2. 程式人生 > >Java多執行緒核心技術(一)：基礎知識總結

Java多執行緒核心技術(一)：基礎知識總結

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

概念

程序：程序是作業系統結構的基礎，是一次程式的執行，是一個程式及其資料在處理機上順序執行時所發生的活動，是程式在一個程式集合上執行的過程，它是系統進行資源分配和排程的一個基本單位。

執行緒：執行緒是程序中獨立執行的子任務。使用多執行緒技術後，可以在同一時間執行更多不同種類的任務。

使用多執行緒

第一種方式：繼承Thread類，並實現run方法

第二種方式：實現Runnable介面

注意：1、程式碼的執行結果與程式碼的順序無關：執行緒是一個子任務，CPU以不確定的方式，或者說以隨機的時間來呼叫執行緒中的run方法。

2、Thread.java類中的start()方法通知"執行緒規劃器"此執行緒已經準備就緒，等待呼叫執行緒物件的run()方法。這個過程其實就是讓系統安排一個時間來呼叫Thread中的run()方法，也就是使執行緒得到執行，啟動執行緒，具有非同步執行的效果，所以如果在程式中直接呼叫執行緒的run方法，那程式就是順序執行的。


Thread類的結構：public class Thread implements Runnable

在Thread類的8個建構函式中，有兩個建構函式Thread(Runnable target)和Thread(Runnable target,String name)可以傳遞Runnable介面，說明建構函式支援傳入一個Runnable介面的物件。而Thread類實現了Runnable介面，所以完全可以將一個Thread物件作為Thread建構函式的引數傳入，這樣該Thread物件實現的run()方法就交由其他的執行緒進行呼叫。

共享資料

實現5個執行緒共同對一個count變數進行減法操作：

class MyThread extends Thread{
    public int count = 5;
    @Override
    public void run(){
    	super.run();
    	count--;
    	System.out.println("由 " + this.currentThread().getName() + "計算，count="+count);
    }
}
public class TestClass{
	public static void main(String[] args){
		MyThread mythread = new MyThread();
		Thread a = new Thread(mythread,"A");
		Thread b = new Thread(mythread,"B");
		Thread c = new Thread(mythread,"C");
		Thread d = new Thread(mythread,"D");
		Thread e = new Thread(mythread,"E");
		a.start();
		b.start();
		c.start();
		d.start();
		e.start();
	}
}
執行結果如下：


在JVM中，i--的操作分成如下3步：

（1）取得原有i值，

（2）計算i-1,

（3）對i進行賦值。

當五個執行緒同時進行操作i--時，其中的某個或某些執行緒在沒執行完這三個步驟的情況下，其他的執行緒就插入進來了，就會造成結果的混亂。解決這個問題的方法是在潤方法錢加synchronized關鍵字，保證run方法的原子性操作。synchronized可以在任意物件及方法上加鎖，而加鎖的這段程式碼稱為”互斥區“或者”臨界區“，當一個執行緒想執行同步方法裡面的程式碼時，執行緒首先嚐試去拿這把鎖，如果能夠拿到這把鎖，那麼這個執行緒就可以執行synchronized裡面的程式碼。如果不能拿到這把鎖，那麼這個執行緒就會不斷地嘗試拿這把鎖，直到能夠拿到為止，而且是有多個執行緒同時去爭搶這把鎖。

currentThread()方法

currentThread()方法可返回程式碼段正在被哪個執行緒呼叫的資訊。


當直接呼叫thread的run方法時，則run方法不是有其所在的執行緒去呼叫，而是由主執行緒去呼叫。

class MyThread extends Thread{
    public MyThread(){
    	System.out.println("建構函式開始");
    	System.out.println("Thread.currentThread().getName()=" + Thread.currentThread().getName());
    	System.out.println("this.Name=" + this.getName());
    	System.out.println("建構函式結束");
    }
    @Override
    public void run(){
    	System.out.println("run方法開始");
    	System.out.println("Thread.currentThread().getName()=" + Thread.currentThread().getName());
    	System.out.println("this.Name=" + this.getName());
    	System.out.println("run方法結束");
    }
}
    public class TestClass{
	public static void main(String[] args){
		MyThread mythread = new MyThread();
		Thread t = new Thread(mythread);
		t.setName("A");
		t.start();
	}
}


輸出結果為： 
建構函式開始
Thread.currentThread().getName()=main
this.Name=Thread-0
建構函式結束
run方法開始
Thread.currentThread().getName()=A
this.Name=Thread-0
run方法結束
在呼叫MyThread建構函式的執行緒是Main執行緒，而呼叫mythread的run方法的是名稱為A的執行緒。


isAlive()方法

isAlive()方法的功能是判斷當前執行緒是否處於活動狀態，活動狀態就是執行緒已經啟動且尚未終止。執行緒處於正在執行或準備開始執行的狀態，就認為執行緒是“存活”的。

class MyThread extends Thread{
    public MyThread(){
    	System.out.println("建構函式開始");
    	System.out.println("Thread.currentThread().getName()=" + Thread.currentThread().getName());
    	System.out.println("Thread.currentThread().isAlive()=" + Thread.currentThread().isAlive());
    	System.out.println("this.Name=" + this.getName());
    	System.out.println("this.isAlive()" + this.isAlive());
    	System.out.println("建構函式結束");
    }
    @Override
    public void run(){
    	System.out.println("run方法開始");
    	System.out.println("Thread.currentThread().getName()=" + Thread.currentThread().getName());
    	System.out.println("Thread.currentThread().isAlive()=" + Thread.currentThread().isAlive());
    	System.out.println("this.Name=" + this.getName());
    	System.out.println("this.isAlive()" + this.isAlive());
    	System.out.println("run方法結束");
    }
}
public class TestClass{
	public static void main(String[] args){
		MyThread mythread = new MyThread();
		Thread t = new Thread(mythread);
		t.setName("A");
		t.start();
	}
}
程式執行結果如下： 
建構函式開始
Thread.currentThread().getName()=main
Thread.currentThread().isAlive()=true
this.Name=Thread-0
this.isAlive()false
建構函式結束
run方法開始
Thread.currentThread().getName()=A
Thread.currentThread().isAlive()=true
this.Name=Thread-0
this.isAlive()false
run方法結束
這說明MyThread在建構函式中並沒有存活，由於把MyThread的run方法交給了其他執行緒執行，所以在run方法中MyThread也不是存活的。

sleep()方法

sleep()方法的作用是在指定的毫秒數內讓當前“正在執行的執行緒”休眠（暫停執行）。這個“正在執行的執行緒”是指this.currentThread()返回的執行緒。

class MyThread extends Thread{
    @Override
    public void run(){
    	try {
    		System.out.println("run threadName=" + this.currentThread().getName()+" begin="+System.currentTimeMillis());        	
			Thread.sleep(2000);
			System.out.println("run threadName=" + this.currentThread().getName()+" end  ="+System.currentTimeMillis());
		    
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
    }
}
public class TestClass{
	public static void main(String[] args){
		MyThread mythread = new MyThread();
		System.out.println("begin="+System.currentTimeMillis());
		mythread.start();
		System.out.println("end  ="+System.currentTimeMillis());
	}
}
程式執行結果如下: 
begin=1487766083887
end  =1487766083887
run threadName=Thread-0 begin=1487766083887
run threadName=Thread-0 end  =1487766085888
由於main執行緒與Mythread2執行緒是非同步執行的，所以首先列印的資訊為begin和end。而MyThread2執行緒是隨後執行的，在最後兩行列印run begin和run end相關的資訊。

getId()方法

getId()方法的作用是取的執行緒的唯一標識

停止執行緒

在Java中有以下3種方法可以終止正在執行的執行緒：

（1）使用退出標誌，使執行緒正常退出，也就是當run方法完成後執行緒終止。

（2）使用stop方法強行終止執行緒，但是不推薦使用這種方法，因為stop方法和suspend及resume方法一樣，都是作廢過期的方法，使用它們可能會產生不可預料的結果。

如果使用stop方法強制讓執行緒停止則有可能會使一下清理性的工作得不到完成。另一個情況就是對鎖定的物件進行了“解鎖”，導致資料得不到同步的處理，出現數據不一致的問題。

（3）使用interrupt方法中斷執行緒，呼叫interrupt()方法僅僅是在當前執行緒中打了一個停止的標記，並不是真的停止執行緒。

判斷執行緒是否是停止狀態：

（1）this.interrupted()：測試當前的執行緒是否已經中斷，靜態方法。執行緒的中斷狀態由該方法清除。所以，連續兩次呼叫該方法，則第二次呼叫返回false（在第一次呼叫已經 清除了其中斷狀態之後，第二次呼叫檢驗完中斷狀態前，當前執行緒再次中斷的情況除外）。

（2）this.isInterrupted()：測試當前執行緒是否已經中斷，非靜態方法，並不會清除狀態標誌。

public class TestClass{
	public static void main(String[] args){
		
		try {
			MyThread mythread = new MyThread();
			mythread.start();
			Thread.sleep(1000);
			mythread.interrupt();
			System.out.println("當前執行緒是否停止？ = "+Thread.interrupted());
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}		
	}
}
程式執行輸出
當前執行緒是否停止？ = false

這是因為mythread執行緒終止了，但是main執行緒一直在執行，這個“當前執行緒”就是main，所以列印了false。

在沉睡中停止

如果線上程的sleep()狀態下停止執行緒，會丟擲java.lang.InterruptedException異常，並且清除停止狀態值，使之變成false。先中斷執行緒在呼叫sleep()方法，結果是一樣的。

暫停執行緒

暫停執行緒意味著此執行緒還可以恢復執行。在Java多執行緒中，可以使用suspend()方法暫停執行緒，使用resume()方法恢復執行緒的執行。

在suspend與resume方法時，如果使用不當，極易造成公共的同步物件的獨佔，是的其他執行緒無法訪問公共同步物件。

class MyThread extends Thread{
	private long i = 0;
    @Override
    public void run(){
    	while(true){
    		i++;
    	}
    }
}
public class TestClass{
	public static void main(String[] args){
		
		try {
			MyThread mythread = new MyThread();
			mythread.start();
			Thread.sleep(1000);
			mythread.suspend();
			System.out.println("main end!");
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}		
	}
}
程式會打印出main end，但是將MyThread改為如下的寫法，執行程式，控制檯將不列印main end，這是因為當程式執行到println()方法內部停止時，同步鎖未被釋放。方法println()原始碼如下所示： 
public void println(long x){
    synchronized(this){
        print(x);
        newLine();
    }
}

yield方法

yield方法的作用是放棄當前的CPU資源，將它讓給其他的任務去佔用CPU執行時間。但放棄的時間不確定，有可能剛剛放棄，馬上又獲得CPU時間片。

class MyThread extends Thread{
    @Override
    public void run(){
    	long beginTime = System.currentTimeMillis();
    	int count = 0;
    	for(int i = 0; i < 50000000; i++){
    		//Thread.yield();
    		count += i;
    	}
    	long  endTime = System.currentTimeMillis();
    	System.out.println("用時："+(endTime - beginTime) + "毫秒！");
    }
}
public class TestClass{
	public static void main(String[] args){
		MyThread thread = new MyThread();
		thread.start();		
	}
}
正常情況下執行時間用了3毫秒，把//Thread.yield()的註釋去掉，用時3189毫秒！

執行緒的優先順序

優先順序較高的執行緒得到的CPU資源較多，也就是CPU優先執行優先順序較高的執行緒物件中的任務。設定執行緒的優先順序使用setPriority(int newPriority)方法。在Java中，執行緒的優先順序分為1~10這10個等級，如果小於1或大於10，則JDK丟擲異常throw new IllegalArgumentException()。

JDK中使用3個常量來預置定義優先順序的值，程式碼如下：

public final static int MIN_PRIORITY = 1;
public final static int NORM_PRIORITY = 5;
public final static int MAX_PRIORITY = 10;
在Java中，執行緒的優先順序具有繼承性，比如A執行緒啟動B執行緒，則B執行緒的優先順序與A是一樣的。下面是程式碼實現的例子： 
class MyThread1 extends Thread{
    @Override
    public void run(){
    	System.out.println("MyThread1 run priority="+this.getPriority());
    	MyThread2 thread2 = new MyThread2();
    	thread2.start();
    }
}
class MyThread2 extends Thread{
    @Override
    public void run(){
    	System.out.println("MyThread2 run priority="+this.getPriority());
    }
}
public class TestClass{
	public static void main(String[] args){
		System.out.println("main thread begin priority="+Thread.currentThread().getPriority());
		Thread.currentThread().setPriority(6);
		System.out.println("main thread begin priority="+Thread.currentThread().getPriority());
	    MyThread1 thread1 = new MyThread1();
	    thread1.start();
	}
}
程式執行結果為： 
main thread begin priority=5
main thread begin priority=6
MyThread1 run priority=6
MyThread2 run priority=6

守護執行緒

在Java執行緒中有兩種執行緒，一種是使用者執行緒，另一種是守護執行緒。

守護執行緒是一種特殊的執行緒，它的特性有“陪伴”的含義，當程序中不存在非守護執行緒了，則守護執行緒自動銷燬。典型的守護執行緒就是垃圾回收執行緒，當程序中沒有非守護執行緒了，則垃圾回收執行緒也就沒有存在的必要了，自動銷燬。

class MyThread extends Thread{
    private int i = 0;
	@Override
    public void run(){   	
		try {
			while(true){
	    		i++;
	    		System.out.println("i="+i);
	    		Thread.sleep(1000);
			}
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}	
    }
}
public class TestClass{
	public static void main(String[] args){		
		try {
			MyThread thread = new MyThread();
			thread.setDaemon(true);
			thread.start();
			Thread.sleep(5000);
			System.out.println("我離開thread物件也不再列印了，也就是停止了！");
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
	}
}
如下是執行結果，當main執行緒執行完，守護執行緒MyThread就銷燬了。 
i=1
i=2
i=3
i=4
i=5
我離開thread物件也不再列印了，也就是停止了！





相關推薦

Java多執行緒核心技術(一)：基礎知識總結

概念 程序：程序是作業系統結構的基礎，是一次程式的執行，是一個程式及其資料在處理機上順序執行時所發生的活動，是程式在一個程式集合上執行的過程，它是系統進行資源分配和排程的一個基本單位。 執行緒：執行緒是程序中獨立執行的子任務。使用多執行緒技術後，可以在同一時間執行更多不同種

Java多執行緒核心技術(四)：Lock的使用

一、使用ReentrantLock類 1、ReentrantLock的簡單使用 程式碼示例： import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock;

Java多執行緒核心技術(五)：定時器Timer

Timer類主要負責計劃任務的功能，也就是在指定的時間開始執行某一個任務。 1、schedule(TimerTask task,Date time) 方法schedule(TimerTask task,Date time)的作用是在指定的日期執行一次某一任務。 如下程式碼是

Java多執行緒核心技術(四)Lock的使用

本文主要介紹使用Java5中Lock物件也能實現同步的效果，而且在使用上更加方便。 本文著重掌握如下2個知識點： ReentrantLock 類的使用。 ReentrantReadWriteLock 類的使用。 1. 使用ReentrantLock 類 在Java多執行緒中，可以使用 synchron

Java多執行緒核心技術(五)單例模式與多執行緒

本文只需要考慮一件事：如何使單例模式遇到多執行緒是安全的、正確的 1.立即載入 / "餓漢模式" 什麼是立即載入？立即載入就是使用類的時候已經將物件建立完畢，常見的實現辦法就是直接 new 例項化。 public class MyObject { private static MyObject m

Java多執行緒核心技術(六)執行緒組與執行緒異常

本文應注重掌握如下知識點： 執行緒組的使用 如何切換執行緒狀態 SimpleDataFormat 類與多執行緒的解決辦法 如何處理執行緒的異常 1.執行緒的狀態 執行緒物件在不同執行時期有不同的狀態，狀態資訊就處於State列舉類中，如圖所示： 執行緒狀態 初始(NEW)：新建立了一個執行緒物件，但還

從ConcurrentHashMap的演進看Java多執行緒核心技術

執行緒不安全的HashMap 眾所周知，HashMap是非執行緒安全的。而HashMap的執行緒不安全主要體現在resize時的死迴圈及使用迭代器時的fast-fail上。 注：本章的程式碼均基於JDK 1.7.0_67 HashMap工作原理 HashMap資料結構

java多執行緒系列（一）基礎概念

前言 這一系列多執行緒的文章，一方面是個人對Java現有的多執行緒機制的學習和記錄，另一方面是希望能給不熟悉Java多執行緒機制、或有一定基礎但理解還不夠深的讀者一個比較全面的介紹，旨在使讀者對Java的多執行緒有一個遞增、全面和較深刻的理解，所以在第一部分就集中介紹一

java多執行緒系列（一）：Thread、Runnable、Callable實現多執行緒的區別

實現多執行緒 java實現多執行緒的方法有三種，分別是繼承thread類，實現runnable介面，實現callable介面（call方法有返回值） /** * 繼承Thread */ public class MyThread extends Thread{ int a = 0;

java多執行緒核心api以及相關概念(一)

這篇部落格總結了對執行緒核心api以及相關概念的學習，黑體字可以理解為重點，其他的都是我對它的理解 個人認為這些是學習java多執行緒的基礎，不理解熟悉這些，後面的也不可能學好滴 目錄 1.什麼是執行緒以及優點 二，多執行緒如何使用 三，執行緒安全問題， 四，synchronized執行過程敘述

Java多執行緒學習筆記(一) synchronized同步方法

synchronized同步方法 1.提出問題-例項變數非執行緒安全 1.1 何為非執行緒安全？ 1.2 舉例 1.2.1 有私有變數的類HasPrivateNum (供多執行緒們去呼叫) 1.2.2 執行緒A

java多執行緒學習(十一) 常見的單例模式執行緒安全性分析

類初始化鎖  怎麼理解？ 為什麼需要了解? 常見的單例模式分析 懶漢式 為什麼執行緒不安全 驗證 餓漢式 為什麼執行緒安全 雙重檢查鎖定方式 演變由來 為什麼執行緒不安全 如何解決執行緒不安全 靜態類方式 為什麼執行緒安全 結

java多執行緒-初探（一）

啥是多執行緒？跟程序又是啥關係？   比方說：我去洗手，洗完手去吃飯。 程序(Processor) 洗手跟吃飯是兩個程序。 執行緒(Thread) 在洗手的程序裡，我同時聽歌，還唱歌。那這裡洗手是一個程序，聽歌跟唱歌是兩個執行緒。 在吃飯的程序裡，我同時聽歌，還

Java多執行緒程式設計筆記2：synchronized同步方法

非執行緒安全會在多個執行緒對同一個物件中的例項變數進行併發訪問時發生，產生的結果就是髒讀，也就是取到的資料是被更改過的。執行緒安全就是獲得的例項變數的值是經過同步處理的。 方法內的變數是執行緒安全的 方法內的變數是執行緒安全的。非執行緒安全的問題存在於例項變數中，如果是方法內部的私有變數，不存在非執行緒安

Java多執行緒程式設計筆記10：單例模式

立即載入：“餓漢模式” 立即載入就是指使用類的時候已經將物件建立完畢，常見的實現方法就是直接new例項化。也就是在呼叫方法前，例項就被建立了。示例程式碼如下所示： class MyObject { private static MyObject myObject=new MyObject();

多執行緒使用場景一：使用者登入增加密碼輸入次數

spring.xml配置檔案中     <bean id="taskExecutor"         class="org.springframework.scheduling.concurrent

JAVA多執行緒機制第二彈：（程式碼）Ｔｈｒｅａｄ的子類建立執行緒

在Java中，執行緒物件的建立是用Ｔｈｒｅａ類或者它的子類建立。 在編寫Thread類的子類時，需要重寫父類的ｒｕｎ（）方法，其目的是規定執行緒的具體操作，否則執行緒就沒有開始的地方 在這裡，做一個小小總結： 　··線上程的編寫的時候，要重寫父類的ｒｕｎ（）方法，在ｒｕ

java多執行緒（1）：執行緒的建立和多執行緒的安全問題

前言 java多執行緒多用於服務端的高併發程式設計，本文就java執行緒的建立和多執行緒安全問題進行討論。 正文 一，建立java執行緒 建立java執行緒有2種方式，一種是繼承自Thread類，另一種是實現Runnable介面。由於java只支援單

Java多執行緒下載技術實現

多執行緒下載 多執行緒下載技術，簡單的說就是把要下載的檔案分成幾塊，由不同的執行緒來負責每一塊資料的下載任務。 技術要點 RandomAccessFile： Java中用來實現隨機訪問檔案的類 http Range請求頭 具體思路 1、檔案分塊。 檔案分塊大小（blockSize）= （

Java多執行緒學習（一）Java多執行緒入門

Java 併發的基礎知識，可能會在筆試中遇到，技術面試中也可能以併發知識環節提問的第一個問題出現。比如面試官可能會問你：“談談自己對於程序和執行緒的理解，兩者的區別是什麼？” 一 程序和多執行緒簡介 1.1 程序和執行緒 程序和執行緒的對比這一知識點