JAVA多线程入门一篇通

最新推荐文章于 2024-10-08 15:07:49 发布

郭贼不是我的菜

最新推荐文章于 2024-10-08 15:07:49 发布

阅读量159

点赞数 1

分类专栏：多线程文章标签： java 多线程编程语言面试大数据

本文链接：https://blog.csdn.net/zSoaring/article/details/111479105

版权

多线程专栏收录该内容

3 篇文章 0 订阅

订阅专栏

创建线程

基本概念

程序是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念。
进程是执行程序的一次执行过程，它是一个动态的概念。它是系统资源分配的单位。
通常在一个进程中可以包含若干个线程，当然一个进程中至少有一个线程，不然没有存在的意义。线程是CPU调度和执行的单位。
注：很多多线程是模拟出来的，真正的多线程是指有多个CPU，即多核，如服务器。如果是模拟出来的多线程，即在一个cpu的情况下，在同一个时间点，CPU只能一次执行一条指令，因为切换的很快，所以就有同时执行的错觉。
线程就是独立的执行路径。
在程序运行时，即使没有自己创建线程，后台也会有多个线程，如主线程，gc线程；
main()称之为主线程，为系统的入口，用于执行整个程序
在一个进程中，如果开辟了多个线程，线程的运行由调度器安排调度，调度器是与操作系统紧密相关的，先后顺序是不能人为的干预的。
对同一份资源操作时，会存在资源抢夺的问题，需要加入并发控制
线程会带来额外的开销，如CPU调度时间，并发控制开销
每个线程在自己的工作内存交互，内存控制不当会造成数据不一致

继承Thread类

自定义线程类继承Thread类
重写run()方法，编写线程执行体
创建线程对象，调用start()方法启动线程

在这里插入图片描述

注：直接调用Thread对象的run()方法相当于调用了普通方法，而调用start()方法相当于开启了一个线程。

package Thread;
//创建线程方式一：继承Thread类，重写run()方法，调用start开启线程
//注意：线程开启不一定立即执行，由CPU调度执行
public class TestThread1 extends Thread{
    @Override
    public void run() {
        //run方法线程体
        for (int i = 0; i < 20; i++) {
            System.out.println("我在看代码---" + i);
        }
    }
    public static void main(String[] args){
        //main线程，主线程
        //创建一个线程对象
        TestThread1 testThread1 = new TestThread1();
        //调用start()方法开启线程
        testThread1.start();//每一次的执行结果都不一样，由CPU安排
        for (int i = 0; i < 2000; i++) {
            System.out.println("我在学习多线程--" + i);
        }
    }
}

执行结果：
在这里插入图片描述

实现Runnable

定义MyRunnable类实现Runnable接口
实现run()方法，编写线程执行体
创建线程对象，调用start()方法启动线程

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

    public static void main(String[] args) {
        //创建Runnable接口的实现类对象
        TestThread2 testThread2 = new TestThread2();
        //创建线程对象，通过线程对象来开启我们的线程，代理
        //Thread thread = new Thread(testThread2);
        //thread.start();
        //简写，可以直接创建一个匿名对象来调用start()方法
        new Thread(testThread2).start();
        for (int i = 0; i < 2000; i++) {
            System.out.println("我在学习多线程--"+i);
        }
    }
}

注：由于Java有单继承局限性，所以更推荐使用实现Runnable接口的方式，这种方法更加灵活方便，且可使同一个对象被多个线程使用。

Runnable案例(龟兔赛跑)：

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

    //胜利者
    private static String winner;

    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {

            //模拟兔子每30步,休息一下
            if(Thread.currentThread().getName().equals("兔子") && i != 0 && i%30 == 0){
                try {
                    Thread.sleep(10);
                } 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) {
        Race race = new Race();
        new Thread(race,"兔子").start();
        new Thread(race,"乌龟").start();

    }
}

执行结果：

$C:\Users\高飞\AppData\Roaming\Typora\typora-user-images\image-20201209160921149.png$

