Java多線程知識點全面總結(jié)

更新時間：2022年04月06日 17:22:41 作者：WG_tomorrow

這篇文章主要介紹了Java多線程知識點全面總結(jié)，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教

Java多線程知識點總結(jié)

（1）什么是進程?什么是線程？

進程：

是并發(fā)執(zhí)行程序在執(zhí)行過程中分配和管理資源的基本單位，當程序進入內(nèi)存圓形時即為線程

進程三大特點:

獨立性: 進程是系統(tǒng)中獨立存在的實體，它可以獨立擁有資源，每個進程都有自己的獨立空間。
動態(tài)性: 進程和程序的區(qū)別在于進程動態(tài)的，進程具有自己的生命周期
并發(fā)性:多個進程可以在單個處理器上并發(fā)執(zhí)行互不影響

并行和并發(fā):

并行是指同一時刻，多個命令同時執(zhí)行；
并發(fā)是指在同一時刻，只有一條命令是在處理器上執(zhí)行的，但多個進程命令被快速輪換執(zhí)行，使得在宏觀上具有多個進程同時執(zhí)行的效果。

線程：

線程（Thread）被稱為輕量級進程，線程是進程的執(zhí)行單元
線程是進程的組成部分，一個進程可以擁有多個線程，而一個線程必須擁有一個父進程。線程可以擁有堆棧，局部變量…但不能擁有系統(tǒng)資源，它與父進程的其他線程共享該進程的所有資源
一個線程可與其父進程的其他線程共同擁有父進程共享變量和部分環(huán)境，共同非合作完成任務(wù)。
可以簡便理解一個Class類執(zhí)行時就是一個JVM的進程，其中的成員屬性是子線程共享資源，main方法是主線程，其他方法是子線程，子線程（方法）相互合作共同完成Class任務(wù)。
線程是獨立運行的，線程的執(zhí)行是搶占式的，也就是說執(zhí)行的線程可能被掛起，以便運行另一個線程。
一個進程可以創(chuàng)建或者撤銷另一個線程，一個進程中的線程是并發(fā)執(zhí)行的。

（2）多線程的運行狀態(tài)

（1）線程一般具有5種基本狀態(tài) ：

創(chuàng)建，就緒，運行，阻塞，終止

在這里插入圖片描述

（2）

創(chuàng)建狀態(tài)：在程序中

（3）線程的創(chuàng)建和使用

（1）線程的創(chuàng)建

在Java 中如果要想實現(xiàn)多線程,那么必須依靠線程的主題類，但這個線程主題類在定義的時候，也需要一類特殊的要求,這個類可以繼承 Thread ,實現(xiàn)Runnable 接口或者實現(xiàn) Callable 接口來完成定義。任何一個類只要繼承了 Thread 類就可以成為一個類的主類，同時線程中需要覆寫父類終點 run( )方法。

（2）線程的使用

public class JavaDemoA {
    public static void main(String[] args) {
        new MyThread("線程A:").start();
        new MyThread("線程B:").start();
        new MyThread("線程C:").start();
    }
}
class MyThread extends Thread{ //線程的主體類
    private String title;
    public MyThread(String title){
        this.title=title;
    }
    @Override
    public void run() {
        for(int i=1;i<=4;i++){
            System.out.println(this.title+i);
        }
    }
}

（4）Runnable 接口實現(xiàn)多線程

Thread是 Runnable 的子類,繼承了 Runnable 的接口，Thread 類的確可以方便實現(xiàn)多線程,但這種方式最大的缺陷就是單繼承局限性

Runnable 接口從 JDK1.8 開始成為一個函數(shù)接口,可以直接利用lambda表達式來實現(xiàn)線程主體代碼，同時在該接口中提供有run()方法進行線程功能定義

Thread構(gòu)造方法:public Thread(Runnable target).

在Thread類中會保存有target屬性，該屬性保存的是Runnable的核心業(yè)務(wù)主體對象

