其實程式是一段靜態的代碼，它是應用程式執行的腳本，行程就是程式動態的執行程序，它具有動態性，并發性，獨立性，執行緒是行程調度和執行的單位，

行程：每個行程都有獨立的代碼和資料空間（行程背景關系），一個行程包含一個或者多個執行緒，同時執行緒是資源分配的最小單位，

執行緒：同一類執行緒共享代碼和資料空間，并且每個執行緒有獨立運行堆疊和程式計數器，同時執行緒是調度的最小單位，

那什么是多行程呢? ，常見的是打開我們自己電腦任務管理器里面就還有多個行程，其實指的是我們的作業系統能同時運行多個任務（微信，QQ等），

多執行緒其實就是一個行程有多條路徑在運行，

一、多執行緒實作的方式

在Java中實作多執行緒有三種方式，第一種方式是繼承Thread類，第二種方式是實作Runnable介面, 第三種是實作Callable，結合Future使用（了解），并發編程中使用，這里不詳細說:

第一種實作多執行緒的方式，繼承Thread類，代碼實作如下：

public class RabbitDemo extends Thread {
    @Override
    public void run() {
        for (int i = 0; i <10 ; i++) {
            System.out.println("兔子跑了："+i+"步");
        }    }}public class TortoiseDemo extends Thread {
    @Override
    public void run() {
        for (int i = 0; i <10 ; i++) {
            System.out.println("烏龜跑了："+i+"步");
        }    }}public class ClientThreadTest {
    public static void main(String[] args) {
        RabbitDemo rabbitDemo = new RabbitDemo();
        TortoiseDemo tortoiseDemo = new TortoiseDemo();
        rabbitDemo.start();        tortoiseDemo.start();        for (int i = 0; i < 10; i++) {
            System.out.println("main==>" + i);
        }    }}復制代碼

第二個實體實作多個執行緒同時共享一個成員變數執行緒的運行狀態，

public class Qp12306 implements Runnable {
    private int num=50;
    @Override
    public void run() {
        while (true){
            if (num<=0){
                break;
            }            System.out.println(Thread.currentThread().getName()+"搶到票"+num--);
        }    }}public class ClientQpTest {
    public static void main(String[] args) {
        Qp12306 qp12306 = new Qp12306();
        Thread thread = new Thread(qp12306, "張三");
        Thread thread1 = new Thread(qp12306, "李四");
        Thread thread2 = new Thread(qp12306, "王五");
        thread.start();        thread1.start();        thread2.start();    }}復制代碼

第二種方式：實作 Runnable介面,重寫run方法，這種方式我們實作多執行緒常用的方式（避免Java單繼承的限制)并且該方式采用了靜態代理設計模式（參考: 靜態代理），代碼實體如下：

public class RunnableDemo implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("Runnable:" + i);
        }    }}public class ClientRunableTest {
    public static void main(String[] args) {
        RunnableDemo runnableDemo = new RunnableDemo();
        Thread thread = new Thread(runnableDemo);
        thread.start();    }}復制代碼

第三方式：實作Callable介面,結合Future實作多執行緒，代碼實體如下：