实现Callable接口（了解）

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

静态代理

静态代理模式需要真实角色和代理角色，并且真实角色和代理角色要实现同一个接口，代理角色要持有真实角色的引用。在java中线程的设计就使用了静态代理设计模式，刚才所讲的实现Runable接口正式如此。现在我们拿过来分析一下。

在这里插入图片描述

接下来我们来模拟一个静态设计模式

//共同接口
interface CommentInterface{
    public abstract void todo();
}

//真实角色
class RealityRole implements CommentInterface{
    @Override
    public void todo() {
        System.out.println("真实角色的功能");
    }
}

//代理角色
class ProxyRole implements CommentInterface{
    //持有代理角色的引用
    private CommentInterface realityRole;

    //传入一个真实角色
    public ProxyRole(CommentInterface role){
        this.realityRole = role;
    }

    @Override
    public void todo() {
        //在真实角色功能运行之前，代理角色做准备工作
        doBefore();
        //执行真实角色的功能
        realityRole.todo();
        //代理角色的首位工作
        doAfter();
    }

    private void doBefore() {
        System.out.println("准备工作");
    }

    private void doAfter() {
        System.out.println("收尾工作");
    }
}
public class StaticProxy {
    public static void main(String[] args) {
        //创建真实角色对象
        CommentInterface realityRole = new RealityRole();
        //创建代理角色对象，并传入真实对象
        ProxyRole proxyRole = new ProxyRole(realityRole);
        //代理角色工作，本质调用的还是真实角色的功能
        proxyRole.todo();
    }
    /**
     * 运行结果：
     * 准备工作
     * 真实角色的功能
     * 收尾工作
     */
}

Lamda表达式

Lamda表达式这个词相信大家都不陌生，其实质属于函数式编程的概念。

为什么要使用lambda表达式
- 避免匿名内部类定义过多
- 可以让代码更简洁
- 去掉了一堆没有意义的代码，只留下核心的逻辑。
函数式接口的定义：
- 任何接口，如果只包含唯一一个抽象方法，那么它就是一个函数式接口。
- 对于函数式接口，我们可以通过lambda表达式来创建该接口的对象。

接下来我们就来演示一下lambda表达式的使用方式。

interface Hello{
    void sayHello(int n);
}
public class TestLambda2 {
    public static void main(String[] args) {
        //1.使用lambda表达式
        Hello hello = (int a)->{
            System.out.println("hello lambda-->"+a);
        };
        hello.sayHello(1);

        //简化1.参数类型
        hello = (a)->{
            System.out.println("hello lambda-->"+a);
        };
        hello.sayHello(2);

        //简化2.简化括号
        //接口方法中只有一个参数时可以去掉(),否则得加上
        hello = a->{
            System.out.println("hello lambda-->"+a);
        };
        hello.sayHello(3);

        //简化3.去掉花括号
        //lambda表达式只能有一行代码的情况下下才能简化成为一行，如果有多行，那么久用代码块包裹。
        hello = a-> System.out.println("hello lambda-->"+a);
        hello.sayHello(4);
    }
}

其实对于Runnable接口就是一个函数式接口，我们来看一下源码。
在这里插入图片描述

所以针对于实现Runnable接口来创建线程，我们同样可以使用lambda表达式。

线程方法

方法	说明
setPriority(int newPriority)	更改线程优先级
static void sleep(long millis)	在指定的毫秒数内让当前正在执行的线程休眠
void join()	等待该线程终止
static void yield()	暂停当前正在执行的线程对象，并执行其他线程
void interrupt()	中断线程
boolean isAlive()	测试线程是否处于活动状态

线程停止

可以设置标志位来停止线程，但是当线程处于阻塞状态，无法到达判断标志位代码行时，此方法无法解决。
或者使用interrupt()方法来中断线程，其本质也是设置了标志位来中断线程。

