Java 基础 10. Java 多线程

2022-01-20 本文已影响0人 yjtuuige

一、线程简介

多任务：用户在同一时间内，运行多个应用程序；
多线程：指程序（一个进程）运行时产生了不止一个线程。
- 进程：操作系统中运行的程序；
- 线程：一个进程里面可以有多个线程，如视频中，同时有声音，图像等。

调用方法与调用多线程的区别：

调用方法：run() 方法，需要执行的方法体;
调用多线程：start() 方法，开启多线程的方法体。

Process（进程）与 Thread（线程）

1. 程序进程、线程

在操作系统中，运行的程序，就是进程，而进程通常采用多进程执行；
程序：指令和数据的有序集合，本身没有任何运行的含义，是静态概念；
进程：是执行程序的一次执行过程，是一个动态概念，是系统资源分配的单位；
线程：一个进程通常包括多个线程，线程是 CPU 调度和执行的单位。

注意：

很多多线程，是模拟出来的，真正的多线程是指，有多个 CPU，即多核，如服务器；如果是模拟出来的多线程，即在一个 CPU 的情况下，在同一个时间点，CPU 只能执行一个代码，因为切换的很快，所以，就有同时执行的错觉。

2. 线程的核心概念

线程，就是独立的执行路径；
在程序运行时，即使没有自己创建线程，后台也会有多个线程，比如主线程，GC 线程；
main() 称之为主线程，为系统的入口，用于执行整个程序；
在一个进程中，如果开辟了多个线程，线程的运行是由调度器（cpu）安排调度的，调度器是与操作系统紧密相关的，先后顺序是不能人为干预的。
对同一份资源操作时，会存在资源抢夺的问题，需要加入并发控制；
线程会带来额外的开销，如 CPU 调度时间，并发控制开销；
每个线程，在自己的工作内存交互，内存控制不当，会造成数据不一致。

二、线程创建

1. 线程创建三种方式：

继承 Thread 类（重要）不建议使用：避免 OOP 单继承局限性

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

package com.xxx.demo01;

/**
 * 创建线程方式 1：继承 Thread 类
 * 1.重写 run() 方法
 * 2.调用 start 开启线程
 */
public class TestThread01 extends Thread {
    // 重写 run() 方法
    // 线程入口点
    @Override
    public void run() {
        // run 方法线程体
        for (int i = 0; i < 20; i++) {
            System.out.println("run 方法线程 -- " + i);
        }
    }

    // main 线程：主线程
    public static void main(String[] args) {
        // 创建线程对象
        TestThread01 testThread01 = new TestThread01();
        // 调用 start() 开启线程
        testThread01.start();
        for (int i = 0; i < 200; i++) {
            System.out.println("main 主线程 -- " + i);
        }
    }
}

运行结果：多线程时，线程交替执行

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

实例：下载网络图片

package com.xxx.demo01;

import org.apache.commons.io.FileUtils;

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

/**
 * 多线程同步下载图片
 * 需下载 Commons IO 包
 */
public class TestThread02 extends Thread {
    private String url; // 网络图片地址
    private String name;    // 保存的文件名

    // 有参构造器
    public TestThread02(String url, String name) {
        this.url = url;
        this.name = name;
    }
    // 下载图片的线程执行体
    @Override
    public void run() {
        WebDownload webDownload = new WebDownload();
        webDownload.download(url, name);
        System.out.println("下载了文件名为：" + name);
    }

    public static void main(String[] args) {
        TestThread02 t1 = new TestThread02("图片地址1", "1.jpg");
        TestThread02 t2 = new TestThread02("图片地址2", "2.jpg");
        TestThread02 t3 = new TestThread02("图片地址3", "3.jpg");
        // 开启多线程：实际执行顺序，不确定（CPU 调度）
        t1.start();
        t2.start();
        t3.start();
    }
}

// 下载器
class WebDownload {
    public void download(String url, String name) {
        // 下载方法
        try {
            //调用 Commons_io 包里面的 copyURLToFile 方法
            FileUtils.copyURLToFile(new URL(url), new File(name));
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("IO异常，downloader下载方法异常");
        }
    }
}

结果：

Commons IO：针对开发 IO 功能的工具类库下载地址

将下载的 jar 包，复制到 lib 包（创建）下，并右键 添加为库...

实现 Runnable 接口（推荐使用）

推荐使用 Runnable 对象，因为 Java 单继承的局限性；

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

