Java多執行緒

Process和Thread

程式是指令和資料的有序集合，本身沒有運行的含義，是一個靜態的概念，
行程是執行程式的一次執行程序，他是一個動態的概念，是系統資源分配的單位
一個行程中可以包含若干個執行緒，執行緒是CPU調度和執行的單位

執行緒創建

三種創建方法

繼承Thread類


//創建執行緒方法一：繼承Thread類，重寫run() 方法，呼叫start開啟主執行緒
public class TestThread01 extends Thread{
    @Override
    public void run() {
        //run方法執行緒體
        for (int i = 0; i < 2000; i++) {
            System.out.println("我在看代碼-----" + i);
        }
    }
    public static void main(String[] args) {
        //main執行緒，主執行緒
        //創建一個執行緒物件
        TestThread01 testThread01 = new TestThread01();
        //呼叫start方法開啟多執行緒,子執行緒呼叫run方法，主執行緒和子執行緒并行交替執行
        testThread01.start();
        //testThread01.run(); //主執行緒呼叫run方法，只有主執行緒一條執行路徑

        for (int i = 0; i < 2000; i++) {
            System.out.println("Im" + i);
        }
    }
}

總結：注意，執行緒開啟不一定立即執行，由CPU調度處理

子類繼承Thread類，具備多執行緒能力、
啟動執行緒：子類物件.start()
不推薦使用：避免OOP單繼承局限性

小練習


import org.apache.commons.io.FileUtils;
import java.io.File;
import java.io.IOException;
import java.net.URL;

//練習Thread，實作多執行緒同步下載圖片
public class TestThread02 extends Thread{
    private String url;
    private String name;

    public TestThread02(String url, String name) {
        this.url = url;
        this.name = name;
    }
    @Override
    public void run() {
        WebDownloader webDownloader = new WebDownloader();
        webDownloader.downloadr(url, name);
        System.out.println("下載了：" + name);

    }

    public static void main(String[] args) {
        TestThread02 t1 = new TestThread02("https://img-blog.csdnimg.cn/20201130170256201.png?…3dlaXhpbl80NDE3NjM5Mw==,size_16,color_FFFFFF,t_70", "1.png");
        TestThread02 t2 = new TestThread02("https://img-blog.csdnimg.cn/20201130170221843.png", "2.png");
        TestThread02 t3 = new TestThread02("https://img-blog.csdnimg.cn/20201130170256201.png?…3dlaXhpbl80NDE3NjM5Mw==,size_16,color_FFFFFF,t_70", "3.png");

        t1.start();
        t2.start();
        t3.start();
    }
}
//下載器
class WebDownloader{
    public void downloadr(String url, String name){
        try {
            FileUtils.copyURLToFile(new URL(url), new File(name));
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("IO例外, downloader出現問題");
        }
    }
}

實作Runnable


//創建執行緒方式二：實作Runnable介面，重寫run方法，執行執行緒需要丟入runnable介面實作類，呼叫start方法
public class TestThread03 implements Runnable{
    @Override
    public void run() {
        //run方法執行緒體
        for (int i = 0; i < 2000; i++) {
            System.out.println("我在看代碼-----" + i);
        }
    }

    public static void main(String[] args) {
        //創建runnable 介面的實作類物件
        TestThread03 testThread03 = new TestThread03();

        //創建執行緒物件，通過執行緒物件來開啟執行緒，代理
//        Thread thread = new Thread(testThread03);
//        thread.start();
        new Thread(testThread03).start();
        

        for (int i = 0; i < 1000; i++) {
            System.out.println("Im" + i);
        }
    }
}

總結：

實作介面Runnable具備多執行緒能力
啟動執行緒：傳入目標物件+Thread物件.start()
推薦使用：避免單繼承局限性，靈活方便，方便同一個物件被執行緒使用

出現的問題

多個執行緒操作操作同一個資源的情況下，執行緒不安全，資料紊亂


//多個執行緒同時操作同一個物件
//買火車票的例子

//發現問題：多個執行緒操作操作同一個資源的情況下，執行緒不安全，資料紊亂
public class TestThread04 implements Runnable {

    //票數
    private int ticketNums = 10;

