JAVA 学習ノート - マルチスレッド

1. 基本的な考え方

タスク
プロセス
- オペレーティングシステムで実行されるプログラムはプロセスであり、プロセスはプログラムの実行プロセスであり、システムリソース割り当ての動的な概念単位です。
- 通常、プロセスには複数のスレッドを含めることができます。もちろん、プロセス内に少なくとも 1 つのスレッドが存在します。そうでなければ存在の意味がありません。スレッドは、CPU のスケジューリングと実行の単位です。
糸
- スレッドは独立した実行パスです
- プログラムの実行中は、自分でスレッドを作成しなくても、バックグラウンドでメインスレッドや GC スレッドなどの複数のスレッドが存在します。
- main() はメインスレッドと呼ばれ、システムのエントリポイントであり、プログラム全体を実行するために使用されます。
- プロセス内で複数のスレッドが開かれている場合、スレッドの実行はスケジューラによってスケジュールされますが、スケジューラはオペレーティングシステムと密接に関係しており、人間がその順序に干渉することはできません。
- 同じリソースを操作する場合、リソースの取得の問題が発生するため、同時実行制御を追加する必要があります。
- スレッドにより、CPU スケジューリング時間や同時実行制御のオーバーヘッドなど、追加のオーバーヘッドが発生します。
- 各スレッドは独自の作業メモリ内で対話するため、メモリ制御が不適切だとデータの不整合が発生します。

2. スレッドの作成

2.1 Threadクラスの継承（ポイント）

カスタムスレッドクラス、Threadクラスを継承
run() メソッドを書き換えて、スレッドの実行本体を書き込みます。
main 関数でスレッドオブジェクトを作成し、start() メソッドを呼び出してスレッドを開始します。

注: スレッドは開始してもすぐに実行されない場合がありますが、CPU によって実行されるようにスケジュールされています。

//创建线程方式一：继承Thread类，重写run方法，调用start开启线程
public class TestThread extends Thread {
    
    
    @Override
    public void run() {
    
    
        //run方法线程方法体
        for (int i = 0; i < 20; i++) {
    
    
            System.out.println("我在看代码----" + i);
        }
    }

    public static void main(String[] args) {
    
    
        //创建一个线程对象
        TestThread testThread = new TestThread();
        //调用start()方法开启线程
        testThread.start();
        //main线程，主线程
        for (int i = 0; i < 200; i++) {
    
    
            System.out.println("我在学习多线程----" + i);
        }
    }
}

事例：画像ダウンロード

//练习Thread,实现多线程同步下载图片
public class TestThread2 extends Thread{
    
    
    private String url; //网络图片地址
    private String name; //保存的文件名
    public TestThread2(String url,String name){
    
    
        this.url = url;
        this.name = name;
    }

    @Override
    public void run() {
    
    
        WebDownloader webDownloader = new WebDownloader();
        webDownloader.downloader(url,name);
        System.out.println("下载了文件名为："+name);
    }

    public static void main(String[] args) {
    
    
        TestThread2 t1 = new TestThread2("https://www.baidu.com/img/bdlogo.png","baidu1.jpg");
        TestThread2 t2 = new TestThread2("https://www.baidu.com/img/bdlogo.png","baidu2.jpg");
        TestThread2 t3 = new TestThread2("https://www.baidu.com/img/bdlogo.png","baidu3.jpg");

        t1.start();
        t2.start();
        t3.start();
    }
}
class WebDownloader{
    
    
    //下载方法
    public void downloader(String url,String name){
    
    
        try {
    
    
            FileUtils.copyURLToFile(new URL(url),new File(name));
        } catch (IOException e) {
    
    
            e.printStackTrace();
            System.out.println("IO异常，downloader方法出现问题");
        }
    }
}

2.2 Runnableインターフェイスの実装（重要なポイント）

カスタムスレッドクラス、Runnable インターフェイスを実装
run() メソッドを書き換えて、スレッドの実行本体を書き込みます。
実行スレッドは、実行可能インターフェイス実装クラスにスローされ、start() メソッドを呼び出す必要があります。

//创建线程方式2：实现runnable接口，重写run方法，执行线程需要丢入runnable接口实现类，调用start方法
public class TestThread3 implements Runnable{
    
    
    @Override
    public void run() {
    
    
        //run方法线程方法体
        for (int i = 0; i < 20; i++) {
    
    
            System.out.println("我在看代码----" + i);
        }
    }

    public static void main(String[] args) {
    
    
        //创建一个runnable接口的实现类对象
        TestThread3 testThread3 = new TestThread3();
        //创建线程对象，通过线程对象来开启我们的线程，代理
        //Thread thread = new Thread(testThread3);
        //thread.start();
        //调用start()方法开启线程
        new Thread(testThread3).start();
        //main线程，主线程
        for (int i = 0; i < 200; i++) {
    
    
            System.out.println("我在学习多线程----" + i);
        }
    }
}

上記 2 つの方法の比較:

Threadクラスを継承する

サブクラスは Thread クラスを継承し、マルチスレッド機能を備えています。
スレッドの開始: サブクラス object.start()
非推奨: OOP 単一継承の制限を回避する
Runnableインターフェイスを実装する

Runnableインターフェイスを実装する

マルチスレッド機能を備えています
スレッドを開始します: ターゲットオブジェクト + Thread object.start() を渡します。
- 新しいスレッド(オブジェクト).start();
推奨される使用法: 単一継承の制限を回避し、複数のスレッドによる同じオブジェクトの使用を容易にします。

同時実行の問題

