本文已参与「新人创作礼」活动，一起开启掘金创作之路。

1、基本概念

进程
- 在操作系统中运行的程序就是进程，进程就是执行程序的一次执行过程，它是一个动态的概念式系统资源分配的单位
- 通常再一个进程中可以包含若干个线程，当然一个进程中至少有一个线程，不然没有存在的意义，线程是CPU调度和执行的单位
线程
- 线程就是独立的执行路径
- 在程序运行时,即使没有自己创建线程，后台也会有多个线程，比如主线程，GC线程
- main()称之为主线程,为系统的入口，用于执行整个程序
- 在一个进程中,如果开辟了多个线程,线程的运行是由调度器安排调度的，调度器是与操作系统紧密相关的，先后顺序是不能人为干预的
- 对同一份资源操作时，会存在资源抢夺的问题，需要加入并发控制
- 线程会带来额外的开销，如CPU调度时间，并发控制开销
- 每个线程在自己的工作内存交互，内存控制不当会造成数据不一致
多线程
- 多条执行路径，主线程与子线程并行交替执行（普通方法只有主线程一条路径）

2、线程创建

2.1、继承 Thread 类（重点）

Thread API

Class Thread

java.lang.Object
- java.lang.Thread
All Implemented Interfaces:
Runnable
已知直接子类：
ForkJoinWorkerThread

public class Thread
extends Object
implements Runnable

线程是程序中执行的线程。Java虚拟机允许应用程序同时执行多个执行线程。
每个线程都有优先权。具有较高优先级的线程优先于优先级较低的线程执行。每个线程可能也可能不会被标记为守护程序。当在某个线程中运行的代码创建一个新的Thread对象时，新线程的优先级最初设置为等于创建线程的优先级，并且当且仅当创建线程是守护进程时才是守护线程。
当Java虚拟机启动时，通常有一个非守护进程线程（通常调用某些指定类的名为main的方法）。 Java虚拟机将继续执行线程，直到发生以下任一情况：

- 已经调用了Runtime类的exit方法，并且安全管理器已经允许进行退出操作。
- 所有不是守护进程线程的线程都已经死亡，无论是从调用返回到run方法还是抛出超出run方法的run 。

创建一个新的执行线程有两种方法。一个是将一个类声明为Thread的子类。这个子类应该重写run类的方法Thread 。然后可以分配并启动子类的实例。例如，计算大于规定值的素数的线程可以写成如下：

     class PrimeThread extends Thread {
         long minPrime;
         PrimeThread(long minPrime) {
             this.minPrime = minPrime;
         }

         public void run() {
             // compute primes larger than minPrime
              . . .
         }
     }

然后，以下代码将创建一个线程并启动它运行：

     PrimeThread p = new PrimeThread(143);
     p.start();

另一种方法来创建一个线程是声明实现类接口。那个类然后实现了run方法。然后可以分配类的实例，在创建Thread时作为参数传递，并启动。这种其他风格的同一个例子如下所示：

     class PrimeRun implements Runnable {
         long minPrime;
         PrimeRun(long minPrime) {
             this.minPrime = minPrime;
         }

         public void run() {
             // compute primes larger than minPrime
              . . .
         }
     }

然后，以下代码将创建一个线程并启动它运行：

     PrimeRun p = new PrimeRun(143);
     new Thread(p).start();

每个线程都有一个用于识别目的的名称。多个线程可能具有相同的名称。如果在创建线程时未指定名称，则会为其生成一个新名称。
除非另有说明，否则将参数传递给null中的构造函数或方法将导致抛出NullPointerException 。

- 从以下版本开始：
  JDK1.0
- 另请参见：
  Runnable ， Runtime.exit(int) ， run() ， stop()

自定义线程类，继承Thread类
重写run()方法，编写线程执行体
在主函数中创建一个线程对象，调用start()方法开启线程。

案例：

案例1：主线程调用run

package com.mao.demo01;

/**
 * @ClassName TestThread1
 * @Description TODO
 * @Author Huchao
 * @Date 2021/11/7 16:21
 * @Version 1.0
 **/
public class TestThread1 extends Thread {
    @Override
    public void run() {
       // run 方法体线程
        for (int i = 0; i < 10; i++) {
            System.out.println("我在看代码----" + i);
        }
    }

    public static void main(String[] args) {

        // 创建一个线程
        final TestThread1 testThread1 = new TestThread1();

        // start 开启线程
//        testThread1.start();
        testThread1.run();

        // 主线程
        for (int i = 0; i < 200; i++) {
            System.out.println("我在学习多线程----"+i);
        }
    }
}

案例2：主线程调用start

package com.mao.demo01;

/**
 * @ClassName TestThread1
 * @Description TODO
 * @Author Huchao
 * @Date 2021/11/7 16:21
 * @Version 1.0
 **/
public class TestThread1 extends Thread {
    @Override
    public void run() {
       // run 方法体线程
        for (int i = 0; i < 10; i++) {
            System.out.println("我在看代码----" + i);
        }
    }

    public static void main(String[] args) {

        // 创建一个线程
        final TestThread1 testThread1 = new TestThread1();

        // start 开启线程
        testThread1.start();
//        testThread1.run();

        // 主线程
        for (int i = 0; i < 200; i++) {
            System.out.println("我在学习多线程----"+i);
        }
    }
}

总结：线程开启不一定立即执行，由CPU调度执行。

案例：图片下载

package com.mao.demo01;

import org.apache.commons.io.FileUtils;

import java.io.File;
import java.io.IOException;
import java.net.URL;

/**
 * @ClassName TestThread2
 * @Description TODO
 * @Author Huchao
 * @Date 2021/11/8 19:32
 * @Version 1.0
 **/
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() {
//        super.run();
        final webDownloader webDownloader = new webDownloader();
        webDownloader.downloader(url,name);
        System.out.println("下载了文件名为:"+name);
    }

    public static void main(String[] args) {
        final TestThread2 test1 = new TestThread2("https://i0.hdslb.com/bfs/article/f39427eefe8b5c9318b6c9ef99c4108efdf1e747.jpg@1320w_740h.webp","edg1.png");
        final TestThread2 test2 = new TestThread2("https://i0.hdslb.com/bfs/archive/57ab5a6e8b36c227cc13c2cd96270e04b0a253be.png","edg2.png");
        final TestThread2 test3 = new TestThread2("https://i0.hdslb.com/bfs/activity-plat/static/b711c4ecbed559f94155437efb3d8532/j6mFBYivhq_w1920_h658.png","文豪试炼场.png");

        // 实际下载并不是按照顺序执行
        test1.start();
        test2.start();
        test3.start();
    }
}

// 下载器
class webDownloader{
    // 下载方法
    public void downloader(String url,String name){

        try {
            FileUtils.copyURLToFile(new URL(url),new File(name));   // 讲url变成图片
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("IO 异常，downloader方法出现问题");
        }
    }

}

实际下载并未按照顺序执行

2.2、实现Runnable接口（重点）

Runnable接口API

     class PrimeRun implements Runnable {
         long minPrime;
         PrimeRun(long minPrime) {
             this.minPrime = minPrime;
         }

         public void run() {
             // compute primes larger than minPrime
              . . .
         }
     }

然后，以下代码将创建一个线程并启动它运行：

     PrimeRun p = new PrimeRun(143);
     new Thread(p).start();

