一、實現Java多線程的方法

1、繼承Thread類創建多線程

Thread類本質實現了Runnable接口。啟動線程為start0()方法。是個native方法。

 1 public class ThreadProcess extends Thread {
 2 
 3     @Override
 4     public void run(){
 5         long lastTime = System.currentTimeMillis();
 6         for(int i = 0; i < 1; i++){
 7             int ele = Integer.MAX_VALUE;
 
 8             while (ele >= 0){
 9                 int ele2 = ele - Integer.MAX_VALUE + 65535 - 37666 + 44443;
10                 int temp = Math.max(ele2, ele);
11                 if(temp != ele){
12                     temp = ele;
13                 }
14                 ele = temp-1;
15             }
 
16         }
17         System.out.println("Time cost from thread " + (System.currentTimeMillis() -  lastTime));
18     }
19 }

2、實現Runnable。一個類已經繼承了Thread類就無法繼承其它類。

 1 class AccountOperator implements Runnable {
 2     private int count;
 3     private final byte[] lock = new byte[0];
 4 
 5     public
 
 AccountOperator() {
 6         this.count = 0;
 7     }
 8 
 9     public void run() {
10         synchronized (lock) {
11             count++;
12             System.out.println(Thread.currentThread().getName() + ":" + count);
13         }
14     }
15 }

3、實現Callable

如果運行完線程並且需要線程返回結果的時候，可以

 1 import java.util.concurrent.Callable;
 2 
 3 public class GetDataThread<V> implements Callable<V> {
 4     private V v;
 5 
 6     public GetDataThread(V v) {
 7         this.v = v;
 8     }
 9 
10     @Override
11     public V call() {
12         return this.v;
13     }
14 }

 1 public class Main {
 2     public static void main(String[] args) throws Exception{
 3         String data = "data";
 4         FutureTask<String> ft = new FutureTask<>(new GetDataCal<>(data));
 5         Thread t = new Thread(ft);
 6         t.start();
 7         String res = ft.get();
 8         System.out.println("Result: " + res);
 9     }
10 }

二、Java線程池

線程的創建和銷毀是需要時間的。記線程創建的時間為T1, 線程運行的時間為T2，線程銷毀的時間為T3。如果T1 + T3 遠遠大於 T2，並且有很多這樣的任務需要並行執行時，就可以使用線程池。

因為通過線程池，線程資源可以重復使用。

1、常見的線程池

• newSingleThreadExecutor
• newFixedThreadExecutor
• newCachedThreadExecutor
• newScheduleThreadExecutor

2、首先看下ThreadPoolExecutor方法。構造函數包含了幾個重要參數，

1     public ThreadPoolExecutor(int corePoolSize,
2                               int maximumPoolSize,
3                               long keepAliveTime,
4                               TimeUnit unit,
5                               BlockingQueue<Runnable> workQueue
6                               RejectedExecutionHandler handler){}

1. corePoolSize, 線程池核心線程數量
2. maximumPoolSize，線程池最大線程數
3. keepAliveTime，當活躍線程數大於核心線程數時，空閑的多余線程最大存活時間
4. unit 存活時間的單位
5. workQueue 存放任務的隊列
6. handler 超出線程範圍和隊列容量的任務的處理程序，也叫拒絕策略。

3、先看下線程池的實現原理

提交一個任務到線程池，線程池的處理流程如下

• 判斷核心線程池是否都在執行任務，如果不是，則創建新的線程執行任務
• 若核心線程都在執行任務，判斷工作隊列滿沒滿，如果沒滿，把任務提交給隊列
• 若隊列滿了，判斷線程池裏的線程是否都處於工作狀態。如果沒有，則創建一個新的工作線程來執行任務，如果滿了則交給拒絕策略處理

Java線程池學習