當Thread.start() 方法啟動多線程時也會調(diào)用Thread.run() 方法，而在 Thread.run() 會判斷是否提供有target實例,如果提供則調(diào)用真實主體

public class JavaDemoB {
    public static void main(String[] args) {
        new Thread(new MyThreadB("線程A:")).start();
        new Thread(new MyThreadB("線程B:")).start();
        new Thread(new MyThreadB("線程C:")).start();
    }
}
class MyThreadB implements Runnable{
    private String title;
    public MyThreadB(String title){
        this.title=title;
    }
    @Override
    public void run() {
        for(int i=1;i<=5;i++){
            System.out.println(title+i);
  加粗樣式      }
    }
}

（5）Callable接口實現(xiàn)多線程

Runnable 接口實例化多線程可以避免單繼承問題，但 Runnable 中的run() 方法不能返回操作結(jié)果,為啦解決這樣的問題,從JDK1.5開始對于多線程的實現(xiàn)提供了一個新的接口 java.util.concurrent.Callable

Callable接口在定義時需要定義泛型。

通過FutureTask 實現(xiàn)Callable接口和Thread類的聯(lián)系，并且通過FutureTask類獲取Callable接口中call()方法的返回值。

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;
public class JavaDemoC {
    public static void main(String[] args) throws Exception{
        FutureTask<String> task=new FutureTask<>(new MyThreadC());
        new Thread(task).start();
        System.out.println(task.get());
    }
}
class MyThreadC implements Callable<String> {
    @Override
    public String call() throws Exception {
        for(int i=1;i<=5;i++){
            System.out.println("線程執(zhí)行:i="+i);
        }
        return "Callable實現(xiàn)多線程";
    }
}

多線程常用操作方法

（1）線程的命名和取得

public Thread (Runnable target,String name) 構(gòu)造實例化線程對象，接受 Runnable 接口子類對象，同時設(shè)置線程名稱;

public final void setName(String name) 普通設(shè)置線程名稱

public final String getName() 取得線程名字

每當實例化Thread類對象時，都會調(diào)用init()方法，并且在沒有為線程命名時，自動命名。

package ThreadTest;
public class JavaDemoD {
    public static void main(String[] args) {
        MyThreadD myThread=new MyThreadD();
        new Thread(myThread,"線程A").start();//線程手動命名
        new Thread(myThread).start();//線程自動命名
        new Thread(myThread,"線程B").start();
    }
}
class MyThreadD implements Runnable{
    @Override
    public void run() {
        //獲取當前線程名稱
        System.out.println(Thread.currentThread().getName());
    }
}

（2）線程休眠

線程有時候需要減緩執(zhí)行速度，所以Thread 類提供啦sleep()方法

public static void sleep(long millis) throws InterruptedException設(shè)置線程毫秒數(shù)，時間一到自動喚醒

public static void sleep(long millis,int nanos) throws InterruptedException設(shè)置線程毫秒數(shù)，納秒數(shù)，時間一到自動喚醒