- 从以下版本开始：
  JDK1.0
- 另请参见：
  Runnable ， Runtime.exit(int) ， run() ， stop()

自定义线程类，实现Runnable接口
重写run()方法，编写线程执行体
执行线程需要丢入runnable接口实现类，调用start()方法。

案例：

package com.nty.test02;

public class TestThread2 implements Runnable {
    @Override
    public void run() {
        //run方法线程方法体
        for (int i = 0; i < 20; i++) {
            System.out.println("我在看代码----" + i);
        }
    }

    public static void main(String[] args) {

        //创建一个线程对象
        TestThread2 testThread2 = new TestThread2();

        //创建线程对象，通过线程对象来开启线程，代理
//        Thread thread = new Thread(testThread2);
//
//        //start开启线程
//        thread.start();
        new Thread(testThread2).start();

        //主线程
        for (int i = 0; i < 200; i++) {
            System.out.println("我在学习多线程-----" + i);
        }
    }
}

以上两种方式的比较：

继承 Thread 类

子类继承 Thread 类具备多线程能力
启动线程：子类对象 .start()
不建议使用：避免 OOP 单继承局限性
实现 Runnable 接口

// Thread 源码探究
public
class Thread implements Runnable {
    /* Make sure registerNatives is the first thing <clinit> does. */
    private static native void registerNatives();
    static {
        registerNatives();
    }

    private volatile String name;
    private int            priority;
    private Thread         threadQ;
    private long           eetop;

    /* Whether or not to single_step this thread. */
    private boolean     single_step;

实现接口 Runnable

具有多线程能力
启动线程：传入目标对象 + Thread对象.start()
推荐使用：避免单继承局限性，方便同一个对象被多个线程使用。

@FunctionalInterface
public interface Runnable {
    /**
     * When an object implementing interface <code>Runnable</code> is used
     * to create a thread, starting the thread causes the object's
     * <code>run</code> method to be called in that separately executing
     * thread.
     * <p>
     * The general contract of the method <code>run</code> is that it may
     * take any action whatsoever.
     *
     * @see     java.lang.Thread#run()
     */
    public abstract void run();
}

初识并发问题——买火车票

package com.mao.demo01;

import com.sun.org.apache.bcel.internal.generic.NEW;

/**
 * @ClassName TestThread
 * @Description TODO
 * @Author HuChao
 * @Date 2021/11/8 20:40
 * @Version 1.0
 **/

// 多个线程同时操作同一个对象
// 买火车票的例子
// 发现问题：多个线程操作同一个资源的情况下，线程不安全，数据紊乱
public class TestThread4 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) {
        final TestThread4 testThread4 = new TestThread4();
        new Thread(testThread4,"超哥").start();
        new Thread(testThread4,"废物凤").start();
        new Thread(testThread4,"黄牛").start();
    }
}

执行结果:

"E:\Program Files\Java\bin\java.exe" "-javaagent:D:\Program Files (x86)\IDEA\IntelliJ IDEA 2020.3.2\lib\idea_rt.jar=60780:D:\Program Files (x86)\IDEA\IntelliJ IDEA 2020.3.2\bin" -Dfile.encoding=UTF-8 -classpath "E:\Program Files\Java\jre\lib\charsets.jar;E:\Program Files\Java\jre\lib\deploy.jar;E:\Program Files\Java\jre\lib\ext\access-bridge-64.jar;E:\Program Files\Java\jre\lib\ext\cldrdata.jar;E:\Program Files\Java\jre\lib\ext\dnsns.jar;E:\Program Files\Java\jre\lib\ext\jaccess.jar;E:\Program Files\Java\jre\lib\ext\jfxrt.jar;E:\Program Files\Java\jre\lib\ext\localedata.jar;E:\Program Files\Java\jre\lib\ext\nashorn.jar;E:\Program Files\Java\jre\lib\ext\sunec.jar;E:\Program Files\Java\jre\lib\ext\sunjce_provider.jar;E:\Program Files\Java\jre\lib\ext\sunmscapi.jar;E:\Program Files\Java\jre\lib\ext\sunpkcs11.jar;E:\Program Files\Java\jre\lib\ext\zipfs.jar;E:\Program Files\Java\jre\lib\javaws.jar;E:\Program Files\Java\jre\lib\jce.jar;E:\Program Files\Java\jre\lib\jfr.jar;E:\Program Files\Java\jre\lib\jfxswt.jar;E:\Program Files\Java\jre\lib\jsse.jar;E:\Program Files\Java\jre\lib\management-agent.jar;E:\Program Files\Java\jre\lib\plugin.jar;E:\Program Files\Java\jre\lib\resources.jar;E:\Program Files\Java\jre\lib\rt.jar;E:\soft\workspace\java\多线程\out\production\多线程;E:\soft\workspace\java\多线程\src\com\lib\commons-io-2.11.0.jar" com.mao.demo01.TestThread4
超哥-->拿到了第10票
废物凤-->拿到了第9票
黄牛-->拿到了第8票
废物凤-->拿到了第7票
黄牛-->拿到了第7票
超哥-->拿到了第7票
超哥-->拿到了第6票
黄牛-->拿到了第5票
废物凤-->拿到了第6票
黄牛-->拿到了第4票
超哥-->拿到了第2票
废物凤-->拿到了第3票
黄牛-->拿到了第1票
超哥-->拿到了第-1票
废物凤-->拿到了第0票

Process finished with exit code 0

发现问题：多个线程操作同一个资源的情况下，线程不安全，数据紊乱

龟兔赛跑问题：

package com.mao.demo01;

/**
 * @ClassName Race
 * @Description TODO
 * @Author HuChao
 * @Date 2021/11/8 21:14
 * @Version 1.0
 **/
public class Race implements Runnable {
    // 胜利者  静态  保证只有一个winner
    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((long) 0.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;    // 比赛结束
        }else {
            if (steps>=100){
                winner=Thread.currentThread().getName();
                System.out.println("winner is"+winner);
                return true;
            }
        }
        return false;
    }

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

2.3、实现Callable接口（了解）

实现Callable接口，重写call方法。

实现 Callable 接口，需要返回值类型
重写 call 方法，需要抛出异常
创建目标对象
创建执行服务：ExecutorService = Executor.newFixedThreadPool(1);
提交执行：Future result1 = ser.submit(1);
获取结果：boolean r1 = result.get()
关闭服务：ser.shutdownNow():

图片下载改写：

package com.mao.demo01;

import org.apache.commons.io.FileUtils;

import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.util.concurrent.*;

/**
 * @ClassName TestCallable
 * @Description TODO
 * @Author Huchao
 * @Date 2021/11/8 22:03
 * @Version 1.0
 **/

