【ZZ：https://www.cnblogs.com/HBDanDing/articles/12696889.html】
創建線程方式一：繼承Thread類。
步驟：
1，定義一個類繼承Thread類。
2，覆蓋Thread類中的run方法。
3，直接創建Thread的子類對象創建線程。
4，調用start方法開啟線程並調用線程的任務run方法執行。
可以通過Thread的getName獲取線程的名稱 Thread-編號(從0開始)
主線程的名字就是main。
例：
class Demo extends Thread
{
private String name;
Demo(String name)
{
super(name); //父類構造函數，改線程的名稱
//this.name = name;
}
//***run方法中定義就是線程要運行的任務代碼。***
public void run()
{
for(int x=0; x<10; x++)
{
//for(int y=-9999999; y<999999999; y++){}
System.out.println(name+"....x="+x+".....name="+Thread.currentThread().getName());
}
}
}
class ThreadDemo2
{
public static void main(String[] args)
{
Demo d1 = new Demo("旺財");
Demo d2 = new Demo("xiaoqiang");
d1.start();//開啟線程，調用run方法。
d2.start();
System.out.println("over...."+Thread.currentThread().getName());
}
}
創建線程方式二 ：當該類有自己父類的時候，通過實現Runnable接口，覆蓋run方法。（*常用*）
步驟：
1，定義類實現Runnable接口。
2，覆蓋接口中的run方法，將線程的任務代碼封裝到run方法中。
3，通過Thread類創建線程對象，並將Runnable接口的子類對象作為Thread類的構造函數的參數進行傳遞。
為什么？因為線程的任務都封裝在Runnable接口子類對象的run方法中。
所以要在線程對象創建時就必須明確要運行的任務。
思想：將線程的任務通過Runnable接口封裝成了對象。
4，調用線程對象的start方法開啟線程。
實現Runnable接口的好處：
1，將線程的任務從線程的子類中分離出來，進行了單獨的封裝，按照面向對象的思想將任務封裝成對象。
2，避免了java單繼承的局限性。
例：
class Demo implements Runnable//extends Fu //准備擴展Demo類的功能，讓其中的內容可以作為線程的任務執行。
//通過接口的形式完成。
{
public void run()
{
show();
}
public void show()
{
for(int x=0; x<20; x++)
{
System.out.println(Thread.currentThread().getName()+"....."+x);
}
}
}
class ThreadDemo
{
public static void main(String[] args)
{
Demo d = new Demo();
Thread t1 = new Thread(d);
Thread t2 = new Thread(d);
t1.start();
t2.start();
}
}
創建線程方式三 ：實現Callable接口
與使用Runnable相比， Callable功能更強大些
1 相比run()方法，可以有返回值
2 方法可以拋出異常
3 支持泛型的返回值
4 需要借助FutureTask類，比如獲取返回結果
Future接口
1 可以對具體Runnable、Callable任務的執行結果進行取消、查詢是
否完成、獲取結果等。
2 FutrueTask是Futrue接口的唯一的實現類
3 FutureTask 同時實現了Runnable, Future接口。它既可以作為 Runnable被線程執行，又可以作為Future得到Callable的返回值
1 //1.創建一個實現Callable的實現類
2 class Stu implements Callable {
3 //2.實現call方法,將此線程需要執行的操作生命call()中
4 @Override
5 public Object call() throws Exception {
6 int sum=0;
7 for (int i = 1; i <=100; i++) {
8 if(i % 2 == 0){
9 System.out.println(i);
10 sum += i;
11 }
12 }
13 return sum;
14 }
15 }
16
17 public class Bank {
18 public static void main(String[] args) {
19 //3.創建Callable接口實現類的對象
20 Stu stu = new Stu();
21 //4.將此Callable接口實現類的對象作為傳遞到FutureTask構造器中，創建FutureTask的對象
22 FutureTask futureTask = new FutureTask(stu);
23 //5.FutureTask的對象作為參數傳遞到Thread類的構造器中創建Thread，並調用start()
24 new Thread(futureTask).start();
25 try {
26 Object sum = futureTask.get();
27 System.out.println("總和為"+sum);
28 } catch (InterruptedException e) {
29 e.printStackTrace();
30 } catch (ExecutionException e) {
31 e.printStackTrace();
32 }
33
34 }
35 }
運行結果
創建線程方式四 ：使用線程池
背景：經常創建和銷毀、使用量特別大的資源，比如並發情況下的線程， 對性能影響很大。
思路：提前創建好多個線程，放入線程池中，使用時直接獲取，使用完 放回池中。可以避免頻繁創建銷毀、實現重復利用。類似生活中的公共交 通工具。
好處:
1提高響應速度（減少了創建新線程的時間）
2降低資源消耗（重復利用線程池中線程，不需要每次都創建）
3便於線程管理
corePoolSize：核心池的大小
maximumPoolSize：最大線程數
keepAliveTime：線程沒有任務時最多保持多長時間后會終止
1 //創建並使用多線程的第四種方法：使用線程池
2 class MyThread implements Runnable {
3
4 @Override
5 public void run() {
6 for (int i = 1; i <= 100; i++) {
7 if(i % 2 ==0){
8 System.out.println(Thread.currentThread().getName() + ":" + i);
9 }
10 }
11 }
12
13 }
14
15 public class ThreadPool {
16 public static void main(String[] args) {
17 // 1.提供指定線程的數量
18 ExecutorService service = Executors.newFixedThreadPool(10);
19 //設置線程的屬性
20 ThreadPoolExecutor service1= (ThreadPoolExecutor) service;
21 //service1.setMaximumPoolSize(15);
22 //service1.setCorePoolSize();*/
23 // 2.將Runnable實現類的對象作為形參傳遞給ExecutorService的submit()方法中，開啟線程
24 // 並執行相關的run()
25 service.execute(new MyThread());//適用於Runnable
26 //service.submit();適用於Callable
27
28 // 3.結束線程的使用
29 service.shutdown();
30
31 }
32 }