public class JavaDemoE {
    public static void main(String[] args){
        Runnable runnable=(()->{//Runnable接口實例
           for(int i=1;i<=5;i++){
               System.out.println(Thread.currentThread().getName()+i);
               try {
                   Thread.sleep(2000);//強制讓線程休眠2秒
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }
        });
        new Thread(runnable,"線程A:").start();
        new Thread(runnable,"線程B:").start();
    }
    //本程序兩個線程對象，每一個線程對象執(zhí)行時都要休眠一秒，因為多線程的啟動和執(zhí)行都是有操作系統(tǒng)，
    //隨機分配，雖然看起來A，B線程同時休眠，但也有先后順序
}

（3）線程中斷

Thread 中提供的線程方法很多都會拋出InterruptedException中斷異常，所以線程在執(zhí)行過程中可以被另一個線程中斷。

public boolean isInterrupted( ) 普通方法判斷線程是否被中斷

public void interrupt( ) 普通中斷線程執(zhí)行

public class JavaDemoF {
    public static void main(String[] args) throws InterruptedException {
        Thread thread=new Thread(()->{
            System.out.println("線程累了想休眠10S");
            try {
                Thread.sleep(10000);
                System.out.println("時間到，自然醒來");
            } catch (InterruptedException e) {
                System.out.println("被強制喚醒，繼續(xù)工作");
            }
        });
        thread.start();//線程執(zhí)行啟動
        Thread.sleep(2000);//先讓子線程運行2秒
        if(!thread.isInterrupted()){//如果線程沒有中斷
            System.out.println("讓線程終止休眠");
            thread.interrupt();//線程中斷
        }
    }
}

（4）線程強制執(zhí)行

在多線程并發(fā)執(zhí)行中每個線程對象都會交替執(zhí)行，如果某個線程對象需要優(yōu)先完成執(zhí)行，可以使用 join ()方法強制執(zhí)行，待其執(zhí)行完畢后其他線程才會繼續(xù)執(zhí)行

public final void join() throws InterruptedException

public class JavaDemoG {
    public static void main(String[] args) {
        Thread threadB=new Thread(new MyThreadH(),"線程B");
        Runnable runnable=(()->{
           for(int i=1;i<=9;i++){
               System.out.println(Thread.currentThread().getName()+i);
               if(i==5){
                   try {
                       threadB.join();//如果i=5,強制執(zhí)行線程B
                   } catch (InterruptedException e) {
                       e.printStackTrace();
                   }
               }
           }
        });
        new Thread(runnable,"線程A").start();
        threadB.start();
    }
}
class MyThreadH implements Runnable{
    @Override
    public void run() {
        for(int i=1;i<=5;i++){
            System.out.println(Thread.currentThread().getName()+i);
        }
    }
}

（5）線程禮讓

多線程在彼此交替執(zhí)行時往往需要進行資源輪流占用，如果某些不是很重要的線程搶占到資源但又不著急執(zhí)行時就可以暫時禮讓出去，讓其他線程先執(zhí)行。

public static void yield( ) 線程禮讓

public class JavaDemoH {
    public static void main(String[] args) {
        Runnable runnable=(()->{//Lambda實例化線程類對象,方便演示
            for(int j=1;j<=15;j++){
                System.out.println(Thread.currentThread().getName()+j);
            }
        });
        new Thread(new MyThreadI(),"禮讓線程A").start();
        new Thread(runnable,"非禮讓線程B:").start();
        new Thread(runnable,"非禮讓線程C:").start();
        new Thread(runnable,"非禮讓線程D:").start();
    }
}
class MyThreadI implements Runnable{
    @Override
    public void run() {
        for(int i=1;i<=10;i++){
            System.out.println(Thread.currentThread().getName()+i);
            if(i%3==0){
                Thread.yield();//線程禮讓
            }
        }
    }
}

（6）線程優(yōu)先級

在java線程操作時，所有線程運行前都保持就緒狀態(tài)，此時那個線程的優(yōu)先級高就有可能優(yōu)先被執(zhí)行

所有創(chuàng)建的線程都是子線程，啟動時都是同樣的優(yōu)先級。

主線程是中等優(yōu)先級 5

public final void setPriority ( int newPriority ) 設(shè)置線程優(yōu)先級

MAX_PRIORITY 最高優(yōu)先級 10

NORM_PRIORITY 中等優(yōu)先級 5

MIN_PRIORITY 最低優(yōu)先級 1

public final int getPriority ( ) 獲取線程優(yōu)先級

public class JavaDemoI {
    public static void main(String[] args) {
        Runnable runnable=(()->{
            for (int i=1;i<=5;i++){
                System.out.println(Thread.currentThread().getName()+i);
            }
        });
        Thread threadA=new Thread(runnable,"線程A");
        Thread threadB=new Thread(runnable,"線程B");
        Thread threadC=new Thread(runnable,"線程C");
        threadA.setPriority(Thread.MIN_PRIORITY);
        threadB.setPriority(Thread.NORM_PRIORITY);
        threadC.setPriority(Thread.MAX_PRIORITY);
        threadA.start();
        threadB.start();
        threadC.start();
    }
}

（7）如何停止線程

（1）停止線程的3個方法（了解）

停止多線：public void stop ()
掛起多線程:：public final void suspend()
恢復(fù)掛起的多線程：public final void resume()

（2）對多線程中 stop ()， suspend()， resume() 方法在jdk1.2開始不建議使用，主要是因為這三個方法在操作時會產(chǎn)生死鎖的問題。

（3）優(yōu)雅的停止一個線程

代碼演示：

package ThreadTest;
public class JavaDemoO {
    private static boolean flag=true;
    public static void main(String[] args) throws InterruptedException {
        new Thread(()->{
            long num=0;
            while (flag){
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"正在運行"+num++);
            }
        },"執(zhí)行線程").start();
        Thread.sleep(200);
        flag=false;
    }
}