//多个线程同时操作同一个对象
//买火车票的例子
//发现问题：多个线程操作同一个资源的情况下，线程不安全，数据紊乱
public class TestThread4 implements Runnable{
    
    
    //票数
    private int ticketNums = 10;
    @Override
    public void run() {
    
    
        while (true){
    
    
            if(ticketNums<=0){
    
    
                break;
            }
            //模拟延时
            /*try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }*/
            System.out.println(Thread.currentThread().getName()+"拿到了第"+ticketNums--+"张票");
        }
    }

    public static void main(String[] args) {
    
    
        TestThread4 testThread4 = new TestThread4();
        new Thread(testThread4,"张三").start();
        new Thread(testThread4,"李四").start();
        new Thread(testThread4,"王五").start();
    }
}

ケース: ウサギとカメ

まずはトラックの距離を設定して、どんどんゴールラインに近づいていきましょう
ゲームが終了したかどうかを判断する
勝者を印刷する
ウサギとカメが始まります
物語では亀が勝ち、ウサギは寝る必要があるので、ウサギが寝ている様子をシミュレートします。
ついにカメがレースに勝ちました

//模拟龟兔赛跑
public class Race implements Runnable {
    
    

    //胜利者
    private static String winner;

    @Override
    public void run() {
    
    
        for (int i = 0; i <= 100; i++) {
    
    
            //模拟兔子休息
            if(Thread.currentThread().getName().equals("兔子")&&i%10==0){
    
    
                try {
    
    
                    Thread.sleep(1);
                } catch (InterruptedException e) {
    
    
                    e.printStackTrace();
                }
            }
            //判断比赛是否结束
            boolean flag = gameOver(i);
            //如果比赛结束，就停止程序
            if (flag) {
    
    
                break;
            }
            System.out.println(Thread.currentThread().getName() + "-->跑了" + i + "步");
        }
    }

    //判断是否完成比赛
    private boolean gameOver(int steps) {
    
    
        //判断是否有胜利者
        if (winner != null) {
    
    //已经存在胜利者了
            return true;
        }
        {
    
    
            if (steps >= 100) {
    
    
                winner = Thread.currentThread().getName();
                System.out.println("胜利者是" + winner);
                return true;
            }
        }
        return false;
    }

    public static void main(String[] args) {
    
    
        Race race = new Race();
        new Thread(race, "兔子").start();
        new Thread(race, "乌龟").start();
    }
}

2.3 Callable インターフェースの実装 (理解)

Callable インターフェイスを実装し、call メソッドをオーバーライドします。

Callable インターフェイスの実装には戻り値の型が必要です
呼び出しメソッドをオーバーライドし、例外をスローする必要がある
ターゲットオブジェクトの作成
実行サービスを作成します: ExecutorService = Executor.newFixedThreadPool(1);
送信実行: 将来の結果 1 = ser.submit(1);
結果を取得します: boolean r1 = result.get()
サービスをシャットダウンします: ser.shutdownNow():

アドバンテージ：

戻り値を定義できる
例外をスローできる

//线程创建方式3，实现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() {
    
    
        WebDownloader webDownloader = new WebDownloader();
        webDownloader.downloader(url, name);
        System.out.println("下载了文件名为：" + name);
        return true;
    }

    public static void main(String[] args) throws Exception{
    
    
        TestCallable t1 = new TestCallable("https://www.baidu.com/img/bdlogo.png", "baidu1.jpg");
        TestCallable t2 = new TestCallable("https://www.baidu.com/img/bdlogo.png", "baidu2.jpg");
        TestCallable t3 = new TestCallable("https://www.baidu.com/img/bdlogo.png", "baidu3.jpg");

        //创建执行服务
        ExecutorService ser = Executors.newFixedThreadPool(3);
        //提交执行
        Future<Boolean> r1 = ser.submit(t1);
        Future<Boolean> r2 = ser.submit(t2);
        Future<Boolean> r3 = ser.submit(t3);

        //获取结果
        boolean rs1 = r1.get();
        boolean rs2 = r2.get();
        boolean rs3 = r3.get();
        System.out.println(rs1);
        System.out.println(rs2);
        System.out.println(rs3);

        //关闭服务
        ser.shutdown();
    }
}

//下载器
class WebDownloader {
    
    
    //下载方法
    public void downloader(String url, String name) {
    
    
        try {
    
    
            FileUtils.copyURLToFile(new URL(url), new File(name));
        } catch (IOException e) {
    
    
            e.printStackTrace();
            System.out.println("IO异常，downloader方法出现问题");
        }
    }
}

2.4 ラムダ式

λ ギリシャ語アルファベットの11番目の文字、英語名はLamdaです。
匿名の内部クラス定義が多すぎることを避ける
その本質は関数型プログラミングの概念に属します
無意味なコードの束を削除し、コアロジックだけを残しました

(paraems) -> expressionp[表达式]
(params) -> statement[语句]
(params) -> {
    
    statements}
a->System.out.println("i like lamda-->"+a);
new Thread(()->System.out.println("多线程学习...")).start();

関数インターフェースを理解することがJava 8 ラムダ式を学習する鍵です

機能インターフェイスの定義:

抽象メソッドを 1 つだけ含むインターフェイスは関数型インターフェイスです。

public interface Runnable{
    
    
    public abstract void run();
}

関数型インターフェイスの場合、インターフェイスのオブジェクトはラムダ式を通じて作成できます。

/*
 * 推导lambda表达式
 */
public class TestLambda1 {
    
    

    //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简化
        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");
    }
}

2.5 静的プロキシ

ケース: 静的プロキシとスレッドの実装

要約:

実オブジェクトとプロキシオブジェクトの両方が同じインターフェイスを実装する必要があります
プロキシオブジェクトは実際の役割を表す必要があります

