Java Thread的一点总结2

为什么需要多线程

众所周知，CPU、内存、I/O 设备的速度是有极大差异的，为了合理利用 CPU 的高性能，平衡这三者的速度差异，计算机体系结构、操作系统、编译程序都做出了贡献，主要体现为:

• CPU 增加了缓存，以均衡与内存的速度差异；// 导致 可见性问题
• 操作系统增加了进程、线程，以分时复用 CPU，进而均衡 CPU 与 I/O 设备的速度差异；// 导致 原子性问题
• 编译程序优化指令执行次序，使得缓存能够得到更加合理地利用。// 导致 有序性问题

Life Cycle of a Thread 线程的生命周期

一个线程从被创建开始，就会有自己的一个生命周期。

java.lang.Thread类包含了一个静态的 State 枚举，它定义了其潜在的状态。在任何给定的时间点上，线程只能处于这些状态的其中一种：

• NEW 一个新创建但是还未执行的线程
• RUNNABLE 正在执行或者等待资源分配后准备执行
• BLOCKED 等待获得 a monitor lock 以进入或者重新进入一个同步块/方法
• WAITING 在没有任何时间限制的情况下，等待其他线程执行一个特定的动作
• TIMED_WAITING 等待其他线程在指定时间内执行一个特定的动作
• TERMINATED 已完成执行

RUNNABLE 不代表 CPU 一定在执行该线程的代码，可能正在执行也可能在等待操作系统分配时间片，只是它没有在等待其他条件。

线程使用方式

有三种使用线程的方法:

• 实现 Runnable 接口；
• 实现 Callable 接口；
• 继承 Thread 类。

实现 Runnable 和 Callable 接口的类只能当做一个可以在线程中运行的任务，不是真正意义上的线程，因此最后还需要通过 Thread 来调用。可以说任务是通过线程驱动从而执行的。

实现 Runnable 接口

需要实现 run() 方法。

通过 Thread 调用 start() 方法来启动线程。

public class MyRunnable implements Runnable {
    public void run() {
        // ...
    }
}

public static void main(String[] args) {
    MyRunnable instance = new MyRunnable();
    Thread thread = new Thread(instance);
    thread.start();
}

实现 Callable 接口

与 Runnable 相比，Callable 可以有返回值，返回值通过 FutureTask 进行封装。

public class MyCallable implements Callable<Integer> {
    public Integer call() {
        return 123;
    }
}

public static void main(String[] args) throws ExecutionException, InterruptedException {
    MyCallable mc = new MyCallable();
    FutureTask<Integer> ft = new FutureTask<>(mc);
    Thread thread = new Thread(ft);
    thread.start();
    System.out.println(ft.get());
}

继承 Thread 类

同样也是需要实现 run() 方法，因为 Thread 类也实现了 Runable 接口。

当调用 start() 方法启动一个线程时，虚拟机会将该线程放入就绪队列中等待被调度，当一个线程被调度时会执行该线程的 run() 方法。

public class MyThread extends Thread {
    public void run() {
        // ...
    }
}

public static void main(String[] args) {
    MyThread mt = new MyThread();
    mt.start();
}

实现接口 VS 继承 Thread

实现接口会更好一些，因为:

• Java 不支持多重继承，因此继承了 Thread 类就无法继承其它类，但是可以实现多个接口；
• 类可能只要求可执行就行，继承整个 Thread 类开销过大。

异步编程

随着编写非阻塞代码的需求越来越大，我们需要有办法异步地执行代码。Java中实现异步编程的几种方法和一些提供开箱即用解决方案的Java库。

• Thread 方式
• FutureTask 方式 - Guide to java.util.concurrent.Future | Baeldung
• CompletableFuture 方式 - Guide To CompletableFuture | Baeldung

提供异步功能的开箱即用的 Java 库：

• Guava
• EA Async
• Cactoos
• Jcabi-Aspects

完整示例：

package com.baeldung.async;

import static com.ea.async.Async.await;

import java.util.concurrent.Callable;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

import com.google.common.util.concurrent.AsyncCallable;
import com.google.common.util.concurrent.Callables;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.ListeningExecutorService;
import com.google.common.util.concurrent.MoreExecutors;
import com.jcabi.aspects.Async;
import com.jcabi.aspects.Loggable;

public class JavaAsync {

    static {
        com.ea.async.Async.init();
    }

    private static final ExecutorService threadpool = Executors.newCachedThreadPool();