//测试强制停止线程
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 == 666){//当主线程到666的时候，让testStop停止
                //调用自己写的公开stop方法切换标志位，让线程停止
                testStop.stop();
                System.out.println("该线程停止了");
            }
        }
    }
}

线程休眠

sleep(时间)指定当前线程阻塞的毫秒数；
sleep存在异常InterruptException；
sleep时间达到后线程进入就绪状态；
sleep可以模拟网络延时，倒计时等等；
每一个对象都有一个锁，sleep不会释放锁。

模拟网络延时可以放大问题的发生性。如果没有模拟，会以为代码是线程安全的，但是模拟之后可能就会发现线程不安全（CPU所分配时间片到了，程序不管执行到哪一行都会停止），接来下我们来利用sleep模拟一下倒计时。

//模拟倒计时
public class TestSleep {
    //倒计时十秒
    public static void tenDown() throws InterruptedException {
        int num = 10;
        while(num > 0){
            Thread.sleep(1000);
            System.out.println(num--);
        }
    }

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

线程礼让

将线程从运行状态转为就绪状态
CPU重新调度，礼让不一定成功！看CPU怎么调度。

//测试礼让线程
class MyYield implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"-->start");
        Thread.yield();//礼让
        System.out.println(Thread.currentThread().getName()+"-->end");
    }
}
public class TestYield {
    public static void main(String[] args) {
        MyYield myYield = new MyYield();
        new Thread(myYield,"a").start();
        new Thread(myYield,"b").start();
        new Thread(myYield,"c").start();
    }
}

运行结果：
在这里插入图片描述

线程等待

有的时候我们需要让正在执行的A线程等待B线程先执行完，再执行A线程，那么就可以使用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();//先执行thread，再执行main
            }
            System.out.println("main"+i);
        }
    }
    //当主线程跑到200时，只能等待线程VIP跑完，才能继续执行。
}

线程状态

在这里插入图片描述

在JDK中Thread提供的状态如下：

在这里插入图片描述

接下来我们通过代码来观测不同时间点下的线程状态

//观察测试线程状态
public class TestState {

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(()->{//使用lambda表达式
            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);
        }
    }
}

线程优先级

Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有进程，线程调度器按照优先级决定应该调度哪个线程来执行。
线程的优先级用数字表示，范围从1~10.
- Thread.MIN_PRIORITY = 1;
- Thread.MAX_PRIORITY = 10;
- Thread.NORM_PRIORITY = 5;
使用getPriority()方法来获取优先级，setPriority(int xxx)来改变优先级。
优先级低只是意味着获得调度的概率低，并不是优先级低就不会被调度了。