package com.xxx.demo01;

/**
 * 创建线程方式 2：实现 Runnable 接口
 * 1.重写 run() 方法
 * 2.执行线程需要，丢入 Runnable 接口实现类
 * 3.调用 start 开启线程
 */
public class TestThread03 implements Runnable {
    // 重写 run() 方法
    // 线程入口点
    @Override
    public void run() {
        // run 方法线程体
        for (int i = 0; i < 20; i++) {
            System.out.println("run 方法线程 -- " + i);
        }
    }

    // main 线程：主线程
    public static void main(String[] args) {
        // 创建 Runnable 接口的实现类对象
        TestThread03 testThread03 = new TestThread03();
        // 代理：创建线程对象，通过线程对象开启线程
//        Thread thread = new Thread(testThread03);
//        thread.start();
        // 简化
        new Thread(testThread03).start();
        for (int i = 0; i < 200; i++) {
            System.out.println("main 主线程 -- " + i);
        }
    }
}

运行结果：线程交替执行

总结：两种方式对比

实例：并发问题

package com.xxx.demo01;

/**
 * 多个线程同时操作同一个对象：买火车票案例
 * 发现问题:多个线程操作同一个资源的情况下,线程不安全,数据紊乱
 */
public class TestThread04 implements Runnable {
    // 票数
    private int ticketNums = 10;

    @Override
    public void run() {
        while (true) {
            if (ticketNums <= 0) {
                break;
            }
            // 模拟延时（需要捕获异常）
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // Thread.currentThread().getName() 获取线程名
            System.out.println(Thread.currentThread().getName() +
                    "-->拿到了第 " + ticketNums-- + " 张票");
        }
    }

    public static void main(String[] args) {
        TestThread04 thread04 = new TestThread04();
        new Thread(thread04, "用户1").start();
        new Thread(thread04, "用户2").start();
        new Thread(thread04, "用户3").start();
    }
}

结果：发现问题，数据重复

实例：龟兔赛跑

package com.xxx.demo01;

/**
 * 模拟龟兔赛跑
 */
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(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();
    }
}

实现 Callable 接口（了解）

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

package com.xxx.demo02;

import org.apache.commons.io.FileUtils;

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

/**
 * 线程创建方式 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() {
        WebDownload webDownload = new WebDownload();
        webDownload.download(url, name);
        System.out.println("下载了文件名为：" + name);
        return true;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        TestCallable t1 = new TestCallable("图片地址1", "1.jpg");
        TestCallable t2 = new TestCallable("图片地址2", "2.jpg");
        TestCallable t3 = new TestCallable("图片地址3", "3.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.shutdownNow();
    }
}

// 下载器
class WebDownload {
    public void download(String url, String name) {
        // 下载方法
        try {
            //调用 Commons_io 包里面的 copyURLToFile 方法
            FileUtils.copyURLToFile(new URL(url), new File(name));
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("IO异常，downloader下载方法异常");
        }
    }
}

Callable 优缺点：
- 优点：可以定义返回值、可以抛出异常；
- 缺点：实现方式比较复杂。

Thread 和 Runnable 对比

继承 Thred 类:
- 子类继承 Thread 类具备多线程能力；
- 启动线程：子类对象.start()；
- 不建议使用：避免OOP单继承局限性。
实现 Runnable 接口
- 实现 Runnable 接口，具有多线程能力；
- 启动线程：传入目标对象 + Thread 对象.start()；
- 推荐使用：避免单继承局限性，灵活方便，方便同一个对象被多个线程使用。

2. 静态代理

实例：实现静态代理，对比 Thread

package com.xxx.demo02;

/**
 * 静态代理
 */
public class StaticProxy {
    public static void main(String[] args) {

//        WeddingCompany weddingCompany = new WeddingCompany(new You());
//        weddingCompany.HappyMarry();
        // 简化
        new WeddingCompany(new You()).HappyMarry();
    }
}

// 自定义接口
interface Marry {
    void HappyMarry();
}

// 真实角色：自定义类，并实现 Marry 接口
class You implements Marry {
    @Override
    public void HappyMarry() {
        System.out.println("You Marry...");
    }
}

// 代理角色:自定义类，并实现 Marry 接口（代理角色帮助真实角色执行）
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("后：收尾款");
    }
}

优化：使用线程，Lamda 表达式。（线程的实现原理，就是代理模式）

