Java多執行緒並行程式設計
2022-08-06 06:00:53
多執行緒並行
在多核CPU中，利用多執行緒並行程式設計，可以更加充分地利用每個核的資源
在Java中，一個應用程式對應著一個JVM範例（也有地方稱為JVM程序），如果程式沒有主動建立執行緒，則只會建立一個主執行緒。但這不代表JVM中只有一個執行緒，JVM範例在建立的時候，同時會建立很多其他的執行緒（比如垃圾收集器執行緒）。
執行緒建立
執行緒有三種建立方式：
- 繼承
Thread類 （可以說是 將任務和執行緒合併在一起） - 實現
Runnable介面 （可以說是 將任務和執行緒分開了） - 實現
Callable介面 (利用FutureTask執行任務)
對比：Runnable介面解決了Thread單繼承的侷限性。而Callable解決了Runnable無法拋異常給呼叫方的侷限性。
class T extends Thread {
@Override
public void run() {
println("我是繼承Thread的任務");
}
}
class R implements Runnable { //解決了單繼承問題
@Override
public void run() {
println("我是實現Runnable的任務");
}
}
class C implements Callable<String> {
@Override
public String call() throws Exception { //可以拋異常
println("我是實現Callable的任務");
return "success"; //任務有返回值
}
}
執行緒啟動
- 呼叫執行緒的start()方法，這裡要注意，只有Thread方法可以呼叫start()，因此需要為其他型別的執行緒建立方式範例分配Thread範例。
// 啟動繼承Thread類的任務
Thread MyThread = new MyThread();
MyThread.start();
class MyThread extends Thread {
@Override
public void run() {
System.out.println("hello myThread" + Thread.currentThread().getName());
}
}
// 啟動實現Runnable介面的任務
MyRunnable myRunnable = new MyRunnable();
Thread thread = new Thread(myRunnable); //要給實現Runnable的範例分配新的物件
thread.start();
class MyRunnable implements Runnable{
@Override
public void run(){
System.out.println("hello myRunnable" + Thread.currentThread().getName());
}
}
// 啟動實現了Callable介面的任務 結合FutureTask 可以獲取執行緒執行的結果
FutureTask<String> target = new FutureTask<>(new C()); //C是實現了Callable介面的類
new Thread(target).start();
log.info(target.get());
各執行緒類圖
常用方法
| 方法 | 說明 |
|---|---|
| setName("String"); | 給執行緒設定名稱 |
| getName(); | 獲取執行緒的名稱 |
| Thread.currentThread(); | 獲取當前執行的執行緒物件 |
| Thread.sleep(ms); | 執行緒休眠(以ms為單位) |
執行緒同步
多個執行緒同時操作某個臨界資源可能出現業務安全問題。採用
互斥存取
加鎖：把臨界資源進行上鎖，每次只允許一個執行緒進入存取完成後才解鎖，允許其他程序進入
同步程式碼塊
對程式碼塊上鎖
快捷鍵：CTRL+ALT+T
關於鎖物件的選擇
最好不要用任意唯一的鎖物件，因為這會影響其他無關執行緒的執行。
規範上：建議使用臨界資源作為鎖物件
對於實體方法建議使用this作為鎖物件
對於靜態方法建議使用位元組碼(類名.class)作為鎖物件
synchronized(同步鎖物件) { //synchronized(this) 只鎖自己的臨界資源
//作業系統資源的程式碼(出現安全問題的核心程式碼)
}
同步方法
對方法上鎖
在方法定義時加上synchronized關鍵字即可
同步方法底層有隱式鎖物件
如果方法是實體方法：同步方法預設使用this作為鎖物件
如果方法是靜態方法：同步方法預設使用類名.class作為鎖物件
修飾符 synchronized 返回值型別 方法名稱(形參列表) {
//作業系統資源的程式碼
}
Lock鎖
//建立鎖
private final Lock lock = new ReentranLock();
lock.lock(); //加鎖
try {
//鎖住的內容
} finally {
lock.unlock(); //解鎖
}
執行緒通訊
典型應用：生產者-消費者模型
實現方法：使用一個共用變數實現執行緒通訊
| 方法名稱 | 功能 |
|---|---|
| 鎖.wait() | 讓當前執行緒等待並釋放所佔鎖，直到另一個執行緒呼叫notify()方法或notifyAll()方法 |
| 鎖.notify() | 喚醒正在等待的單個執行緒 |
| 鎖.notifyAll() | 喚醒正在等待的所有執行緒 |
執行緒池
一個可以複用執行緒的技術，當請求過多時用於降低系統開銷
ExecutorService代表執行緒池介面
如何得到執行緒池物件
方式一：使用ExecutorService的實現類ThreadPoolExecutor建立執行緒池物件
建立臨時執行緒的條件：①核心執行緒全忙 ②任務佇列滿
拒絕任務的條件：臨時執行緒和核心執行緒全忙
執行緒池處理Runnable任務的方法：
public class Communication {
public static void main(String[] args) {
//執行緒池建立
ExecutorService pool = new ThreadPoolExecutor(3,5,2, TimeUnit.MINUTES, new ArrayBlockingQueue<>(5),new ThreadPoolExecutor.AbortPolicy());
Runnable myRunnable = new myRunnable();
//執行緒池產生Runnable執行緒物件
pool.execute(myRunnable);
pool.execute(myRunnable);
pool.execute(myRunnable);
pool.execute(myRunnable);
pool.execute(myRunnable);
pool.execute(myRunnable);
pool.execute(myRunnable);
pool.execute(myRunnable);
//開始建立臨時執行緒
pool.execute(myRunnable);
pool.execute(myRunnable);
//丟擲異常
pool.execute(myRunnable);
}
}
/**
* 功能：用執行緒池實現Runnable物件
*/
class myRunnable implements Runnable {
@Override
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println(Thread.currentThread().getName() + "正在列印hello ==>" + i);
}
try {
System.out.println(Thread.currentThread().getName() + "開始睡眠");
Thread.sleep(1000000);
} catch (Exception e) {
e.printStackTrace();
}
}
}
執行緒池處理Callable任務的方法
public class Communication {
public static void main(String[] args) throws ExecutionException, InterruptedException {
//執行緒池建立（不變）
ExecutorService pool = new ThreadPoolExecutor(3,5,2,
TimeUnit.MINUTES, new ArrayBlockingQueue<>(5),new ThreadPoolExecutor.AbortPolicy());
//呼叫執行緒池的submit方法處理myCallable物件，並用Future Task的父類別Future繼承
Future<String> f1 = pool.submit(new myCallable(100));
Future<String> f2 = pool.submit(new myCallable(200));
Future<String> f3 = pool.submit(new myCallable(300));
Future<String> f4 = pool.submit(new myCallable(400));
Future<String> f5 = pool.submit(new myCallable(500));
//呼叫get方法返回內容
System.out.println(f1.get());
System.out.println(f2.get());
System.out.println(f3.get());
System.out.println(f4.get());
System.out.println(f5.get());
}
}
/**
* 功能：用執行緒池實現Callable執行緒物件
*/
class myCallable implements Callable<String> {
private int n;
public myCallable(int n) {
this.n = n;
}
@Override
public String call() throws Exception {
int sum = 0;
for (int i = 0; i < n; i++) {
sum += i;
}
return Thread.currentThread().getName() + "計算的1-" + n + "結果為" + sum;
}
}
方式二：使用Executors（執行緒池的工具類）呼叫方法返回不同執行緒池物件【非重點】
Executors工具類底層是ThreadPoolExecutor，但在大型並行系統環境使用Executors可能出現系統風險
ExecutorService pool = Executors.newFixedThreadPool(固定執行緒個數)
//底層呼叫ThreadPoolExecutor，僅有核心執行緒
定時器
一種控制任務延時呼叫，或者週期呼叫的技術
實現方式：：①Timer ②ScheduledExecutorService定時器
Timer定時器
Timer timer = new Timer();
//schedule還有其他幾種過載方式，見jdk
timer.schedule(new TimerTask() {
@Override
public void run() {
//執行緒內容1
}
},0,2000);
timer.schedule(new TimerTask() {
@Override
public void run() {
//執行緒內容2
}
},0,2000);
Timer定時器存在的問題
1、Timer定時器是單執行緒，處理多個任務順序執行，存在延時問題
2、因為是單執行緒，若Timer執行緒死掉，會影響後續任務執行
ScheduledExecutorService定時器
ScheduledExecutorService內部是一個執行緒池,一個任務不會干擾其他任務
ScheduledExecutorService在日常開發中更加常用
public static void main(String[] args) {
//
ScheduledExecutorService timer = new ScheduledThreadPoolExecutor(3);
//scheduleAtFixedRate表示以固定頻率定時
timer.scheduleAtFixedRate(new Runnable() {
@Override
public void run() {
System.out.println("定時1" + new Date());
}
},0,2,TimeUnit.SECONDS);
timer.scheduleAtFixedRate(new Runnable() {
@Override
public void run() {
System.out.println("定時2" + new Date());
}
},0,3,TimeUnit.SECONDS);
}