//测试线程的优先级
class MyPriority implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"-->"+
                Thread.currentThread().getPriority());
    }
}
public class TestPriority {
    public static void main(String[] args) {
        //主线程默认优先级
        System.out.println(Thread.currentThread().getName()+"-->"+
                Thread.currentThread().getPriority());

        MyPriority myPriority = new MyPriority();

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

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

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

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

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

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

守护线程

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

//上帝
class God implements Runnable{
    @Override
    public void run() {
        while(true){
            System.out.println("上帝保佑着你");
        }
    }
}

//You
class You implements Runnable{
    @Override
    public void run() {
        for(int i = 0;i < 36500;i++){
            System.out.println("我正开心的活着");
        }
        System.out.println("====goodbye!world====");
    }
}
public class TestDaemon {
    public static void main(String[] args) {
        God god = new God();
        You you = new You();

        Thread threadGod = new Thread(god);
        threadGod.setDaemon(true);//默认是false表示用户线程，正常的线程都是用户线程。。。
        threadGod.start();//上帝守护线程启动

        new Thread(you).start();
    }
}

线程安全

如果多线程环境下代码运行的结果是符合我们的预期的，即在单线程环境应该得到的结果，那么这个程序就是线程安全的。

线程不安全原因

线程不安全示例一：模拟抢票

//多个线程同时操作同一个对象
//买火车票的例子
public class TestThread3 implements Runnable{
    //票数
    private int ticketNums = 10;

    @Override
    public void run() {
        while(true){
            if(ticketNums <= 0){
                break;
            }
            //CPU的处理速度太快，使用Thread.sleep模拟延时
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"-->拿到了第" + ticketNums--+"票");
        }
    }

    public static void main(String[] args) {

        TestThread3 ticket = new TestThread3();

        new Thread(ticket,"小红").start();
        new Thread(ticket,"小明").start();
        new Thread(ticket,"小黑").start();
    }
}

运行结果：
在这里插入图片描述

分析为什么会线程不安全：

很明显，我们可以看到在ticketNums==1时，发生了问题。可见小黑都拿到票了，但还没来得及给ticketNums减1，CPU就调度了小红，小红拿到票之后也没来得及减1，CPU又调度了小明，所以就会出现三个人都拿到票的现象。

原子性

我们可以把上面出现线程不安全的代码部分想象成一个房间，每个线程就是要进入这个房间的人。但是如果这个房间没有锁（任何机制保证），那么小黑进入房间之后，还没有出来，小红和小明也都可以进入房间，并且打乱小黑的正常执行，这就是不具备原子性。有时也把这个现象叫做同步互斥。

可见性

主内存-工作内存
在这里插入图片描述

为了提高效率，JVM在执行过程中，会尽可能的将数据在工作内存中执行，但这样会造成一个问题，共享变量在多线程之间不能及时看到改变，这个就是可见性问题。

有序性

如果是在单线程情况下，JVM、CPU指令集会对没有依赖关系的代码进行优化，使得其执行顺序改变，这叫做指令重排序。如果我们需要线程间相互协调工作，那么任意一个线程站在自己的视角看代码执行，总是有序的，而站在其它线程的视角来看，总是无序的（指令重排序优化）。

解决线程不安全

synchronized

要满足线程安全则得满足以上三个特性：原子性、可见性、有序性。那么再来研究一下抢票问题，如果我们把每个用户的抢票动作（与公共资源有关的所有可能会影响其他线程正常操作的代码）都放到一个房子里，只要有用户在抢票了，那该用户就给房子上一把锁，从而告知其他用户，现在有人请稍等，直到这个用户出来，把锁去掉了，下一个用户再进去，就可以做到线程安全的抢票了。

synchronized关键字：线程安全用的同步关键字，其底层是使用操作系统的mutex lock（监视器锁）实现的。多个线程间同步互斥时，一段代码在任意一个时间点，只有一个线程执行：加锁、释放锁（基于对象来进行加锁/释放锁）。

语法：

(1)同步代码块：synchronized(某个对象){...}
(2)同步方法：实例同步方法（this加锁）、静态同步方法（当前对象加锁）

在这里插入图片描述

使用synchronized解决刚才的抢票问题：

public class TestThread3 implements Runnable{
    //票数
    private int ticketNums = 10;