（8）后臺守護線程

（1）java中的線程分為兩類:

用戶線程和守護線程，守護線程：是一種運行在后臺的線程服務(wù)線程，當用戶線程存在時，守護線程也可以用時存在；當用戶線程消失時，守護線程也會消失。
public final void setDaemon(boolean on) 設(shè)置為守護線程
public final boolean idDaemon() 判斷是否是守護線程

代碼：

package ThreadTest;
public class JavaDemoP {
    public static void main(String[] args) {
        Thread threadA=new Thread(()->{
            for(int i=1;i<=100;i++){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+i);
            }
        },"用戶線程");
        Thread threadB=new Thread(()->{
            for(int i=1;i<=200;i++){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+i);
            }
        },"守護線程");
        threadB.setDaemon(true);//設(shè)置為守護線程
        threadA.start();
        threadB.start();
    }
}

結(jié)果：用戶線程結(jié)束時，守護線程也結(jié)束

在這里插入圖片描述

（9）volatile 關(guān)鍵字

在多線程編程中，若干個線程為了可以實現(xiàn)公共資源的操作，往往是復(fù)制相應(yīng)變量的副本，待完成操作后再將副本變量的數(shù)據(jù)與原始數(shù)據(jù)進行同步處理，如果開發(fā)者不希望通過副本數(shù)據(jù)進行操作，而是希望可以直接通過原始變量的操作（節(jié)省了復(fù)制變量副本與同步的時間），則可以在變量聲明時使用volatile關(guān)鍵字.

使用volatile關(guān)鍵字

代碼：

package ThreadTest;
public class JavaDemoQ {
    public static void main(String[] args) {
        new Thread(new MyThreadQ(),"線程A售票成功_剩余票數(shù):").start();
        new Thread(new MyThreadQ(),"線程B售票成功_剩余票數(shù):").start();
        new Thread(new MyThreadQ(),"線程C售票成功_剩余票數(shù):").start();
        new Thread(new MyThreadQ(),"線程D售票成功_剩余票數(shù):").start();
    }
}
class MyThreadQ implements Runnable{
    private volatile int ticket=50;//直接內(nèi)存操作
    @Override
    public void run() {
        while (ticket>0){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            ticket--;
            System.out.println(Thread.currentThread().getName()+ticket);
        }
    }
}

結(jié)果:

在這里插入圖片描述

volatile與synchronized的區(qū)別:

volatile無法進行同步處理操作，它只是一種直接內(nèi)存的處理，避免副本操作
volatile主要是在屬性上使用，而synchronize是在方法和代碼塊上使用。

線程的同步和死鎖

（1）線程同步問題

（1）同步問題的引出

