【Java】線程的建立方式

 

一、繼承Thread類方式

這種方式適用於執行特定任務，而且須要獲取處理後的數據的場景。

舉例：一個用於累加數組內數據的和的線程。

public class AdditionThread extends Thread {
    private int sum = 0;
    private int[] nums;
​
    public AdditionThread(int[] nums, String threadName) {
        super(threadName);
        this.nums = nums;
    }
​
    @Override
    public void run() {
        for (int num : nums) {
            sum += num;
        }
    }
​
    public int getSum() {
        return sum;
    }
}

調用方式：

public class Main {
    public static void main(String[] args) throws InterruptedException {
        int[] nums = {10, 12, 15, 200, 100};
        AdditionThread thread = new AdditionThread(nums, "AdditionThread");
        thread.start();
        thread.join();
​
        System.out.println("sum=" + thread.getSum());
    }
}

 

二、Runnable 接口方式

定義一個實現Runnable接口的類，或者直接建立一個匿名內部類，並覆蓋 run() 方法。最後做爲參數傳給Thread的構造函數。

public class Main {
    public static void main(String[] args) {
        // 自定義的 Runnable
        Runnable runnable = new MyRunnable();
        Thread thread = new Thread(runnable, "Runnable-Thread");
        thread.start();
​
        // 自定義匿名內部類
        new Thread(() -> {
            System.out.println("Inner class");
        }).start();
    }
​
    static class MyRunnable implements Runnable {
        @Override
        public void run() {
            System.out.println("MyRunnable");
        }
    }
}

 

三、 Callable 接口方式

Callable 接口與 Runnable 接口的區別：

（1）Callable 的方法爲call()，Runnable的方法爲run()。

（2）Callable 的方法由返回值，Runnable 沒有。

（3）Callable 的方法聲明的Exception，Runnable的沒有。

public class Main {
    public static void main(String[] args) {
        MyCallable myCallable = new MyCallable();
        FutureTask<String> task = new FutureTask<>(myCallable);
        Thread thread = new Thread(task, "FutureTask");
        thread.start();
        try {
            // 經過get方法獲取返回值
            String result = task.get();
            System.out.println(result);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }
​
    static class MyCallable implements Callable<String> {
        @Override
        public String call() throws Exception {
            // 模擬超時操做
            Thread.sleep(1000);
            return "OK";
        }
    }
}

 

四、線程池方式

咱們能夠經過 ThreadPoolExecutor 類的構造函數來建立線程池，也能夠經過Executors工廠方法來建立，如

// 建立固定線程數的線程池
Executors.newFixedThreadPool(); 
// 建立只有一個核心線程的線程池
Executors.newSingleThreadExecutor();
// 建立一個沒有核心線程，但能夠緩存線程的線程池
Executors.newCachedThreadPool();
// 建立一個適用於執行定時任務的線程池
Executors.newScheduledThreadPool();

 

在建立線程池時，最好傳入 ThreadFactory 參數，指定線程池所建立線程的名稱。這樣有利於分析定位可能存在的問題。

public class Main {
    private static final ExecutorService SERVICE =
        Executors.newFixedThreadPool(5, new BasicThreadFactory("My-Thread"));
​
    public static void main(String[] args) {
        // 打印線程的名字
        System.out.println("main thread name:" + Thread.currentThread().getName());
        SERVICE.execute(() -> {
            System.out.println("Hello thread pool.");
            // 打印線程池裏的線程的名字
            System.out.println("thread name:" + Thread.currentThread().getName());
        });
    }
​
    static class BasicThreadFactory implements ThreadFactory {
        private final AtomicInteger threadNumber = new AtomicInteger(0);
        private final String basicName;
​
        public BasicThreadFactory(String basicName) {
            this.basicName = basicName;
        }
​
        @Override
        public Thread newThread(Runnable runnable) {
            Thread thread = new Thread(runnable);
            String name = this.basicName + "-" + threadNumber.incrementAndGet();
            thread.setName(name);
            return thread;
        }
    }
}