package com.xxx.demo02;

/**
 * 线程中的代理模式
 */
public class StaticProxy02 {
    public static void main(String[] args) {
        // 线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("线程中的代理模式");
            }
        }).start();
        // 简化：Lambda 表达式
        new Thread(() -> System.out.println("线程，Lambda 表达式")).start();
        // 静态代理模式
        new WeddingCompany(new You()).HappyMarry();
    }
}

总结：
- 真实对象和代理对象，都要实现同一个接口；
- 代理对象要代理真实角色。
好处
- 代理对象可以做很多真实对象做不了的事情；
- 真实对象专注做自己的事。

3. Lambda 表达式

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

(params) -> expression [表达式]
(params) -> statement [语句]
(params) -> {statements}
a -> System.out.println("i like lamda-->"+a)
new Thread (()->System.out.println(“多线程学习。。。。”)).start()；
理解 Functional Interface (函数式接口)，是学习 Java 8 lambda 表达式的关键。

函数式接口的定义

任何接口，如果 只包含唯一 1 个抽象方法，那么它就是一个函数式接口。

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

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

推导 Lambda 表达式

案例 1：

package com.xxx.lambda;

/**
 * 推导 Lambda 表达式
 */
public class TestLambda01 {
    public static void main(String[] args) {
        // 接口方式创建对象
        ILike like = new Like();
        like.lambda();
    }
}

// 1.定义一下函数式接口
interface ILike {
    void lambda();
}

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

优化一：静态内部类方式

package com.xxx.lambda;

/**
 * 推导 Lambda 表达式
 */
public class TestLambda01 {
    // 3.静态内部类
    static class Like2 implements ILike {
        @Override
        public void lambda() {
            System.out.println("I like lambda 2");
        }
    }

    public static void main(String[] args) {
        // 静态内部类方式
        Like2 like2 = new Like2();
        like2.lambda();
    }
}

// 1.定义一下函数式接口
interface ILike {
    void lambda();
}

优化二：局部内部类方式

package com.xxx.lambda;

/**
 * 推导 Lambda 表达式
 */
public class TestLambda01 {   
    public static void main(String[] args) {        
        // 4.局部内部类
        class Like3 implements ILike {
            @Override
            public void lambda() {
                System.out.println("I like lambda 3");
            }
        }
        Like3 like3 = new Like3();
        like3.lambda();
    }
}

// 1.定义一下函数式接口
interface ILike {
    void lambda();
}

优化三：匿名内部类方式

package com.xxx.lambda;

/**
 * 推导 Lambda 表达式
 */
public class TestLambda01 {
    public static void main(String[] args) {
        // 5.匿名内部类：没有类的名称，必须借助接口或者父类
        ILike like4 = new ILike() {
            @Override
            public void lambda() {
                System.out.println("I like lambda 4");
            }
        };
        like4.lambda();
    }
}

// 1.定义一下函数式接口
interface ILike {
    void lambda();
}

最终版：用 Lambda 简化

package com.xxx.lambda;

/**
 * 推导 Lambda 表达式
 */
public class TestLambda01 {
    public static void main(String[] args) {
        // 6.用 Lambda 简化
        ILike like5 = () -> {
            System.out.println("I like lambda 5");
        };
        like5.lambda();
    }
}

// 1.定义一下函数式接口
interface ILike {
    void lambda();
}

案例 2：Lambda 表达式简化

package com.xxx.lambda;

/**
 * Lambda 表达式简化
 */
public class TestLambda02 {
    public static void main(String[] args) {
        ILove love = null;
        // 1.Lambda 表达式简化
        love = (int a) -> {
            System.out.println("I love you -> " + a);
        };
        // 简化1：去掉参数类型
        love = (a) -> {
            System.out.println("I love you -> " + a);
        };
        // 简化2：去掉括号
        love = a -> {
            System.out.println("I love you -> " + a);
        };
        // 简化3：去掉花括号
        love = a -> System.out.println("I love you -> " + a);

        /*
        总结：
        1.{} 简略的条件是，只能有一行代码,多行代码，{} 就不能简略
        2.前提是接口为函数式接口(只能有一个方法)
        3.多个参数也可以去掉参数类型,要去掉就全部去掉,但必须加上()
        */
        love.love(1);
    }
}
// 自定义接口
interface ILove {
    void love(int a);
}