アドバンテージ：

プロキシオブジェクトは、実際のオブジェクトではできない多くのことを実行できます。
現実のオブジェクトは独自の動作に重点を置いています

public class StaticProxy {
    
    
    public static void main(String[] args) {
    
    
      	//You you = new You();//你要结婚
   
        WeddingCompany weddingCompany = new WeddingCompany(new You());
        weddingCompany.HappyMarry();
    }
}
interface Marry{
    
    

    void HappyMarry();
}
//真实角色，你去结婚
class You implements Marry{
    
    
    @Override
    public void HappyMarry() {
    
    
        System.out.println("结婚了，超开心！");
    }
}
//代理角色，帮助你结婚
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("结婚之前，布置现场");
    }
}

パラメータのあるケース

概要:

ラムダ式はコードが 1 行の場合のみ 1 行に簡略化できますが、複数行の場合はコードブロックで囲むことができます。
前提条件は、インターフェイスが機能的なインターフェイスであることです。
複数のパラメータのパラメータタイプを削除することもできます。削除する場合は、かっこを追加する必要があります。

public class TestLambda2 {
    
    
    //3. 静态内部类
    static class Love implements ILove {
    
    
        @Override
        public void love(int a) {
    
    
            System.out.println("i love you -->" + a);
        }
    }

    public static void main(String[] args) {
    
    
        //4. 局部内部类
        class Love implements ILove {
    
    
            @Override
            public void love(int a) {
    
    
                System.out.println("i love you -->" + a);
            }
        }
        ILove love = new Love();
        love.love(2);
        //5. 匿名内部类 没有类的名称，必须借助接口或者父类
        love = new ILove() {
    
    
            @Override
            public void love(int a) {
    
    
                System.out.println("i love you -->" + a);
            }
        };
        //6. lambda简化
        love = (int a) -> {
    
    
            System.out.println("i love you -->" + a);
        };
        love.love(10);
        //6.1 简化1 去掉参数类型
        love = (a) -> {
    
    
            System.out.println("i love you -->" + a);
        };
        love.love(12);

        //6.2 简化2 简化括号
        love = a -> {
    
    
            System.out.println("i love you -->" + a);
        };
        love.love(520);

        //6.3 简化3 去化花括号
        love = a -> System.out.println("i love you -->" + a);
        love.love(521);
        
    }
}

//1. 定义一个函数式接口
interface ILove {
    
    
    void love(int a);
}

//2. 实现类
class Love implements ILove {
    
    
    @Override
    public void love(int a) {
    
    
        System.out.println("i love you -->" + a);
    }
}

スレッドのステータス

主要な 5 つの州:

ステータスの作成
準備完了状態
ブロッキング状態
稼働状況
死の状態

3.1. スレッドのいくつかの一般的なメソッド

方法	説明する
setPriority(int 新しい優先度)	スレッドの優先順位を変更する
静的ボイドスリープ(長いミリ)	現在実行中のスレッド本体を指定されたミリ秒間スリープします。
ボイド結合()	スレッドが終了するまで待ちます
静的 void yield()	現在実行中のスレッドオブジェクトを一時停止し、他のスレッドを実行します。
ボイド割り込み()	スレッドを中断します。この方法は使用しないでください
ブール値 isAlive()	スレッドがアクティブかどうかをテストする

3.2. スレッドを停止する方法

JDK が提供する stop () メソッドと destroy () メソッドを使用することはお勧めできません。[非推奨]
スレッド自体を停止することをお勧めします
変数の終了にはフラグビットを使用することをお勧めします。 flag == false の場合、スレッドは終了します。

//测试Stop
//1. 建议线程正常停止->利用次数，不建议死循环
//2. 建议使用标志位->设置一个标志位
//3. 不要使用stop或者destory等过时或者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) {
    
    
        TestStop testStop = new TestStop();
        new Thread(testStop).start();
        for(int i=0;i<1000;i++){
    
    
            System.out.println("main"+i);
            if(i==900){
    
    
                //调用stop方法，切换标志位，让线程停止
                testStop.stop();
                System.out.println("线程停止了");
            }
        }
    }
}

3.3. スレッド sleep-sleep()

sleep (time) は、現在のスレッドがブロックされる時間をミリ秒単位で指定します。
スリープ中に例外 InterruptedException が発生しました
スリープ時間に達すると、スレッドは準備完了状態になります。
sleep はネットワーク遅延、カウントダウンなどをシミュレートできます。
各スリープオブジェクトにはロックがあり、スリープしてもロックは解除されません。

//模拟网络延时:放大问题的发生性
public class TestSleep 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) {
    
    
        TestSleep ticket = new TestSleep();
        new Thread(ticket, "张三").start();
        new Thread(ticket, "李四").start();
        new Thread(ticket, "王五").start();
    }
}

//模拟倒计时
public class TestSleep2 {
    
    
    public static void main(String[] args) {
    
    
        try {
    
    
            tenDown();
        } catch (InterruptedException e) {
    
    
            e.printStackTrace();
        }
        //打印当前系统时间
        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();
            }

        }
    }
    public static void tenDown() throws InterruptedException {
    
    
        int num = 10;
        while(true){
    
    
            Thread.sleep(1000);
            System.out.println(num--);
            if(num<=0){
    
    
                break;
            }
        }
    }
}

3.3. スレッドの厚意 - yield()

ポライトスレッド。現在実行中のスレッドは一時停止できますが、ブロックはできません。
スレッドを実行状態から準備完了状態に移行します。
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()+"线程结束执行");
    }
}

3.4. スレッドのマージ—Join()