/**
 * 使用Callable創建執行緒 */public class Race implements Callable<Integer> {    private String name;    private long time; //延時時間
    private boolean flag = true;
    private int step = 0; //步
    @Override    public Integer call() throws Exception {        while (flag) {
            Thread.sleep(time);
            step++;        }        return step;
    }    public Race(String name, long time) {
        this.name = name;        this.time = time;
    }    public void setFlag(boolean flag) {        this.flag = flag;    }}public class CallableTest {    public static void main(String[] args) throws InterruptedException, ExecutionException {        ExecutorService executorService = Executors.newFixedThreadPool(2);
        Race race = new Race("張三", 200);
        Race race1 = new Race("李四", 500);
        Future<Integer> result = executorService.submit(race);        Future<Integer> result1 = executorService.submit(race1);        Thread.sleep(3000);
        race.setFlag(false);
        race1.setFlag(false);
        int num1 = result.get();        int num2 = result1.get();        System.out.println("張三-->" + num1 + "步");
        System.out.println("李四-->" + num2 + "步");
        //停止服務        executorService.shutdownNow();    }}復制代碼

如果一個類繼承Thread，則不適合資源共享，但是如果實作了Runable介面的話，則很容易的實作資源共享，

總結：

實作Runnable介面比繼承Thread類所具有的優勢：

1、適合多個相同的程式代碼的執行緒去處理同一個資源

2、可以避免java中的單繼承的限制

3、增加程式的健壯性，代碼可以被多個執行緒共享，代碼和資料獨立

4、執行緒池只能放入實作Runable或callable類執行緒，不能直接放入繼承Thread的類

main方法其實也是一個執行緒，在java中所以的執行緒都是同時啟動的，至于什么時候，哪個先執行，完全看誰先得到CPU的資源，

在java中，每次程式運行至少啟動2個執行緒，一個是main執行緒，一個是垃圾收集執行緒，因為每當使用java命令執行一個類的時候，實際上都會啟動一個ＪＶＭ，每一個ｊＶＭ就是在作業系統中啟動了一個行程，

二、執行緒的狀態和方法

執行緒從創建，運行到結束總是處于五種狀態之一：新建狀態，就緒狀態，運行狀態，阻塞狀態，死亡狀態，執行緒共包括以下5種狀態：

1.新建狀態：執行緒物件被創建后就進入了新建狀態，Thread thread = new Thread();

2.就緒狀態（Runnable）：也被稱之為“可執行狀態”，當執行緒被new出來后，其他的執行緒呼叫了該物件的start()方法，即thread.start()，此時執行緒位于“可運行執行緒池”中，只等待獲取CPU的使用權，隨時可以被CPU呼叫，進入就緒狀態的行程除CPU之外，其他運行所需的資源都已經全部獲得，

3.運行狀態（Running）：執行緒獲取CPU權限開始執行，注意：執行緒只能從就緒狀態進入到運行狀態，

4.阻塞狀態（Bloacked）：阻塞狀態是執行緒因為某種原因放棄CPU的使用權，暫時停止運行，知道執行緒進入就緒狀態后才能有機會轉到運行狀態，

阻塞的情況分三種：

（1）、等待阻塞：運行的執行緒執行wait()方法，該執行緒會釋放占用的所有資源，JVM會把該執行緒放入“等待池中”，進入這個狀態后是不能自動喚醒的，必須依靠其他執行緒呼叫notify()或者notifyAll()方法才能被喚醒，（2）、同步阻塞：運行的執行緒在獲取物件的（synchronized）同步鎖時，若該同步鎖被其他執行緒占用，則JVM會把該執行緒放入“鎖池”中，（3）、其他阻塞：通過呼叫執行緒的sleep()或者join()或發出了I/O請求時，執行緒會進入到阻塞狀態，當 sleep()狀態超時、join()等待執行緒終止或者超時、或者I/O處理完畢時，執行緒重新回到就緒狀態 5. 死亡（Dead）：執行緒執行完了或因例外退出了run()方法，則該執行緒結束生命周期，

阻塞執行緒方法的說明：

wait(), notify(),notifyAll()這三個方法是結合使用的，都屬于Object中的方法，wait的作用是當當前執行緒釋放它所持有的鎖進入等待狀態（釋放物件鎖），而notify和notifyAll則是喚醒當前物件上的等待執行緒， wait() —— 讓當前執行緒處于“等待(阻塞)狀態”，“直到其他執行緒呼叫此物件的 notify() 方法或 notifyAll() 方法”，當前執行緒被喚醒(進入“就緒狀態”)，

sleep() 和 yield()方法是屬于Thread類中的sleep()的作用是讓當前執行緒休眠（正在執行的執行緒主動讓出cpu，然后cpu就可以去執行其他任務），即當前執行緒會從“運行狀態”進入到阻塞狀態”，但仍然保持物件鎖，仍然占有該鎖，當延時時間過后該執行緒重新阻塞狀態變成就緒狀態，從而等待cpu的調度執行， sleep()睡眠時，保持物件鎖，仍然占有該鎖， yield()的作用是讓步，它能夠讓當前執行緒從運行狀態進入到就緒狀態”，從而讓其他等待執行緒獲取執行權，但是不能保證在當前執行緒呼叫yield()之后，其他執行緒就一定能獲得執行權，也有可能是當前執行緒又回到“運行狀態”繼續運行，

wait () ， sleep()的區別：

1、每個物件都有一個鎖來控制同步訪問，Synchronized關鍵字可以和物件的鎖互動，來實作執行緒的同步， sleep方法沒有釋放鎖，而wait方法釋放了鎖，使得其他執行緒可以使用同步控制塊或者方法， 2、 wait,notify和notifyAll只能在同步控制方法或者同步控制塊里面使用，而sleep可以在任何地方使用 3、 sleep必須捕獲例外，而wait，notify和notifyAll不需要捕獲例外 4、 sleep()睡眠時，保持物件鎖，仍然占有該鎖,而wait()釋放物件鎖；

三、執行緒的基本資訊和優先級

涉及到執行緒的方法：Thread.currentThread() 當前執行緒，setName():設定名稱，getName():獲取名稱，isAlive():判斷狀態優先級：Java執行緒有優先級，優先級高的執行緒能獲取更多的運行機會， Java執行緒的優先級用整數表示，取值范圍是1~10，Thread類有以下三個靜態常量： static int MAX_PRIORITY 執行緒可以具有的最高優先級，取值為10， static int MIN_PRIORITY 執行緒可以具有的最低優先級，取值為1， static int NORM_PRIORITY 分配給執行緒的默認優先級，取值為5，

下面代碼實作：基本資訊

public static void main(String[] args) throws InterruptedException {
        Rundemo rundemo = new Rundemo();
        Thread thread = new Thread(rundemo);
        thread.setName("執行緒"); //設定執行緒的名稱
        System.out.println(thread.getName()); //獲取當前線性的名稱
        System.out.println(Thread.currentThread().getName()); //main執行緒
        thread.start();
        System.out.println("執行緒啟動后的狀態：" + thread.isAlive());
        Thread.sleep(10);
        rundemo.stop();
        Thread.sleep(1000); //停止后休眠一下，再看執行緒的狀態
        System.out.println("執行緒停止后的狀態：" + thread.isAlive());
        test();
    }
復制代碼

優先級

public static void test() throws InterruptedException {
        Rundemo rundemo1 = new Rundemo();
        Thread thread1 = new Thread(rundemo1);
        thread1.setName("執行緒thread1");
        Rundemo rundemo2 = new Rundemo();
        Thread thread2 = new Thread(rundemo2);
        thread2.setName("執行緒thread2");
        thread1.setPriority(Thread.MAX_PRIORITY);        thread2.setPriority(Thread.MIN_PRIORITY);        thread1.start();        thread2.start();        Thread.sleep(1000);
        rundemo1.stop();        rundemo2.stop();    }復制代碼

四、執行緒的同步和死鎖問題

同步方法：synchronized 同步代碼塊：synchronized（參考型別|this|類.class）{ } 執行緒同步是為了多個執行緒同時訪問一份資源確保資料的正確，不會造成資料的樁讀，死鎖是執行緒間相互等待鎖鎖造成的.

下面代碼實作：多個執行緒同時訪問一份資源使用synchronized

public class Qp12306 implements Runnable {
    private int num = 10;  
    private boolean flag = true;
    @Override
    public synchronized void run() {
        while (true) {
            test();        }    }    public synchronized void test() {
        if (num <= 0) {
            flag = false;
            return;
        }        System.out.println(Thread.currentThread().getName() + "搶到票" + num--);
    }}public class ClientQpTest {
    public static void main(String[] args) {
        Qp12306 qp12306 = new Qp12306();
        Thread thread = new Thread(qp12306, "張三");
        Thread thread1 = new Thread(qp12306, "李四");
        Thread thread2 = new Thread(qp12306, "王五");
        thread.start();        thread1.start();        thread2.start();    }}復制代碼

運行結果

面試騰訊，位元組跳動首先要掌握的Java多執行緒，一次幫你全掌握

synchronized 靜態代碼塊

public class Client {
    public static void main(String[] args) throws InterruptedException {
        JvmThread thread1 = new JvmThread(100);
        JvmThread thread2 = new JvmThread(500);
        thread1.start();        thread2.start();    }}class JvmThread extends Thread{
    private long time;
    public JvmThread() {
    }    public JvmThread(long time) {
        this.time =time;
    }    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"-->創建:"+Jvm.getInstance(time));
    }}/**
 * 單例設計模式
 * 確保一個類只有一個物件
 * 懶漢式  
 * 1、構造器私有化,避免外部直接創建物件
 * 2、宣告一個私有的靜態變數
 * 3、創建一個對外的公共的靜態方法 訪問該變數，如果變數沒有物件，創建該物件
 */