lambda 表达式只有一行代码才能简化成，多行得用代码块。
hello = a->System.out.println("hello " + a);
多个参数需要括号，要去掉类型，所有参数都要去掉类型。
hello = (a, b)->System.out.println(a + " Hello " + b);

三、线程状态

1. 线程的五大状态

2. 线程方法

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

停止线程

实例：设置标志位，让线程停止

package com.xxx.state;

/**
 * 线程停止：测试 stop
 * 1.建议线程正常停止 --> 利用次数,不建议死循环
 * 2.建议使用标志位 --> 设置一个标志位
 * 3.不要使用 stop 或者 destroy 等过时或者 JDK 不建议使用的方法
 */
public class TestStop implements Runnable {
    // 1.设置一个标志位
    private Boolean flag = true;

    @Override
    public void run() {
        int i = 0;
        // 2.线程体使用该标志位
        while (flag) {
            System.out.println("run......Thread" + i++);
        }
    }

    // 3.自定义一个公开的方法，停止线程，转换标志位
    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("线程该停止了！");
            }
        }
    }
}

线程休眠

实例：模拟网络延时：放大问题的发生性

package com.xxx.state;

/**
 * 模拟网络延时：放大问题的发生性
 */
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();
            }
            // Thread.currentThread().getName() 获取线程名
            System.out.println(Thread.currentThread().getName() +
                    "-->拿到了第 " + ticketNums-- + " 张票");
        }
    }

    public static void main(String[] args) {
        TestSleep thread = new TestSleep();
        new Thread(thread, "用户1").start();
        new Thread(thread, "用户2").start();
        new Thread(thread, "用户3").start();
    }
}

实例：模拟倒计时

package com.xxx.state;

/**
 * 模拟倒计时
 */
public class TestSleep02 {
    public static void main(String[] args) {
        try {
            tenDown();
        } 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;
            }
        }
    }
}

实例：每隔一秒，获取当前时间

package com.xxx.state;

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

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

线程礼让

礼让线程，让当前正在执行的线程暂停，但不阻塞；
将线程从运行状态转为就绪状态；
让 CPU 重新调试，礼让不一定成功，主要看 CPU。
实例：

package com.xxx.state;

/**
 * 礼让线程
 * 礼让不一定成功，取决于 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() + "线程停止执行");
    }
}

礼让成功

图片.png

礼让不成功

线程插队

Join 合并线程，只能是当前线程执行完之后，才能执行其他线程，对其他线程造成阻塞；
可以想象成插队（强制执行）

实例：

package com.xxx.state;

/**
 * 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. 线程状态观测

public static enum Thread.State
extends Enum<Thread.State>

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

NEW：尚未启动的线程处于此状态。
RUNNABLE：在Java虚拟机中执行的线程处于此状态。
BLOCKED：被阻塞等待监视器锁定的线程处于此状态。
WAITING：正在等待另一个线程执行特定动作的线程处于此状态。
TIMED_WAITING：正在等待另一个线程执行动作达到指定等待时间的线程处于此状态。
TERMINATED：已退出的线程处于此状态。
一个线程可以在给定时间点处于一个状态。这些状态是不反映任何操作系统线程状态的虚拟机状态。
实例：

package com.xxx.state;

/**
 * 观测线程状态
 */
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);  // 输出状态
        }
        // 线程只开启一次：死亡后的线程不能再启动了，启动会报异常
        // thread.start();
    }
}

4. 线程优先级

Java 提供一个线程调度器，来监控程序中启动后，进入就绪状态的所有线程，线程调度器按照优先级，决定应该调度哪个线程来执行。
线程的优先级用数字表示，范围从1~10。
- 最小优先级：Thread.MIN_PRIORITY= 1;
- 最大优先级：Thread.MAX_PRIORITY = 10;
- 默认优先级：Thread.NORM_PRIORITY= 5;
使用以下方式获取或改变优先级
- getPriority() ，setPriority(int xxx)

注意：

先设置优先级再启动，优先级的设定，建议在 start() 调度前；
main 方法的默认优先级为 5；
理论上来说，优先级越高的越先执行，哪怕 start() 更晚；
优先级低，只意味着获得调度的概率低，并不是优先级低就不会被调用了，这都是看 CPU 的调度。

实例：

package com.xxx.state;

/**
 * 测试线程优先级：getPriority()
 */