// 线程创建方式三：实现 Callable 接口
/*
 * callable 的好处
 * 1.可以定义返回值
 * 2.可以抛出异常
 **/

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 ExecutionException, InterruptedException {
         TestCallable test1 = new TestCallable("https://i0.hdslb.com/bfs/article/f39427eefe8b5c9318b6c9ef99c4108efdf1e747.jpg@1320w_740h.webp","edg1.png");
         TestCallable test2 = new TestCallable("https://i0.hdslb.com/bfs/archive/57ab5a6e8b36c227cc13c2cd96270e04b0a253be.png","edg2.png");
         TestCallable test3 = new TestCallable("https://i0.hdslb.com/bfs/activity-plat/static/b711c4ecbed559f94155437efb3d8532/j6mFBYivhq_w1920_h658.png","文豪试炼场.png");

        //创建执行服务:
        ExecutorService service = Executors.newFixedThreadPool(3);
        //提交执行:
        Future<Boolean> r1 = service.submit(test1);
        Future<Boolean> r2 = service.submit(test2);
        Future<Boolean> r3 = service.submit(test3);
        // 获取结果:
        boolean rs1 = r1.get();
        boolean rs2 = r2.get();
        boolean rs3 = r3.get();
        //关闭服务:
        service.shutdownNow();
    }
}

案例2：

package com.nty.test02;


import java.util.concurrent.*;

public class TestCallable2 implements Callable<Boolean> {
    @Override
    public Boolean call() throws Exception {
        System.out.println("创建成功");
        return true;
    }

    public static void main(String[] args) {
        TestCallable2 callable = new TestCallable2();

        //创建执行服务
        ExecutorService service = Executors.newFixedThreadPool(1);
        //提交执行
        Future<Boolean> result = service.submit(callable);

        try {
            boolean isTrue = result.get();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        service.shutdownNow();
    }
}

2.4、 Lambda表达式

Lambda 表达式属于函数式编程的概念

λ 希腊字母表中排序第十一位的字母，英语名称为 Lamda
避免匿名内部类定义过多
其实质属于函数式编程的概念
去掉了一堆没有意义的代码,只留下核心逻辑

案例：

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

理解 Functional Interface（函数式接口）是学习 Java 8 Lambda 表达式的关键所在
函数式接口的定义：
- 任何接口，如果只包含唯一一个抽象方法，那么它就是函数式接口

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

- 对于函数式接口，可以通过 Lambda 表达式来创建该接口的对象

//1.定义一个函数式接口
interface ILike{
    void like();
}
//6.用lambda简化，-->函数式接口
like = ()->{
System.out.println("i like lambda5");
};

Lambda表达式简化：

/**
 * @ClassName TestLambda1
 * @Description TODO
 * @Author Huchao
 * @Date 2021/11/9 11:59
 * @Version 1.0
 **/
public class TestLambda1 {
    // 3.静态内部类
    static class like3 implements ILike {
        @Override
        public void lambda() {
            System.out.println("3.静态内部类");
        }
    }

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

        final like3 like3 = new like3();
        like3.lambda();

        // 4.局部内部类
        class like4 implements ILike {
            @Override
            public void lambda() {
                System.out.println("4.局部内部类");
            }
        }
        final like4 like4 = new like4();
        like4.lambda();

        // 5.匿名内部类，没有类的名称，必须借助接口或者父类
        like2= new ILike(){
            @Override
            public void lambda() {
                System.out.println("5.匿名内部类，没有类的名称，必须借助接口或者父类");
            }
        };
        like2.lambda();
        // 6.用lambda简化
        like2= ()->{
            System.out.println("6.用lambda简化");
        };
        like2.lambda();

    }
}

// 1.定义一个接口
interface ILike{
    void lambda();      
}

// 2.实现类
class Like implements ILike{
    @Override
    public void lambda() {
        System.out.println("2.实现类");
    }
}

打印结果：

"E:\Program Files\Java\bin\java.exe" "-javaagent:D:\Program Files (x86)\IDEA\IntelliJ IDEA 2020.3.2\lib\idea_rt.jar=53483:D:\Program Files (x86)\IDEA\IntelliJ IDEA 2020.3.2\bin" -Dfile.encoding=UTF-8 -classpath "E:\Program Files\Java\jre\lib\charsets.jar;E:\Program Files\Java\jre\lib\deploy.jar;E:\Program Files\Java\jre\lib\ext\access-bridge-64.jar;E:\Program Files\Java\jre\lib\ext\cldrdata.jar;E:\Program Files\Java\jre\lib\ext\dnsns.jar;E:\Program Files\Java\jre\lib\ext\jaccess.jar;E:\Program Files\Java\jre\lib\ext\jfxrt.jar;E:\Program Files\Java\jre\lib\ext\localedata.jar;E:\Program Files\Java\jre\lib\ext\nashorn.jar;E:\Program Files\Java\jre\lib\ext\sunec.jar;E:\Program Files\Java\jre\lib\ext\sunjce_provider.jar;E:\Program Files\Java\jre\lib\ext\sunmscapi.jar;E:\Program Files\Java\jre\lib\ext\sunpkcs11.jar;E:\Program Files\Java\jre\lib\ext\zipfs.jar;E:\Program Files\Java\jre\lib\javaws.jar;E:\Program Files\Java\jre\lib\jce.jar;E:\Program Files\Java\jre\lib\jfr.jar;E:\Program Files\Java\jre\lib\jfxswt.jar;E:\Program Files\Java\jre\lib\jsse.jar;E:\Program Files\Java\jre\lib\management-agent.jar;E:\Program Files\Java\jre\lib\plugin.jar;E:\Program Files\Java\jre\lib\resources.jar;E:\Program Files\Java\jre\lib\rt.jar;E:\soft\workspace\java\LambdaShow\out\production\LambdaShow" TestLambda1
2.实现类
3.静态内部类
4.局部内部类
5.匿名内部类，没有类的名称，必须借助接口或者父类
6.用lambda简化

Process finished with exit code 0

/**
 * @ClassName TestLambda2
 * @Description TODO
 * @Author Huchao
 * @Date 2021/11/9 12:50
 * @Version 1.0
 **/
public class TestLambda2 {
    // 静态内部类
    static class Love2 implements ILove{
        @Override
        public void love(int a) {
            System.out.println("i love 美女--》"+a);
        }
    }

    public static void main(String[] args) {
        final Love love1 = new Love();
        love1.love(1);

        final Love2 love2 = new Love2();
        love2.love(2);

        // 匿名内部类
        ILove iLove1 = new ILove(){
            @Override
            public void love(int a) {
                System.out.println("i love 美女--》"+a);
            }
        };
        iLove1.love(3);

        // 1.lambda表达式简化
        ILove iLove2 = (int a)-> {
            System.out.println("i love 美女--》"+a);
        };
        iLove2.love(4);

        // 简化1：参数类型
        ILove iLove3=(a)-> {
            System.out.println("i love 美女--》"+a);
        };
        iLove3.love(5);

        // 简化2：简化括号
        ILove iLove4 = a-> {
            System.out.println("i love 美女--》"+a);
            System.out.println("超哥爱美女"+a);
        };
        iLove4.love(6);

        // 简化3：去掉花括号
        ILove iLove5 = a-> System.out.println("i love 美女--》"+a);
        iLove5.love(7);

        /**
         * //总结:
         * lambda表达式只能有一行代码的情况下才能简化成为一行，如果有多行，那么就用代码块包裹。
         * 前提是接口为函数式接口
         * 多个参数也可以去掉参数类型，要去掉就都去掉,必须加上括号，
         **/
    }
}

interface ILove{
    void love(int a);
}

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

打印结果：