    @Override
    public void run() {
        while (true) {
            if (ticketNums <= 0) {
                break;
            }
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "拿到了第" + ticketNums-- + "票");
        }
    }

    public static void main(String[] args) {
        TestThread04 testThread04 = new TestThread04();

        new Thread(testThread04, "老師").start();
        new Thread(testThread04, "黃牛").start();
        new Thread(testThread04, "小明").start();
    }
}

實作Callable介面

1、實作Callable介面，需要回傳值型別

2、重寫call方法，需要拋出例外

3、創建目標物件

4、創建執行服務：ExecutorService ser = Executors.newFixedThreadPool(3);(使用了執行緒池)

5、提交執行：Future r1 = ser.submit(t1);

6、獲取結果：boolean res1 = r1.get();

7、關閉服務：ser.shutdown();


import org.apache.commons.io.FileUtils;
import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.util.concurrent.*;

//執行緒創建方式三：實作Callable介面(了解即可)
// 實作Callable介面
public class TestCallable implements Callable<Boolean> {

    private String url;
    private String name;

    public TestCallable(String url, String name) {
        this.url = url;
        this.name = name;
    }
    @Override
    public Boolean call() {
        WebDownloader1 webDownloader1 = new WebDownloader1();
        webDownloader1.downloadr(url, name);
        System.out.println("下載了：" + name);
        return true;

    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        TestCallable t1 = new TestCallable("https://img-blog.csdnimg.cn/20201130170256201.png?…3dlaXhpbl80NDE3NjM5Mw==,size_16,color_FFFFFF,t_70", "1.png");
        TestCallable t2 = new TestCallable("https://img-blog.csdnimg.cn/20201130170221843.png", "2.png");
        TestCallable t3 = new TestCallable("https://img-blog.csdnimg.cn/20201130170256201.png?…3dlaXhpbl80NDE3NjM5Mw==,size_16,color_FFFFFF,t_70", "3.png");

        //1、創建執行服務()    執行緒池
        ExecutorService ser = Executors.newFixedThreadPool(3);
        //2、提交執行
        Future<Boolean> r1 = ser.submit(t1);
        Future<Boolean> r2 = ser.submit(t2);
        Future<Boolean> r3 = ser.submit(t3);

        //3、獲取結果
        boolean res1 = r1.get();
        boolean res2 = r2.get();
        boolean res3 = r3.get();

        //4、關閉服務
        ser.shutdown();

    }

}
//下載器
class WebDownloader1{
    public void downloadr(String url, String name){
        try {
            FileUtils.copyURLToFile(new URL(url), new File(name));
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("IO例外, downloader出現問題");
        }
    }
}

Lambda運算式

為什么要使用lamba運算式

避免匿名內部類定義過多

可以讓代碼看起來更整潔

去掉了一堆沒有意義的代碼，只留下核心邏輯

示例


/**
 * 推導lambda運算式
 */

public class TestLambda01 {

    //3、靜態內部類
    static class Like2 implements ILike {

        @Override
        public void lambda() {
            System.out.println("I like lambda2");
        }
    }

    public static void main(String[] args) {
        ILike like = new Like();
        like.lambda();

        like = new Like2();
        like.lambda();

        //4、區域內部類
        class Like3 implements ILike {
            @Override
            public void lambda() {
                System.out.println("I like lambda3");
            }
        }
        like = new Like3();
        like.lambda();

        //5、匿名內部類
        like = new ILike() {
            @Override
            public void lambda() {
                System.out.println("I like lambda4");
            }
        };
        like.lambda();

        //6、用lambda簡化 jdk1.8特性
        like = ()->{
            System.out.println("I like lambda5");
        };
        like.lambda();

    }
}

//1、定義一個函式式介面----必須有
interface ILike {
    void lambda();
}

//2、實作類
class Like implements ILike {

    @Override
    public void lambda() {
        System.out.println("I like lambda");
    }
}

對于lambda運算式的簡化


public class TestLambda02 {

    public static void main(String[] args) {
        //標準格式
//        ILove love = (int a)->{
//                System.out.println("I Love you " + a);
//        };
        //簡化1   去掉引數型別，多個不同型別的引數也可以直接去掉
        ILove love = (a) -> {
            System.out.println("I love you " + a);
        };
        //簡化2   去掉括號    -->僅單引數
        love = a->{
            System.out.println("I love you " + a);
        };
        //簡化3   去掉花括號  --> 僅lambda運算式有一行時才可
        love = a -> System.out.println("I love you " + a);
        love.love(520);
        //使用lambda運算式僅適用于函式式介面(介面里只有一個函式介面)
    }
}

