使用Thread實現Java多線程編程

Java中的線程是一種輕量級的進程，它可以實現多個任務同時運行，提高了程序的性能。使用Thread類和Runnable接口可以方便地實現Java多線程編程。

一、創建線程

Java中使用Thread類來創建一個線程。繼承Thread類，重寫run()方法，並在該方法中定義需要執行的任務。

class MyThread extends Thread {
    public void run() {
        // 執行任務
    }
}

使用start()方法來啟動這個線程。當start()被調用時，它會在一個新線程上執行run()方法。

MyThread thread = new MyThread();
thread.start();

當線程開始執行時，它會執行run()方法中定義的任務。

二、實現Runnable接口

除了繼承Thread類來創建一個線程，還可以實現Runnable接口來創建一個線程。Runnable接口代表了一個可以被線程執行的任務。使用實現了Runnable接口的類創建線程，它的實例代表了一個可執行的任務。

class MyRunnable implements Runnable {
    public void run() {
        // 執行任務
    }
}

MyRunnable runnable = new MyRunnable();
Thread thread = new Thread(runnable);
thread.start();

使用Thread對象執行實現了Runnable接口的類的實例，調用Thread類的start()方法來啟動這個線程，會在新線程上執行實現Runnable接口的類的實例的run()方法。

三、線程同步

在多線程編程中，有可能會出現多個線程同時訪問共享的資源的情況，這時就需要用到線程同步。

Java中使用synchronized關鍵字來實現線程同步。synchronized關鍵字可以用來修飾方法、代碼塊、靜態方法和類等。當一個線程訪問synchronized代碼塊時，其他線程需要等待該線程執行完畢後才能訪問該代碼塊。

例如：

class MyThread {
    private int count;

    public synchronized void increment() {
        count++;
    }

    public synchronized int getCount() {
        return count;
    }
}

在這個例子中，兩個方法都被synchronized修飾，保證了多個線程同時訪問count變量時，只有一個線程能夠訪問它。

四、線程優先級

在Java中，每個線程都有一個優先級，可以使用setPriority()方法來設置線程的優先級。優先級越高的線程會更容易地獲取CPU資源。

線程的優先級被定義為數字1到10，1是最低優先級，而10是最高優先級。可以使用Thread類的常量MIN_PRIORITY、NORM_PRIORITY和MAX_PRIORITY分別來表示最低、默認、最高優先級。

例如：

MyThread thread1 = new MyThread();
thread1.setPriority(Thread.MAX_PRIORITY);

MyThread thread2 = new MyThread();
thread2.setPriority(Thread.MIN_PRIORITY);

MyThread thread3 = new MyThread();
thread3.setPriority(Thread.NORM_PRIORITY);

五、線程阻塞

線程阻塞是指線程暫停執行，直到一個特定的條件得到滿足。

Java中有幾種常見的線程阻塞方法，包括sleep、wait和join。

sleep方法可以用來暫停當前線程的執行，等待一定的時間後再繼續執行。

try {
    Thread.sleep(1000); // 暫停一秒鐘
} catch (InterruptedException e) {
    e.printStackTrace();
}

wait方法是一種方式，可以用來讓線程進入等待狀態，直到被喚醒。

synchronized (object) {
    try {
        object.wait(); // 線程進入等待狀態
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

join方法是一種方式，可以等待另一個線程的結束。

Thread thread1 = new Thread();
Thread thread2 = new Thread();

thread1.start();
try {
    thread1.join(); // 等待thread1線程執行完
} catch (InterruptedException e) {
    e.printStackTrace();
}
thread2.start();

在這個例子中，thread1線程會先執行，執行完後，主線程會等待它執行結束後再執行thread2線程。

六、總結

Java中的線程模型非常靈活，可以通過繼承Thread類或實現Runnable接口來創建線程，通過synchronized關鍵字來實現線程同步，通過設置線程優先級和線程阻塞等機制來調整線程的執行順序。

下面是一個完整的示例代碼：

class MyThread extends Thread {
    private int count;

    public MyThread(int count) {
        this.count = count;
    }

    public void run() {
        for (int i = 0; i < count; i++) {
            System.out.println("Thread-" + Thread.currentThread().getId() + " count: " + i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class Main {
    public static void main(String[] args) {
        MyThread thread1 = new MyThread(5);
        thread1.setPriority(Thread.MAX_PRIORITY);

        MyThread thread2 = new MyThread(5);
        thread2.setPriority(Thread.MIN_PRIORITY);

        MyThread thread3 = new MyThread(5);
        thread3.setPriority(Thread.NORM_PRIORITY);

        thread1.start();
        thread2.start();
        thread3.start();
    }
}