Java多線程編程實踐

隨著硬體技術的不斷提升，計算機的性能越來越快，人們也越來越需要通過多線程技術來提升軟體的性能。Java作為一門面向對象的語言，其多線程編程實踐非常重要，很多Java開發人員都需要掌握相關技術。

一、多線程背景知識

1、線程的創建方式

Java中創建一個線程有兩種方式：繼承Thread類和實現Runnable介面。使用繼承Thread類的方式可以重寫Thread中的run()方法，使用實現Runnable介面的方式需要自己定義一個run()方法並在創建線程時傳入。

public class MyThread extends Thread{
    @Override
    public void run(){
        //do something
    }
}

public class MyRunnable implements Runnable{
    @Override
    public void run(){
        //do something
    }
}

//創建線程
MyThread t = new MyThread();
t.start();

MyRunnable r = new MyRunnable();
Thread t = new Thread(r);
t.start();

2、線程的狀態轉換

Java中線程的狀態有如下幾種：新建、就緒、運行、阻塞和死亡。線程的狀態可以通過Thread類的getState()方法獲取，也可以通過Thread.State枚舉類來獲取。

Thread t = new Thread();
t.start(); //線程就緒
t.join(); //線程阻塞
t.interrupt(); //中斷阻塞線程
t.stop(); //強制結束線程

二、線程同步和鎖

1、synchronized關鍵字

Java中的synchronized關鍵字可以實現線程同步，多線程訪問共享資源時可以使用synchronized來保證線程安全。

public class MyCounter{
    private int count;
    //加鎖，只有一個線程進入方法，其他線程等待
    public synchronized void increment(){
        count++;
    }
}

//使用
MyCounter counter = new MyCounter();
Thread t1 = new Thread(() -> {
    for(int i=0;i {
    for(int i=0;i<1000;i++){
        counter.increment();
    }
});

t1.start();
t2.start();

t1.join();
t2.join();
System.out.println(counter.getCount()); //2000

2、ReentrantLock

ReentrantLock是Java中的一個鎖，相比synchronized關鍵字，它可以手動控制鎖的獲取和釋放。

public class MyCounter{
    private int count;
    private ReentrantLock lock = new ReentrantLock();
    public void increment(){
        lock.lock(); //加鎖
        try{
            count++;
        }finally{
            lock.unlock(); //釋放鎖
        }
    }
}

//使用
MyCounter counter = new MyCounter();
Thread t1 = new Thread(() -> {
    for(int i=0;i {
    for(int i=0;i<1000;i++){
        counter.increment();
    }
});

t1.start();
t2.start();

t1.join();
t2.join();
System.out.println(counter.getCount()); //2000

三、多線程實戰案例

1、生產者-消費者模型

生產者-消費者模型是一個典型的多線程問題，其中一個或多個生產者線程生成數據並將其傳遞給一個或多個消費者線程，消費者線程使用數據。

public class ProducerConsumer{
    private int count;
    private LinkedList queue = new LinkedList();
    private Object lock = new Object();

    public void produce(){
        synchronized(lock){
            while(queue.size() == count){ //隊列滿了，等待消費者
                try{
                    lock.wait();
                }catch(Exception e){}
            }
            int num = new Random().nextInt(100);
            System.out.println("Producing: " + num);
            queue.add(num);
            lock.notifyAll(); //喚醒所有等待線程
        }
    }

    public void consume(){
        synchronized(lock){
            while(queue.size() == 0){ //隊列為空，等待生產者
                try{
                    lock.wait();
                }catch(Exception e){}
            }
            int num = queue.removeFirst();
            System.out.println("Consuming: " + num);
            lock.notifyAll(); //喚醒所有等待線程
        }
    }
}

//使用
ProducerConsumer pc = new ProducerConsumer();
Thread t1 = new Thread(() -> {
    for(int i=0;i {
    for(int i=0;i<10;i++){
        pc.consume();
    }
});

t1.start();
t2.start();

t1.join();
t2.join();

2、多線程並發執行任務

在實際生產開發中，經常需要以多線程形式執行某個任務，這時可以使用Thread類、Callable介面或者線程池來實現。以下是使用ExecutorService線程池來並發執行任務的例子。

ExecutorService executor = Executors.newFixedThreadPool(4);
List<Future> results = new ArrayList();
for(int i=0;i<10;i++){
    int num = i;
    Future result = executor.submit(() -> {
        System.out.println("Thread " + num + " start");
        try{
            Thread.sleep(1000); //模擬任務執行時間
        }catch(Exception e){}
        System.out.println("Thread " + num + " end");
        return num;
    });
    results.add(result);
}
executor.shutdown();

四、結束語

通過對Java多線程技術的了解和實踐，可以提高軟體的並發處理能力和運行效率。在實際應用中，需要根據具體情況選擇適當的線程同步和鎖機制，合理使用多線程提高程序的性能和響應速度。