import java.util.concurrent.*;

public class ThreadTest {
    public static void main(String[] args) {
        //1、繼承Thread類
       /* MyThread myThread = new MyThread();
        myThread.start();
        System.out.println("主執行緒");*/
        /*
         * 執行結果：
         * 主執行緒
         * 執行子執行緒
         * 當然，這裡的結果不代表執行緒的執行順序，執行緒是併發執行的，如果多執行幾次，列印順序可能會不一樣。多執行緒的執行過程中，CPU是以不確定的方式去執行執行緒的，故執行結果與程式碼的執行順序或者呼叫順序無關，執行結果也可能不一樣。關於執行緒執行的隨機性本文後面也有程式碼示例。
         * 這裡還有一個需要注意的點就是main方法中應該呼叫的是myThread的start方法，而不是run()方法。呼叫start()方法是告訴CPU此執行緒已經準備就緒可以執行，進而系統有時間就會來執行其run()方法。而直接呼叫run()方法，則不是非同步執行，而是等同於呼叫函式般按順序同步執行，這就失去了多執行緒的意義了。
         
 
*/
        //2.實現Runnable介面
        /*Runnable runnable = new MyRunnable();
        Thread thread = new Thread(runnable);
        thread.start();
        System.out.println("主執行緒。。");*/
        /*
         *執行結果
         *主執行緒。。
         *執行子執行緒
         * 真正建立新執行緒還是通過Thread建立：
         * Thread thread = new Thread(runnable); 這一步Thread類的作用就是把run()方法包裝成執行緒執行體，然後依然通過start去告訴系統這個執行緒已經準備好了可以安排執行。
         
 
*/
       // 3、使用Callable和Future建立執行緒
            //上面的兩種方式都有這兩個問題：
            //a.    無法獲取子執行緒的返回值
            //b.    run方法不可以丟擲異常
       /* Callable callable = new MyCallable();
        for (int i = 0; i < 5 ; i++) {
            FutureTask task = new FutureTask(callable);
            new Thread(task,"子執行緒"+i).start();
            try{
                //獲取返回子執行緒的值
                System.out.println("子執行緒的返回值："+task.get()+"\n");
            }catch (Exception e){
                e.printStackTrace();
            }
        }
 
*/
        /*
            子執行緒0i的值==0
            子執行緒的返回值：0

            子執行緒1i的值==1
            子執行緒的返回值：1

            子執行緒2i的值==2
            子執行緒的返回值：2

            子執行緒3i的值==3
            子執行緒的返回值：3

            子執行緒4i的值==4
            子執行緒的返回值：4

            如何啟動執行緒？
            （1）建立一個Callable介面的實現類的物件
            （2）建立一個FutureTask物件，傳入Callable型別的引數
            （3）呼叫Thread類過載的引數為Runnable的構造器建立Thread物件
            (4)取返回值呼叫FutureTask類的get()方法
         */
        //4.執行緒池 Executors類
        //  Executor    負責現成的使用和排程的根介面
        // *    |--ExecutorService    執行緒池的主要介面
        // *          |--ThreadPoolExecutor    執行緒池的實現類
        // *          |--ScheduledExecutorService    介面，負責執行緒的排程
        // *              |--ScheduledThreadPoolExecutor    (extends ThreadPoolExecutor implements ScheduledExecutorService)
        //使用Executors工具類中的方法建立執行緒池
       /* ExecutorService executorService = Executors.newFixedThreadPool(5);
        MyThreadPool myThreadPool = new MyThreadPool();
        //為執行緒池中的執行緒分配任務,使用submit方法，傳入的引數可以是Runnable的實現類，也可以是Callable的實現類
        for (int i = 0; i < 5; i++) {
            executorService.submit(myThreadPool);
        }
        //關閉執行緒池
        //shutdown ： 以一種平和的方式關閉執行緒池，在關閉執行緒池之前，會等待執行緒池中的所有的任務都結束，不在接受新任務
        //shutdownNow ： 立即關閉執行緒池
        executorService.shutdown();*/

        /*
        pool-1-thread-4-------0
        pool-1-thread-3-------2
        pool-1-thread-3-------5
        pool-1-thread-3-------6
        pool-1-thread-1-------1
        pool-1-thread-2-------8
        pool-1-thread-2-------10
        pool-1-thread-2-------11
        pool-1-thread-2-------12
        pool-1-thread-2-------13
        pool-1-thread-2-------14
        pool-1-thread-2-------15
        pool-1-thread-2-------16
        pool-1-thread-2-------17
        pool-1-thread-2-------18
        pool-1-thread-3-------7
        pool-1-thread-3-------20
        pool-1-thread-4-------3
        pool-1-thread-5-------4
        pool-1-thread-5-------23
        pool-1-thread-5-------24
        pool-1-thread-5-------25
        pool-1-thread-5-------26
        pool-1-thread-5-------27
        pool-1-thread-5-------28
        pool-1-thread-5-------29
        pool-1-thread-5-------30
        pool-1-thread-5-------31
        pool-1-thread-5-------32
        pool-1-thread-5-------33
        pool-1-thread-5-------34
        pool-1-thread-5-------35
        pool-1-thread-5-------36
        pool-1-thread-5-------37
        pool-1-thread-5-------38
        pool-1-thread-5-------39
        pool-1-thread-5-------40
        pool-1-thread-5-------41
        pool-1-thread-5-------42
        pool-1-thread-5-------43
        pool-1-thread-5-------44
        pool-1-thread-5-------45
        pool-1-thread-5-------46
        pool-1-thread-5-------47
        pool-1-thread-4-------22
        pool-1-thread-3-------21
        pool-1-thread-2-------19
        pool-1-thread-1-------9
        pool-1-thread-4-------49
        pool-1-thread-5-------48
         */

       ExecutorService executorService = Executors.newFixedThreadPool(5);
        for (int i = 0; i <5 ; i++) {
            Future<Integer> future = executorService.submit(new Callable<Integer>() {
                @Override
                public Integer call() throws Exception {
                    int result = 0;
                    for (int j = 0; j < 10; j++) {
                        result += j;
                    }
                    return result;
                }
            });

            try {
                System.out.println(Thread.currentThread().getName()+"-----"+future.get());
            }catch (Exception e){
                e.printStackTrace();
            }
        }
        executorService.shutdown();
        /*
        main-----45
        main-----45
        main-----45
        main-----45
        main-----45
         */

    }
}
class MyThread extends Thread{
    @Override
    public void run() {
        super.run();
        System.out.println("執行子執行緒");
    }
}

class MyRunnable implements Runnable{

    @Override
    public void run() {
        System.out.println("執行子執行緒");
    }
}

class MyCallable implements Callable{
    int i = 0;
    @Override
    public Object call() throws Exception {
        System.out.println(Thread.currentThread().getName()+"i的值=="+i);
        return i++;//call方法有返回值
    }
}
class  MyThreadPool implements Runnable{
    int i = 0;
    @Override
    public void run() {
        while(i<50){
            System.out.println(Thread.currentThread().getName()+"-------"+i++);
        }
    }
}