public class TestPriority {
    public static void main(String[] args) {
        // 主线程优先级 main（Thread-0 --> 5）
        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();
        // MAX_PRIORITY=10 最大优先级
        t4.setPriority(Thread.MAX_PRIORITY);
        t4.start();
//        t5.setPriority(-1);   报错
//        t5.start();
//        t6.setPriority(11);   报错
//        t6.start();
    }
}

class MyPriority implements Runnable {

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

5. 守护（daemon）线程

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

package com.xxx.state;

/**
 * 守护线程
 */
public class TestDaemon {
    public static void main(String[] args) {
        Guard guard = new Guard();
        You you = new You();
        Thread thread = new Thread(guard);
        // 默认 false：表示是用户线程，正常线程都是用户线程
        thread.setDaemon(true);
        // 守护线程启动
        thread.start();
        // 用户线程启动
        new Thread(you).start();
    }
}

// 守护线程
class Guard implements Runnable {
    @Override
    public void run() {
        while (true) {
            System.out.println("守护线程一直运行");
        }
    }
}

// 用户线程
class You implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("用户线程 " + i);
        }
        System.out.println("------用户线程结束------");
    }
}

四、线程同步

1. 介绍

多个线程操作同一个资源 ；
并发：同一个对象，被多个线程同时操作。

现实生活中，我们会遇到 同—个资源，多个人都想使用 的问题，比如：食堂排队打饭，每个人都想吃饭，最天然的解決办法就是：排队，一个个来。
处理多线程问题时，多个线程访问同一个对象，并且，某些线程还想修改这个对象，这时，就需要线程同步。
线程同步：其实就是一种等待机制，多个需要同时访问此对象的线程，进入这个 对象的等待池 形成队列，等待前面线程使用完毕，下一个线程再使用。

队列和锁

队列：排队
锁：每个对象都有把锁，当获取对象时，独占资源，其他线程必须等待，使用结束后才释放。

线程同步：

由于同一进程的多个线程，共享同一块存储空间，在带来方便的同时，也带来了访问冲突问题，为了保证数据，在方法中被访问时的正确性，在访问时加入 锁机制 synchronized。
当一个线程获得对象的排它锁，独占资源，其他线程必须等待，使用后释放锁即可。
锁机制，存在以下问题：
- 一个线程持有锁，会导致其他所有需要此锁的线程挂起；
- 在多线程竞争下，加锁，释放锁，会导致比较多的上下文切换，和调度延时，引起性能问题；
- 如果一个优先级高的线程，等待一个优先级低的线程释放锁，会导致优先级倒置，引起性能问题。

2. 不安全的线程案例

实例 1：

package com.xxx.syn;

/**
 * 多线程不安全实例：不安全买票
 * 线程不安全：有负数
 */
public class UnsafeBuyTicket {
    public static void main(String[] args) {
        BuyTicket station = new BuyTicket();

        new Thread(station, "用户1").start();
        new Thread(station, "用户2").start();
        new Thread(station, "用户3").start();
    }
}

class BuyTicket implements Runnable {
    // 票
    private int ticketNums = 10;
    // 外部停止标志
    private 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：

package com.xxx.syn;

/**
 * 不安全取钱：两个人同时取一个账户的钱
 */
public class UnsafeBank {
    public static void main(String[] args) {
        // 账户
        Account account = new Account(100, "个人账户");
        Drawing youA = new Drawing(account, 50, "YouA");
        Drawing youB = new Drawing(account, 100, "YouB");
        youA.start();
        youB.start();
    }
}

//账户
class Account {
    int money;  // 余额
    String cardName;    // 卡名

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

// 银行：模拟取款
class Drawing extends Thread {
    // 账户
    Account account;
    // 取钱
    int drawingMoney;
    // 手里的钱
    int nowMoney;

