一、什麼是多線程
在計算機科學中，多線程是指一個進程內部的並發執行，也就是在一個進程中同時執行多個線程。在Java中，線程是Java程序執行的基本單位，允許程序同時運行多個部分。Java多線程編程的主要目的是提高程序的執行效率和資源利用率，提高程序的響應速度，確保程序並發執行，也就是線程安全。
多線程可以單獨執行各自的任務，在執行多任務時可以充分利用CPU資源。Java多線程技術可以通過創建Thread類對象、實現Runnable介面或使用線程池等方式實現，並且支持同步（Synchronized）和非同步（Asynchronized）操作。
二、Java多線程的基本操作
Java多線程的基本操作包括線程的創建、啟動、休眠、中斷、等待、喚醒等。下面我們來一個個介紹。
1. 線程的創建和啟動
為了創建和啟動一個線程，需要以下步驟：
// 繼承Thread類
class MyThread extends Thread {
@Override
public void run() {
System.out.println("Thread " + this.getName() + " is running");
}
}
public class Main {
public static void main(String[] args) {
// 創建Thread類的實例對象
MyThread thread1 = new MyThread();
MyThread thread2 = new MyThread();
// 啟動線程
thread1.start();
thread2.start();
}
}
在上面的例子中，我們創建了兩個線程MyThread，並啟動它們。當調用start()方法時，程序會自動調用run()方法，從而執行線程體中的代碼。
2. 線程的休眠和中斷
在有些情況下，我們需要線程休眠一段時間，或者中斷線程的執行。這時可以使用Thread類的sleep()和interrupt()方法來實現。例如：
class MyThread extends Thread {
@Override
public void run() {
try {
// 線程休眠2秒
Thread.sleep(2000);
System.out.println("Thread " + this.getName() + " is running");
} catch (InterruptedException e) {
System.out.println("Thread " + this.getName() + " is interrupted");
}
}
}
public class Main {
public static void main(String[] args) {
MyThread thread1 = new MyThread();
MyThread thread2 = new MyThread();
thread1.start();
// 線程休眠1秒
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 中斷線程
thread2.interrupt();
}
}
在上面的例子中，我們創建了兩個線程MyThread，並啟動它們。其中一個線程休眠2秒後輸出信息，另一個線程等待1秒後中斷它的執行。
3. 線程的等待和喚醒
有些線程可能需要等待其他線程的執行完成後再繼續執行，此時就可以使用Thread類的wait()和notify()方法。下面是一個簡單的例子：
class MyThread extends Thread {
private int count = 0;
private final Object lock;
public MyThread(Object lock) {
this.lock = lock;
}
public void increment() {
count++;
}
public int getCount() {
return count;
}
@Override
public void run() {
synchronized (lock) {
while (count < 5) {
try {
System.out.println("Thread " + this.getName() + " is waiting");
// 等待喚醒
lock.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("Thread " + this.getName() + " is running");
}
}
}
public class Main {
public static void main(String[] args) throws InterruptedException {
Object lock = new Object();
MyThread thread1 = new MyThread(lock);
MyThread thread2 = new MyThread(lock);
thread1.start();
thread2.start();
for (int i = 0; i < 5; i++) {
synchronized (lock) {
thread1.increment();
thread2.increment();
lock.notifyAll();
}
Thread.sleep(1000);
}
}
}
在上面的例子中，我們創建了兩個線程MyThread，並啟動它們。這兩個線程都等待lock對象的喚醒。當每次循環時，我們通過synchronized塊和notifyAll()方法來喚醒兩個線程的執行。
三、Java多線程的問題
在多線程編程中，可能會出現一些問題，例如死鎖、競爭條件、線程安全等等。下面我們來逐個介紹。
1. 死鎖
死鎖是指兩個或多個線程互相等待其它線程完成執行然後無限期地等待，導致程序不能終止。這種情況下，所有線程都被阻塞，導致程序陷入停滯。下面是一個簡單的死鎖例子:
public class DeadLockDemo {
static class Waiter implements Runnable {
private Object lock1;
private Object lock2;
public Waiter(Object lock1, Object lock2) {
this.lock1 = lock1;
this.lock2 = lock2;
}
@Override
public void run() {
synchronized (lock1) {
System.out.println(Thread.currentThread().getName() + " acquired lock1");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (lock2) {
System.out.println(Thread.currentThread().getName() + " acquired lock2");
}
}
}
}
static class Notifier implements Runnable {
private Object lock1;
private Object lock2;
public Notifier(Object lock1, Object lock2) {
this.lock1 = lock1;
this.lock2 = lock2;
}
@Override
public void run() {
synchronized (lock2) {
System.out.println(Thread.currentThread().getName() + " acquired lock2");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (lock1) {
System.out.println(Thread.currentThread().getName() + " acquired lock1");
}
}
}
}
public static void main(String[] args) {
Object lock1 = new Object();
Object lock2 = new Object();
new Thread(new Waiter(lock1, lock2), "Thread1").start();
new Thread(new Notifier(lock1, lock2), "Thread2").start();
}
}
在上面的例子中，我們創建了兩個線程Waiter和Notifier，並啟動它們。這兩個線程互相等待對方釋放其鎖對象，產生死鎖。
2. 競爭條件
在多線程程序中，可能會出現競爭條件，即多個線程同時訪問共享資源。競爭條件可能導致數據一致性問題，例如線程間數據覆蓋、數據錯亂等。下面是一段簡單的競爭條件示例代碼:
public class RaceConditionDemo {
static class IncrementThread extends Thread {
private int count = 0;
@Override
public void run() {
while (count < 5) {
System.out.println(Thread.currentThread().getName() + ": " + count++);
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public static void main(String[] args) {
IncrementThread thread1 = new IncrementThread();
IncrementThread thread2 = new IncrementThread();
thread1.start();
thread2.start();
}
}
在上面的例子中，我們創建了兩個線程，每個線程自增一個計數器。由於線程的執行順序不確定，所以每次程序輸出的結果可能不同，產生數據一致性問題。
3. 線程安全
線程安全是指在多線程環境下，共享資源能夠正確地被多個線程並發訪問。Java中有多種方式來實現線程安全，例如Synchronized關鍵字、Lock介面、原子變數等。下面是一個使用Synchronized關鍵字實現線程安全的示例：
public class ThreadSafeDemo {
private int count = 0;
public synchronized void increment() {
count++;
}
public int getCount() {
return count;
}
static class IncrementThread extends Thread {
private ThreadSafeDemo demo;
public IncrementThread(ThreadSafeDemo demo) {
this.demo = demo;
}
@Override
public void run() {
for (int i = 0; i < 10000; i++) {
demo.increment();
}
}
}
public static void main(String[] args) throws InterruptedException {
ThreadSafeDemo demo = new ThreadSafeDemo();
IncrementThread thread1 = new IncrementThread(demo);
IncrementThread thread2 = new IncrementThread(demo);
thread1.start();
thread2.start();
thread1.join();
thread2.join();
System.out.println("Count: " + demo.getCount());
}
}
在上面的例子中，我們創建了兩個線程IncrementThread，並啟動它們，每個線程增加一個計數器。由於increment()方法加上了Synchronized關鍵字，所以線程安全。
原創文章，作者：小藍，如若轉載，請註明出處：https://www.506064.com/zh-tw/n/151204.html
微信掃一掃 
支付寶掃一掃 