1.建立方式一：繼承Thread類

package com.cjj.duoxiancheng;

/*
* 路人假helloWorld
* 多執行緒的建立，方式一：繼承Thread類
*   1.建立一個繼承於Thread類的子類
*   2.重寫Thread類的run()方法  --> 將此執行緒的操作宣告在run()中
*   3.建立Thread類的子類物件
*   4.通過此物件呼叫start()
* 例子：遍歷輸出100以內的所有偶數。
* */

class MyThread extends Thread{
    //重寫run()方法
    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {
            if (i % 2 == 0){
                System.out.println(i);
            }
        }
    }
}

public class ThreadTest {
    public static void main(String[] args) {
        //建立Thread類的子類物件
        MyThread p = new MyThread();

        p.start();
        for (int i = 0; i <= 100; i++) {
            System.out.println("===main執行緒=====" + i);
        }

    }
}
 

2.建立方式二：實現Runnable介面

package com.cjj.duoxiancheng;

/*
* 路人假helloWorld
* 多執行緒的建立方式二：實現Runnable介面
* 1.建立一個實現了Runnable介面的類
* 2.實現類去實現Runnable中的抽象方法：run()
* 3.建立實現類的物件
* 4.將此物件作為引數傳遞到Thread類的構造器當中，建立Thread類的物件
* 5.通過Thread類的物件呼叫start()
* */

//1.建立一個實現了Runnable介面的類
class MThread implements Runnable{

    //2.實現類去實現Runnable中的抽象方法：run()
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}

public class ThreadTest1 {
    public static void main(String[] args) {
        //3.建立實現類的物件
        MThread myThread = new MThread();

        //4.將此物件作為引數傳遞到Thread類的構造器當中，建立Thread類的物件
        Thread t1 = new Thread(myThread);

        //5.通過Thread類的物件呼叫start()
        t1.start();

        Thread t2 = new Thread(myThread);
        t2.start();
    }


}
 

3.建立方式三：實現Callable介面

/*
* 路人假helloWorld
* 建立執行緒的方式三：實現Callable介面 --> JDK5.0 新增
*
* 如何理解實現Callable介面的方式建立多執行緒比實現Runnable介面建立多執行緒方式更強大？
* 1.call()方法可以有返回值
* 2.call()方法可以丟擲異常，被外面的操作捕獲，獲取異常的資訊
* 3.Callable是支援泛型的
* */

class NumThread implements Callable {

    @Override
    public Object call() throws Exception {
        int sum = 0;
        for (int i = 0; i <= 100; i++) {
            if (i % 2 == 0){
                System.out.println(i);
                sum += i;
            }
        }
        return sum;
    }
}

public class ThreadCallable {

    public static void main(String[] args) {
        //建立Callable介面實現類物件
        NumThread numThread = new NumThread();
        //將Callable介面實現類物件傳遞到FutureTask構造器中，建立FutureTask的物件
        FutureTask futureTask = new FutureTask(numThread);
        //將FutureTask的物件作為引數傳遞到Thread類的構造器中，建立Thread物件，並呼叫start()方法
        new Thread(futureTask).start();

        try {
            //獲取Callable中call方法的返回值
            //get()返 回值即為FutureTask構造器引數Callable實現類重寫的call()的返回值。
            Object sum = futureTask.get();
            System.out.println("總和為：" + sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }

}
 

4.建立方式四：使用執行緒池

/*
*路人假helloWorld
*/
class NumThread1 implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {
            if(i % 2 == 0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}

class NumThread2 implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {
            if(i % 2 != 0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}

public class ThreadPool {
    public static void main(String[] args) {
        //提供指定執行緒數量的執行緒池
        ExecutorService service = Executors.newFixedThreadPool(10);

        //可以設定執行緒池的屬性
        ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;
        service1.setCorePoolSize(15);

        //執行指定的執行緒操作
        service.execute(new NumThread1()); //適用於實現Runnable介面
        service.execute(new NumThread2()); //適用於實現Runnable介面
        //service.submit(Callable callable);  //適用於實現Callable介面

        //關閉執行緒池
        service.shutdown();
    }
}