interface ILove {
    void love(int a);
}

靜態代理


//靜態代理模式：
//真實物件和代理物件都要實作同一個介面
//代理物件要代理真實角色
//好處：
    //代理物件可以做很多真實物件做不了的事
    //真實物件專注做自己的事
public class StaticProxy {
    public static void main(String[] args) {
        You you = new You();

        new Thread(	() -> System.out.println("I Love You")).start();
        new WeddingCompany(new You()). HappyMarry();
        
        
    }
}

interface Marry {
    void HappyMarry();

}
// 真實物件
class You implements Marry {
    @Override
    public void HappyMarry() {
        System.out.println("Happy");
    }
}

// 代理
class WeddingCompany implements Marry {
    //代理誰->真實目標角色
    private Marry target;

    public WeddingCompany(Marry target) {
        this.target = target;
    }

    @Override
    public void HappyMarry() {
        before();
        this.target.HappyMarry();
        after();
    }

    private void after() {
        System.out.println("后");
    }

    private void before() {
        System.out.println("前");
    }
}

執行緒狀態

方法	說明
setPriority(int newPriority)	更改執行緒的優先級
static void sleep(long millis)	在指定的毫秒數內讓當前正在執行的執行緒休眠
void join()	等待該執行緒終止
static void yield()	暫停當前正在執行的執行緒物件，并執行其他執行緒
void interrupt()	中斷執行緒，別用這個方式
boolean isAlive()	測驗執行緒是否處于某個活動狀態

執行緒終止

不推薦使用JDK提供的stop()、destroy()方法
推薦執行緒自己停止下來
建議使用一個標志位進行終止變數，當flag = false，則終止執行緒運行


//測驗stop
//1、建議執行緒正常停止---->利用次數，不建議死回圈
//2、建議使用標志位----->設定一個標志位
//3、不要使用stop或者destroy等過時或者jdk不推薦的方法
public class TestStop implements Runnable {
    //1、設定一個標志位
    private boolean flag = true;

    @Override
    public void run() {
        int i = 0;
        while (flag) {
            System.out.println("run-----thread" + i++);
        }
    }
    //2、設定一個公開的方法停止執行緒，轉換標志位
    public void stop() {
        this.flag = false;
    }
    public static void main(String[] args) throws InterruptedException {
        TestStop testStop = new TestStop();

        new Thread(testStop).start();

        for (int i = 0; i < 1000; i++) {
            Thread.sleep(1);
            if (i == 900) {
                testStop.stop();

                System.out.println("Stop");
                break;
            }
        }
    }
}

執行緒休眠

sleep(時間) 指定當前執行緒阻塞的毫秒數
sleep存在例外InterruptedException
sleep時間達到后進入就緒狀態
sleep可以模擬網路延時(放大問題的發生性)，倒計時等
每一個物件都有一個鎖，sleep不會釋放鎖


import java.text.SimpleDateFormat;
import java.util.Date;