    public Drawing(Account account, int drawingMoney, String name) {
        // super(name) =  父类构造方法(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;
        }
        // 延时：可以放大问题的发生性
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 卡内余额 = 余额 - 取的钱
        account.money = account.money - drawingMoney;
        // 手里的钱
        nowMoney = nowMoney + drawingMoney;
        System.out.println(account.cardName + "余额为：" + account.money);
        // Thread.currentThread().getName() = this.getName()
        System.out.println(this.getName() + "手里的钱：" + nowMoney);
    }
}

实例 3：

package com.xxx.syn;

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

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

3. 同步方法

由于可以通过 private 关键字，来保证数据对象，只能被方法访问，所以只需要针对方法，提岀一套机制，这套机制就是： synchronized 关键字，它包括两种用法: synchronized 方法 和 synchronized 块。
- 同步方法：public synchronized void method (int args) {}
synchronized 方法，控制对 “对象” 的访问，每个对象对应一把锁，每个 synchronized 方法，都必须获得调用该方法的对象的锁，才能执行，否则线程会阻塞，方法一旦执行，就独占该锁，直到该方法返回，才释放锁，后面被阻塞的线程，才能获得这个锁，继续执行。
- 缺陷：若将一个大的方法，申明为 synchronized 将会影响效率。
实例 1：同步方法

package com.xxx.syn;

/**
 * 安全买票
 * 同步方法：synchronized
 */
public class SafeBuyTicket {
    public static void main(String[] args) {
        BuyTicket station = new BuyTicket();

        new Thread(station, "用户1").start();
        new Thread(station, "用户2").start();
        new Thread(station, "用户3").start();
    }
}

class BuyTicket implements Runnable {
    // 票
    private int ticketNums = 10;
    // 外部停止标志
    private Boolean flag = true;

    @Override
    public void run() {
        // 买票
        while (flag) {
            try {
                buy();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    // 买票
    // synchronized 同步方法，锁的是 this
    private synchronized void buy() throws InterruptedException {
        // 判断是否有票
        if (ticketNums <= 0) {
            flag = false;
            return;
        }
        // 模拟延时
        Thread.sleep(100);
        System.out.println(Thread.currentThread().getName() +
                "拿到了第 " + ticketNums-- + " 张票");
    }
}

4. 同步块

同步块：synchronized (Obj) {}
Obj 称之为同步监视器
- Obj 可以是任何对象，但是推荐使用共享资源，作为同步监视器。
- 同步方法中，无需指定同步监视器，因为同步方法的同步监视器，就是 this，就是这个对象本身，或者是 class。
同步监视器的执行过程：
1. 第一个线程访问，锁定同步监视器，执行其中代码；
2. 第二个线程访问，发现同步监视器被锁定，无法访问；
3. 第一个线程访问完毕，解锁同步监视器；
4. 第二个线程访问，发现同步监视器没有锁，然后锁定并访问。
同步块：锁的对象就是变化的量，需要增、删、改的对象
实例 2：同步块

package com.xxx.syn;

/**
 * 安全取钱：两个人同时取一个账户的钱
 * 同步块：synchronized (Obj) {}
 * 锁的对象就是变化的量,需要增、删、改的对象
 */
public class SafeBank {
    public static void main(String[] args) {
        // 账户
        Account account = new Account(1000, "个人账户");
        Drawing youA = new Drawing(account, 50, "YouA");
        Drawing youB = new Drawing(account, 100, "YouB");
        youA.start();
        youB.start();
    }
}

//账户
class Account {
    int money;  // 余额
    String cardName;    // 卡名

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

// 银行：模拟取款
class Drawing extends Thread {
    // 账户
    Account account;
    // 取钱
    int drawingMoney;
    // 手里的钱
    int nowMoney;

    public Drawing(Account account, int drawingMoney, String name) {
        // super(name) =  父类构造方法(name)
        super(name);
        this.account = account;
        this.drawingMoney = drawingMoney;
    }

    // 取钱
    // synchronized 默认锁的是 this
    @Override
    public void run() {
        // 同步块：锁的对象就是变化的量,需要增、删、改的对象
        synchronized (account) {
            // 判断有没有钱
            if (account.money - drawingMoney < 0) {
                System.out.println(Thread.currentThread().getName() + " 钱不够，取不了！");
                return;
            }
            // 延时：可以放大问题的发生性
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // 卡内余额 = 余额 - 取的钱
            account.money = account.money - drawingMoney;
            // 手里的钱
            nowMoney = nowMoney + drawingMoney;
            System.out.println(account.cardName + "余额为：" + account.money);
            // Thread.currentThread().getName() = this.getName()
            System.out.println(this.getName() + "手里的钱：" + nowMoney);
        }
    }
}

方法里面有需要修改的内容，才需要锁，锁的太多，会浪费资源。
实例 3：同步块，线程安全的集合

package com.xxx.syn;

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

/**
 * 线程安全的集合
 * 同步块：synchronized (Obj) {}
 */
public class SafeList {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        for (int i = 0; i < 10000; i++) {
            new Thread(() -> {
                // 同步块
                synchronized (list) {
                    list.add(Thread.currentThread().getName());
                }
            }).start();
        }
        // 延时
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(list.size());
    }
}

JUC 安全集合类型扩充

实例：

package com.xxx.syn;

import java.util.concurrent.CopyOnWriteArrayList;

/**
 * concurrent 并发：测试 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) {
            e.printStackTrace();
        }
        System.out.println(list.size());
    }
}

5. 死锁

多个线程，各自占有一些共享资源，并且，互相等待其他线程占有的资源，才能运行，而导致两个或者多个线程，都在等待对方释放资源，都停止执行的情形。某一个同步块，同时拥有 两个以上对象的锁 时，就可能会发生死锁的问题。
实例：程序锁死

package com.xxx.syn;

/**
 * 死锁：多个线程互相抱着对方需要的资源，然后形成僵持
 * 解决：一个锁只锁一个对象
 */
public class DeadLock {
    public static void main(String[] args) {
        Makeup g1 = new Makeup(0, "girl001");
        Makeup g2 = new Makeup(1, "girl002");
        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);
                // 1 秒后，获得镜子的锁
                synchronized (mirror) {
                    System.out.println(this.girlName + "获得镜子的锁");
                }
            }
        } else {
            // 获得镜子的锁
            synchronized (mirror) {
                System.out.println(this.girlName + "获得镜子的锁");
                // 延时
                Thread.sleep(2000);
                // 2 秒后，获得口红的锁
                synchronized (lipstick) {
                    System.out.println(this.girlName + "获得口红的锁");
                }
            }
        }
    }
}

实例：解决死锁问题

package com.xxx.syn;

/**
 * 死锁：多个线程互相抱着对方需要的资源，然后形成僵持
 * 解决：一个锁只锁一个对象
 */
public class DeadLock {
    public static void main(String[] args) {
        Makeup g1 = new Makeup(0, "girl001");
        Makeup g2 = new Makeup(1, "girl002");
        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);
            }
            // 1 秒后，获得镜子的锁
            synchronized (mirror) {
                System.out.println(this.girlName + "获得镜子的锁");
            }
        } else {
            // 获得镜子的锁
            synchronized (mirror) {
                System.out.println(this.girlName + "获得镜子的锁");
                // 延时
                Thread.sleep(2000);
            }
            // 2 秒后，获得口红的锁
            synchronized (lipstick) {
                System.out.println(this.girlName + "获得口红的锁");
            }
        }
    }
}