Join はスレッドをマージします。このスレッドの実行が完了すると、他のスレッドが実行され、他のスレッドはブロックされます。列に並んでジャンプするようなものだと考えてください。

//测试join方法，想象为插队
public class TestJoin implements Runnable {
    
    

    @Override
    public void run() {
    
    
        for (int i = 0; i < 1000; i++) {
    
    
            System.out.println("线程vip来了"+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<500;i++){
    
    
            if(i==200){
    
    
               thread.join();
            }
            System.out.println("main"+i);
        }
    }
}

3.6. スレッド状態の監視

スレッドの状態

スレッドの状態: スレッドは次のいずれかの状態になります。

NEW: まだ開始されていないスレッドはこの状態になります。
RUNNABLE: Java 仮想マシンで実行中のスレッドはこの状態です。
BLOCKED: モニターロックを待ってブロックされているスレッドは、この状態になります。
WAITING: 別のスレッドが特定のアクションを実行するのを待っているスレッドは、この状態になります。
TERMINATED: 終了したスレッドはこの状態です。

スレッドは、特定の時点で 1 つの状態になることができます。これらの状態は、オペレーティングシステムのスレッド状態を反映しない仮想マシンの状態です。

//观测测试线程状态
public class TestState {
    
    
    public static void main(String[] args) throws InterruptedException {
    
    
        Thread thread = new Thread(()->{
    
    
            for(int i=0;i<5;i++){
    
    
                try {
    
    
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
    
    
                    e.printStackTrace();
                }
            }
            System.out.println("--------");
        });

        //观察状态
        Thread.State state = thread.getState();
        System.out.println(state); //New

        //观察启动后
        thread.start();//启动线程
        state = thread.getState();
        System.out.println(state); //Run

        while(state!=Thread.State.TERMINATED){
    
    //只要线程不终止，就一直输出状态
            Thread.sleep(100);
            state = thread.getState();//更新线程状态
            System.out.println(state);//输出状态
        }
    }
}

3.7. スレッドの優先順位

Java には、起動後に準備完了状態になるプログラム内のすべてのスレッドを監視するスレッドスケジューラが用意されており、優先度に基づいてどのスレッドの実行をスケジュールするかを決定します。

スレッドの優先順位は 1 ～ 10 の数値で表されます。
- スレッド.MIN_PRIORITY=1
- スレッド.MAX_PRIORITY=10
- スレッド.NORM_PRIORITY=5
優先度を変更または取得するには、次のメソッドを使用します。
- getPriority().setPriority(int xxx)

start() スケジュールの前に優先度を設定することをお勧めします。

//测试线程的优先级
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);
        Thread t6 = new Thread(myPriority);

        //先设置优先级，再启动
        t1.start();

        t2.setPriority(1);
        t2.start();

        t3.setPriority(4);
        t3.start();

        t4.setPriority(Thread.MAX_PRIORITY);//MAX_PRIORITY = 10
        t4.start();

        t5.setPriority(8);
        t5.start();

        t6.setPriority(7);
        t6.start();
    }
}
class MyPriority implements Runnable{
    
    

    @Override
    public void run() {
    
    
        try {
    
    
            Thread.sleep(1000);
        } catch (InterruptedException e) {
    
    
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());

    }
}

3.8. デーモンスレッド

スレッドはユーザースレッドとデーモンスレッドに分かれています
仮想マシンは、ユーザースレッドが実行を完了したことを確認する必要があります。
仮想マシンは、デーモンスレッドの実行が完了するまで待つ必要はありません。
バックグラウンドでの操作ログの記録やメモリのガベージコレクション待機の監視など。

//测试守护线程
//上帝守护你
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("上帝保佑你");
        }
    }
}

//你
class You implements Runnable{
    
    
    @Override
    public void run() {
    
    
        for(int i=0;i<36500;i++){
    
    
            System.out.println("你一生都很开心的活着");
        }
        System.out.println("--------死了---------------------");
    }
}

3.9. 同時実行性

同じオブジェクトが複数のスレッドで同時に操作される

現実の生活では、「複数の人が同じリソースを使用したい」という問題に遭遇することがあります。たとえば、食堂に食べ物を手に入れるために行列ができている場合、全員が食べたいと考えます。最も自然な解決策は、1 人の列に並ぶことです。一つ。

マルチスレッドの問題に対処する場合、複数のスレッドが同じオブジェクトにアクセスし、一部のスレッドがオブジェクトを変更したい場合、スレッドの同期が必要になります。スレッド同期は実際には待機メカニズムであり、複数のメカニズムに同時にアクセスする必要があります。このオブジェクトのスレッドは、このオブジェクトの待機プールに入ってキューを形成し、前のスレッドがキューを使用し終わるまで待機してから、次のスレッドがキューを使用します。

スレッドセーフを形成するための条件: キューとロック

4. スレッドの同期

同時実行性: 同じオブジェクトが複数のスレッドによって同時に操作されます (チケット取得)
スレッド同期は待機メカニズムです。セカンダリオブジェクトに同時にアクセスする必要がある複数のスレッドは、このオブジェクトの待機プールに入ってキューを形成し、前のスレッドがそのオブジェクトの使用を終了するまで待機してから、次のスレッドがそのオブジェクトを使用できるようになります。

形成条件：キュー＋ロック

同じプロセスの複数のスレッドが同じ記憶領域を共有するため、利便性がもたらされるだけでなく、アクセス競合の問題も引き起こされます。メソッド内でアクセスされる際にデータの正確性を確保するために、アクセス中に同期ロック機構が追加されます。スレッドがオブジェクトの排他ロックを取得し、排他リソースを占有します。他のスレッドは使用後にロックを待機して解放する必要があります。次の問題があります。