public class JavaDemoJ {
    private static int ticket=5;//總票數(shù)5張
    public static void main(String[] args) {
        Runnable runnable=(()->{
            while (true){//持續(xù)賣票
                if(ticket>0){
                    try {
                        Thread.sleep(100);//模擬網(wǎng)絡(luò)延遲
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+"賣票成功\t剩余票數(shù):"+ticket--);
                }
                if(ticket<=0){
                    System.out.println(Thread.currentThread().getName()+"賣票失敗\t剩余票數(shù):"+ticket);
                    break;
                }
            }
        }) ;
        new Thread(runnable,"售票員A:").start();
        new Thread(runnable,"售票員B:").start();
        new Thread(runnable,"售票員C:").start();
        //假設(shè)此時還有一張票，當?shù)谝粋€線程滿足售票條件時（還未減少票數(shù)），其他線程也可能滿足售票條件，
        //就有可能造成同一張票賣出去兩次。
    }
}

問題所在:

假設(shè)此時還有一張票，當?shù)谝粋€線程滿足售票條件時（還未減少票數(shù)），其他線程也可能滿足售票條件就有可能造成同一張票賣出去兩次。

在這里插入圖片描述

(2) 解決同步問題

Java使用Synchronized關(guān)鍵字實現(xiàn)同步操作，同步的關(guān)鍵是要給代碼上“鎖”，而對于鎖的操作有兩種：同步代碼塊，同步方法。

（1）同步代碼塊

同步代碼塊是指使用synchronized關(guān)鍵字定義的代碼塊，在代碼執(zhí)行時，往往需要設(shè)置一個同步對象，由于線程操作的不確定性所以這時候的同步對象可以選擇 this。

將票數(shù)判斷和票數(shù)自減放在同一代碼塊中，當多線程并發(fā)執(zhí)行時，只允許一個線程執(zhí)行該部分代碼塊，就實現(xiàn)啦同步處理操作、

public class JavaDemoK {
    public static void main(String[] args) {
        MyThreadK myThreadK=new MyThreadK();
        new Thread(myThreadK,"線程A售票成功,剩余票數(shù):").start();
        new Thread(myThreadK,"線程B售票成功,剩余票數(shù):").start();
        new Thread(myThreadK,"線程C售票成功,剩余票數(shù):").start();
        new Thread(myThreadK,"線程D售票成功,剩余票數(shù):").start();
    }
}
class MyThreadK implements Runnable{
    private static int ticket=10;//總票數(shù)
    @Override
    public void run() {
        while (true){
            synchronized (this){//同步代碼塊
                if(ticket>0){
                    try {
                        Thread.sleep(100);//模擬網(wǎng)絡(luò)延遲
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+(--ticket));
                }else {
                    System.out.println("全部售空");
                    break;
                }
            }
        }
    }
}

結(jié)果：

在這里插入圖片描述

（2）同步方法解決