class Jvm {
    //宣告一個私有的靜態變數
    private static Jvm instance =null;
    //構造器私有化,避免外部直接創建物件
    private Jvm(){
    }
    //創建一個對外的公共的靜態方法 訪問該變數，如果變數沒有物件，創建該物件
    public static Jvm getInstance(long time){
        if(null==instance){
            synchronized(Jvm.class){
                if(null==instance ){
                    try {
                        Thread.sleep(time); 
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    instance =new Jvm();
                }
            }
        }
        return instance;
    }
    public static Jvm getInstance3(long time){
        synchronized(Jvm.class){
            if(null==instance ){
                try {
                    Thread.sleep(time); 
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                instance =new Jvm();
            }
            return instance;
        }
    }
    
}
復制代碼

五、生產者消費者模式

生產者和消費者問題是執行緒模型中的經典問題：生產者和消費者在同一時間段內共用同一個存盤空間，如下圖所示，生產者向空間里存放資料，而消費者取用資料，如果不加以協調可能會出現以下情況：存盤空間已滿，而生產者占用著它，消費者等著生產者讓出空間從而去除產品，生產者等著消費者消費產品，從而向空間中添加產品，互相等待，從而發生死鎖.

具體實作代碼如下：

/**
 * 生產者
 */
public class ProduceRu implements Runnable {
    private Movie movie;
    public ProduceRu(Movie movie) {
        this.movie = movie;
    }    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            if (0 == i % 2) {
                movie.proTest("向往的生活");
            } else {
                movie.proTest("好聲音");
            }        }    }}/**
 *消費者
 */