1 つのスレッドがロックを保持すると、ロックを必要とする他のすべてのスレッドがハングします。
マルチスレッドの競合下では、ロックのロックと解放によりコンテキストの切り替えやスケジューリングの遅延が増加し、パフォーマンスの問題が発生します。
優先順位の高いスレッドが優先順位の低いスレッドがロックを解放するのを待つと、優先順位の逆転が発生し、パフォーマンスの問題が発生します。

4.1. スレッドの安全でない例

1. 安全でない発券

//不安全的买票
public class UnsafeBuyTicket {
    
    
    public static void main(String[] args) {
    
    
        BuyTicket station = new BuyTicket();
        new Thread(station,"我").start();
        new Thread(station,"美女").start();
        new Thread(station,"黄牛党").start();
    }
}

class BuyTicket implements Runnable{
    
    
    //票数
    private int ticketNums = 10;
    boolean flag = true;
    @Override
    public void run() {
    
    
        //买票
        while(flag){
    
    
            try {
    
    
                buy();
            } catch (InterruptedException e) {
    
    
                e.printStackTrace();
            }
        }
    }
    private void buy() throws InterruptedException {
    
    
        //判断是否有票
        if(ticketNums<=0){
    
    
            flag = false;
            return;
        }
        //模拟延迟
        Thread.sleep(100);
        //买票
        System.out.println(Thread.currentThread().getName()+"买到了第"+ticketNums--+"张票");
    }
}

2. お金を引き出すのは安全ではありません

//取钱线程不安全
//两个人去银行取钱，账户
public class UnsafeBank {
    
    
    public static void main(String[] args) {
    
    
        Account account = new Account(100,"结婚基金");
        Drawing you = new Drawing(account,50,"你");
        Drawing girlfrend = new Drawing(account,100,"女朋友");

        you.start();
        girlfrend.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 drawingMoney;//取了多少钱
    int nowMoney;//剩余多少钱

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

    //取钱
    @Override
    public void run() {
    
    
        //判断有没有钱
        if (account.money - drawingMoney < 0) {
    
    
            System.out.println(Thread.currentThread().getName() + "余额不足");
            return;
        }
        //sleep可以放大问题的发生性
        try {
    
    
            Thread.sleep(1000);
        } catch (InterruptedException e) {
    
    
            e.printStackTrace();
        }
        // 卡内余额 = 余额 – 你取的钱
        account.money = account.money - drawingMoney;
        //你手里的钱
        nowMoney = nowMoney + drawingMoney;

        System.out.println("账户余额：" + account.money);
        //Thread.currentThread().getName() == this.getName()
        System.out.println(this.getName() + "手里的钱" + nowMoney);
    }
}

3. 安全でないコレクション

//线程不安全的集合
public class UnsafeList {
    
    
    public static void main(String[] args) throws InterruptedException {
    
    
        List<String> list = new ArrayList<>();
        for (int i = 0; i < 10000; i++) {
    
    
            new Thread(()->{
    
    
                list.add(Thread.currentThread().getName());
            }).start();
        }
        Thread.sleep(3000);
        System.out.println(list.size());
    }
}

4.2. 同期方法と同期ブロック

private キーワードを使用すると、メソッドによってのみデータオブジェクトにアクセスできるようにできるため、メソッドのメカニズム (synchronized キーワード) を提案するだけで済みます。
同期メソッドと同期ブロックの 2 つのメソッドが含まれます。

synchronized 方法:

public synchronized void method(int args){
    
    }

同期メソッドは、「オブジェクト」へのアクセスを制御します。各オブジェクトはロックに対応します。各同期メソッドは、実行する前にメソッドを呼び出すオブジェクトのロックを取得する必要があります。そうでない場合、スレッドはブロックされます。メソッドが実行されると、メソッドが実行されるまでロックは排他的に占有されますが、メソッドが戻った後でのみロックが解放され、後でブロックされたスレッドがロックを取得して実行を継続できます。
欠点: 大規模なメソッドが同期済みとして宣言されている場合、効率が影響を受けます。

同期ブロック:

同期ブロック: synchronized(Obj){}

Objは同期モニターと呼ばれます

Obj には任意のオブジェクトを指定できますが、共有リソースを同期モニターとして使用することをお勧めします。
同期メソッドの同期モニターはオブジェクトそのもの、またはクラスである this であるため、同期メソッドで同期モニターを指定する必要はありません。
モニターの実行を同期する

最初のスレッドは同期モニターにアクセスしてロックし、その中のコードを実行します。
2 番目のスレッドがアクセスすると、同期モニターがロックされておりアクセスできないことがわかります。
最初のスレッドがアクセスを完了し、同期モニターのロックを解除します。
2 番目のスレッドがアクセスし、同期モニターにロックがないことがわかり、ロックしてアクセスします。

チケットを買う

public class UnsafeBuyTicket {
    
    
    public static void main(String[] args) {
    
    
        BuyTicket station = new BuyTicket();
        new Thread(station,"我").start();
        new Thread(station,"美女").start();
        new Thread(station,"黄牛党").start();
    }
}

class BuyTicket implements Runnable{
    
    
    //票数
    private int ticketNums = 10;
    boolean flag = true;
    @Override
    public void run() {
    
    
        //买票
        while(flag){
    
    
            try {
    
    
                buy();
                //模拟延迟
                Thread.sleep(100);
            } catch (InterruptedException e) {
    
    
                e.printStackTrace();
            }
        }
    }
    //synchronized 同步方法 ，锁的是this
    private synchronized void buy() throws InterruptedException {
    
    
        //判断是否有票
        if(ticketNums<=0){
    
    
            flag = false;
            return;
        }

        //买票
        System.out.println(Thread.currentThread().getName()+"买到了第"+ticketNums--+"张票");
    }
}

お金を引き出す

//取钱线程不安全
//两个人去银行取钱，账户
public class UnsafeBank {
    
    
    public static void main(String[] args) {
    
    
        Account account = new Account(500,"结婚基金");
        Drawing you = new Drawing(account,50,"你");
        Drawing girlfrend = new Drawing(account,100,"女朋友");

        you.start();
        girlfrend.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 drawingMoney;//取了多少钱
    int nowMoney;//剩余多少钱

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

    //取钱
    // synchronized
    @Override
    public void run() {
    
    
        synchronized (account){
    
    
            //判断有没有钱
            if (account.money - drawingMoney < 0) {
    
    
                System.out.println(Thread.currentThread().getName() + "余额不足");
                return;
            }
            //sleep可以放大问题的发生性
            try {
    
    
                Thread.sleep(1000);
            } catch (InterruptedException e) {
    
    
                e.printStackTrace();
            }
            // 卡内余额 = 余额 – 你取的钱
            account.money = account.money - drawingMoney;
            //你手里的钱
            nowMoney = nowMoney + drawingMoney;

            System.out.println("账户余额：" + account.money);
            //Thread.currentThread().getName() == this.getName()
            System.out.println(this.getName() + "手里的钱" + nowMoney);
        }
    }
}

集める

public class UnsafeList {
    
    
    public static void main(String[] args) throws InterruptedException {
    
    
        List<String> list = new ArrayList<>();
        for (int i = 0; i < 10000; i++) {
    
    
            new Thread(()->{
    
    
                synchronized (list){
    
    
                    list.add(Thread.currentThread().getName());
                }
            }).start();
        }
        Thread.sleep(3000);
        System.out.println(list.size());
    }
}

JUC セキュリティタイプのコレクション

**CopyOnWriteArrayList **

//测试JUC安全类型的集合
public class TestJUC {
    
    
    public static void main(String[] args) {
    
    
        CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList();
        for (int i = 0; i < 10000; i++) {
    
    
            new Thread(()->{
    
    
                list.add(Thread.currentThread().getName());
            }).start();
        }
        try {
    
    
            Thread.sleep(3000);
        } catch (InterruptedException e) {
    
    
            throw new RuntimeException(e);
        }
        System.out.println(list.size());
    }
}

4.3. デッドロックとロック

デッドロック:

複数のスレッドはそれぞれ共有リソースを占有し、互いのリソースが他のスレッドによって占有されるのを待ってから実行できるようになります。その結果、2 つ以上のスレッドが互いのリソースの解放を待機し、両方のスレッドが実行を停止する状況が発生します。同期

ブロックが「2 つ以上のオブジェクトのロック」を同時に保持すると、「デッドロック」問題が発生する可能性があります。

デッドロックが発生するために必要な 4 つの条件:

相互に排他的な条件: リソースは一度に 1 つのプロセスによってのみ使用できます。
要求と保持の条件: リソースの要求によりプロセスがブロックされた場合、取得したリソースは保持されます。
非剥奪条件: プロセスによって取得されたリソースは、使い果たされる前に強制的に剥奪することはできません。
循環待機条件: いくつかのプロセスは、リソースに対する先頭から末尾までの循環待機関係を形成します。

上記 4 つの条件のいずれか 1 つ以上が違反されていれば、デッドロックは回避できます。

package com.yuan.Demo04;

//多个线程互相抱着对方需要的资源，然后形成僵持
public class DeadLock {
    
    
    public static void main(String[] args) {
    
    
        Makeup g1 = new Makeup(0, "灰姑娘");
        Makeup g2 = new Makeup(1, "白雪公主");
        g1.start();
        g2.start();
    }
}

//口红
class Lipstick {
    
    

}

//镜子
class Mirror {
    
    

}

class Makeup extends Thread {
    
    
    //需要的资源只有一份，用static来保证只有一份
    static Lipstick lipstick = new Lipstick();
    static Mirror mirror = new Mirror();