    public static void main (String[] args) throws InterruptedException, ExecutionException {
        int number = 20;

        //Thread Example
        factorialUsingThread(number).start();

        //FutureTask Example
        Future<Long> futureTask = factorialUsingFutureTask(number);
        System.out.println("Factorial of " + number + " is: " + futureTask.get());

        // CompletableFuture Example
        Future<Long> completableFuture = factorialUsingCompletableFuture(number);
        System.out.println("Factorial of " + number + " is: " + completableFuture.get());

        // EA Async example
        System.out.println("Factorial of " + number + " is: " + factorialUsingEAAsync(number));

        // cactoos async example
        Future<Long> asyncFuture = factorialUsingCactoos(number);
        System.out.println("Factorial of " + number + " is: " + asyncFuture.get());

        // Guava example
        ListenableFuture<Long> guavaFuture = factorialUsingGuavaServiceSubmit(number);
        System.out.println("Factorial of " + number + " is: " + guavaFuture.get());

        ListenableFuture<Long> guavaFutures = factorialUsingGuavaFutures(number);
        System.out.println("Factorial of " + number + " is: " + guavaFutures.get());

        // @async jcabi-aspect example
        Future<Long> aspectFuture = factorialUsingJcabiAspect(number);
        System.out.println("Factorial of " + number + " is: " + aspectFuture.get());

    }

    /**
     * Finds factorial of a number
     * @param number
     * @return
     */
    public static long factorial(int number) {
        long result = 1; 
        for(int i=number;i>0;i--) {
            result *= i; 
        } 
        return result; 
    }

    /**
     * Finds factorial of a number using Thread
     * @param number
     * @return
     */
    @Loggable
    public static Thread factorialUsingThread(int number) {
        Thread newThread = new Thread(() -> {
            System.out.println("Factorial of " + number + " is: " + factorial(number));
        });

        return newThread;
    }

    /**
     * Finds factorial of a number using FutureTask
     * @param number
     * @return
     */
    @Loggable
    public static Future<Long> factorialUsingFutureTask(int number) {
        Future<Long> futureTask = threadpool.submit(() -> factorial(number)); 

        while (!futureTask.isDone()) { 
            System.out.println("FutureTask is not finished yet..."); 
        } 

        return futureTask;
    }

    /**
     * Finds factorial of a number using CompletableFuture
     * @param number
     * @return
     */
    @Loggable
    public static Future<Long> factorialUsingCompletableFuture(int number) {
        CompletableFuture<Long> completableFuture = CompletableFuture.supplyAsync(() -> factorial(number));
        return completableFuture;
    }

    /**
     * Finds factorial of a number using EA Async
     * @param number
     * @return
     */
    @Loggable
    public static long factorialUsingEAAsync(int number) {
        CompletableFuture<Long> completableFuture = CompletableFuture.supplyAsync(() -> factorial(number));
        long result = await(completableFuture);
        return result;
    }

    /**
     * Finds factorial of a number using Async of Cactoos
     * @param number
     * @return
     * @throws InterruptedException
     * @throws ExecutionException
     */
    @Loggable
    public static Future<Long> factorialUsingCactoos(int number) throws InterruptedException, ExecutionException {
        org.cactoos.func.Async<Integer, Long> asyncFunction = new org.cactoos.func.Async<Integer, Long>(input -> factorial(input));
        Future<Long> asyncFuture = asyncFunction.apply(number);
        return asyncFuture;
    }

    /**
     * Finds factorial of a number using Guava's ListeningExecutorService.submit()
     * @param number
     * @return
     */
    @Loggable
    public static ListenableFuture<Long> factorialUsingGuavaServiceSubmit(int number) {
        ListeningExecutorService service = MoreExecutors.listeningDecorator(threadpool);
        ListenableFuture<Long> factorialFuture = (ListenableFuture<Long>) service.submit(()-> factorial(number));
        return factorialFuture;
    }

    /**
     * Finds factorial of a number using Guava's Futures.submitAsync()
     * @param number
     * @return
     */
    @Loggable
    public static ListenableFuture<Long> factorialUsingGuavaFutures(int number) {
        ListeningExecutorService service = MoreExecutors.listeningDecorator(threadpool);
        AsyncCallable<Long> asyncCallable = Callables.asAsyncCallable(new Callable<Long>() {
            public Long call() {
                return factorial(number);
            }
        }, service);
        return Futures.submitAsync(asyncCallable, service);
    }

    /**
     * Finds factorial of a number using @Async of jcabi-aspects
     * @param number
     * @return
     */
    @Async
    @Loggable
    public static Future<Long> factorialUsingJcabiAspect(int number) {
        Future<Long> factorialFuture = CompletableFuture.supplyAsync(() -> factorial(number));
        return factorialFuture;
    }

}

---

参考资料：

Java 并发 - 线程基础 | Java 全栈知识体系 (pdai.tech)

tutorials/JavaAsync.java at master · eugenp/tutorials · GitHub

Asynchronous Programming in Java | Baeldung

The Difference Between Asynchronous And Multi-Threading | Baeldung on Computer Science