避免死锁的办法

产生死锁的四个必要条件
1. 互斥条件：一个资源毎次只能被一个进程使用；
2. 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放；
3. 不剥夺条件∶进程已获得的资源，在末使用完之前，不能强行剥夺；
4. 循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系。
上面列出了死锁的四个必要条件，只要想办法破其中的任意一个，或多个条件，就可以避免死锁发生。

6. Lock（锁）

从 JDK 5.0 开始，Java 提供了更强大的线程同步机制：通过显式定义同步锁对象，来实现同步。同步锁使用 Lock 对象充当。
java.util.concurrent.locks.Lock 接口，是控制多个线程，对共享资源进行访问的工具。锁，提供了对共享资源的独占访问，每次只能有一个线程，对 Lock 对象加锁，线程开始访问共享资源之前，应先获得 Lock 对象。
ReentrantLock 类，实现了 Lock，它拥有与 synchronized 相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是 ReentrantLock，可以显式加锁、释放锁。
锁代码格式

class A{
    private final ReentrantLock lock = new ReentrantLock();
    public void m(){
        lock.lock();
        try{
            // 保证线程安全的代码
        }
        finally{
            lock.unlock();
            // 如果同步代码有异常，要将unlock()写入finally语句块
        } 
    }
}

实例：测试 Lock 锁

package com.xxx.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 {
    // 票
    private 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();
            }
        }
    }
}

7. synchroized 与 Lock 对比

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

五、线程通信问题

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

1. 线程通信方法

Java提供了几个方法解决线程之间的通信问题。

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

注意：均是 Object 类的方法，都只能在同步方法，或者同步代码块中使用，否则会抛出异常 IIIegalMonitorStateException。
这是一个线程同步问题，生产者和消费者共享同一个资源，并且生产者和消费者之间相互依赖，互为条件：
- 对于生产者，没有生产产品之前，要通知消费者等待。而生产了产品之后，又需要马上通知消费者消费；
- 对于消费者，在消费之后，要通知生产者已经结束消费，需要生产新的产品以供消费；
- 在生产者消费者问题中，仅有 synchronized 是不够的：
  - synchronized 可阻止并发更新同一个共享资源，实现了同步；
  - synchronized 不能用来实现不同线程之间的消息传递（通信）。