"E:\Program Files\Java\bin\java.exe" "-javaagent:D:\Program Files (x86)\IDEA\IntelliJ IDEA 2020.3.2\lib\idea_rt.jar=54722:D:\Program Files (x86)\IDEA\IntelliJ IDEA 2020.3.2\bin" -Dfile.encoding=UTF-8 -classpath "E:\Program Files\Java\jre\lib\charsets.jar;E:\Program Files\Java\jre\lib\deploy.jar;E:\Program Files\Java\jre\lib\ext\access-bridge-64.jar;E:\Program Files\Java\jre\lib\ext\cldrdata.jar;E:\Program Files\Java\jre\lib\ext\dnsns.jar;E:\Program Files\Java\jre\lib\ext\jaccess.jar;E:\Program Files\Java\jre\lib\ext\jfxrt.jar;E:\Program Files\Java\jre\lib\ext\localedata.jar;E:\Program Files\Java\jre\lib\ext\nashorn.jar;E:\Program Files\Java\jre\lib\ext\sunec.jar;E:\Program Files\Java\jre\lib\ext\sunjce_provider.jar;E:\Program Files\Java\jre\lib\ext\sunmscapi.jar;E:\Program Files\Java\jre\lib\ext\sunpkcs11.jar;E:\Program Files\Java\jre\lib\ext\zipfs.jar;E:\Program Files\Java\jre\lib\javaws.jar;E:\Program Files\Java\jre\lib\jce.jar;E:\Program Files\Java\jre\lib\jfr.jar;E:\Program Files\Java\jre\lib\jfxswt.jar;E:\Program Files\Java\jre\lib\jsse.jar;E:\Program Files\Java\jre\lib\management-agent.jar;E:\Program Files\Java\jre\lib\plugin.jar;E:\Program Files\Java\jre\lib\resources.jar;E:\Program Files\Java\jre\lib\rt.jar;E:\soft\workspace\java\LambdaShow\out\production\LambdaShow" TestLambda2
i love 美女--》1
i love 美女--》2
i love 美女--》3
i love 美女--》4
i love 美女--》5
i love 美女--》6
超哥爱美女6
i love 美女--》7

Process finished with exit code 0

2.5、静态代理模式

案例：

/**
 * @ClassName StaticProxy
 * @Description TODO
 * @Author Huchao
 * @Date 2021/11/8 22:31
 * @Version 1.0
 **/

// 静态代理模式总结：
// 真实对象和代理对象都要实现同一个接口
// 代理对象要代理真是角色

import com.sun.org.apache.bcel.internal.generic.NEW;

/**
 * 好处：
 * 代理对象可以做很多真实对象做不了的事情
 * 真实对象专注做自己的事情
*/
public class StaticProxy {
    public static void main(String[] args) {
        final You you = new You();  // 你要结婚
        new Thread(()-> System.out.println("我爱你")).start(); // Thread 相当于WeddingCompany 是一个代理  代理runnable接口 ，调用start方法
        new WeddingCompany(new You()).HappyMarry();
//        final WeddingCompany weddingCompany = new WeddingCompany(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 before() {
        System.out.println("结婚之前，布置现场");
    }
    private void after() {
        System.out.println("结婚之后，收尾款");
    }
}

Thread 相当于WeddingCompany 是一个代理代理runnable接口，调用start方法

3、线程状态

五大状态：

创建状态
就绪状态
阻塞状态
运行状态
死亡状态

3.1、线程的一些常用方法

常用方法——API

void	setPriority(int newPriority)更改此线程的优先级。

boolean	isAlive()测试这个线程是否活着。

void	interrupt()中断这个线程。
static boolean	interrupted()测试当前线程是否中断。

3.2、线程休眠——sleep()

sleep——API

static void	sleep(long millis)使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行），具体取决于系统定时器和调度程序的精度和准确性。
static void	sleep(long millis, int nanos)导致正在执行的线程以指定的毫秒数加上指定的纳秒数来暂停（临时停止执行），这取决于系统定时器和调度器的精度和准确性。

sleep（时间）指定当前线程阻塞的毫秒数
sleep 存在异常 InterruptedException
sleep 时间达到后线程进入就绪状态
sleep 可以模拟网络延时，倒计时等（故意设置延时收优化钱💴，不道德，比如某盘）
sleep 每一个对象都有一个锁，sleep 不会释放锁

案例：

一：买火车票

package com.mao.state;

/**
 * @ClassName TestSleep
 * @Description TODO
 * @Author Huchao
 * @Date 2021/11/9 15:14
 * @Version 1.0
 **/

// 多个线程同时操作同一个对象
// 买火车票的例子
// 发现问题：多个线程操作同一个资源的情况下，线程不安全，数据紊乱
public class TestSleep implements Runnable{

    // 票数
    private int ticketNums = 10;

    @Override
    public void run() {
        while (true){
            if (ticketNums<=0){
                break;
            }
            // 模拟网络延时，放大问题的发生性
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"-->拿到了第"+ticketNums--+"票");
        }
    }

    public static void main(String[] args) {
        final com.mao.demo01.TestThread4 testThread4 = new com.mao.demo01.TestThread4();
        new Thread(testThread4,"超哥").start();
        new Thread(testThread4,"废物凤").start();
        new Thread(testThread4,"黄牛").start();
    }
}

二、倒计时

package com.mao.state;

/**
 * @ClassName TestSleep2
 * @Description TODO
 * @Author Huchao
 * @Date 2021/11/9 15:26
 * @Version 1.0
 **/
// 模拟倒计时
public class TestSleep2 {

