Javanewthread 新線程的創建及使用

一、引言

Java 是一種並發編程語言，多線程就是 Java 並發編程的一個重要特徵。線程是進程中的一個實體，是 CPU 調度和執行的基本單位。

Java 提供了豐富的線程 API，開發者可以利用這些 API 來實現並發執行的程序。新線程的創建即是多線程編程中一個重要的環節，本文就此主題進行講解。

二、新線程的概念

線程是程序中的一個執行單元，每個線程都有自己的執行路徑。

在 Java 中，線程是通過 thread 類來實現的。若要創建一個新線程，可以通過三種方式：

1. 實現 Runnable 接口
2. 繼承 Thread 類
3. 使用 Callable 和 Future 接口

三、新線程的創建

1.實現 Runnable 接口

  public class MyThread implements Runnable {
    public void run() {
      System.out.println("MyThread running");
    }
  }
  //創建新線程
  Thread thread = new Thread(new MyThread());
  thread.start();

需要注意的是，實現 Runnable 接口並不會導致類繼承 Thread 類，而是將 Runnable 接口實現類的實例作為 target 對象傳遞給 Thread 類的構造方法中。

2.繼承 Thread 類

  public class MyThread extends Thread {
    public void run() {
      System.out.println("MyThread running");
    }
  }
  //創建新線程
  MyThread thread = new MyThread();
  thread.start();

在繼承 Thread 類的方式中，需要覆蓋 run() 方法，此方法是新線程運行時執行的方法。新線程對象創建後，通過 start() 方法啟動線程。

3.使用 Callable 和 Future 接口

  public class MyThread implements Callable {
    public Integer call() throws Exception {
        int i = 0;
        for (;i<10;i++) {
            System.out.println(Thread.currentThread().getName()+" : "+i);
        }
        return i;
    }
  }
  //創建新線程
  ExecutorService executorService = Executors.newCachedThreadPool();
  Future future = executorService.submit(new MyThread());

Callable 接口是一個泛型接口，類似於 Runnable 接口。但是，Callable 接口可以返回一個結果，而且可以拋出異常。

Future 接口可以用於異步獲取執行結果，當提供者線程計算完成後，獲取者線程可以通過 Future.get() 獲取執行結果。

四、新線程的使用

1.sleep() 方法

sleep() 方法會使當前線程暫停指定的時間。可以實現線程睡眠、調整線程優先級等功能。

  Thread thread = new Thread(new Runnable() {
    public void run() {
        Thread.currentThread().setPriority(Thread.MAX_PRIORITY);
        for (int i = 0; i < 10 ; i++) {
            System.out.println(Thread.currentThread().getName()+" : "+i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
  });
  //啟動新線程
  thread.start();

2.yield() 方法

yield() 方法會使當前線程讓出 CPU 佔用，但並不是一定能讓出 CPU，具體可以參考 Java API。

  Thread thread1 = new Thread(new Runnable() {
    public void run() {
        for (int i = 0; i < 10 ; i++) {
            System.out.println(Thread.currentThread().getName()+" : "+i);
            Thread.yield();
        }
    }
  });
  Thread thread2 = new Thread(new Runnable() {
    public void run() {
        for (int i = 0; i < 10 ; i++) {
            System.out.println(Thread.currentThread().getName()+" : "+i);
            Thread.yield();
        }
    }
  });
  thread1.start();
  thread2.start();

3.join() 方法

join() 方法會使調用線程等待新線程完成後再繼續執行，使用該方法可以實現簡單的線程同步。

  Thread thread = new Thread(new Runnable() {
    public void run() {
        for (int i = 0; i < 10 ; i++) {
            System.out.println(Thread.currentThread().getName()+" : "+i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
  });
  //啟動新線程
  thread.start();
  //等待新線程完成
  try {
    thread.join();
  } catch (InterruptedException e) {
    e.printStackTrace();
  }

五、總結

本文主要介紹了新線程的創建和使用，包括實現 Runnable 接口、繼承 Thread 類以及使用 Callable 和 Future 接口等方式創建新線程，並介紹了 sleep()、yield()、join() 等常用的新線程處理方法。

多線程是 Java 的一個重要特性，但是線程安全也是開發者需要理解和注意的地方。在實際應用中，需要了解多線程編程的基本原理，並採用合適的編程方式來實現多線程處理。