    int choice;//选择
    String girlName;//使用化妆品的人

    public Makeup(int choice, String girlName) {
    
    
        this.choice = choice;
        this.girlName = girlName;
    }

    @Override
    public void run() {
    
    
        //化妆
        try {
    
    
            makeup();
        } catch (InterruptedException e) {
    
    
            throw new RuntimeException(e);
        }
    }

    //化妆，互相持有对方的锁，就是需要拿到对方的资源
    private void makeup() throws InterruptedException {
    
    
        if (choice == 0) {
    
    
            synchronized (lipstick) {
    
    //获得口红的锁
                System.out.println(this.girlName + "获得口红的锁");
                Thread.sleep(1000);
            }
            synchronized (mirror) {
    
    //1s钟后 获得镜子的锁
                System.out.println(this.girlName + "获得镜子的锁");
            }
        } else {
    
    
            synchronized (mirror) {
    
    //获得口红的锁
                System.out.println(this.girlName + "获得镜子的锁");
                Thread.sleep(2000);
            }
            synchronized (lipstick) {
    
    //1s钟后 获得镜子的锁
                System.out.println(this.girlName + "获得口红的锁");
            }
        }
    }
}

ロック：

JDK 5.0 以降、Java はより強力なスレッド同期メカニズムを提供します。同期は、同期ロックオブジェクトを明示的に定義することによって実現されます。同期ロックは Lock オブジェクトを次のように使用します。
java.util.concurrent.locks.Lock インターフェースは、共有リソースへの複数のスレッドのアクセスを制御するツールです。ロックは、共有リソースへの排他的アクセスを提供します。一度に 1 つのスレッドのみが Lock オブジェクトをロックできます。スレッドは、共有リソースへのアクセスを開始する前に Lock オブジェクトを取得する必要があります。
ReentrantLock クラスは、synchronized と同じ同時実行性とメモリセマンティクスを備えた Lock を実装します。スレッドセーフな制御の実装では、ReentrantLock の方が一般的に使用され、ロックの表示とロックの解放ができます。

import java.util.concurrent.locks.ReentrantLock;

public class TestLock {
    
    
    public static void main(String[] args) {
    
    
        TestLock2 testLock2 = new TestLock2();
        new Thread(testLock2).start();
        new Thread(testLock2).start();
        new Thread(testLock2).start();
    }
}

class TestLock2 implements Runnable {
    
    
    int ticketNums = 10;
    //定义lock锁
    private final ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
    
    
        while (true) {
    
    
            try {
    
    
                lock.lock();//加锁
                if (ticketNums > 0) {
    
    
                    try {
    
    
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
    
    
                        throw new RuntimeException(e);
                    }
                    System.out.println(ticketNums--);
                } else {
    
    
                    break;
                }
            } finally {
    
    
                //解锁
                lock.unlock();
            }
        }
    }
}

同期とロックの比較:

Lock は明示的なロック (手動でオン/オフ)、synchronized は暗黙的なロックで、範囲外になると自動的に解放されます。
Lock にはコードロックのみがあり、synchronized にはコードブロックロックとメソッドロックがあります。
Lock を使用すると、JVM はスレッドのスケジュールに費やす時間が短縮され、パフォーマンスが向上します。スケーラビリティが向上します (より多くのサブクラスを提供します)
ロック > 同期されたコードブロック (メソッド本体に入り、対応するリソースが割り当てられている) > 同期されたメソッド (メソッド本体の外側)

5. スレッド通信

適用シナリオ: 生産者と消費者の問題

倉庫に保管できる製品は 1 つだけであり、生産者は生産した製品を倉庫に入れ、消費者は消費するために倉庫から製品を持ち出すとします。
倉庫に製品がない場合、生産者は製品を倉庫に入れますが、そうでない場合は生産を停止し、倉庫内の製品が消費者によって引き取られるまで待ちます。
倉庫に製品がある場合、消費者はその製品を持ち帰って消費することができますが、そうでない場合は、製品が再び倉庫に置かれるまで消費は停止します。

これはスレッド同期の問題であり、プロデューサーとコンシューマーは同じリソースを共有しており、プロデューサーとコンシューマーは相互に依存しており、互いに条件付きです。

生産者は、商品を作る前に消費者に「待ってください」と通知し、商品を作ったらすぐに消費者に「消費してください」と通知する必要があります。
消費者にとっては、消費後、消費が終了し、消費のために新しい製品を生産する必要があることを生産者に通知する必要があります。
生産者と消費者の問題では、同期だけでは十分ではありません

**synchronized: **同じ共有リソースの同時更新を防止し、同期を実現できますが、異なるスレッド間のメッセージパッシング (通信) の実装には使用できません

5.1. スレッド通信を解決するためのいくつかの方法

注: これらはすべて Object クラスのメソッドであり、同期メソッドまたは同期コードブロックでのみ使用できます。それ以外の場合は、illegalMonitorStateException がスローされます。

メソッド名	効果
待って（）	他のスレッドから通知されるまで待機することを示し、スリープとは異なりロックが解除されます。
待機(長いタイムアウト)	待機するミリ秒数を指定します
通知()	待機中のスレッドを起動する
すべて通知()	同じオブジェクトの wait() メソッドを呼び出すすべてのスレッドをウェイクアップします。優先度の高いスレッドが最初にスケジュールされます。

5.2. スレッド間の通信の問題を解決する

5.2.1. パイプライン方式

同時書き込みモデル「プロデューサー/コンシューマーモデル」→処理方法

プロデューサー: データの生成を担当するモジュール (メソッド、オブジェクト、スレッド、プロセスなど)
Consumer: データの処理を担当するモジュール (メソッド、オブジェクト、スレッド、プロセスなど)
バッファ: コンシューマはプロデューサのデータを直接使用できません。コンシューマの間にはバッファが存在します。

プロデューサーは生成したデータをバッファに入れ、コンシューマはバッファからデータを取り出します。

//测试：生产者消费者模型->利用缓冲区解决：管程法
//生产者、消费者、产品、缓冲区
public class TestPC {
    
    
    public static void main(String[] args) {
    
    
        SynContainer container = new SynContainer();
        new Productor(container).start();
        new Consumer(container).start();
    }
}

//生产者
class Productor extends Thread {
    
    
    SynContainer container;