2. 线程通信问题解决方式

解决方式 1：管程法

并发协作模型，生产者/消费者模式 —> 管程法：
- 生产者：负责生产数据的模块（可能是方法，对象，线程，进程）；
- 消费者：负责处理数据的模块（可能是方法，对象，线程，进程）；
- 缓冲区：消费者不能直接使用生产者的数据，他们之间有个 缓冲区。
生产者将生产好的数据放入缓冲区，消费者从缓冲区拿出数据。
实例：管程法

package com.xxx.gaoji;

/**
 * 测试:生产者消费者模型-->利用缓冲区解决:管程法
 * 生产者、消费者、产品、缓冲区
 */
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 Product(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 Product {
    // 产品编号
    int id;

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

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

    // 生产者放入产品
    public synchronized void push(Product product) {
        // 如果容器满了，就需要等待消费者消费
        /*
        如果是 if 的话，假如消费者1 消费了最后一个，
        这时 index 变成 0 此时释放锁，被消费者2 拿到，而不是生产者拿到，
        这时消费者的 wait 是在 if 里，所以它就直接去消费 index-1 下标越界，
        如果是 while 就会再去判断一下 index 得值是不是变成 0 了
        */
        while (count == products.length) {
            // 生产等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        // 如果没有满，就需要放入产品
        products[count] = product;
        count++;
        // 通知消费者消费
        this.notify();
    }

    // 消费者消费产品
    public synchronized Product pop() {
        // 判断能否消费
        while (count <= 0) {
            // 等待生产者生产，消费者等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        // 如果可以消费
        count--;
        Product product = products[count];
        // 消费完了，通知生产者生产
        this.notify();
        return product;
    }
}

解决方式 2：信号灯法

并发协作模型：生产者/消费者模式 —> 信号灯法。
实例：

package com.xxx.gaoji;

/**
 * 测试:生产者消费者模型 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("节目--1");
            } else {
                this.tv.play("节目--2");
            }
        }
    }
}

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

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

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            this.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.notifyAll();
        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.notifyAll();
        this.flag = !this.flag;
    }
}

六、线程池

背景：经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大。
思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具。
好处：
- 提高响应速度（减少了创建新线程的时间）；
- 降低资源消耗（重复利用线程池中线程，不需要毎次都创建）；
- 便于线程管理（…）
  - corePoolSize：核心池的大小；
  - maximumPoolSize：最大线程数；
  - keepAliveTime：线程没有任务时，最多保持多长时间后会终止。
JDK 5.0 起提供了线程池相关 API：ExecutorService 和 Executors。
ExecutorService：真正的线程池接口。常见子类 ThreadPoolExecutor。
- void execute（ Runnable command）：执行任务命令，没有返回值，一般用来执行 Runnable；
- <T> Future<T> submit（ Callable<T>task）：执行任务，有返回值，一般又来执行 Callable；
- void shutdown()：关闭连接池。
Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池。
实例：线程池

package com.xxx.gaoji;

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);

        // 执行 Runnable 接口的实现类
        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() {
        System.out.println(Thread.currentThread().getName());
    }
}

总结：

package com.xxx.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) {
        // 1.继承 Thread 类
        new MyThread1().start();
        // 2.实现 Runnable 接口
        new Thread(new MyThread2()).start();
        // 3.实现 Callable 接口
        FutureTask<Integer> futureTask = new FutureTask(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");
    }
}

// 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;
    }
}

Java 基础 10. Java 多线程

一、线程简介

1. 程序进程、线程

2. 线程的核心概念

二、线程创建

1. 线程创建三种方式：

2. 静态代理

3. Lambda 表达式

三、线程状态

1. 线程的五大状态

2. 线程方法

3. 线程状态观测

4. 线程优先级

5. 守护（daemon）线程

四、线程同步

1. 介绍

2. 不安全的线程案例

3. 同步方法

4. 同步块

5. 死锁

6. Lock（锁）

7. synchroized 与 Lock 对比

五、线程通信问题

1. 线程通信方法

2. 线程通信问题解决方式

六、线程池

猜你喜欢

热点阅读