    public static void main(String[] args) {
        try {
            tenDown();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

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

三、打印当前时间

package com.mao.state;

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

/**
 * @ClassName TestSleep2
 * @Description TODO
 * @Author Huchao
 * @Date 2021/11/9 15:26
 * @Version 1.0
 **/
// 模拟倒计时
public class TestSleep2 {

    public static void main(String[] args) {
        // 打印当前系统时间
        Date date = new Date(System.currentTimeMillis());   //获取当前系统时间
        while (true){
            try {
                Thread.sleep(1000);
                System.out.println(new SimpleDateFormat("HH:mm:ss").format(date));
                date = new Date(System.currentTimeMillis());  //更新当前时间
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    
}

3.3、线程礼让——yield()

yield()——API

static void	yield()对调度程序的一个暗示，即当前线程愿意产生当前使用的处理器。

礼让线程，让当前正在执行的线程暂停，但不阻塞
将线程从运行状态转为就绪状态
让 CPU 从新调度，有可能还是调度该礼让线程

案例：

package com.mao.state;

/**
 * @ClassName TestYield
 * @Description TODO
 * @Author Huchao
 * @Date 2021/11/9 15:42
 * @Version 1.0
 **/
// 测试礼让线程
// 礼让不一定成功，看cpu心情
public class TestYield {
    public static void main(String[] args) {
        final 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()——API

void	join()等待这个线程死亡。
void	join(long millis)等待这个线程死亡最多 millis毫秒。

Join 合并线程，待此线程执行完成后，再执行其他线程，其他线程阻塞。可以想象成插队。

案例：

package com.mao.state;

/**
 * @ClassName TestJoin
 * @Description TODO
 * @Author Huchao
 * @Date 2021/11/9 16:07
 * @Version 1.0
 **/
public class TestJoin implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("线程vip来了"+i);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        // 启动我们的线程
        final TestJoin testJoin = new TestJoin();
        final Thread thread = new Thread(testJoin);

        // 主线程
        for (int i = 0; i < 200; i++) {
            if (i==100){
                thread.start();
                thread.join();  //插队
            }
            System.out.println("main:"+i);
        }
    }
}

3.5、停止线程的方式

不推荐使用 JDK 提供的 stop ()、destroy()方法。【已弃用】
推荐线程自己停止下来
建议使用一个标志位进行终止变量，当 flag == false，则终止线程运行

案例：

package com.mao.state;

/**
 * @ClassName TestStop
 * @Description TODO
 * @Author Huchao
 * @Date 2021/11/9 13:40
 * @Version 1.0
 **/

//测试stop
//1.建议线程正常停止--->利用次数,不建议死循环。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) {
        final TestStop testStop = new TestStop();
        new Thread(testStop).start();
        for (int i = 0; i < 1000; i++) {
            System.out.println("Main"+Thread.currentThread().getName()+""+i);
            if (i==900){
                // 调用stop方法切换标识位，让线程停止
                testStop.stop();
                System.out.println("线程停止了");
            }
        }
    }

}

3.6、线程状态观测

Thread.State——API

public static enum Thread.State extends Enum<Thread.State>线程状态。线程可以处于以下状态之一：一个线程可以在给定时间点处于一个状态。这些状态是不反映任何操作系统线程状态的虚拟机状态。从以下版本开始：1.5 另请参见：Thread.getState()
- NEW尚未启动的线程处于此状态。
- RUNNABLE在Java虚拟机中执行的线程处于此状态。
- BLOCKED被阻塞等待监视器锁定的线程处于此状态。
- WAITING正在等待另一个线程执行特定动作的线程处于此状态。
- TIMED_WAITING正在等待另一个线程执行动作达到指定等待时间的线程处于此状态。
- TERMINATED已退出的线程处于此状态。

Enum Constant Summary

Enum Constant and Description
BLOCKED一个线程的线程状态阻塞等待监视器锁定。
NEW线程尚未启动的线程状态。
RUNNABLE可运行线程的线程状态。
TERMINATED终止线程的线程状态。
TIMED_WAITING具有指定等待时间的等待线程的线程状态。
WAITING等待线程的线程状态

Thread.State

线程状态：线程可以处于以下状态之一：

NEW：尚未启动的线程处于此状态。
RUNNABLE：在 Java 虚拟机中执行的线程处于此状态。
BLOCKED：被阻塞等待监视器锁定的线程处于此状态。
WAITING：正在等待另一个线程执行特定动作的线程处于此状态。
TERMINATED：已退出的线程处于此状态。

一个线程可以在给定时间点处于一个状态。这些状态是不反映任何操作系统线程状态的虚拟机状态。

案例：

package com.mao.state;

/**
 * @ClassName TestThreadState
 * @Description TODO
 * @Author Huchao
 * @Date 2021/11/9 16:19
 * @Version 1.0
 **/
// 观察线程的状态
public class TestThreadState {
    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);  // 输出状态
        }
    }

}

"E:\Program Files\Java\bin\java.exe" "-javaagent:D:\Program Files (x86)\IDEA\IntelliJ IDEA 2020.3.2\lib\idea_rt.jar=59851:D:\Program Files (x86)\IDEA\IntelliJ IDEA 2020.3.2\bin" -Dfile.encoding=UTF-8 -classpath "E:\Program Files\Java\jre\lib\charsets.jar;E:\Program Files\Java\jre\lib\deploy.jar;E:\Program Files\Java\jre\lib\ext\access-bridge-64.jar;E:\Program Files\Java\jre\lib\ext\cldrdata.jar;E:\Program Files\Java\jre\lib\ext\dnsns.jar;E:\Program Files\Java\jre\lib\ext\jaccess.jar;E:\Program Files\Java\jre\lib\ext\jfxrt.jar;E:\Program Files\Java\jre\lib\ext\localedata.jar;E:\Program Files\Java\jre\lib\ext\nashorn.jar;E:\Program Files\Java\jre\lib\ext\sunec.jar;E:\Program Files\Java\jre\lib\ext\sunjce_provider.jar;E:\Program Files\Java\jre\lib\ext\sunmscapi.jar;E:\Program Files\Java\jre\lib\ext\sunpkcs11.jar;E:\Program Files\Java\jre\lib\ext\zipfs.jar;E:\Program Files\Java\jre\lib\javaws.jar;E:\Program Files\Java\jre\lib\jce.jar;E:\Program Files\Java\jre\lib\jfr.jar;E:\Program Files\Java\jre\lib\jfxswt.jar;E:\Program Files\Java\jre\lib\jsse.jar;E:\Program Files\Java\jre\lib\management-agent.jar;E:\Program Files\Java\jre\lib\plugin.jar;E:\Program Files\Java\jre\lib\resources.jar;E:\Program Files\Java\jre\lib\rt.jar;E:\soft\workspace\java\多线程\out\production\多线程;E:\soft\workspace\java\多线程\src\com\lib\commons-io-2.11.0.jar" com.mao.state.TestThreadState
NEW
RUNNABLE
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
///
TERMINATED

Process finished with exit code 0

3.7、线程优先级

字段详细信息

MIN_PRIORITY

- - public static final int MIN_PRIORITY线程可以拥有的最小优先级。另请参见：Constant Field Values

NORM_PRIORITY

- - public static final int NORM_PRIORITY分配给线程的默认优先级。另请参见：Constant Field Values

MAX_PRIORITY

- - public static final int MAX_PRIORITY线程可以拥有的最大优先级。另请参见：Constant Field Values

getPriority

- - public final int getPriority()返回此线程的优先级。结果这个线程的优先级。另请参见：setPriority(int)

setPriority

- - public final void setPriority(int newPriority)
  - 更改此线程的优先级。
- - 首先调用这个线程的checkAccess方法，没有参数。
  - 这可能会导致投掷SecurityException 。
- - 否则，该线程的优先级设置为指定的小newPriority和最大允许的线程的线程组的优先级。
  - 参数
- - newPriority - 设置此线程的优先级
  - 异常
- - IllegalArgumentException - 如果优先级不在 MIN_PRIORITY到 MAX_PRIORITY 。
  - SecurityException - 如果当前线程不能修改此线程。
- - 另请参见：
  - getPriority() ， checkAccess() ， getThreadGroup() ， MAX_PRIORITY ， MIN_PRIORITY ， ThreadGroup.getMaxPriority()

Java 提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照优先级决定应该调度哪个线程来执行。

线程的优先级用数字表示，范围从1~10
- Thread.MIN_PRIORITY=1
- Thread.MAX_PRIORITY=10
- Thread.NORM_PRIORITY=5
使用以下方式改变或获取优先级
- getPriority().setPriority(int xxx)

优先级的设定建议在 start() 调度前

案例：

package com.mao.state;

/**
 * @ClassName TestPriority
 * @Description TODO
 * @Author Huchao
 * @Date 2021/11/9 22:17
 * @Version 1.0
 **/
public class TestPriority {

    public static void main(String[] args) {
        // 主线程默认优先级
        System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());

        final MyPriority myPriority = new MyPriority();

        final Thread thread1 = new Thread(myPriority);
        final Thread thread2 = new Thread(myPriority);
        final Thread thread3 = new Thread(myPriority);
        final Thread thread4 = new Thread(myPriority);
        final Thread thread5 = new Thread(myPriority);
        final Thread thread6 = new Thread(myPriority);

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