public class TestSleep2 {
    //模擬倒計時
    public static void tenDown(){
        int num = 10;
        while (num > 0) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(num--);
        }
    }

    public static void main(String[] args) {
        //列印當前時間
        Date startTime = new Date(System.currentTimeMillis());  //獲取時間

        while (true) {
            try {
                Thread.sleep(1000);
                System.out.println(new SimpleDateFormat("HH:MM:SS").format(startTime));
                startTime = new Date(System.currentTimeMillis());//更新時間
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

執行緒禮讓

禮讓執行緒，讓當前正在執行的執行緒停止，但不阻塞
讓執行緒從運行態轉換為就緒態
讓CPU重新進行調度，禮讓不一定成功，看CPU心情


public class TestYield {
    public static void main(String[] args) {
        Myyield myyield = new Myyield();

        new Thread(myyield, "A").start();
        new Thread(myyield, "B").start();
    }
}

class Myyield implements Runnable {

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() +  "執行緒開始");
        Thread.yield();
        System.out.println(Thread.currentThread().getName() +  "執行緒停止");
    }
}

JOIN

JOIN合并執行緒，待此執行緒執行完后，再執行其他執行緒，其他執行緒阻塞
可以想象成插隊


//插隊
public class TestJoin implements Runnable{
    @Override
    public void run() {
        try {
            Thread.sleep(20);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        for (int i = 0; i < 100; i++) {
            System.out.println("VIP" + i);
        }
    }

    public static void main(String[] args) {
        TestJoin testJoin = new TestJoin();
        Thread thread = new Thread(testJoin);
        thread.start();

        for (int i = 0; i < 1000; i++) {
            if (i == 200) {
                try {
                    thread.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("main" + i);
        }
    }
}

執行緒狀態觀測

執行緒狀態，執行緒可以處于以下狀態之一：

NEW
尚未啟動的執行緒處于此狀態，
RUNNABLE
在Java虛擬機中執行的執行緒處于此狀態，
BLOCKED
被阻塞等待監視器鎖定的執行緒處于此狀態，
WAITING
無限期等待另一個執行緒執行特定操作的執行緒處于此狀態，
TIMED_WAITING
正在等待另一個執行緒執行最多指定等待時間的操作的執行緒處于此狀態，
TERMINATED
已退出的執行緒處于此狀態，


//觀測測驗執行緒的狀態
public class TestStatus {

    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(i);
            }
            System.out.println("/////////////");
        });

        //觀察狀態
        Thread.State state = thread.getState();
        System.out.println(state);

        //觀察啟動后
        thread.start();

        state = thread.getState();
        System.out.println(state);

        while (state != Thread.State.TERMINATED) { //只要執行緒不終止，就一直輸出狀態
            try {
                Thread.sleep(100);
                state = thread.getState();
                System.out.println(state);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }


    }
}

執行緒的優先級

Java提供一個執行緒調度器來監控程式中啟動后進入就緒態的所有執行緒，執行緒調度器按照優先級決定應該調度哪個執行緒來執行
執行緒的優先級用數字表示，范圍從1~10
- Thread.MIN_PRIORITY = 1;
- Thread.MAX_PRIORITY = 10;
- Thread.NORM_PRIORITY = 5;
使用以下方法改變或者獲取優先級
- getPriority
- setPriority

優先級低只是意味著獲得調度的概率低，并不是優先級低的就不會呼叫了，這都是看CPU的調度


public class TestPriority extends Thread {

    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName() + "====>" + Thread.currentThread().getPriority());

        MyPriority myPriority = new MyPriority();

        Thread t1 = new Thread(myPriority);
        Thread t2 = new Thread(myPriority);
        Thread t3 = new Thread(myPriority);
        Thread t4 = new Thread(myPriority);
        Thread t5 = new Thread(myPriority);

        t1.start();
        t2.setPriority(1);
        t2.start();
        t3.setPriority(4);
        t3.start();
        t4.setPriority(Thread.MAX_PRIORITY);
        t4.start();
        t5.setPriority(8);
        t5.start();
    }
}

class MyPriority implements Runnable {

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "====>" + Thread.currentThread().getPriority());
    }
}

守護(daemon)執行緒

執行緒分為用戶執行緒和守護執行緒
JVM虛擬機必須確保用戶執行緒執行完畢
JVM虛擬機不用等待守護執行緒執行完畢



public class TestDaemon {
    public static void main(String[] args) {
        God god = new God();
        You you = new You();

        Thread thread = new Thread(god);
        thread.setDaemon(true);//默認式false表示是用戶執行緒，正常的執行緒是用戶執行緒

        thread.start();

        new Thread(you).start();
    }

}

//上帝
class God implements Runnable {

    @Override
    public void run() {
        while (true) {
            System.out.println("god");
        }
    }
}
//你
class You implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 36500; i++) {
            System.out.println("Happy");
        }
        System.out.println("Goodbye world");
    }
}

同步(synchronized)

synchronized

由于我們可以提出private關鍵字來保證資料物件只能被方法訪問，所以我們只需要針對方法提出一套機制，這套機制就是synchronized關鍵字，它包括兩種用法：synchronized方法和synchronized塊，
```
public synchronized void method(){}
```
synchronized方法控制對“物件”的訪問，每個物件對應一把鎖，每個synchronized方法都必須獲得呼叫該方法的物件的鎖才能執行，否則執行緒會阻塞，方法一旦執行，就獨占該鎖，直到該方法回傳才釋放鎖，后面被阻塞的執行緒才能獲得這個鎖，繼續執行

