Java中實現線程的方式

Java中實現線程的方式

Java中實現多線程的方式的方式中最核心的就是 run()方法，不管何種方式其最終都是通過run()來運行。

Java剛發布時也就是JDK 1.0版本提供了兩種實現方式，一個是繼承Thread類，一個是實現Runnable接口。兩種方式都是去重寫run()方法，在run()方法中去實現具體的業務代碼。

但這兩種方式有一個共同的弊端，就是由於run()方法是沒有返回值的，所以通過這兩方式實現的多線程讀無法獲得執行的結果。

為了解決這個問題在JDK 1.5的時候引入一個Callable<V>接口，根據泛型V設定返回值的類型，實現他的call()方法，可以獲得線程執行的返回結果。

雖然call()方法可以獲得返回值，但它需要配合一個Future<V>才能拿到返回結果，而這個Future<V>又是繼承了Runnable的一個接口。 通過查閱源碼就可以發現Future<V>的實現FutureTask<V>其在做具體業務代碼執行的時候仍是在run()里面實現的。

FutureTask 源碼片段：

public void run() {
        if (state != NEW ||
            !UNSAFE.compareAndSwapObject(this, runnerOffset,
                                         null, Thread.currentThread()))
            return;
        try {
            Callable<V> c = callable;
            if (c != null && state == NEW) {
                V result;
                boolean ran;
                try {
                    result = c.call();
                    ran = true;
                } catch (Throwable ex) {
                    result = null;
                    ran = false;
                    setException(ex);
                }
                if (ran)
                    set(result);
            }
        } finally {
            // runner must be non-null until state is settled to
            // prevent concurrent calls to run()
            runner = null;
            // state must be re-read after nulling runner to prevent
            // leaked interrupts
            int s = state;
            if (s >= INTERRUPTING)
                handlePossibleCancellationInterrupt(s);
        }
    }

Java多線程實現方式的代碼示例:

通過繼承Thread類實現

public class ThreadTest {

  public static void main(String[] args) throws Exception {
    Thread myThread = new MyThread();
    myThread.setName("MyThread-entends-Thread-test");
    myThread.start();

  }
}

class MyThread extends Thread {

  @Override
  public void run() {
    System.out.println("Thread Name:" + Thread.currentThread().getName());
  }
}

通過實現Runnable接口實現

public class ThreadTest {

  public static void main(String[] args) throws Exception {

    MyRunnableThread myRunnable = new MyRunnableThread();
    Thread myRunnableThread = new Thread(myRunnable);
    myRunnableThread.setName("MyThread-implements-Runnable-test");
    myRunnableThread.start();
  }
}

class MyRunnableThread implements Runnable {

  @Override
  public void run() {
    System.out.println("Thread Name:" + Thread.currentThread().getName());
  }
}

通過實現Callable接口實現

public class ThreadTest {

  public static void main(String[] args) throws Exception {

    Callable<String> myCallable = new MyCallableThread();
    FutureTask<String> futureTask = new FutureTask<>(myCallable);
    Thread myCallableThread = new Thread(futureTask);
    myCallableThread.setName("MyThread-implements-Callable-test");
    myCallableThread.start();
    System.out.println("Run by Thread:" + futureTask.get());

    //通過線程池執行
    ExecutorService executorService = Executors.newCachedThreadPool();
    executorService.submit(futureTask);
    executorService.shutdown();
    System.out.println("Run by ExecutorService:" + futureTask.get());
  }
}

class MyCallableThread implements Callable<String> {

  @Override
  public String call() throws Exception {
    return Thread.currentThread().getName();
  }
}

當然由於線程的創建和銷毀需要消耗資源，Java中還通過了許多線程池相關的API,上述示例中ExecutorService就是線程池API中的一個，關於線程池的詳細內容將會在下一篇繼續，歡迎大家關注。

​