        thread2.setPriority(1);
        thread2.start();

        thread3.setPriority(4);
        thread3.start();

        thread4.setPriority(Thread.MAX_PRIORITY);
        thread4.start();

//        thread5.setPriority(-1);
//        thread5.start();
//
//        thread6.setPriority(11);
//        thread6.start();
//        if (newPriority > MAX_PRIORITY || newPriority < MIN_PRIORITY) {
//            throw new IllegalArgumentException();
//        }

    }
}

class MyPriority implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
    }
}

"E:\Program Files\Java\bin\java.exe" "-javaagent:D:\Program Files (x86)\IDEA\IntelliJ IDEA 2020.3.2\lib\idea_rt.jar=57569:D:\Program Files (x86)\IDEA\IntelliJ IDEA 2020.3.2\bin" -Dfile.encoding=UTF-8 -classpath "E:\Program Files\Java\jre\lib\charsets.jar;E:\Program Files\Java\jre\lib\deploy.jar;E:\Program Files\Java\jre\lib\ext\access-bridge-64.jar;E:\Program Files\Java\jre\lib\ext\cldrdata.jar;E:\Program Files\Java\jre\lib\ext\dnsns.jar;E:\Program Files\Java\jre\lib\ext\jaccess.jar;E:\Program Files\Java\jre\lib\ext\jfxrt.jar;E:\Program Files\Java\jre\lib\ext\localedata.jar;E:\Program Files\Java\jre\lib\ext\nashorn.jar;E:\Program Files\Java\jre\lib\ext\sunec.jar;E:\Program Files\Java\jre\lib\ext\sunjce_provider.jar;E:\Program Files\Java\jre\lib\ext\sunmscapi.jar;E:\Program Files\Java\jre\lib\ext\sunpkcs11.jar;E:\Program Files\Java\jre\lib\ext\zipfs.jar;E:\Program Files\Java\jre\lib\javaws.jar;E:\Program Files\Java\jre\lib\jce.jar;E:\Program Files\Java\jre\lib\jfr.jar;E:\Program Files\Java\jre\lib\jfxswt.jar;E:\Program Files\Java\jre\lib\jsse.jar;E:\Program Files\Java\jre\lib\management-agent.jar;E:\Program Files\Java\jre\lib\plugin.jar;E:\Program Files\Java\jre\lib\resources.jar;E:\Program Files\Java\jre\lib\rt.jar;E:\soft\workspace\java\多线程\out\production\多线程;E:\soft\workspace\java\多线程\src\com\lib\commons-io-2.11.0.jar" com.mao.state.TestPriority
main-->5
Thread-0-->5
Thread-3-->10
Thread-2-->4
Thread-1-->1

Process finished with exit code 0

优先级低只是意味着获得调度的概率低，并不是优先级低就不会被调用了，这都是看CPU的调度

3.8、守护（daemon）线程

线程分为用户线程和守护线程
虚拟机必须确保用户线程执行完毕
虚拟机不用等待守护线程执行完毕
如后台记录操作日志，监控内存垃圾回收等待

package com.mao.state;

/**
 * @ClassName TestDaemon
 * @Description TODO
 * @Author Huchao
 * @Date 2021/11/9 22:32
 * @Version 1.0
 **/
// 测试守护线程
// 上帝守护你
//● 虚拟机必须确保用户线程执行完毕
//● 虚拟机不用等待守护线程执行完毕
public class TestDaemon {
    public static void main(String[] args) {
        final God god = new God();
        final Thread thread = new Thread(god);
        thread.setDaemon(true); // 默认是false表示用户线程，正常的线程都是用户线程
        thread.start(); // 上帝守护线程启动

        new Thread(new 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("====goodbye! Hello,world!=====");
    }
}

3.9、并发

同一个对象被多个线程同时操作

现实生活中，我们会遇到”同一个资源，多个人都想使用”的问题，比如，食堂排队打饭，每个人都想吃饭，最天然的解决办法就是，排队一个个来。

处理多线程问题时，多个线程访问同一个对象，并且某些线程还想修改这个对象，这时候我们就需要线程同步。线程同步其实就是一种等待机制，多个需要同时访

问！此对象的线程进入这个对象的等待池形成队列，等待前面线程使用完毕，下一个线程再使用。

形成线程安全的条件：队列和锁

4、线程同步（重点、难点）

并发：同一对象被多个线程同时操作（抢票）
线程同步是一个等待机制，多个需要同时访问次对象的线程进入这个对象的等待池形成队列，等待前一个线程使用完毕，下一个线程才能使用。

形成条件：队列+锁

由于同一进程的多个线程共享同一块存储空间，在带来方便的同时，也带来了访问冲突问题，为了保证数据在方法中被访问时的正确性，在访问时加入锁机制

synchronized，当一个线程获得对象的排它锁，独占资源，其他线程必须等待，使用后释放锁即可.存在以下问题：

一个线程持有锁会导致其他所有需要此锁的线程挂起；

在多线程竞争下，加锁，释放锁会导致比较多的上下文切换和调度延时，引起性能问题；

如果一个优先级高的线程等待一个优先级低的线程释放锁会导致优先级倒置，引起性能问题.

4.1、线程不安全举例

1.不安全的售票

package com.mao.syn;

/**
 * @ClassName UnsafeBuyTicket
 * @Description TODO
 * @Author Huchao
 * @Date 2021/11/10 20:07
 * @Version 1.0
 **/
// 不安全的买票
// 线程不安全，有负数
public class UnsafeBuyTicket{
    public static void main(String[] args) {
        final BuyTicket buyTicket = new BuyTicket();
        new Thread(buyTicket,"超哥").start();
        new Thread(buyTicket,"废物凤").start();
        new Thread(buyTicket,"黄牛").start();
    }
}

class BuyTicket implements Runnable{

    // 票
    private int ticketNums=10;
    boolean flag = true;
    @Override
    public void run() {
        while (true){
            buy();
        }
    }

