Thinking In Java 21.2 基本的線程進制 學習摘要
對筆者近期剛閱讀完的Thinking In Java的12.2節簡單作個概述：java
本節的主要內容：編程
- 爲何要引入多線程
- 多線程實現的機制：搶佔式的輪轉調度機制（如何避免搶佔能夠參考使用協做線程）
- 多線程的基本兩種實現方式：實現
Runnable接口、Callable接口以及繼承Thread類，而且各自實現的優點 - 多線程的安全使用方式：引入了相似線程池的管理機制--
Executor（線程執行器），簡要介紹了CachedThreadPool、SingleThreadPool以及FixedThreadPool三種基本的線程執行器 - 講述了
Runnable接口（無返回值的任務描述）以及Callable接口（有返回值的任務描述） Thread對象的 基本操做方式：Thread t=>t.yield()t.start()t.sleep()t.join()t.wait()t.interrupt(join,wait和interrupt筆者沒有書寫特定的示例，在下方的博客資料中有詳細的更優秀的博客作了相關方面的描述)- 如何處理
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;
}
}
附：學習中借鑑的幾篇優秀的博客安全
相關文章
- 1. Thinking in Java 學習筆記
- 2. Thinking in JaVa 4th 讀書摘錄--前言
- 3. Thinking in java中創建線程任務Task的基本方法
- 4. Thinking in Java 15
- 5. 11.併發(Thinking in java學習11)
- 6. thinking-in-java-version2
- 7. Thinking in Java [Java編程機制] 學習筆記 -- Priority Queue
- 8. Thinking in java
- 9. Thinking In Java 學習筆記 21.併發
- 10. JAVA學習摘要
- 更多相關文章...
- • C# 多線程 - C#教程
- • C# 二進制文件的讀寫 - C#教程
- • Kotlin學習（一）基本語法
- • Kotlin學習（二）基本類型
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
歡迎關注本站公眾號,獲取更多信息
相關文章