Java進(jìn)階中的多線程詳解
1、程序、進(jìn)程、線程
程序：是指令和數(shù)據(jù)的有序集合，其本身沒有任何運行的含義，是一個靜態(tài)的概念。
進(jìn)程（Process）：是執(zhí)行程序的一次執(zhí)行過程，是一個動態(tài)的概念，是系統(tǒng)資源分配的單位。
線程（Thread）：通常在一個進(jìn)程中可以包含若干個線程，一個進(jìn)程中至少有一個線程，不然沒有存在的意義。線程是CPU調(diào)度和執(zhí)行的單位。
很多多線程是模擬出來的，真正的多線程是指有多個cpu，即多核，如服務(wù)器。如果是模擬出來的多線程，即在一個cpu的情況下，在同一時間點，cpu只能執(zhí)行一個代碼，因為切換的很快，所以就有同時執(zhí)行的錯覺。
- 線程就是獨立的執(zhí)行路徑；
- 在程序運行時，即使沒有自己創(chuàng)建線程，后臺也會有多個線程，如主線程，gc線程；
- main()稱之為主線程，為系統(tǒng)的入口，用于執(zhí)行整個程序；
- 在一個進(jìn)程中，如果開辟了多個線程，線程的運行由調(diào)度器安排調(diào)度，調(diào)度器是與操作系統(tǒng)緊密相關(guān)的，先后順序是不能人為的干預(yù)的；
- 對同一份資源操作時，會存在資源搶奪的問題，需要加入并發(fā)控制；
- 線程會帶來額外的開銷，如cpu調(diào)度時間，并發(fā)控制開銷；
- 每個線程在自己的工作內(nèi)存交互，內(nèi)存控制不當(dāng)會造成數(shù)據(jù)不一致。
2、線程的創(chuàng)建
- Thread class——->繼承Thread類
- Runnable接口——>實現(xiàn)Runnable接口
- Callable接口——>實現(xiàn)Callable接口
方式一：（1）自定義線程類繼承Thread類；（2）重寫run()方法，編寫線程執(zhí)行體；（3）創(chuàng)建線程對象，調(diào)用start()方法啟動線程
public class StartThread extends Thread{ //1、自定義線程類繼承Thread類
@Override //2、重寫run()方法，編寫線程執(zhí)行體
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println("run"+i);
}
}
public static void main(String[] args) {
StartThread startThread = new StartThread();
startThread.start(); //3、創(chuàng)建線程對象，調(diào)用start()方法啟動線程
for (int i = 0; i < 500; i++) {
System.out.println("main"+i);
}
}
}
線程不一定立即執(zhí)行，由CPU安排調(diào)度
方式二：（1）自定義線程類實現(xiàn)Runnable接口；（2）實現(xiàn)run()方法，編寫線程執(zhí)行體；（3）創(chuàng)建線程對象，調(diào)用start()方法啟動線程
public class MyRunnable implements Runnable{ //1、自定義線程類實現(xiàn)Runnable接口
@Override //2、重寫run()方法，編寫線程執(zhí)行體
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println("run"+i);
}
}
public static void main(String[] args) {
MyRunnable myRunnable = new MyRunnable();
//3、創(chuàng)建線程對象，調(diào)用start()方法啟動線程，代理
new Thread(myRunnable).start();
for (int i = 0; i < 500; i++) {
System.out.println("main"+i);
}
}
}
推薦使用實現(xiàn)Runnable接口，避免單繼承局限性。
方式三：（1）實現(xiàn)Callable接口，需要返回值類型；（2）重寫call方法，需要拋出異常；（3)創(chuàng)建目標(biāo)對象；（4）創(chuàng)建執(zhí)行服務(wù)：ExecutorService s = Executors.newFixedThreadPool(1);
（5）提交執(zhí)行：Future result = s.submit(t);（6）獲取結(jié)果：boolean r = result.get();（7）關(guān)閉服務(wù)：s.shutdownNow();
public class MyCallable implements Callable<Boolean> { //1、實現(xiàn)Callable接口，需要返回值類型
@Override //2、重寫call方法，需要拋出異常；
public Boolean call() throws Exception {
for (int i = 0; i < 100; i++) {
System.out.println(Thread.currentThread().getName()+":"+i); //獲取當(dāng)前線程名字
}
return true;
}
public static void main(String[] args) {
//3、創(chuàng)建目標(biāo)對象；
MyCallable m1 = new MyCallable();
MyCallable m2 = new MyCallable();
MyCallable m3 = new MyCallable();
//4、創(chuàng)建執(zhí)行服務(wù)：
ExecutorService s = Executors.newFixedThreadPool(3);
//5、提交執(zhí)行：
Future<Boolean> r1 = s.submit(m1);
Future<Boolean> r2 = s.submit(m2);
Future<Boolean> r3 = s.submit(m3);
//6、獲取結(jié)果：
try {
boolean rs1 = r1.get();
boolean rs2 = r2.get();
boolean rs3 = r3.get();
} catch (InterruptedException | ExecutionException e) {
throw new RuntimeException(e);
}
//7關(guān)閉服務(wù)：
s.shutdownNow();
}
}3、Lambda表達(dá)式 (JDK8)
- 希臘字母表中排序第十一位的字母
- 避免匿名內(nèi)部類定義過多
- 其實質(zhì)屬于函數(shù)式編程的概念
（params) -> expression[表達(dá)式]
(params) -> statement[語句]
(params) -> {statements}
函數(shù)式接口：任何接口，如果只包含唯一一個抽象方法，那么它就是一個函數(shù)式接口。對于函數(shù)式接口，我們可以通過lambda表達(dá)式來創(chuàng)建該接口的對象。
public class TestLambda {
//靜態(tài)內(nèi)部類
static class Like2 implements ILike{
@Override
public void like() {
System.out.println("I like lambda2");
}
}
public static void main(String[] args) {
//局部內(nèi)部類
class Like3 implements ILike{
@Override
public void like() {
System.out.println("I like lambda3");
}
}
ILike like = new Like1();
like.like();
like = new Like2();
like.like();
like = new Like3();
like.like();
//匿名內(nèi)部類
like = new ILike() {
@Override
public void like() {
System.out.println("I like lambda4");
}
};
like.like();
//lambda表達(dá)式
//(1)
like = () -> {
System.out.println("I like lambda5");
};
like.like();
//（2）花括號簡化，只允許有一行代碼,多行必須要用代碼塊
like = () -> System.out.println("I like lambda6");
like.like();
//（3）若帶參數(shù)，可去掉小括號簡化，可去掉返回類型簡化
//like = (int a,int b) -> System.out.println("I like lambda6");
//like = a,b -> System.out.println("I like lambda6");
}
}
interface ILike{ //函數(shù)式接口
void like();
}
//實現(xiàn)類
class Like1 implements ILike{
@Override
public void like() {
System.out.println("I like lambda1");
}
}4、線程狀態(tài)
5、停止線程
不推薦使用JDK提供的stop()、destroy()方法。
建議使用一個標(biāo)志位進(jìn)行終止變量，當(dāng)flag=false，則終止線程運行。
public class TestStop implements Runnable{
//設(shè)置標(biāo)志位
private boolean flag = true;
public static void main(String[] args) {
TestStop testStop = new TestStop();
new Thread(testStop).start(); //開啟線程
for (int i = 0; i < 500; i++) {
if(i == 200){ //當(dāng)主線程跑到200時，停止run線程
testStop.stop();
System.out.println("stop run");
}
System.out.println("main"+i);
}
}
//提供停止線程的方法，轉(zhuǎn)換標(biāo)志位
public void stop(){
this.flag = false;
}
@Override
public void run() {
int i = 0;
while (flag){
System.out.println("run"+ i++);
}
}
}6、線程休眠 sleep()
- sleep(時間)指定當(dāng)前線程阻塞的毫秒數(shù)；
- sleep存在異常InterruptedException;
- sleep時間達(dá)到后線程進(jìn)入就緒狀態(tài)；
- sleep可以模擬網(wǎng)絡(luò)延時，倒計時等；
- 每一個對象都有一個鎖，sleep不會釋放鎖
7、線程禮讓 yield()
- 禮讓線程，讓當(dāng)前正在執(zhí)行的線程暫停，但不阻塞；
- 將線程從運行狀態(tài)轉(zhuǎn)為就緒狀態(tài)
- 讓cpu重新調(diào)度，禮讓不一定成功，看cpu
8、線程強制執(zhí)行 join()
- join合并線程，待此線程執(zhí)行完成后，再執(zhí)行其他線程，其他線程阻塞，就是插隊
9、線程狀態(tài)觀測
Thread.State state = thread.getState();
- NEW : 尚未啟動的線程處于此狀態(tài)；
- RUNNABLE ：在Java虛擬機中執(zhí)行的線程處于此狀態(tài)；
- BLOCKED ：被阻塞等待監(jiān)視器鎖定的線程處于此狀態(tài)；
- WAITING ：正在等待另一個線程執(zhí)行待定動作的線程處于此狀態(tài)；
- TIMED_WAITING ：正在等待另一個線程執(zhí)行動作達(dá)到指定等待時間的線程處于此狀態(tài)；
- TERMINATED ：已退出的線程處于此狀態(tài)
10、線程的優(yōu)先級
- Java提供一個線程調(diào)度器來監(jiān)控程序中啟動后進(jìn)入就緒狀態(tài)的所有線程，線程調(diào)度器按照優(yōu)先級決定應(yīng)該調(diào)度哪個線程來執(zhí)行。
- 線程的優(yōu)先級用數(shù)字表示，范圍從1-10。優(yōu)先級高的不一定會先執(zhí)行。優(yōu)先級的設(shè)定建議在start()調(diào)度前。
- Thread.MIN_PRIORITY = 1;
- Thread.MAX_PRIORITY = 10;
- Thread.NORM_PRIORITY = 5;
- 使用以下方式來改變或獲取優(yōu)先級
getPriority().setPriority(int p);
getPriority().getPriority();
public class TestPriority implements Runnable{
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+“–>”+Thread.currentThread().getPriority());
}
public static void main(String[] args) {
//主線程
System.out.println(Thread.currentThread().getName()+“–>”+Thread.currentThread().getPriority());
TestPriority testPriority = new TestPriority();
Thread t1 = new Thread(testPriority);
Thread t2 = new Thread(testPriority);
Thread t3 = new Thread(testPriority);
Thread t4 = new Thread(testPriority);
t1.setPriority(Thread.MAX_PRIORITY);
t1.start();
t2.setPriority(Thread.MIN_PRIORITY);
t2.start();
t3.setPriority(8);
t3.start();
t4.setPriority(4);
t4.start();
}
}
優(yōu)先級低只是意味著獲得調(diào)度的概率低，并不是優(yōu)先級低就不會被調(diào)用了，要看cpu的調(diào)度。
11、守護(hù)線程 setDaemon()
- 線程分為用戶線程和守護(hù)線程
- 虛擬機必須確保用戶線程執(zhí)行完畢
- 虛擬機不用等待守護(hù)線程執(zhí)行完畢
- 如后臺記錄操作日志，內(nèi)存監(jiān)控，垃圾回收等…
12、線程同步
并發(fā)：同一個對象被多個線程同時操作。
線程同步：就是一種等待機制，多個需要同時訪問此對象是線程進(jìn)入這個對象的等待池形成隊列，等待前面線程使用完畢，下一個線程在使用。
形成條件：隊列 + 鎖
在訪問時加入鎖機制synchronized，當(dāng)一個線程獲得對象的排它鎖，獨占資源，其他線程必須等待，使用后釋放鎖即可。但也存在一些問題：
- 一個線程持有鎖會導(dǎo)致其他所有需要此鎖的線程掛起；
- 在多線程競爭下，加鎖，釋放鎖會導(dǎo)致比較多的上下文切換和調(diào)度延時，引起性能問題；
- 如果一個優(yōu)先級高的線程等待一個優(yōu)先級低的線程釋放鎖，會導(dǎo)致優(yōu)先級倒置，引起性能問題。
13、同步方法
（1）synchronized關(guān)鍵字包括兩種用法：synchronized方法和synchronized塊。
（2）synchronized方法控制對“對象”的訪問，每個對象對應(yīng)一把鎖，每個synchronized方法都必須獲得調(diào)用該方法的對象的鎖才能執(zhí)行，否則線程會阻塞，方法一旦執(zhí)行，就獨占該鎖，直到該方法返回才釋放鎖，后面被阻塞的線程才能獲得這個鎖，繼續(xù)執(zhí)行。
缺陷：若將一個大的方法申明為synchronized，將會影響效率。
public class SafeBuyTicket{
public static void main(String[] args) {
BuyTicket station = new BuyTicket();
new Thread(station ,"lily").start();
new Thread(station ,"Ming").start();
new Thread(station ,"Jenny").start();
}
}
class BuyTicket implements Runnable{
private int ticketNum = 10;
boolean flag = true;
@Override
public void run() {
while(flag){
try {
buy();
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
//同步方法
private synchronized void buy() throws InterruptedException {
if(ticketNum <= 0){
flag = false;
return;
}
Thread.sleep(100);
System.out.println(Thread.currentThread().getName() + " get " + ticketNum--);
}
}14、同步塊
synchronized(obj){}
obj稱之為同步監(jiān)聽器：
（1）obj可以是任何對象，但是推薦使用共享資源作為同步監(jiān)視器
（2）同步方法中無需指定同步監(jiān)視器，因為同步方法的同步監(jiān)視器就是this，就是這個對象本身，或者是class。
同步監(jiān)視器的執(zhí)行過程：
（1）第一個線程訪問，鎖定同步監(jiān)視器，執(zhí)行其中代碼；
（2）第二個線程訪問，發(fā)現(xiàn)同步監(jiān)視器被鎖定，無法訪問；
（3）第一個線程訪問完畢，解鎖同步監(jiān)視器；
（4）第二個線程訪問，發(fā)現(xiàn)同步監(jiān)視器沒有鎖，然后鎖定并訪問；
public class SafeList {
public static void main(String[] args) {
List<String> list = new ArrayList<String>();
for (int i = 0; i < 1000; i++) {
new Thread(()->{
//代碼塊
synchronized (list){
list.add(Thread.currentThread().getName());
}
}).start();
}
try {
Thread.sleep(300);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.println(list.size());
}
}CopyOnWriteArrayList是JUC包下的一個線程安全集合。
15、死鎖
多個線程各自占有一些共享資源，并且互相等待其他線程占有的資源才能運行，而導(dǎo)致兩個或者多個線程都在等待對方釋放的資源，都停止執(zhí)行的情形。某一個同步塊同時擁有“兩個以上對象的鎖”時，就可能會發(fā)生“死鎖”的問題。
死鎖避免方法：
- 產(chǎn)生死鎖的四個必要條件：（破其一可避免死鎖）
（1）互斥條件：一個資源每次只能被一個進(jìn)程使用；
（2）請求與保持條件：一個進(jìn)程因請求資源而阻塞時，對已獲得的資源保持不放；
（3）不剝奪條件：進(jìn)程已獲得的資源，在未使用完之前，不能強行剝奪；
（4）循環(huán)等條件：若干進(jìn)程之前形成一種頭尾相接的循環(huán)等待資源關(guān)系。
16、Lock
JDK5.0開始，Java提供了更強大的線程同步機制——通過顯式定義同步鎖對象來實現(xiàn)同步。同步鎖使用Lock對象充當(dāng)；
java.util.concurrent.locks.Lock接口是控制多個線程對共享資源進(jìn)行訪問的工具。鎖提供了對共享資源的獨占訪問，每次只能有一個線程對Lock對象加鎖，線程開始訪問共享資源之前應(yīng)先獲得Lock對象；
ReentrantLock類實現(xiàn)Lock，它擁有與synchronized相同的并發(fā)性和內(nèi)存語義，在實現(xiàn)線程安全的控制中，比較常用的是ReentrantLock，可以顯式加鎖、釋放鎖。
class A {
private final ReentrantLock lock = new ReentrantLock();
public void m(){
lock.lock();
try {
//保證線程安全的代碼
}catch (Exception e){
}finally {
lock.unlock();
}
}
}17、Lock與synchronized的對比
- Lock是顯式鎖（手動開啟和關(guān)閉鎖),synchronized是隱式鎖，出了作用域自動釋放；
- Lock只有代碼塊鎖，synchronized有代碼塊鎖和方法鎖；
- 使用Lock鎖，JVM將花費較少的時間來調(diào)度線程，性能更好。并且具有更好的擴展性；
- 優(yōu)先使用順序：Lock > 同步代碼塊 > 同步方法
18、線程協(xié)作
生產(chǎn)者和消費者共享同一個資源，并且生產(chǎn)者和消費者之間相互依賴，互為條件。
- 對于生產(chǎn)者，沒有生產(chǎn)產(chǎn)品之前，要通知消費者等待，而生產(chǎn)了產(chǎn)品之后，又需要馬上通知消費者消費；
- 對于消費者，在消費之后，要通知生產(chǎn)者已經(jīng)結(jié)束消費，需要生產(chǎn)新的產(chǎn)品以供消費；
- 在生產(chǎn)者消費問題中，僅有synchronized是不夠的：synchronized可阻止并發(fā)更新同一個共享資源，實現(xiàn)了同步；synchronized不能用來實現(xiàn)不同線程之間的消息傳遞（通信）。
Java提供了幾個方法解決線程之間的通信問題：
- wait()：表示線程一直等待，直到其他線程通知，與sleep不同，會釋放鎖
- wait(long timeout)：指定等待的毫秒數(shù)
- notify()：喚醒一個處于等待狀態(tài)的線程
- notifyAll()：喚醒同一個對象上所有調(diào)用wait()方法的線程，優(yōu)先級別高的線程優(yōu)先調(diào)度
注意：均是Object類的方法，都只能在同步方法或者同步代碼塊中使用，否則會拋出異常IllegalMonitorStateException.
解決方式1：
并發(fā)協(xié)作模型“生產(chǎn)者/消費者模式”—>管程法
（1）生產(chǎn)者：負(fù)責(zé)生產(chǎn)數(shù)據(jù)的模塊（可能是方法，對象，線程，進(jìn)程）；
（2）消費者：負(fù)責(zé)處理數(shù)據(jù)的模塊（可能是方法，對象，線程，進(jìn)程）；
（3）緩沖區(qū)：消費者不能直接使用生產(chǎn)者的數(shù)據(jù)，他們之間有個“緩沖區(qū)”。
解決方式2：
并發(fā)協(xié)作模型“生產(chǎn)者/消費者模式”—>信號燈法（通過標(biāo)志位來實現(xiàn)）
19、線程池
經(jīng)常創(chuàng)建和銷毀、使用量特別大的資源，比如并發(fā)情況下的線程，對性能影響很大。解決思路，可以提前創(chuàng)建好多個線程，放入線程池中，使用時直接獲取，使用完放回池子中，避免頻繁創(chuàng)建銷毀，實現(xiàn)重復(fù)利用。這樣能減少創(chuàng)建新線程的時間，提高響應(yīng)速度；重復(fù)利用線程池中線程，降低資源消耗；便于線程管理等。
- corePoolSize：核心池的大小
- maxnumPoolSize：最大線程數(shù)
- keepAliveTime：線程沒有任務(wù)時最多保持多長時間后會終止
JDK5.0起提供了線程池相關(guān)的API：ExecutorService和Executors
ExecutorService：真正的線程池接口。常見子類ThreadPoolExecutor
- void execute(Runnable command)：執(zhí)行任務(wù)/命令，沒有返回值，一般用來執(zhí)行Runnable
- Future submit(Callable task)：執(zhí)行任務(wù)，有返回值，一般又來執(zhí)行Callable
- void shutdown()：關(guān)閉連接池
Executors：工具類、線程池的工廠類，用于創(chuàng)建并返回不同類型的線程池。
public class TestPool {
public static void main(String[] args) {
//創(chuàng)建服務(wù)，創(chuàng)建線程池
ExecutorService service = Executors.newFixedThreadPool(10);
//執(zhí)行
service.execute(new MyThread());
service.execute(new MyThread());
service.execute(new MyThread());
service.execute(new MyThread());
//關(guān)閉連接
service.shutdown();
}
}
class MyThread implements Runnable{
@Override
public void run() {
System.out.println(Thread.currentThread().getName());
}
}到此這篇關(guān)于Java進(jìn)階之多線程的文章就介紹到這了,更多相關(guān)java多線程內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！
相關(guān)文章
SpringBoot實現(xiàn)WebSocket通信過程解讀
文章講解了WebSocket在SpringBoot中的集成,涵蓋技術(shù)原理、實戰(zhàn)步驟、性能優(yōu)化及安全措施,提供環(huán)境搭建、消息處理、STOMP支持等關(guān)鍵實現(xiàn),結(jié)合業(yè)務(wù)場景構(gòu)建高效實時通信系統(tǒng)2025-08-08
聊聊Kotlin?中?lateinit?和?lazy?的原理區(qū)別
使用 Kotlin 進(jìn)行開發(fā)，對于 latelinit 和 lazy 肯定不陌生。但其原理上的區(qū)別，可能鮮少了解過，借著本篇文章普及下這方面的知識，感興趣的朋友一起看看吧2022-07-07
java高級用法之綁定CPU的線程Thread?Affinity簡介
java線程thread affinity是用來將java代碼中的線程綁定到CPU特定的核上，用來提升程序運行的性能，這篇文章主要介紹了java高級用法之綁定CPU的線程thread affinity的相關(guān)知識,需要的朋友可以參考下2022-05-05
spring data jpa @Query注解中delete語句報錯的解決
這篇文章主要介紹了spring data jpa @Query注解中delete語句報錯的解決，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教2021-12-12
java數(shù)據(jù)結(jié)構(gòu)與算法之簡單選擇排序詳解
這篇文章主要介紹了java數(shù)據(jù)結(jié)構(gòu)與算法之簡單選擇排序,結(jié)合實例形式分析了選擇排序的原理、實現(xiàn)方法與相關(guān)操作技巧,需要的朋友可以參考下2017-05-05
Sublime是一款強大的代碼編輯器,它提供了豐富的功能和插件,可以幫助開發(fā)者提高代碼的編寫效率和質(zhì)量,通過安裝相關(guān)插件和進(jìn)行簡單配置,我們可以輕松地在Sublime中編譯和運行Java代碼,下面我們將詳細(xì)介紹如何配置Sublime,使其能夠高效地運行Java代碼2024-06-06
下面小編就為大家?guī)硪黄狹yBatis 延遲加載、一級緩存、二級緩存(詳解)。小編覺得挺不錯的，現(xiàn)在就分享給大家，也給大家做個參考。一起跟隨小編過來看看吧2017-08-08
這篇文章主要介紹了idea將項目上傳到Gitee上,本文通過圖文并茂的形式給大家介紹的非常詳細(xì)，對大家的學(xué)習(xí)或工作具有一定的參考借鑒價值，需要的朋友可以參考下2021-08-08
Spring Boot 中的任務(wù)執(zhí)行器基本概念及使用方法
務(wù)執(zhí)行器是 Spring Boot 中的一個非常實用的模塊，它可以簡化異步任務(wù)的開發(fā)和管理，在本文中，我們介紹了任務(wù)執(zhí)行器的基本概念和使用方法，以及一個完整的示例代碼，需要的朋友可以參考下2023-07-07
mybatis條件語句中帶數(shù)組參數(shù)的處理
這篇文章主要介紹了mybatis條件語句中帶數(shù)組參數(shù)的處理方式，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教2021-09-09