java多執行緒學習二

阿新 • • 發佈：2021-10-20

執行緒學習二

lambda表示式

(params) ->expression[表示式]

(params) ->statement[表示式]

(params) ->{statement}

為什麼使用lambda表示式

避免匿名內部類定義過多
可以使程式碼更簡潔
去掉一堆沒有意義的程式碼，只留下最核心的邏輯

lambda表達：

package lineProxy;

public class TestLambda2 {
    public static void main(String[] args) {
        Iter iter =null;
        //使用lambda表示式
        iter = (int a)->{
            System.out.println("lambda"+a);
        };
        //不建議簡化
        //只有在lambda表示式只有一行的情況下才可簡化為一行即去掉{}，如果有多行，那麼就有{}程式碼塊包裹。
        //前提是介面是函式式介面（介面中只有一個函式）
        //多個引數也可以去掉引數型別，引數型別相同，要去掉都去掉，必須加上（）
        //簡化： 去引數型別，去（），去{}
        iter = a -> System.out.println("lambda"+a);
        iter.ite(20);
        
        
    }

}
//先定義一個函式式介面
interface Iter{
    void ite(int a);
}

lambda表示式與其他程式碼優化的比較：

package lineProxy;

/*
推導lambda表示式
*/
public class TestLambda {

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

        @Override
        public void lambda() {
            System.out.println("lambda231");
        }
    }
    public static void main(String[] args) {
        Like like = new Like();
        like.lambda();

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


        //4.區域性內部類
        class Like3 implements ILike{

            @Override
            public void lambda() {
                System.out.println("lambda3");
            }
        }
        Like3 like3 = new Like3();
        like3.lambda();



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

        iLike.lambda();



        //6.lambda簡化
        ILike iLike1 =()->{
            System.out.println("lambda5");
        };
        iLike1.lambda();

    }
}
//1.定義一個函式式介面
interface ILike{
    void lambda();
}

//2.實現類
class Like implements ILike{

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

執行緒狀態

停止執行緒

不推薦使用JDK提供的stop()、destroy()方法。（已廢棄）
推薦執行緒自我停止
或者使用一個標誌位進行終止變數，例如當flag=false，則停止執行緒執行。

package state;

//測試stop
//1.建議執行緒正常停止，利用次數，不建議死迴圈
//2.建議使用標誌位，設定一個標誌
//3.不要使用stop或者destroy等已經過時的方法JDK不建議使用的方法
public class TestStop implements Runnable{

    //設定一個標誌
    private boolean flag=true;
    @Override
    public void run() {
        int i=0;
        while (flag){
            System.out.println("執行緒執行中"+ i++);
        }
    }

    //設定一個方法停止執行緒，轉換標誌
    public void stop(){
        this.flag =false;
    }

    public static void main(String[] args) {
        TestStop testStop = new TestStop();
        new Thread(testStop).start();

        for (int i = 0; i < 100; i++) {
            if (i==90){
                testStop.stop();
                System.out.println("執行緒stop");
            }
        }
    }
}

執行緒休眠_seelp

sleep（時間）指定當前執行緒阻塞的毫秒數
sleep存在異常InterruptedException
sleep時間達到後執行緒進入就緒狀態
sleep可以模擬網路延時，倒計時等
每個物件都有一個鎖，sleep不會釋放鎖

模擬網路延時

package state;


//模擬網路延時：放大問題的發生性
public class TestSleep implements Runnable{

    //票的總數
    private int ticketNums=10;

    @Override//重寫run
    public void run() {
        while (true){
            if (ticketNums<=0){//設定為==0會有意外驚喜
                break;
            }
            //模擬延時
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            //輸出新建代理的 name 與票的數量 票數自減
            System.out.println(Thread.currentThread().getName()+"拿到了"+ticketNums--);
        }
    }


    public static void main(String[] args) {
        TestSleep testSleep = new TestSleep();

        //新建代理
        new Thread(testSleep,"name1").start();
        new Thread(testSleep,"name2").start();
        new Thread(testSleep,"name3").start();
        //多個執行緒操作同一個資源的情況之下，執行緒不安全，資料紊亂。
    }
}

模擬倒計時與列印系統時間

package state;

import org.omg.CORBA.INTERNAL;

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

public class TestSleep2 {
    public static void main(String[] args) throws InterruptedException {

        //tenDown();
        //列印當前系統時間
        Date date = new Date(System.currentTimeMillis());//列印當前系統時間
        int i=0;
        while (true){
            i++;
            Thread.sleep(1000);
            System.out.println(new SimpleDateFormat("HH:mm:ss").format(date));
            date =new Date(System.currentTimeMillis());//更新系統時間
            if (i==10){
                break;
            }
        }
    }


    //模擬倒計時
    public static void tenDown() throws InterruptedException {
        int ten=10;
        while (true){
            Thread.sleep(1000);
            System.out.println(ten--);
            if (ten==0){
                break;
            }
        }
    }
}

執行緒禮讓_yield

禮讓執行緒，讓當前正在執行的執行緒暫停，但不阻塞
將執行緒從執行狀態轉為就緒狀態
禮讓後還是任cpu重新排程，所以禮讓不一定成功。

package state;

//禮讓不一定成功，看cpu心情
public class TestYield {

    public static void main(String[] args) {
        MyYield myYield = new MyYield();

        new Thread(myYield,"xianc1").start();
        new Thread(myYield,"xianc2").start();
    }
}

class MyYield implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"start");
        Thread.yield();//設定禮讓
        System.out.println(Thread.currentThread().getName()+"stop");
    }
}

禮讓不一定成功，同一程式碼可能多次執行結果不同

執行緒強制執行_join

join合併執行緒，待此執行緒執行完成後，在執行其他執行緒，其他執行緒阻塞

package state;

//join可以理解為插隊
public class TestJoin implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("插隊執行join"+i);
        }
    }

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

        thread.start();

        //主執行緒
        for (int i = 0; i < 100; i++) {
            if (i==50){
                thread.join();
            }
            System.out.println("main"+i);
        }
    }
}