Thinking In Java 21.2 基本的線程進制 學習摘要

  對筆者近期剛閱讀完的Thinking In Java的12.2節簡單作個概述：

本節的主要內容：

1. 爲何要引入多線程
2. 多線程實現的機制：搶佔式的輪轉調度機制（如何避免搶佔能夠參考使用協做線程）
3. 多線程的基本兩種實現方式：實現 Runnable 接口、Callable 接口以及繼承 Thread 類，而且各自實現的優點
4. 多線程的安全使用方式：引入了相似線程池的管理機制--Executor（線程執行器），簡要介紹了 CachedThreadPool、SingleThreadPool 以及 FixedThreadPool 三種基本的線程執行器
5. 講述了 Runnable 接口（無返回值的任務描述）以及 Callable接口（有返回值的任務描述）
6. Thread 對象的 基本操做方式： Thread t => t.yield() t.start() t.sleep() t.join() t.wait() t.interrupt( join, wait 和interrupt筆者沒有書寫特定的示例，在下方的博客資料中有詳細的更優秀的博客作了相關方面的描述)
7. 如何處理 run() 方法中逃逸的異常（在Main線程中沒法try/catch到的）

如下是筆者的筆記，對於Java中的進程的基本概念有不少知識還須要參考操做系統（如：線程的三種基本態：執行態、等待態、執行態以及補充的掛起態和激活態）。大部分筆者本身的理解都放在了代碼中，若是有疏漏的還期望dalao們私聊指點下筆者（小萌新一隻）！

package cnboy.henu.xb;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadFactory;

/**
 * Thinking In Java 21.2 基本的線程進制  學習的樣例代碼
 * @author Administrator
 *
 * 最重要要理清概念 「線程」與「任務」，任務須要線程的驅動，Runnable以及Callable接口所作的事情是描述一個任務，而Thread則是開啓一個線程，附着在任務上，驅動任務的執行
 */
public class ExcutorTry {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
//		// 執行器對象 提供中間層管理任務對象（線程）		
//		/**
//		 * 下面是使用的SingleTheadPool作的示例
//		 */
//		ExecutorService exec1 = Executors.newSingleThreadExecutor();
//		// 此對象緩存的線程對象僅只有一個，所以其它須要執行的任務會自動排隊等待執行
//		for(int i=0;i<10;i++) {
//			exec1.execute(new TaskWithoutResult(i));
//		}
//		exec1.shutdown();
		
//		/**
//		 * 下面是利用的 CachedThreadPool 作的示例
//		 */
//		ExecutorService exec = Executors.newCachedThreadPool();
//		// Future對象正如名字所示，能夠表明一個異步任務返回的對象並提供獲取其值的方式
//		List<Future<String>>  results = new ArrayList<Future<String>>();
//		for(int i=0;i<10;i++) {
//			results.add(exec.submit(new TaskWithResult(i)));
//		}
//		// 關閉執行器，不讓新的任務添加進來
//		exec.shutdown();
//		for(Future<String> fs:results) {
//			try {
//				// 判斷fs是否已經執行完畢，也能夠不加，不加的狀況下會自動阻塞等待其執行完畢
//				if(fs.isDone()) {
//					System.out.println(fs.get());
//				}
//			}catch(InterruptedException e){
//				e.printStackTrace();
//			} catch (ExecutionException e) {
//				// TODO Auto-generated catch block
//				e.printStackTrace();
//			}
//		}
		
//		// 這裏執行描述的任務的Runner其實是Main線程而不是launch對象
		LiffOff launch = new LiffOff(10);launch.run();
		Thread.yield();
		
//		// 這裏執行描述的任務對象是線程 t ，此處纔是真正的多線程併發執行(main 線程以及 t 線程)
//		Thread t = new Thread(new LiffOff(10));
//		t.start();System.out.println("Waiting for Liff Out!");
		
//		// 這裏模仿了6個線程併發的執行狀況(main + 五個new Thread)
//		for(int i=0;i<5;i++) {
//			new Thread(new LiffOff(10)).start();
//		}
		