    void buy(){
        // 判断是否有票
        if (ticketNums<=0){
            flag=false;
            return;
        }
        // 模拟延时
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //买票
        System.out.println(Thread.currentThread().getName()+"拿到"+ticketNums--);
    }
}

废物凤拿到10
黄牛拿到8
超哥拿到9
黄牛拿到7
废物凤拿到6
超哥拿到7
超哥拿到4
黄牛拿到5
废物凤拿到5
超哥拿到1
黄牛拿到3
废物凤拿到2

2.不安全取钱

package com.mao.syn;

/**
 * @ClassName UnsafeBank
 * @Description TODO
 * @Author Huchao
 * @Date 2021/11/10 20:33
 * @Version 1.0
 **/
// 不安全的取钱
// 两个人去银行取钱，账户
public class UnsafeBank {
    public static void main(String[] args) {
        // 账户
        final Account account = new Account(100, "结婚基金");
        final Drawing you = new Drawing(account, 50, "胡超");
        final Drawing girlfriend = new Drawing(account, 100, "胡超的女人");
        you.start();
        girlfriend.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;
        // Thread.currentThread().getName() = this.getName()
        System.out.println(account.name+"余额为:"+account.money);
        System.out.println(this.getName()+"手里的钱："+nowMoney);
    }
}

"E:\Program Files\Java\bin\java.exe" "-javaagent:D:\Program Files (x86)\IDEA\IntelliJ IDEA 2020.3.2\lib\idea_rt.jar=63542:D:\Program Files (x86)\IDEA\IntelliJ IDEA 2020.3.2\bin" -Dfile.encoding=UTF-8 -classpath "E:\Program Files\Java\jre\lib\charsets.jar;E:\Program Files\Java\jre\lib\deploy.jar;E:\Program Files\Java\jre\lib\ext\access-bridge-64.jar;E:\Program Files\Java\jre\lib\ext\cldrdata.jar;E:\Program Files\Java\jre\lib\ext\dnsns.jar;E:\Program Files\Java\jre\lib\ext\jaccess.jar;E:\Program Files\Java\jre\lib\ext\jfxrt.jar;E:\Program Files\Java\jre\lib\ext\localedata.jar;E:\Program Files\Java\jre\lib\ext\nashorn.jar;E:\Program Files\Java\jre\lib\ext\sunec.jar;E:\Program Files\Java\jre\lib\ext\sunjce_provider.jar;E:\Program Files\Java\jre\lib\ext\sunmscapi.jar;E:\Program Files\Java\jre\lib\ext\sunpkcs11.jar;E:\Program Files\Java\jre\lib\ext\zipfs.jar;E:\Program Files\Java\jre\lib\javaws.jar;E:\Program Files\Java\jre\lib\jce.jar;E:\Program Files\Java\jre\lib\jfr.jar;E:\Program Files\Java\jre\lib\jfxswt.jar;E:\Program Files\Java\jre\lib\jsse.jar;E:\Program Files\Java\jre\lib\management-agent.jar;E:\Program Files\Java\jre\lib\plugin.jar;E:\Program Files\Java\jre\lib\resources.jar;E:\Program Files\Java\jre\lib\rt.jar;E:\soft\workspace\java\多线程\out\production\多线程;E:\soft\workspace\java\多线程\src\com\lib\commons-io-2.11.0.jar" com.mao.syn.UnsafeBank
结婚基金余额为:50
胡超手里的钱：50
结婚基金余额为:-50
胡超的女人手里的钱：100

Process finished with exit code 0

3.不安全的集合

package com.mao.syn;

import java.util.ArrayList;
import java.util.List;

/**
 * @ClassName UnsafeList
 * @Description TODO
 * @Author Huchao
 * @Date 2021/11/10 20:53
 * @Version 1.0
 **/
// 线程不安全的集合
public class UnsafeList {
    public static void main(String[] args) {
        List<String>list=new ArrayList<String>();
        for (int i = 0; i < 10000; i++) {
            new Thread(()->{
                list.add(Thread.currentThread().getName());
            }).start();
        }
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(list.size());
    }
}

"E:\Program Files\Java\bin\java.exe" "-javaagent:D:\Program Files (x86)\IDEA\IntelliJ IDEA 2020.3.2\lib\idea_rt.jar=64318:D:\Program Files (x86)\IDEA\IntelliJ IDEA 2020.3.2\bin" -Dfile.encoding=UTF-8 -classpath "E:\Program Files\Java\jre\lib\charsets.jar;E:\Program Files\Java\jre\lib\deploy.jar;E:\Program Files\Java\jre\lib\ext\access-bridge-64.jar;E:\Program Files\Java\jre\lib\ext\cldrdata.jar;E:\Program Files\Java\jre\lib\ext\dnsns.jar;E:\Program Files\Java\jre\lib\ext\jaccess.jar;E:\Program Files\Java\jre\lib\ext\jfxrt.jar;E:\Program Files\Java\jre\lib\ext\localedata.jar;E:\Program Files\Java\jre\lib\ext\nashorn.jar;E:\Program Files\Java\jre\lib\ext\sunec.jar;E:\Program Files\Java\jre\lib\ext\sunjce_provider.jar;E:\Program Files\Java\jre\lib\ext\sunmscapi.jar;E:\Program Files\Java\jre\lib\ext\sunpkcs11.jar;E:\Program Files\Java\jre\lib\ext\zipfs.jar;E:\Program Files\Java\jre\lib\javaws.jar;E:\Program Files\Java\jre\lib\jce.jar;E:\Program Files\Java\jre\lib\jfr.jar;E:\Program Files\Java\jre\lib\jfxswt.jar;E:\Program Files\Java\jre\lib\jsse.jar;E:\Program Files\Java\jre\lib\management-agent.jar;E:\Program Files\Java\jre\lib\plugin.jar;E:\Program Files\Java\jre\lib\resources.jar;E:\Program Files\Java\jre\lib\rt.jar;E:\soft\workspace\java\多线程\out\production\多线程;E:\soft\workspace\java\多线程\src\com\lib\commons-io-2.11.0.jar" com.mao.syn.UnsafeList
9999

Process finished with exit code 0

4.2、同步方法及同步块

由于我们可以通过关键字 private 关键字来保证数据对象只能被方法访问，所以我们只要针对方法提出一套机制，这套机制就是 synchronized 关键字，

它包括两种方法：synchronized 方法和 synchronized 块.

synchronized 方法:

public synchronized void method(int args){}

synchronized 方法控制 “对象” 的访问，每个对象对应一把锁，每个 synchronized 方法都必须获得调用该方法的对象的锁才能执行，否则线程会阻塞，方法一旦

执行，就独占该锁，直到该方法返回才释放，后面被阻塞的线程才能获得这个锁，继续执行。

缺陷：若将一个大的方法申明为 synchronized 将会影响效率。

synchronized 块:

同步块：synchronized(Obj){}

Obj 称之为同步监视器

Obj 可以是任何对象，但是推荐使用共享资源作为同步监视器
同步方法中无需指定同步监视器，因为同步方法的同步监视器就是 this ，就是这个对象本身，或者是 class
同步监视器的执行过程

第一个线程访问，锁定同步监视器，执行其中的代码
第二个线程访问，发现同步监视器被锁定，无法访问
第一个线程访问完毕，解锁同步监视器
第二个线程访问，发现同步监视器没有锁，然后锁定并访问

4.3、死锁和Lock锁、

死锁：

多个线程各自占有一些共享资源，并且互相等待其他线程占有的资源才能运行，而导致两个或者多个线程都在等待对方释放资源，都停止执行的情形。某一个同步

块同时拥“两个以上对象的锁”时，就可能会发生“死锁”的问题。

产生死锁的四个必要条件：

互斥条件：一个资源每次只能被一个进程使用。
请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。
不剥夺条件：进程已获得的资源，在未使用完之前，不能强行剥夺。
循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系。

上述四个条件，只要破坏其任意一个或多个条件就可避免死锁的发生。

案例：

package com.nty.thread;

//死锁：两个线程拥有对方拥有的资源，然后形成僵持
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) {
            e.printStackTrace();
        }
    }

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

Lock(锁):

从 JDK 5.0 开始，Java 提供了更强大的线程同步机制——通过显示定义同步锁对象来实现同步。同步锁使用 Lock对象充当java.util.concurrent.locks.Lock 接口是

控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对 Lock 对象加锁，线程开始访问共享资源之前应先获得 Lock对

象。

ReentrantLock 类实现了 Lock ，它拥有与 synchronized 相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是 ReentrantLock ，可以显示加锁释

放锁。

synchronized 与 Lock 的对比:

