Java Thread編程指南

Java是一種高性能、跨平台、面向對象的語言。在Java編程中，線程是一個非常重要的概念。線程可以使代碼並發執行，提高應用程序的並發性和性能。本文將從多個方面對Java線程進行闡述。

一、線程的創建

Java中線程的創建方式有兩種：繼承Thread類、實現Runnable介面。

//繼承Thread類
class MyThread extends Thread {
    public void run() {
        //線程執行代碼
    }
}
MyThread thread = new MyThread();
thread.start();

//實現Runnable介面
class MyRunnable implements Runnable {
    public void run() {
        //線程執行代碼
    }
}
MyRunnable runnable = new MyRunnable();
Thread thread = new Thread(runnable);
thread.start();

在使用繼承Thread類的方式創建線程時，需要重寫run()方法，在該方法中編寫線程的執行代碼。使用實現Runnable介面的方式創建線程時，需要先定義一個實現Runnable介面的類。在該類中，同樣需要實現run()方法。線程的啟動通過調用start()方法實現。

二、線程的狀態

Java中線程的狀態有6種：新建、就緒、運行、阻塞、等待、終止。

• 新建狀態：當創建一個線程對象時，線程處於新建狀態。
• 就緒狀態：當調用start()方法後，線程進入就緒狀態。
• 運行狀態：線程被分配CPU時間片並執行run()方法後，進入運行狀態。
• 阻塞狀態：線程被某些原因阻塞，如等待輸入輸出、調用sleep()方法等，進入阻塞狀態。
• 等待狀態：當線程等待某個條件時，進入等待狀態。
• 終止狀態：如果run()方法執行完畢或者調用stop()方法後，線程進入終止狀態。

三、線程的同步

Java中多個線程訪問共享數據時，可能會出現數據不一致等問題，這就需要進行線程的同步。

Java中線程同步的方式主要有三種：synchronized關鍵字、wait()和notify()方法、Lock和Condition介面。

synchronized關鍵字的使用：

class MyThread extends Thread {
    public void run() {
        synchronized (this) {
            //線程執行代碼
        }
    }
}

在synchronized關鍵字塊內的代碼，同一時間只能有一個線程執行。

wait()和notify()方法進行線程同步：

class MyThread extends Thread {
    public void run() {
        synchronized (this) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //線程執行代碼
        }
    }
}
class MyNotifyThread extends Thread {
    private Object obj;
    public MyNotifyThread(Object obj) {
        this.obj = obj;
    }
    public void run() {
        synchronized (obj) {
            obj.notify();
        }
    }
}
MyThread thread = new MyThread();
MyNotifyThread notifyThread = new MyNotifyThread(thread);
notifyThread.start();

在wait()方法內的線程將進入等待狀態，只有當其他線程調用notify()方法時，該線程才會被喚醒。

Lock和Condition進行線程同步：

Lock lock = new ReentrantLock();
Condition condition = lock.newCondition();
class MyThread extends Thread {
    public void run() {
        lock.lock();
        try {
            //線程執行代碼
            condition.signal();
        } finally {
            lock.unlock();
        }
    }
}
class MyWaitThread extends Thread {
    private Lock lock;
    private Condition condition;
    public MyWaitThread(Lock lock, Condition condition) {
        this.lock = lock;
        this.condition = condition;
    }
    public void run() {
        lock.lock();
        try {
            condition.await();
            //線程執行代碼
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}
MyThread thread = new MyThread();
MyWaitThread waitThread = new MyWaitThread(lock, condition);
waitThread.start();
thread.start();

使用Lock和Condition進行線程同步時，需要先定義一個Lock對象，並根據該Lock對象創建一個Condition對象。在代碼中，需要先獲取Lock鎖，執行完業務代碼後，使用Condition的signal()方法喚醒等待的線程。在等待線程中，需要在獲取Lock鎖後，使用Condition的await()方法進入等待狀態。