缺陷：若將一個大的方法宣告為synchronized，將會影響效率

同步方法

synchronized方法控制對成員變數或者類屬性物件的訪問，每個物件對應一把鎖，寫法如下：

public synchronized void test(){
    //，，，，
}

如果修飾的是具體物件：鎖的是物件
如果修飾的是成員方法：鎖的是this
如果修飾的是靜態方法：鎖的就是這個物件.class

每個synchronized方法都必須獲得該方法的物件的鎖才能執行，否則所屬的這個執行緒阻塞，方法一旦執行，就獨占該鎖，直到該方法回傳時，鎖釋放，

原程式：

public class Checkout {

    public static void main(String[] args) {
        Account account = new Account(200000, "禮金");
        Drawing you = new Drawing(account, 80000, "你");
        Drawing wife = new Drawing(account, 140000, "your wife");
        you.start();
        wife.start();
    }
}

class Account {
    int money;
    String name;

    public Account(int money, String name) {
        this.money = money;
        this.name = name;
    }
}

class Drawing extends Thread {
    Account account;
    int outMoney;
    int outTotal;

    public Drawing(Account account, int outMoney, String name) {
        super(name);
        this.account = account;
        this.outMoney = outMoney;
    }

    @Override
    public void run() {
        test();
    }

    public void test() {
        if (account.money < outMoney) {
            System.out.println("余額不足");
            return;
        }
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        account.money -= outMoney;
        outTotal += outMoney;
        System.out.println(this.getName() + "-----賬戶余額為：" + account.money);
        System.out.println(this.getName() + "-----總共取到了：" + outTotal);
    }
}

顯然，上面的代碼會出現負數，但是我們不希望它出現負數，

同步方法的寫法代碼，以上面代碼為例，直接在提款機的操作，把run方法或者里面的內容提出來變成test，加上synchronized修飾：

@Override
public void run(){
}
public synchronized void test(){
}

但是這樣仍會發現出現負數，鎖定失敗，

分析：

我們認為在test方法里進行的物件修改，所以把他鎖上就好了，但是，對于這個類，這個提款機來說，test時成員方法，因此鎖的物件實際上是this，也就是提款機(Drawing)，

但是我們的初衷，希望執行緒鎖定的資源是Account物件，而不是提款機物件，

同步塊

除了方法，synchronized還可以修飾塊，叫做同步塊，

synchronized修飾同步塊的方式是：

synchonized (obj){ }

其中的obj可以是任何物件，但是用到它，肯定是設定為那個共享資源，這個obj被稱為同步監視器，同步監視器的作用就是，判斷這個監視器是否被鎖定(是否能訪問)，從而決定其是否能執行其中的代碼，

Java的花括號中內容有一下幾種：

方法里面的塊：區域快，解決變數作用域的問題，快速釋放記憶體(比如方法里面再有個for回圈，里面的變數)
類層的塊：構造塊，初始化資訊，和構造方法是一樣的
類層的靜態塊：靜態構造塊，最早加載，不是物件的資訊，而是類的資訊；
方法里面的同步塊：監視物件，

第四種就是我們目前學習的同步塊，

注意：如果是同步方法里，沒必要指定同步監視器，因為同步方法的監視器已經是this或者.class

使用同步塊對提款機問題進行修改：

public void test(){
    synchronized(account){
        
    }
}

也就是加上對account的監視器，鎖住了這個物件，這樣運行結果就正確了，

這種做法的效率不高，因為雖然對account上了鎖，但是每一次都要把整個流程走一遍，方法體內的內容是很多的，另外，每次加鎖與否，都是對性能的消耗，進入之后再出來，哪怕什么都不做，也是消耗，

其實，我們可以在加鎖的外面再加一重判斷，那么之后就沒有必要再進行鎖的程序了，

public void test(){
    if (account.money == 0){
        return;
    }
    synchronized(account){
    }
}

就是這樣的代碼，在并發量很高的時候，往往可以大大提高效率，

問題

synchronized塊太小，可能鎖不住，安全性又太低了，鎖的方法太大，又會降低效率，所以要很注意控制范圍

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

標籤：Java

上一篇：Spring-IOC學習筆記

下一篇：==與equals的區別(全網最詳細

Java多執行緒學習隨記