    @Override
    public void run() {
        while(true) {
            synchronized (this) {
                if (ticketNums <= 0) {
                    break;
                }
                System.out.println(Thread.currentThread().getName() + "-->拿到了第" + ticketNums-- + "票");
            }
            //CPU的处理速度太快，使用Thread.sleep模拟延时
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {

        TestThread3 ticket = new TestThread3();

        new Thread(ticket,"小红").start();
        new Thread(ticket,"小明").start();
        new Thread(ticket,"小黑").start();
    }
}

注：只有对同一个对象加锁，才会让线程产生同步互斥的作用

Lock锁

synchronized是隐式锁，我们不能直观的看到加锁与解锁的过程，而Lock锁是通过显示定义同步锁对象来实现的。Lock是一个接口，包为java.util.concurrent.locks.Lock。ReentrantLock类实现了Lock，它拥有与synchronized相同的并发性和内存语义。还是用抢票来说明。

import java.util.concurrent.locks.ReentrantLock;

public class LockTest implements Runnable{
    //票
    private static int ticketNums = 1000;

    //定义Lock锁
    private final ReentrantLock lock = new ReentrantLock();
    @Override
    public void run() {
        while(true){
            lock.lock();
            try{
                if(ticketNums>0){
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+":"+ticketNums--);
                }else{
                    break;
                }
            }finally {
                //解锁
                lock.unlock();
            }
        }
    }

    public static void main(String[] args) {
        LockTest lockTest = new LockTest();
        new Thread(lockTest,"小黑").start();
        new Thread(lockTest,"小红").start();
        new Thread(lockTest,"小明").start();
    }
}

线程间通信

生产者消费者问题

在这里插入图片描述

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

对于生产者，没有生产产品之前，要通知消费者等待，而生产了产品之后，又需要马上通知消费者消费。
对于消费者，在消费之后，要通知生产者已经结束消费，需要生产新的产品。

JAVA在Object类中提供了以下几个方法解决线程之间的通信问题，这些方法只能在同步方法或者同步代码块中使用，否则会抛出异常。

方法名	作用
wait()	表示线程一直等待，直到其它线程通知，与sleep不同，会释放锁。
wait(long timeout)	指定等待的毫秒数
notify()	唤醒一个处于等待状态的线程
notifyAll()	唤醒同一个对象上所有调用wait()方法的线程，优先级别高的线程优先调度

管程法

管程法即使用缓冲区解决问题。

生产者：负责生产数据(可能是方法，对象，线程，进程)；
消费者：负责处理数据(可能是方法，对象，线程，进程);
缓冲区：生产者将生产好的数据放入缓冲区，消费者从缓冲区拿出数据。

//测试：生产者消费者问题
//利用缓冲区解决：管程法
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){
        //如果容器满了，就需要等待消费者消费
        if(count == chickens.length){
            //生产者等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //如果没有满，就需要生产产品
        chickens[count]=chicken;
        count++;

        //可以通知消费者消费了
        this.notifyAll();
    }
    //消费者消费产品
    public synchronized Chicken pop(){
        //判断能否消费
        if(count == 0){
            //等待生产者生产，消费者等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //如果可以消费
        count--;
        Chicken chicken = chickens[count];
        // 吃完了，通知生产者生产
        this.notifyAll();
        return chicken;
    }
}

信号灯法

通过设置标志位来判断资源需求是否满足，从而达到通信协作的效果。

//测试生产者消费者问题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++) {
            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{
    //演员拍戏，观众等待
    //观众观看，演员等待
    String movie;
    boolean flag = true;
    //拍戏
    public synchronized void play(String movie){
        if(!flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("新电影:"+movie);
        //通知观众观看
        this.notifyAll();
        this.movie = movie;
        this.flag = false;
    }
    //观看
    public synchronized void watch(){
        if(flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("观看了:"+movie);
        //通知演员拍戏
        this.notifyAll();
        this.flag = true;
    }
}

线程池

在这之前，我们使用线程都是通过手动创建的方式，但经常创建和销毁会消耗特别大的资源，比如并发情况下的线程，对性能影响很大。线程池可以避免这个问题，使创建好的线程可重复利用，使用时直接获取，使用结束放回池中。这样可以提高响应速度(减少创建新线程的时间)，降低资源消耗(重复利用线程池中线程，不需要每次都创建)，便于线程管理。

ExecutorService：真正的线程池接口。常见子类ThreadPoolExecutor
- void execute(Runnable command):执行任务/命令，没有返回值，一般用来执行Runnable
- Future submit(Callable task):执行任务，有返回值，一般用来执行Callable
- void shutdown():关闭连接池
Executors:工具类、线程池的工厂类，用于创建并返回不同类型的线程池。

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

//测试线程池
public class TestPool {
    public static void main(String[] args) {
        //1.创建线程池
        //newFixedThreadPool 参数为：线程池大小
        ExecutorService service = Executors.newFixedThreadPool(10);
        //执行
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());

        //2.关闭连接
        service.shutdown();
    }
}
class MyThread implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}