    public Productor(SynContainer container) {
    
    
        this.container = container;
    }
    //生产

    @Override
    public void run() {
    
    
        for (int i = 0; i < 100; i++) {
    
    
            container.push(new Chicken(i));
            System.out.println("生产了" + i + "只鸡");
        }
    }
}

//消费者
class Consumer extends Thread {
    
    
    SynContainer container;

    public Consumer(SynContainer container) {
    
    
        this.container = container;
    }
    //消费

    @Override
    public void run() {
    
    
        for (int i = 0; i < 100; i++) {
    
    
            System.out.println("消费了->" + container.pop().id + "只鸡");
        }
    }
}

//产品
class Chicken {
    
    
    int id;//产品编号

    public Chicken(int id) {
    
    
        this.id = id;
    }
}

//缓冲区
class SynContainer {
    
    
    //需要一个容器大小
    Chicken[] chickens = new Chicken[10];
    //容器计数器
    int count = 0;

    //生产者放入产品
    public synchronized void push(Chicken chicken) {
    
    
        //如果容器满了，就需要等待消费者消费产品
        while (count == chickens.length) {
    
    
            //通知消费者消费，生产等待
            try {
    
    
                this.wait();
            } catch (InterruptedException e) {
    
    
                throw new RuntimeException(e);
            }
        }
        //如果没有满，我们需要丢入产品
        chickens[count] = chicken;
        count++;

        //可以通知消费者消费
        this.notifyAll();
    }