public class JavaDemoL {
    public static void main(String[] args) {
        MyThreadL myThreadL=new MyThreadL();
        new Thread(myThreadL,"售票員A售票成功，剩余票數(shù):").start();
        new Thread(myThreadL,"售票員B售票成功，剩余票數(shù):").start();
        new Thread(myThreadL,"售票員C售票成功，剩余票數(shù):").start();
        new Thread(myThreadL,"售票員D售票成功，剩余票數(shù):").start();
    }
}
class MyThreadL implements Runnable{
    private static int ticket=10;
    @Override
    public void run() {
        sale();
    }
    public synchronized void sale() {//同步方法
        while (true){
        if(this.ticket>0){
            try {
                Thread.sleep(100);//網(wǎng)絡(luò)延遲
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            this.ticket--;
            System.out.println(Thread.currentThread().getName()+this.ticket);
        } else {
            System.out.println("票已售空");
            break;
        }
    }
    }
}

結(jié)果:

在這里插入圖片描述

（2）線程死鎖問題

（1）死鎖問題的引出

代碼：

package ThreadTest;
public class JavaDemoJ implements Runnable{
    private book book=new book();
    private money money=new money();
    public JavaDemoJ(){
        new Thread(this).start();
        book.tell(money);
    }
    public void run(){
        money.tell(book);
    }
    public static void main(String[] args) {
        new JavaDemoJ();
    }
}
class book{
    public synchronized void tell(money money){
        System.out.println("你先給我錢，我才給你書！");
        money.get();
    }
    public synchronized void get(){
        System.out.println("收到錢,把書給買家！");
    }
}
class money{
    public synchronized void tell(book book){
        System.out.println("你先給我書，我再給你錢!");
        book.get();
    }
    public synchronized void get(){
        System.out.println("收到書,把錢給賣家！");
    }
}

結(jié)果：

在這里插入圖片描述

結(jié)論：本程序中采用大量同步處理操作，而死鎖一旦出現(xiàn)線程將進入等待操作，并且不會向下繼續(xù)執(zhí)行。

（3）生產(chǎn)者消費者問題

（1）生產(chǎn)者生產(chǎn)，消費者取出，生產(chǎn)者生產(chǎn)一個，消費者取出一個

未同步代碼:

package ThreadTest;
public class JavaDemoM {
    public static void main(String[] args) {
        Message message=new Message();
        new Thread(new Producer(message)).start();
        new Thread(new Consumer(message)).start();
    }
}
class Message{//消息類
    private String title;//標題
    private String content;//內(nèi)容
    public String getTitle() {
        return title;
    }
    public void setTitle(String title) {
        this.title = title;
    }
    public String getContent() {
        return content;
    }
    public void setContent(String content) {
        this.content = content;
    }
}
class Producer implements Runnable{//定義生產(chǎn)者
    private Message msg=null;
    public Producer(Message msg){
        this.msg=msg;
    }
    @Override
    public void run() {
        for(int i=1;i<=50;i++){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if(i%2==0){
                msg.setTitle(i+"英雄");
                msg.setContent("名垂千古");
            }else {
                msg.setTitle(i+"小人");
                msg.setContent("遺臭萬年");
            }
        }
    }
}
class Consumer implements Runnable{
    private Message msg;
    public Consumer(Message msg){
        this.msg=msg;
    }
    @Override
    public void run() {
        for (int i=1;i<=50;i++){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("【"+msg.getTitle()+","+msg.getContent()+"】");
        }
    }
}

錯誤產(chǎn)生結(jié)果:

在這里插入圖片描述

問題分析：

數(shù)據(jù)錯位：假設(shè)生產(chǎn)者線程還剛在存儲空間添加一個數(shù)據(jù)的標題，還未添加內(nèi)容，程序就切換到消費者線程，消費者就會把沒有生產(chǎn)者沒有添加的內(nèi)容和上一組生產(chǎn)的內(nèi)容聯(lián)系在一起導(dǎo)致數(shù)據(jù)錯位。重復(fù)操作：生產(chǎn)者線程放入多組數(shù)據(jù)，消費者線程才開始取出，或者是消費者還沒生產(chǎn)數(shù)據(jù)，消費者就已經(jīng)重復(fù)取出數(shù)據(jù)。

同步代碼解決：

package ThreadTest;
public class JavaDemoN {
    public static void main(String[] args) {
        Message2 msg=new Message2();
        new Thread(new Producer2(msg)).start();
        new Thread(new Consumer2(msg)).start();
    }
}
class Message2 {
    private String title;
    private String content;
    private boolean key=true;
    //true 允許生產(chǎn)不允許消費
    //false 允許消費不允許生產(chǎn)
    public synchronized void set(String title,String content) {//同步方法
        if(this.key==false){//允許消費不允許生產(chǎn)
            try {
                super.wait();//線程等待
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        this.title = title;
        this.content = content;
        this.key=false;//生產(chǎn)完畢
        super.notify();//喚醒線程
    }
    public synchronized String get() {
        if(this.key==true){//允許生產(chǎn)不允許消費
            try {
                super.wait();//線程等待
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
       try {
           return title +","+ content;
       }finally {
           this.key=true;
           super.notify();
       }
    }
}
class Producer2 implements Runnable{//定義生產(chǎn)者
    private Message2 msg=null;
    public Producer2(Message2 msg){
        this.msg=msg;
    }
    @Override
    public void run() {
        for(int i=1;i<=50;i++){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if(i%2==0){
                this.msg.set(i+"英雄","萬古流芳");
            }else {
                this.msg.set(i+"小人","遺臭萬年");
            }
        }
    }
}
class Consumer2 implements Runnable{
    private Message2 msg;
    public Consumer2(Message2 msg){
        this.msg=msg;
    }
    @Override
    public void run() {
        for (int i=1;i<=50;i++){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("【"+msg.get()+"】");
        }
    }
}

正確執(zhí)行結(jié)果：

在這里插入圖片描述

原理解釋：

將同步操作設(shè)置在Message類中，使用synchronized關(guān)鍵字可以使消息內(nèi)容同步，不會造成消息錯位。

在生產(chǎn)者和消費者線程中根據(jù)key判斷，是否可以生產(chǎn)或者取出，如果不能生產(chǎn)或者取出，可使用 wait( ) 線程等待方法等待另一方線程取出或者生產(chǎn)后，使用 notify( ) 線程喚醒，繼續(xù)執(zhí)行操作。notifyAll( ) 是喚醒全部等待的線程

以上為個人經(jīng)驗，希望能給大家一個參考，也希望大家多多支持腳本之家。

您可能感興趣的文章:

国产无遮挡裸体免费直播视频,久久精品国产蜜臀av,动漫在线视频一区二区,欧亚日韩一区二区三区,久艹在线免费视频,国产精品美女网站免费,正在播放 97超级视频在线观看,斗破苍穹年番在线观看免费,51最新乱码中文字幕

Java多線程知識點全面總結(jié)

目錄

Java多線程知識點總結(jié)

（1）什么是進程?什么是線程？

（2）多線程的運行狀態(tài)

（3）線程的創(chuàng)建和使用

（4）Runnable 接口實現(xiàn)多線程

（5）Callable接口實現(xiàn)多線程

多線程常用操作方法

（1）線程的命名和取得

（2）線程休眠

（3）線程中斷

（4）線程強制執(zhí)行

（5）線程禮讓

（6）線程優(yōu)先級

（7）如何停止線程

（8）后臺守護線程

（9）volatile 關(guān)鍵字

線程的同步和死鎖

（1）線程同步問題

（2）線程死鎖問題

（3）生產(chǎn)者消費者問題

相關(guān)文章

最新評論

大家感興趣的內(nèi)容

最近更新的內(nèi)容

常用在線小工具

国产无遮挡裸体免费直播视频,久久精品国产蜜臀av,动漫在线视频一区二区,欧亚日韩一区二区三区,久艹在线 免费视频,国产精品美女网站免费,正在播放 97超级视频在线观看,斗破苍穹年番在线观看免费,51最新乱码中文字幕

Java多線程知識點全面總結(jié)

目錄

Java多線程知識點總結(jié)

（1）什么是進程?什么是線程？

（2）多線程的運行狀態(tài)

（3）線程的創(chuàng)建和使用

（4）Runnable 接口實現(xiàn)多線程

（5）Callable接口實現(xiàn)多線程

多線程常用操作方法

（1）線程的命名和取得

（2）線程休眠

（3）線程中斷

（4）線程強制執(zhí)行

（5）線程禮讓

（6）線程優(yōu)先級

（7）如何停止線程

（8）后臺守護線程

（9）volatile 關(guān)鍵字

線程的同步和死鎖

（1）線程同步問題

（2）線程死鎖問題

（3）生產(chǎn)者消費者問題

相關(guān)文章

最新評論

大家感興趣的內(nèi)容

最近更新的內(nèi)容

常用在線小工具

国产无遮挡裸体免费直播视频,久久精品国产蜜臀av,动漫在线视频一区二区,欧亚日韩一区二区三区,久艹在线免费视频,国产精品美女网站免费,正在播放 97超级视频在线观看,斗破苍穹年番在线观看免费,51最新乱码中文字幕

（1）什么是進程?什么是線程？