Lock 是显示锁（手动开启和关闭），synchronized 是隐式锁，出了作用域自动释放
Lock 只有代码加锁，synchronized 有代码块锁和方法锁
使用 Lock 锁，JVM 将花费较少的时间来调度线程，性能更好。并具有更好的扩展性（提供更多的子类）
Lock > 同步代码块（已经进入了方法体，分配了相应资源）>同步方法（在方法体之外）

案例：

package com.nty.gaoji;

import java.util.concurrent.locks.ReentrantLock;

//测试Lock锁
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) {
                        e.printStackTrace();
                    }
                    System.out.println(ticketNums--);
                } else {
                    break;
                }
            } finally {
                lock.unlock();//解锁
            }
        }
    }
}

5、线程通信

应用场景：生产者和消费者问题

假设仓库中只能存放一件产品，生产者将生产出来的产品放入仓库，消费者将仓库中产品取走消费。
如果仓库中没有产品，则将生产者将产品放入仓库，否则停止生产并等待，直到仓库中的产品被消费者取走为止。
如果仓库中放有产品，则消费者可以将产品取走消费，否则停止消费，直到仓库中再次放入产品为止。

这是一个线程同步问题，生产者和消费者共享同一个资源，并且生产者和消费者之间相互依赖，互为条件。

对于生产者，没有生产产品之前，要通知消费者等待.而生产了产品之后，又需要马上通知消费者消费
对于消费者，在消费之后，要通知生产者已经结束消费，需要生产新的产品以供消费.
在生产者消费者问题中，仅有synchronized是不够的

**synchronized ：**可阻止并发更新同一个共享资源，实现了同步，不能用来实现不同线程之间的消息传递（通信）

5.1、解决线程通信的几个方法

注意：均是 Object 类的方法，都只能在同步方法或者同步代码块中使用，否则会抛出异常 illegalMonitorStateException

5.2、解决线程之间通信的方式

5.2.1、管程法

并发写作模型"“生产者/消费者模式”"–>管程法

生产者：负责生产数据的模块（可能是方法，对象，线程，进程）
消费者：负责处理数据的模块（可能是方法，对象，线程，进程）
缓冲区：消费者不能直接使用生产者的数据，他们之间有个缓冲区

生产者将生产好的数据放入缓冲区，消费者从缓冲区拿出数据

案例：

package com.nty.gaoji;


//测试：生产者消费者模型---》管程法

//消费者，生产者，商品，缓冲区
public class TestPC {
    public static void main(String[] args) {
        SyncContainer syncContainer = new SyncContainer();
        new Customer(syncContainer).start();
        new Productor(syncContainer).start();
    }
}


//消费者
class Customer extends Thread {

    //创建缓冲区
    private SyncContainer syncContainer;

    public Customer(SyncContainer syncContainer) {
        this.syncContainer = syncContainer;
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            Product pop = syncContainer.pop();
            System.out.println("消费了第" + pop.getId() + "号产品");
        }
    }
}

//生产者
class Productor extends Thread {
    //创建新的缓冲区
    private SyncContainer syncContainer;

    public Productor(SyncContainer syncContainer) {
        this.syncContainer = syncContainer;
    }

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

//商品
class Product {
    int id;//产品编号

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

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }
}

//缓冲区
class SyncContainer {
    //定义容器大小
    Product[] products = new Product[10];

    //容器计数器
    int count = 0;

    //生产者放入产品
    public synchronized void push(Product[] product) {
        //如果容器满了，就等待消费者消费
        if (count == product.length) {
            //通知消费者消费，生产等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        // 如果没有满，我们就需要丢入产品
        products = product;
        count++;


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

    //消费者消费产品

    public synchronized Product pop() {
        if (count == 0) {
            //通知生产者生产，消费者等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //如果可以消费
        count--;
        Product product = products[count];

        //通知生产者消费
        this.notifyAll();
        return product;
    }
}

5.2.2、信号灯法

package com.nty.gaoji;

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) {
                e.printStackTrace();
            }
        }
        System.out.println("演员表演了：" + voice);
        //通知观众观看
        this.notify();//通知唤醒
        this.voice = voice;
        this.flag = !this.flag;
    }

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

5.2.3、使用线程池

背景：经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大。
思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具。
优点：
- 提高响应速度（减少了创建新线程的时间）
- 降低资源消耗（重复利用线程池中线程，不需要每次都创建）
- 便于线程管理…
- - **corePoolSize：**核心池的大小
  - **maximumPoolSize：**最大线程数
- - **keepAliveTime：**线程没有任务时最多保持多长时间会终止

案例：

package com.nty.gaoji;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

//测试线程池
public class TestPool {
    public static void main(String[] args) {
        //1.创建服务，创建线程池
        ExecutorService service = Executors.newFixedThreadPool(10);
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());

        //2.关闭链接
        service.shutdown();
    }

}


class MyThread implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + i);
        }
    }
}

6、线程总结

创建线程的三种方式

package com.nty.gaoji;

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<Integer>(new MyThread3());
        new Thread(futureTask).start();

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

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

//实现Runnable接口
class MyThread2 implements Runnable {

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

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

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

最后分享一首自己很喜欢的诗(姑且算是吧)。我欲乘风向北行，雪落轩辕大如席，我欲借船向东游，绰约仙子迎风立，我欲踏云千万里，庙堂龙吟耐我何，昆仑之巅沐日光，沧海绝境见青山，长风万里燕归来，不见天涯人不回。

【Java学习】多线程：线程创建、线程状态、线程同步、线程通信全总结

目录

1、基本概念

2、线程创建

2.1、 继承 Thread 类（重点）

Thread API

2.2、 实现Runnable接口（重点）

Runnable接口API

以上两种方式的比较：

初识并发问题——买火车票

龟兔赛跑问题：

2.3、 实现Callable接口（了解）

2.4、 Lambda表达式

2.5、 静态代理模式

3、线程状态

3.1、 线程的一些常用方法

常用方法——API

3.2、 线程休眠——sleep()

sleep——API

3.3、 线程礼让——yield()

yield()——API

3.4、 合并线程——Join()

Join()——API

3.5、 停止线程的方式

3.6、 线程状态观测

Thread.State——API

Enum Constant Summary

3.7、 线程优先级

字段详细信息

MIN_PRIORITY

NORM_PRIORITY

MAX_PRIORITY

getPriority

setPriority

3.8、 守护（daemon）线程

3.9、 并发

4、线程同步（重点、难点）

4.1、 线程不安全举例

4.2、 同步方法及同步块

4.3、 死锁和Lock锁、

5、线程通信

5.1、解决线程通信的几个方法

5.2、 解决线程之间通信的方式

5.2.1、管程法

5.2.2、信号灯法

5.2.3、使用线程池

6、线程总结

更多文章点这里

2.1、继承 Thread 类（重点）

2.2、实现Runnable接口（重点）

2.3、实现Callable接口（了解）

2.5、静态代理模式

3.1、线程的一些常用方法

3.2、线程休眠——sleep()

3.3、线程礼让——yield()

3.4、合并线程——Join()

3.5、停止线程的方式

3.6、线程状态观测

3.7、线程优先级

3.8、守护（daemon）线程

3.9、并发

4.1、线程不安全举例

4.2、同步方法及同步块

4.3、死锁和Lock锁、

5.2、解决线程之间通信的方式