		/**
		 * Daemon線程 （守護線程，定義爲DaemonThread意味着此線程不屬於程序中不可或缺的一部分，常見的 GC線程是Daemon線程）
		 * Daemon進程fork出來的子線程也會被自動設置爲Daemon線程
		 */
//		// 將線程執行器設置爲後臺線程執行器（即建立執行任務的線程都是後臺線程），採用構造注入的方式將後臺線程Factory注入執行器中
//		ExecutorService daemonExec = Executors.newCachedThreadPool(new DaemonThreadFactory());
//		for(int i =0;i<5;i++) {
//			// 後臺執行
//			daemonExec.execute(new TaskWithoutResult(i));
//		}
//		daemonExec.shutdown();
//		System.out.println("All Daemon Thread Started!");
//		try {
//			// 等待一下Daemon 線程的執行（有趣的是能夠調節等待時間觀察Daemon線程執行與非後臺線程執行的關係，即非後臺線程執行完畢，Daemon線程也會同時退出）
//			//TimeUnit.SECONDS.sleep(10);// 後臺線程執行完畢
//			TimeUnit.MICROSECONDS.sleep(1000);// 後臺線程來不及執行完畢
//		} catch (InterruptedException e) {
//			// TODO Auto-generated catch block
//			e.printStackTrace();
//		}
		
		/**
		 * 使用繼承Thread類的方式實現多線程，缺點在於沒法再繼承其餘類，而實現Runnable接口任然能夠繼承其餘類
		 */
//		for(int i=0;i<5;i++) {
//			new SimpleThread();
//		}		
		
		/**
		 * 一般咱們在run()裏出現的異常（從線程中逃逸，向父線程傳播）若是不加以特殊處理（如使用UncaughtExceptionHandle），而只是簡單的在Main裏經過try/catch是沒辦法捕獲並處理異常的
		 * 所以咱們須要引入UncaughtExceptionHandle爲咱們的線程加上一道安全防線（使用在ThreadFactory、Executor）
		 * 
		 */
//		ExecutorService exceptionExec = 
//				Executors.newCachedThreadPool(new HandleThreadFactory());
//		exceptionExec.execute(new ExceptionThread());
//		exceptionExec.shutdown();
		
	}
}
/**
 * 不帶返回值的任務
 * @author Administrator
 *
 */
class TaskWithoutResult implements Runnable{
	private int id;	
	public TaskWithoutResult(int id) {
		// TODO Auto-generated constructor stub
		this.id = id;
		System.out.println("Generate Runnable Task : id = "+id);
	}
	
	@Override
	public void run() {
		// TODO Auto-generated method stub
		System.out.println(String.format("Task Without Result => id = %d", id));
	}
	
}

/**
 * 帶返回值的任務  實現的Callable接口
 * @author Administrator
 *
 */
class TaskWithResult implements Callable<String>{

	private int id=0;
	
	public TaskWithResult(int id) {
		// TODO Auto-generated constructor stub
		this.id = id;
	}
	
	/**
	 * 注意不是Run方法
	 */
	@Override
	public String call() throws Exception {
		// TODO Auto-generated method stub
		// 模仿下有任務的線程		
		return String.format("ask With Result => id = %d", id);
	}
	
}

/**
 * 這個任務描述是模擬的火箭發射的例子
 * @author Administrator
 *
 */
class LiffOff implements Runnable{

	protected int countDown =10;
	private static int taskCount = 0;
	private final int id=taskCount++;
	public LiffOff(int countDown) {
		// TODO Auto-generated constructor stub
		this.countDown = countDown;
	}
	
	public String Status() {
		return String.format("# %d (", id)+(countDown>0?countDown:"Liff Off!")+")";
	}
	