public class ConsumeRu implements Runnable {
    private Movie movie;
    public ConsumeRu(Movie movie) {
        this.movie = movie;
    }    @Override
    public void run() {
        for(int i=0;i<10;i++){
            movie.conTest();        }    }}/**
 * 生產者消費者模式共同訪問同一份資源
 * wait() 等等，釋放鎖，sleep()不釋放鎖
 * notify()/notifyAll():喚醒
 */
public class Movie {
    private String pic;
    //flag--->true 生產者生產，消費者等待，生產完后通知消費
    //flag--->false 消費者消費，生產者等待，消費完通知生產
    private boolean flag = true;
    /**
     * 生產者生產，消費者等待，生產完后通知消費
     * @param pic
     */
    public synchronized void proTest(String pic) {
        if (!flag) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("生產了：" + pic);
        this.pic = pic;
        this.notify();
        this.flag = false;
    }
    /**
     * 消費者消費，生產者等待，消費完通知生產
     */
    public synchronized void conTest() {
        if (flag) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("消費者：" + pic);
        this.notifyAll();
        this.flag = true;
    }
}
public class ClientTest {
    public static void main(String[] args) {
        Movie movie=new Movie();
        new Thread(new ProduceRu(movie)).start();
        new Thread(new ConsumeRu(movie)).start();
    }
}
復制代碼

六、任務調度

1.Thread實作方法這是最常見的，創建一個thread，然后讓它在while回圈里一直運行著，通過sleep方法來達到定時任務的效果，這樣可以快速簡單的實作，代碼如下：

public class ThreadTest {
    public static void main(String[] args) {
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println("任務開始了");
                    while (true) {
                        Thread.sleep(1000);
                        System.out.println("hello");
                    }                } catch (InterruptedException e) {
                    e.printStackTrace();                }            }        };        Thread thread = new Thread(runnable);
        thread.start();    }}復制代碼

2.TimeTask實作方法 Thread方法優點就是簡單，但缺少了靈活性，TimeTask實作方法最主要的兩個優點是：可以控制啟動和取消任務的時間、第一次執行任務時可以指定想要delay的時間，實作的程序中Timer用于調度任務，TimeTask用戶具體的實作，是執行緒安全的，代碼如下：

public class TimeTest {
    public static void main(String[] args) {
        Timer timer=new Timer();
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("任務運行開始.......");
            }        },new Date(),1000);
    }}復制代碼

3.ScheduledExecutorService實作方法 ScheduledExecutorService是從Java java.util.concurrent里相比于上兩個方法，它有以下好處：相比于Timer的單執行緒，它是通過執行緒池的方式來執行任務的可以很靈活的去設定第一次執行任務 delay時間具體代碼如下：

方法說明： ScheduledFuture<?> scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit) 創建并執行在給定的初始延遲之后首先啟用的定期動作，隨后在一個執行的終止和下一個執行的開始之間給定的延遲，如果任務的執行遇到例外，則后續的執行被抑制，否則，任務將僅通過取消或終止執行人終止，引數 command - 要執行的任務 initialDelay - 延遲第一次執行的時間（就是第一次指定定時延時多久），代碼里我延時10秒 delay - 一個執行終止與下一個執行的開始之間的延遲 unit - initialDelay和delay引數的時間單位

public class ScheduledExecutorServiceTest {
    public static void main(String[] args) {
        ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(1);
        scheduledExecutorService.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println("任務！！！！");
            }        },10000,1000, TimeUnit.MILLISECONDS);
    }}復制代碼

讀者福利

對于大廠面試，我最后想要強調的一點就是心態真的很重要，是決定你在面試程序中發揮的關鍵，若不能正常發揮，很可能就因為一個小失誤與offer失之交臂，所以一定要重視起來，另外提醒一點，充分復習，是消除你緊張的心理狀態的關鍵，但你復習充分了，自然面試程序中就要有底氣得多，

我這邊為大家準備了近幾年來各大廠的Java面試資料，均可以免費提供，希望大家金九銀十面試順利，拿下自己心儀的offer！

有需要的加我小助手VX“免費獲取”

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/90415.html

標籤：java

上一篇：怎么解決金額準確問題

下一篇：不好！我中了美人計！