    //消费者消费产品
    public synchronized Chicken pop() {
    
    
        //判断能否消费
        while (count == 0) {
    
    
            //等待生产者生产，消费者等待
            try {
    
    
                this.wait();
            } catch (InterruptedException e) {
    
    
                throw new RuntimeException(e);
            }
        }
        //如果可以消费
        count--;
        Chicken chicken = chickens[count];

        //吃完了，通知生产者生产
        this.notifyAll();
        return chicken;
    }
}

5.2.2. 信号灯方式

//测试：生产者消费者模型->利用缓冲区解决：信号灯法
public class TestPC2 {
    
    
    public static void main(String[] args) {
    
    
        TV tv = new TV();
        new Player(tv).start();
        new Watcher(tv).start();
    }
}

//生产者-->演员
class Player extends Thread {
    
    
    TV tv;

    public Player(TV tv) {
    
    
        this.tv = tv;
    }

    @Override
    public void run() {
    
    
        for (int i = 0; i < 20; i++) {
    
    
            if (i % 2 == 0) {
    
    
                this.tv.play("快乐大本营播放中");
            } else {
    
    
                this.tv.play("抖音，记录美好生活");
            }
        }
    }
}

//消费者-->观众
class Watcher extends Thread {
    
    
    TV tv;

    public Watcher(TV tv) {
    
    
        this.tv = tv;
    }

    @Override
    public void run() {
    
    
        for (int i = 0; i < 20; i++) {
    
    
            tv.watch();
        }
    }
}

//产品-->节目
class TV {
    
    
    //演员表演，观众等待 T
    //观众观看，演员等待 F
    String voice;//表演的节目
    boolean flag = true;

    //表演
    public synchronized void play(String voice) {
    
    
        if (!flag) {
    
    
            try {
    
    
                this.wait();
            } catch (InterruptedException e) {
    
    
                throw new RuntimeException(e);
            }
        }
        System.out.println("演员表演了：" + voice);
        //通知观众观看
        this.notifyAll();//通知唤醒
        this.voice = voice;
        this.flag = !this.flag;

    }

    //观看
    public synchronized void watch() {
    
    
        if (flag) {
    
    
            try {
    
    
                this.wait();
            } catch (InterruptedException e) {
    
    
                throw new RuntimeException(e);
            }
        }
        System.out.println("观看了：" + voice);
        //通知演员表演
        this.notifyAll();
        this.flag = !this.flag;
    }
}

5.2.3. スレッドプールの使用

背景: 同時状況のスレッドなど、頻繁に作成および破棄され、特に頻繁に使用されるリソースは、パフォーマンスに大きな影響を与えます。

アイデア: 事前に複数のスレッドを作成し、スレッドプールに入れ、使用時に直接取得し、使用後にプールに戻します。頻繁な作成と破壊を回避し、再利用を実現します。生活における公共交通機関と同じです。

アドバンテージ：

応答性の向上 (新しいスレッドの作成時間の短縮)
リソース消費を削減します (スレッドプール内のスレッドを再利用します。毎回スレッドを作成する必要はありません)。
スレッド管理が容易になります…
1. **corePoolSize:**コアプールのサイズ
2. **maximumPoolSize:** スレッドの最大数
3. **keepAliveTime:** タスクがないときにスレッドが終了するまでに保持できる最大時間
JDK 5.0 は、スレッドプール関連の API を提供します: ExecutorService および Executor
ExecutorServic: 実スレッドプールインターフェイス。共通のサブクラス ThreadPoolExecutor
- voidexecute(Runnable command): タスク/コマンドを実行します。戻り値はありません。通常、Runnable を実行するために使用されます。
- Future submit(Callable task): タスクを実行し、戻り値を持ち、通常は Callable を実行するために使用されます。
- void shutdown(): 接続プールを閉じる
エグゼキュータ: ツールクラス、スレッドプールのファクトリクラス。さまざまなタイプのスレッドプールを作成して返すために使用されます。

6. スレッドの概要

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

//回顾总结县城的创建
public class ThreadNew {
    
    
    public static void main(String[] args) {
    
    
        new MyThread1().start();
        new Thread(new MyThread2()).start();
        FutureTask<Integer> futureTask = new FutureTask(new MyThread3());
        new Thread(futureTask).start();

        try {
    
    
            Integer integer = futureTask.get();
            System.out.println(integer);
        } catch (InterruptedException e) {
    
    
            throw new RuntimeException(e);
        } catch (ExecutionException e) {
    
    
            throw new RuntimeException(e);
        }
    }
}

//1. 继承Thread类
class MyThread1 extends Thread {
    
    
    @Override
    public void run() {
    
    
        System.out.println("MyThread1");
    }
}

//2. 实现Runnable 接口
class MyThread2 implements Runnable{
    
    
    @Override
    public void run() {
    
    
        System.out.println("MyThread2");
    }
}

//3. 实现Callable接口
class MyThread3 implements Callable<Integer>{
    
    

    @Override
    public Integer call() throws Exception {
    
    
        System.out.println("MyThread3");
        return 100;
    }
}