	@Override
	public void run() {
		// 模擬火箭發射倒計時
		while(countDown-- >0) {
			System.out.println(Status());
			// 讓步 告訴線程調度器此線程核心工做已完成，能夠進行上下文切換了
			/**
			 * 與sleep不一樣的是，sleep是讓線程進入阻塞態，這時不管比線程高優先級仍是低優先級的線程均可以被執行
			 * 而yeild僅僅只是讓出此時間片，進入可執行態也就是它並不會等待一次完整的輪轉後再之執行，而是有可能隨時又進入執行態(可能剛yeild完畢又被調用了)，所以它只能讓步與它同優先級或者是高優先級的線程
			 */
			//Thread.yield();
			/**
			 * 換成sleep，能夠看到每一個線程都會按照時間輪轉進行輸出，而不是搶佔的輸出（會按照順序輸出）
			 */
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
	
}

/**
 * 專門用於建立後臺進程的ThreadFactory
 * @author Administrator
 *
 */
class DaemonThreadFactory implements ThreadFactory{

	@Override
	public Thread newThread(Runnable r) {
		// TODO Auto-generated method stub
		Thread t = new Thread(r);
		// 這裏設置線程爲後臺線程
		t.setDaemon(true);
		return t;
	}
	
}

/**
 * 模擬一種實現線程的方式：繼承自Thread類
 * @author Administrator
 *
 */
class SimpleThread extends Thread{
	protected int countDown =5;
	private static int taskCount = 0;
	public SimpleThread() {
		// TODO Auto-generated constructor stub
		// 經過調用父類的構造函數，給線程名字賦值
		super(Integer.toString(taskCount++));
		// 在構造函數中便啓動線程  -- 不推薦的方式，僅爲了方便作示例
		start();
	}
	
	@Override
	public String toString() {
		// TODO Auto-generated method stub
		return "#"+getName()+"("+countDown+")";
	}
	@Override
	public void run() {
		// TODO Auto-generated method stub
		while(true) {
			System.out.println(this);
			if(countDown-- ==0) {
				return;
			}
		}
	}
}

/**
 * 模擬一個在run()方法中拋出異常的Runnable對象
 * @author Administrator
 *
 */
class ExceptionThread implements Runnable{
	@Override
	public void run() {
		// TODO Auto-generated method stub
		// 模擬執行過程當中拋出異常
		Thread t = Thread.currentThread();
		System.out.println("run() by "+ t);
		System.out.println("eh = "+t.getUncaughtExceptionHandler());
		throw new RuntimeException();
	}
	
}

/**
 * 模擬一個用以處理逃逸的異常的UncaughtExceptionHandler對象
 * @author Administrator
 *
 */
class MyUncaughtExceptionHandler implements Thread.UncaughtExceptionHandler{
	/**
	 * uncaughtException方法會在線程因未捕獲的異常而面臨死亡的時候被調用
	 */
	@Override
	public void uncaughtException(Thread t, Throwable e) {
		// TODO Auto-generated method stub
		System.out.println("caught :"+e);
	}
	
}

/**
 * 模擬的一個爲線程設置異常處理的ThreadFactory
 * @author Administrator
 *
 */
class HandleThreadFactory implements ThreadFactory{
	@Override
	public Thread newThread(Runnable r) {
		// TODO Auto-generated method stub
		// 記錄建立線程的過程
		System.out.println(this+"\tcreating new Thread");
		Thread t = new Thread(r);
		System.out.println("created \t" + t);
		// 給與線程UncaughtException處理器
		t.setUncaughtExceptionHandler(new MyUncaughtExceptionHandler());
		System.out.println("eh = "+t.getUncaughtExceptionHandler());
		return t;
	}
	
}

附：學習中借鑑的幾篇優秀的博客

Java多線程之interrupt()方法與sleep(),join(),wait()的關係

Java多線程編程：Callable、Future和FutureTask淺析（多線程編程之四）