多线程

基本概念：程序、进程、线程

• 程序(program)是为完成特定任务、用某种语言编写的一组指令的有序集合。即指一段静态的代码，其本身没有任何运行的含义，是一个静态对象。
• 进程(process)是程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程：有它自身的产生、存在和消亡的过程。——生命周期
  • 程序是静态的，进程是动态的
  • 进程作为系统资源分配的单位，系统在运行时会为每个进程分配不同的内存区域
• 线程(thread)，进程可进一步细化为线程，是一个程序内部的一条执行路径。
  • 若一个进程同一时间并行执行多个线程，就是支持多线程的
  • 线程是CPU调度和执行的单位，每个线程拥有独立的运行栈和程序计数器(pc)，线程切换的开销小。
  • 通常一个进程中可以包含多个线程，当然一个进程中至少有一个线程，不然没有存在的意义。
  • 一个进程中的多个线程共享相同的内存单元/内存地址空间 —> 它们从同一堆中分配对象，可以访问相同的变量和对象，使得线程间通信更简便、高效。但多个线程操作共享的系统资源可能就会带来安全的隐患。

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

1）进程与线程

• 单核CPU和多核CPU的理解
  • 单核CPU，其实是一种假的多线程，因为在一个时间单元内，只能执行一个线程的任务。但是因为CPU时间单元特别短，因此感觉不出来。
  • 如果是多核的话，才能更好的发挥多线程的效率。
  • 一个Java应用程序java.exe，其实至少有三个线程：main()主线程，gc()垃圾回收线程，异常处理线程。当然如果发生异常，会影响主线程。
• 并行与并发
  • 并行：多个CPU同时执行多个任务。比如：多个人同时做不同的事。
  • 并发：一个CPU(采用时间片)同时执行多个任务。比如：秒杀、多个人做同一件事。

2）普通方法调用和多线程

3）使用多线程的优点

• 提高应用程序的响应。对图形化界面更有意义，可增强用户体验。
• 提高计算机系统CPU的利用率
• 改善程序结构。将既长又复杂的进程分为多个线程，独立运行，利于理解和修改

4）何时需要多线程

• 程序需要同时执行两个或多个任务。
• 程序需要实现一些需要等待的任务时，如用户输入、文件读写操作、网络操作、搜索等。
• 需要一些后台运行的程序时。

5）本章核心概念

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

线程创建和使用（重点）

• Java语言的JVM允许程序运行多个线程，它通过java.lang.Thread类来体现。
• Thread类的特性
  • 每个线程都是通过某个特定Thread对象的run()方法来完成操作的，经常把run()方法的主体称为线程体
  • 通过该Thread对象的start()方法来启动这个线程，而非直接调用run()
• 构造器
  • Thread()：创建新的Thread对象
  • Thread(String threadname)：创建线程并指定线程实例名
  • Thread(Runnabletarget)：指定创建线程的目标对象，它实现了Runnable接口中的run方法
  • Thread(Runnable target, String name)：创建新的Thread对象

1）三种创建方式

• JDK1.5之前创建新执行线程有两种方法：
  • 继承Thread类的方式
  • 实现Runnable接口的方式

2）继承Thread类

学习提示：查看JDK帮助文档

• 自定义线程类继承Thread类。
• 子类中重写Thread类中的run()方法，编写线程执行体。
• 创建Thread子类对象，即创建了线程对象。
• 调用线程对象的start()方法：启动线程，调用run方法。

注意：线程不一定立即执行，CPU安排调度

package com.wang.thread;
//创建线程方式一：基础Thread类，重写run()方法，调用start开启线程
public class ThreadTest01 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()线程，主线程
        //创建一个线程对象
        ThreadTest01 threadTest01 = new ThreadTest01();
        //调用start()方法开启线程
        threadTest01.start();
        for (int i = 0; i < 200; i++) {
            System.out.println("我再学习多线程--" + i);
        }
    }
}

• 注意点：
  • 如果自己手动调用run()方法，那么就只是普通方法，没有启动多线程模式。
  • run()方法由JVM调用，什么时候调用，执行的过程控制都由操作系统的CPU调度决定。
  • 想要启动多线程，必须调用start方法。
  • 一个线程对象只能调用一次start()方法启动，如果重复调用了，则将抛出以上的异常“IllegalThreadStateException”。

案例：实现多线程下载图片

package com.wang.thread;
import org.apache.commons.io.FileUtils;
import java.io.File;
import java.io.IOException;
import java.net.URL;
//练习Thread,实现多线程同步下载图片
public class ThreadTest02 extends Thread {
    private String url;  //网络图片地址
    private String name;  //保存的文件名
    public ThreadTest02(String url, String name) {
        this.url = url;
        this.name = name;
    }
    //重写run()方法
    @Override
    public void run() {
        //run()方法的执行体 - 下载图片线程的执行体
        WebDownloader webDownloader = new WebDownloader();
        webDownloader.downloader(url, name);
        System.out.println("下载的文件名为：" + name);
    }
    //主线程 
    public static void main(String[] args) {
        ThreadTest02 t1 = new ThreadTest02("https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/70535af2cf4d4887ae52faa218600606~tplv-k3u1fbpfcp-no-mark:480:400:0:0.awebp?", "1.jpg");
        ThreadTest02 t2 = new ThreadTest02("https://p6-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/08787c0586aa4ee680de770873deb0c6~tplv-k3u1fbpfcp-zoom-crop-mark:1304:1304:1304:734.awebp", "2.jpg");
        ThreadTest02 t3 = new ThreadTest02("https://pic1.zhimg.com/v2-19effed5b68c877608d720d205c6f37d_1440w.jpg?source=172ae18b", "3.jpg");
        //调用start()方法开启线程
        t1.start();
        t2.start();
        t3.start();
    }
}
//下载器
class WebDownloader {
    //下载方法
    public void downloader(String url, String name) {
        try {
            FileUtils.copyURLToFile(new URL(url), new File(name));
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("IO异常，downloader方法出现问题！");
        }
    }
}

运行结果：

Thread类的有关方法

• start(): 启动线程，并执行对象的run()方法
• run(): 线程在被调度时执行的操作
• String getName(): 返回线程的名称
• void setName(String name): 设置该线程名称
• static Thread currentThread(): 返回当前线程。在Thread子类中就是this，通常用于主线程和Runnable实现类
• static void yield()： 线程让步
  • 暂停当前正在执行的线程，把执行机会让给优先级相同或更高的线程
  • 若队列中没有同优先级的线程，忽略此方法
• join()：当某个程序执行流中调用其他线程的join() 方法时，调用线程将被阻塞，直到join() 方法加入的join线程执行完为止
  • 低优先级的线程也可以获得执行
• static void sleep(long millis)：(指定时间:毫秒)
  • 令当前活动线程在指定时间段内放弃对CPU控制,使其他线程有机会被执行,时间到后重排队。
  • 抛出InterruptedException异常
• stop(): 强制线程生命期结束，不推荐使用。
• booleanisAlive()：返回boolean，判断线程是否还活着

3）实现Runable接口

学习提示：查看JDK帮助文档

• 定义子类，实现Runnable接口。
• 子类中重写Runnable接口中的run方法。
• 通过Thread类含参构造器创建线程对象。
• 将Runnable接口的子类对象作为实际参数传递给Thread类的构造器中。
• 调用Thread类的start方法：开启线程，调用Runnable子类接口的run方法。

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

package com.wang.thread;
//创建线程方式二： 实现runnable接口，重写run方法，执行线程需要丢入runnable接口实现类，调用start方法开启线程。
public class ThreadTest03 implements Runnable {
    @Override
    public void run() {
        //run()方法线程体
        for (int i = 0; i < 20; i++) {
            System.out.println("我在看代码--" + i);
        }
    }
    public static void main(String[] args) {
        //main()线程，主线程
        //创建runnable接口的实现类对象
        ThreadTest03 threadTest03 = new ThreadTest03();
        //创建线程对象，通过线程对象来开启线程 -- 代理
        //Thread thread = new Thread(threadTest03);
        //thread.start();
        new Thread(threadTest03).start();
        for (int i = 0; i < 200; i++) {
            System.out.println("我再学习多线程--" + i);
        }
    }
}

案例：用Runnable接口实现多线程下载图片

package com.wang.thread;
import org.apache.commons.io.FileUtils;
import java.io.File;
import java.io.IOException;
import java.net.URL;
//用Runnable接口实现多线程同步下载图片
public class ThreadTest04 implements Runnable {
    private String url;  //网络图片地址
    private String name;  //保存的文件名
    public ThreadTest04(String url, String name) {
        this.url = url;
        this.name = name;
    }
    //重写run()方法
    @Override
    public void run() {
        //run()方法的执行体 - 下载图片线程的执行体
        WebDownloader01 webDownloader = new WebDownloader01();
        webDownloader.downloader(url, name);
        System.out.println("下载的文件名为：" + name);
    }
    //主线程
    public static void main(String[] args) {
        ThreadTest02 t1 = new ThreadTest02("https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/70535af2cf4d4887ae52faa218600606~tplv-k3u1fbpfcp-no-mark:480:400:0:0.awebp?", "1.jpg");
        ThreadTest02 t2 = new ThreadTest02("https://p6-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/08787c0586aa4ee680de770873deb0c6~tplv-k3u1fbpfcp-zoom-crop-mark:1304:1304:1304:734.awebp", "2.jpg");
        ThreadTest02 t3 = new ThreadTest02("https://pic1.zhimg.com/v2-19effed5b68c877608d720d205c6f37d_1440w.jpg?source=172ae18b", "3.jpg");
        //调用start()方法开启线程
        new Thread(t1).start();
        new Thread(t2).start();
        new Thread(t3).start();
    }
}
//下载器
class WebDownloader01 {
    //下载方法
    public void downloader(String url, String name) {
        try {
            FileUtils.copyURLToFile(new URL(url), new File(name));
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("IO异常，downloader方法出现问题！");
        }
    }
}

小结

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

继承方式和实现方式的联系与区别
**public class Thread extends Objectimplements Runnable**

• 区别
  • 继承Thread：线程代码存放Thread子类run方法中。
  • 实现Runnable：线程代码存在接口的子类的run方法。
• 实现方式的好处
  • 避免了单继承的局限性
  • 多个线程可以共享同一个接口实现类的对象，非常适合多个相同线程来处理同一份资源。

package com.wang.thread;
//多个线程操作同一个对象
//买火车票的例子
//发现问题：多个线程操作同一个资源的情况下，线程不安全，数据紊乱。
public class ThreadTest05 implements Runnable {
    //票数
    private int ticketNums = 10;
    //重写run方法
    @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) {
        ThreadTest05 ticket = new ThreadTest05();
        new Thread(ticket, "小明").start();
        new Thread(ticket, "老师").start();
        new Thread(ticket, "黄牛党").start();
    }
}

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

案例：龟兔赛跑- Race

• 首先来个赛道距离，然后要离终点越来越近
• 判断比赛是否结束
• 打印出胜利者
• 龟兔赛跑开始
• 故事中是乌龟赢的，兔子需要睡觉，所以需要模拟兔子睡觉
• 最终，乌龟赢的比赛。 ```java package com.wang.thread;

//模拟龟兔赛跑 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;
    }{
        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();
      //调用start方法开启线程
    new Thread(race, "乌龟").start();
    new Thread(race, "兔子").start();
}

}

<a name="059f3bff"></a>
### 4）实现Callable接口（了解即可）
1.  实现Callable接口，需要返回值类型 
2.  重写call方法，需要抛出异常 
3.  创建目标对象 
4.  创建执行服务：`**ExecutorService ser = Executors.newFixedThreadPool(1);**` 
5.  提交执行：`**Future<Boolean> result1 = ser.submit(t1);**` 
6.  获取结果：`**boolean r1 = result1.get()**` 
7.  关闭服务：`**ser.shutdownNow();**` 
```java
package com.wang.thread.callable;
import org.apache.commons.io.FileUtils;
import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.util.concurrent.*;
//线程创建方式三：实现callable接口
/*
callable好处：
1.可以定义返回值
2.可以抛出异常
 */
public class CallableTest implements Callable<Boolean> {
    private String url;  //网络图片地址
    private String name;  //保存的文件名
    public CallableTest(String url, String name) {
        this.url = url;
        this.name = name;
    }
    //下载图片线程的执行体
    @Override
    public Boolean call() throws Exception {
        WebDownloader02 webDownloader = new WebDownloader02();
        webDownloader.download(url, name);
        System.out.println("下载的文件名为：" + name);
        return true;
    }
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CallableTest t1 = new CallableTest("https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/70535af2cf4d4887ae52faa218600606~tplv-k3u1fbpfcp-no-mark:480:400:0:0.awebp?", "1.jpg");
        CallableTest t2 = new CallableTest("https://p6-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/08787c0586aa4ee680de770873deb0c6~tplv-k3u1fbpfcp-zoom-crop-mark:1304:1304:1304:734.awebp", "2.jpg");
        CallableTest t3 = new CallableTest("https://pic1.zhimg.com/v2-19effed5b68c877608d720d205c6f37d_1440w.jpg?source=172ae18b", "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();
        //关闭服务
        ser.shutdown();
    }
}
//下载器
class WebDownloader02 {
    //下载方法
    public void download(String url, String name) {
        try {
            FileUtils.copyURLToFile(new URL(url), new File(name));
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("IO异常，downloader方法出现问题！");
        }
    }
}

5）静态代理模式

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

package com.wang.thread;
public class StaticProxy {
    public static void main(String[] args) {
        You you = new You();
        new Thread(() -> System.out.println("我爱你")).start(); //lambda表达式
        new WeddingCompany(new You()).HappyMarry();
    }
}
interface Marry {
    void HappyMarry();
}
//真实角色
class You implements Marry {
    @Override
    public void HappyMarry() {
        System.out.println("要结婚了，超开心！");
    }
}
//代理角色
class WeddingCompany implements Marry {
    private Marry target;
    public WeddingCompany(Marry target) {
        this.target = target;
    }
    @Override
    public void HappyMarry() {
        before();
        this.target.HappyMarry();
        after();
    }
    private void after() {
        System.out.println("结婚之后，收尾款！");
    }
    private void before() {
        System.out.println("结婚之前，布置现场！");
    }
}

静态代理模式总结：

• 真实对象和代理对象都要实现同一个接口
• 代理对象要代理真实角色

好处：

• 代理对象可以做很多真实对象做不了的事情
• 真实对象专注于做自己的事情

6）Lamda表达式

• λ 希腊字母表中排序第十一位的字母，英语名称为Lambda
• 避免匿名内部类定义过多
• 其实质属于函数式编程的概念

  （params）-> expression [ 表达式 ]
  （params）-> statement [ 语句 ]
  （params）-> { statements }

  

为什么要使用lambda表达式?

• 避免匿名内部类定义过多
• 让代码看起来很简洁
• 去掉没有意义的代码，只留下核心的逻辑
• 理解Functional Interface（函数式接口）是学习Java8 lambda表达式的关键所在。

• 函数式接口的定义：

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

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

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

代码推导lambda表达式

package com.wang.lambda;
//推导lambda表达式
public class LambdaTest {
    //3.静态内部类
    static class Like2 implements ILike {
        @Override
        public void lambda() {
            System.out.println("I like lambda2");
        }
    }
    public static void main(String[] args) {
        ILike like = new Like();
        like.lambda();
        like = new Like2();
        like.lambda();
        //4.局部内部类
        class Like3 implements ILike {
            @Override
            public void lambda() {
                System.out.println("I like lambda3");
            }
        }
        like = new Like3();
        like.lambda();
        //5.匿名内部类 --类没有名称，必须借助接口或父类
        like = new ILike() {
            @Override
            public void lambda() {
                System.out.println("I like lambda4");
            }
        };
        like.lambda();
        //6.用lambda简化
        like = () -> {
            System.out.println("I like lambda5");
        };
        like.lambda();
    }
}
//1.定义一个函数式接口
interface ILike {
    void lambda();
}
//2.实现类
class Like implements ILike {
    @Override
    public void lambda() {
        System.out.println("I like lambda");
    }
}

案例

package com.wang.lambda;
public class LambdaTest02 {
    public static void main(String[] args) {
        ILove love = null;
        //1.lambda表达式简化
        love = (int a, int b, int c) -> {
            System.out.println("I love you -->" + a);
            System.out.println("I love you -->" + b);
            System.out.println("I love you -->" + c);
        };
        //简化1：去掉参数类型
        love = (a, b, c) -> {
            System.out.println("I love you -->" + a);
            System.out.println("I love you -->" + b);
            System.out.println("I love you -->" + c);
        };
        //简化2：简化括号
        //love = a -> {
        //    System.out.println("I love you -->" + a);
        //};
        //简化3:去掉花括号
        //love = a -> System.out.println("I love you -->" + a);
        love.love(520, 520, 250);
    }
}
//定义一个函数式接口
interface ILove {
    void love(int a, int b, int c);
}

总结：

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

线程的生命周期

1）线程状态

• JDK中用Thread.State类定义了线程的几种状态
  要想实现多线程，必须在主线程中创建新的线程对象。Java语言使用Thread类及其子类的对象来表示线程，在它的一个完整的生命周期中通常要经历如下的五种状态：
  • 新建：当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态
  • 就绪：处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已具备了运行的条件，只是没分配到CPU资源
  • 运行：当就绪的线程被调度并获得CPU资源时,便进入运行状态，run()方法定义了线程的操作和功能
  • 阻塞：在某种特殊情况下，被人为挂起或执行输入输出操作时，让出CPU并临时中止自己的执行，进入阻塞状态
  • 死亡：线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结束

2）线程方法

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

3）停止线程

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

//测试停止线程 //1.建议线程正常停止 ——> 利用次数，不建议死循环 //2.建议使用标志位 ——> 设置一个标志位 //3.不要使用stop 或者destroy等过时或JDK不建议使用的方法

public class StopTest implements Runnable { //1.设置一个标识位 private boolean flag = true;

@Override
public void run() {
    int i = 0;
    while (true) {
        System.out.println("run...Thread" + i);
    }
}
//2.设置一个公开的方法停止线程，转换标识位
public void stop() {
    this.flag = false;
}
public static void main(String[] args) {
    StopTest stopTest = new StopTest();
    new Thread(stopTest).start();
    for (int i = 0; i < 1000; i++) {
        System.out.println("main --> " + i);
        if (i == 900) {
            //调用stop方法切换标识位，让线程停止
            stopTest.stop();
            System.out.println("线程该停止了！");
        }
    }
}

}

<a name="b2390e61"></a>
### 4）线程休眠-sleep
- sleep (时间) 指定当前线程阻塞的毫秒数。（1000毫秒=1秒）
- sleep存在异常InterruptedException。
- sleep时间达到后线程进入就绪状态。
- sleep可以模拟网络延时、倒计时等。
- **每一个对象都有一个锁，sleep不会释放锁。**
**演示：模拟网络延时**
```java
package com.wang.thread.sleep;
//模拟网络延时：放大问题的发生性
public class SleepTest implements Runnable{
    //票数
    private int tickNums =10;
    @Override
    public void run() {
        while (true){
            if (tickNums<=0){
                break;
            }
            //模拟网络延时
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+" --> 拿到了第"+tickNums--+"张票");
        }
    }
    public static void main(String[] args) {
        SleepTest ticket = new SleepTest();
        new Thread(ticket,"小明").start();
        new Thread(ticket," 老师").start();
        new Thread(ticket,"黄牛").start();
    }
}

演示：模拟倒计时

package com.wang.thread.sleep;
//模拟倒计时
public class SleepTest02 {
    public static void main(String[] args) {
        try {
            tenDown();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
      //10秒倒计时
    public static void tenDown() throws InterruptedException {
        int num = 10;
        while (true) {
            Thread.sleep(1000);
            System.out.println(num--);
            if (num <= 0) {
                break;
            }
        }
    }
}

演示：打印系统当前时间

package com.wang.thread.sleep;
import java.text.SimpleDateFormat;
import java.util.Date;
public class SleepTest03 {
    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();
            }
        }
    }
}

5）线程礼让-yield

• 礼让线程，让当前正在执行的线程暂停，但不阻塞
• 将线程从运行状态转为就绪状态
• 让cpu重新调度，礼让不一定成功！看CPU心情 ```java package com.wang.thread.yield;

//测试礼让线程 //由CPU重新调度，礼让不一定成功，看CPU心情 public class YieldTest { 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() + "线程停止执行");
}

}

![](https://gitee.com/wang_jin0751/image-host/raw/master/202205051414693.png#crop=0&crop=0&crop=1&crop=1&height=199&id=U72F9&originHeight=398&originWidth=1660&originalType=binary&ratio=1&rotation=0&showTitle=false&status=done&style=none&title=&width=830)<br />礼让成功。<br />![](https://gitee.com/wang_jin0751/image-host/raw/master/202205051416887.png#crop=0&crop=0&crop=1&crop=1&height=143&id=M2CKj&originHeight=286&originWidth=1506&originalType=binary&ratio=1&rotation=0&showTitle=false&status=done&style=none&title=&width=753)
没有礼让成功。
<a name="bccc1b09"></a>
### 6）join
- Join合并线程，待此线程执行完成后，再执行其他线程，其他线程阻塞
- 可以想象成插队
```java
package com.wang.thread.join;
//测试join方法
//想象为插队
public class JoinTest 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 {
        //启动我们的线程
        JoinTest joinTest = new JoinTest();
        Thread thread = new Thread(joinTest);
        thread.start();
        //主线程
        for (int i = 0; i < 500; i++) {
            if (i == 200) {
                thread.join();//插队
            }
            System.out.println("main" + i);
        }
    }
}

7）线程状态观测

• Thread.State

查看JDK帮助文档

package com.wang.thread.state;
//线程状态的观测
public class StateTest {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                try {
                    Thread.sleep(200);
                } 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) {//只要线程不终止，就一直输出线程状态
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            state = thread.getState();//更新线程状态
            System.out.println(state);//输出线程状态
        }
    }
}

8）线程的调度

• 调度策略
  • 时间片

• 抢占式：高优先级的线程抢占CPU
  • Java的调度方法
• 同优先级线程组成先进先出队列（先到先服务），使用时间片策略
• 对高优先级，使用优先调度的抢占式策略

9）线程的优先级

• Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照优先级决定应该调度哪个线程来执行。
• 线程的优先级用数字表示，范围从1～10
  • MIN _PRIORITY：1
  • MAX_PRIORITY：10
  • NORM_PRIORITY：5
• 涉及的方法
  • getPriority() ：返回线程优先值
  • setPriority(intnewPriority) ：改变线程的优先级
• 说明
  • 优先级的设定建议在start()调度前
  • 线程创建时继承父线程的优先级
  • 低优先级只是意味着获得调度的概率低，并非优先级低的一定是在高优先级线程之后才被调用，这取决于CPU的调度 ```java package com.wang.thread;

//线程优先级 public class PriorityTest { public static void main(String[] args) {

    //主线程默认优先级
    System.out.println(Thread.currentThread().getName() + "-->" + Thread.currentThread().getPriority());
    MyPriority myPriority = new MyPriority();
    Thread t1 = new Thread(myPriority);
    Thread t2 = new Thread(myPriority);
    Thread t3 = new Thread(myPriority);
    Thread t4 = new Thread(myPriority);
    Thread t5 = new Thread(myPriority);
    Thread t6 = new Thread(myPriority);
    //先设置优先级，再启动
    t1.start();
    t2.setPriority(1);
    t2.start();
    t3.setPriority(4);
    t3.start();
    t4.setPriority(Thread.MIN_PRIORITY);//MIN_PRIORITY=1
    t4.start();
    t5.setPriority(Thread.MAX_PRIORITY);//MAX_PRIORITY=10
    t5.start();
    t6.setPriority(8);
    t6.start();
}

}

class MyPriority implements Runnable {

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

}

<a name="852abfe1"></a>
### 10）线程的分类
Java中的线程分为两类：一种是**守护（daemon）线程**，一种是**用户线程**。它们在几乎每个方面都是相同的，唯一的区别是判断JVM何时离开。
- 虚拟机必须确保用户线程执行完毕，不用等待守护线程执行完毕。
- 守护线程是用来服务用户线程的，通过在start()方法前调用**thread.setDaemon(true**)可以把一个用户线程变成一个守护线程。
- Java垃圾回收就是一个典型的守护线程。
- 若JVM中都是守护线程，当前JVM将退出。
```java
package com.wang.thread;
//守护线程
//上帝守护我们
public class DaemonTest {
    public static void main(String[] args) {
        God god = new God();
        We we = new We();
        Thread thread = new Thread(god);
        thread.setDaemon(true);//默认是false表示是用户线程，正常的线程都是用户线程
        thread.start();//上帝守护线程启动
        new Thread(we).start();//用户线程启动
    }
}
//上帝
class God implements Runnable {
    @Override
    public void run() {
        while (true) {
            System.out.println("上帝保佑着我们");
        }
    }
}
//你
class We implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 36500; i++) {
            System.out.println("我们一生开心地活着");
        }
        System.out.println("====goodbye world!====");
    }
}

线程同步（重点）

• 线程同步：多个线程操作同一个资源。
• 并发 : 同一个对象被多个线程同时操作
• 处理多线程问题时 , 多个线程访问同一个对象（兵法） , 并且某些线程还想修改这个对象，这时候就需要线程同步。线程同步其实就是一种等待机制 , 多个需要同时访问此对象的线程进入这个对象的等待池形成队列, 等待前面线程使用完毕 , 下一个线程再使用。
• 队列和锁保证线程同步的安全性
• 问题的提出
  • 多个线程执行的不确定性引起执行结果的不稳定
  • 多个线程对账本的共享，会造成操作的不完整性，会破坏数据。

例题：模拟火车站售票程序，开启三个窗口售票。

private int tick = 100;
public void run(){
  while(true){
    if(tick>0){
      try{
        Thread.sleep(10);
      }catch(InterruptedException e){ e.printStackTrace();}
      System.out.println(Thread.currentThread().getName()+"售出车票,tick号为:"+ tick--);
    } 
  } 
}

• 多线程出现了安全问题
• 问题的原因：
  • 当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完，另一个线程参与进来执行，导致共享数据的错误。
• 解决办法：
  • 对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以参与执行。

1）线程同步

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

三大不安全案例
1、不安全的买票问题

package com.wang.thread.syn;
//不安全的买票
public class UnsafeBuyTicket {
    public static void main(String[] args) {
        BuyTicket station = new BuyTicket();
        new Thread(station, "苦逼的我").start();
        new Thread(station, "牛逼的你们").start();
        new Thread(station, "可恶的黄牛党").start();
    }
}
class BuyTicket implements Runnable {
    private int ticketNums = 10;//票数
    boolean flag = true;//外部停止标识位
    @Override
    public void run() {
        //买票
        while (flag) {
            try {
                buy();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    private void buy() throws InterruptedException {
        //判断是否有票
        if (ticketNums <= 0) {
            flag = false;
            return;
        }
        //模拟延时
        Thread.sleep(100);
        //买票
        System.out.println(Thread.currentThread().getName() + "拿到了第" + ticketNums-- + "张票");
    }
}

线程不安全：

• 出现同一张票被不同的人拿到的
• 出现负数

2、不安全的银行取钱问题

package com.wang.thread.syn;
//两个人取钱
//需要账户：余额、卡名
public class UnsafeBank {
    public static void main(String[] args) {
        //账户
        Account account = new Account(100, "结婚基金");
        Drawing you = new Drawing(account, 50, "you");
        Drawing girlFriend = new Drawing(account, 100, "girlFriend");
        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;
        System.out.println(account.name + "余额为：" + account.money);
        //Thread.currentThread().getName() = this.getName()
        System.out.println(this.getName() + "手里的钱：" + nowMoney);
    }
}

3、线程不安全的集合

package com.wang.thread.syn;
import java.util.ArrayList;
import java.util.List;
//线程不安全的集合
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(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(list.size());
    }
}

2）同步方法

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

使用线程同步实现买票（synchronized关键字）

package com.wang.thread.syn;
public class BuyTicketDemo {
    public static void main(String[] args) {
        BuyTickets station = new BuyTickets();
        new Thread(station, "苦逼的我").start();
        new Thread(station, "牛逼的你们").start();
        new Thread(station, "可恶的黄牛党").start();
    }
}
class BuyTickets implements Runnable {
    private int ticketNums = 10;//票数
    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-- + "张票");
    }
}

3）同步块

• 同步块

  synchronized (obj) {
  //需要被同步的代码
  }

• Obj 称之为 同步监视器

  • Obj 可以是任何对象 , 但推荐使用共享资源作为同步监视器
  • 同步方法中无需指定同步监视器 , 因为同步方法的同步监视器就是this , 就是这个对象本身 , 或者是 class [ 反射中讲解 ]
• 同步监视器的执行过程
  • 第一个线程访问 , 锁定同步监视器 , 执行其中代码 .
  • 第二个线程访问 , 发现同步监视器被锁定 , 无法访问 .
  • 第一个线程访问完毕 , 解锁同步监视器 .
  • 第二个线程访问, 发现同步监视器没有锁 , 然后锁定并访问

同步块实现银行取钱

package com.wang.thread.syn;
//两个人取钱
//需要账户：余额、卡名
public class UnsafeBank {
    public static void main(String[] args) {
        //账户
        Account account = new Account(100, "结婚基金");
        Drawing you = new Drawing(account, 50, "you");
        Drawing girlFriend = new Drawing(account, 100, "girlFriend");
        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() {
        synchronized (account) {
            //判断有没有钱
            if (account.money - drawingMoney < 0) {
                System.out.println(Thread.currentThread().getName() + "钱不够了，取不了了");
                return;
            }
            //模拟延时
            //sleep可以放大问题的发生性
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //卡内的余额 = 余额 - 取的钱
            account.money = account.money - drawingMoney;
            //你手里的钱
            nowMoney = nowMoney + drawingMoney;
            System.out.println(account.name + "余额为：" + account.money);
            //Thread.currentThread().getName() = this.getName()
            System.out.println(this.getName() + "手里的钱：" + nowMoney);
        }
    }
}

同步块实现集合

package com.wang.thread.syn;
import java.util.ArrayList;
import java.util.List;
public class UnsafeList {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        for (int i = 0; i < 10000; i++) {
            new Thread(() -> {
                   //synchronized同步块
                synchronized (list) {
                    list.add(Thread.currentThread().getName());
                }
            }).start();
        }
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(list.size());
    }
}

总结：

• 加上Synchronized关键字的方法锁的是方法锁在类的本身
• synchronized同步块可以锁任何对象，锁的对象就是变化的量，即需要增删改的量

补充：JUC安全类型的集合

package com.wang.thread;
import java.util.concurrent.CopyOnWriteArrayList;
//JUC安全类型的集合
public class JucTest {
    public static void main(String[] args) {
        CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<String>();
        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());
    }
}

拓展阅读：
为什么线程安全的List推荐用CopyOnWriteArrayList，而不是Vector

4）同步机制中的锁Lock

• 同步锁机制：
  在《Thinking in Java》中，是这么说的：对于并发工作，你需要某种方式来防止两个任务访问相同的资源（其实就是共享资源竞争）。防止这种冲突的方法就是当资源被一个任务使用时，在其上加锁。第一个访问某项资源的任务必须锁定这项资源，使其他任务在其被解锁之前，就无法访问它了，而在其被解锁之时，另一个任务就可以锁定并使用它了。
• synchronized的锁是什么？
  • 任意对象都可以作为同步锁。所有对象都自动含有单一的锁（监视器）。
  • 同步方法的锁：静态方法（类名.class）、非静态方法（this）
  • 同步代码块：自己指定，很多时候也是指定为this或类名.class
• 注意：
  • 必须确保使用同一个资源的多个线程共用一把锁，这个非常重要，否则就无法保证共享资源的安全
  • 一个线程类中的所有静态方法共用同一把锁（类名.class），所有非静态方法共用同一把锁（this），同步代码块（指定需谨慎）

同步的范围
1、如何找问题，即代码是否存在线程安全？（非常重要）
（1）明确哪些代码是多线程运行的代码
（2）明确多个线程是否有共享数据
（3）明确多线程运行代码中是否有多条语句操作共享数据

2、如何解决呢？（非常重要）
对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以参与执行。
即所有操作共享数据的这些语句都要放在同步范围中

3、切记：

• 范围太小：没锁住所有有安全问题的代码
• 范围太大：没发挥多线程的功能。

释放锁的操作

• 当前线程的同步方法、同步代码块执行结束。
• 当前线程在同步代码块、同步方法中遇到break、return终止了该代码块、该方法的继续执行。
• 当前线程在同步代码块、同步方法中出现了未处理的Error或Exception，导致异常结束。
• 当前线程在同步代码块、同步方法中执行了线程对象的wait()方法，当前线程暂停，并释放锁。

不会释放锁的操作

• 线程执行同步代码块或同步方法时，程序调用Thread.sleep()、Thread.yield()方法暂停当前线程的执行
• 线程执行同步代码块时，其他线程调用了该线程的suspend()方法将该线程挂起，该线程不会释放锁（同步监视器）。
  • 应尽量避免使用suspend()和resume()来控制线程

单例设计模式之懒汉式（线程安全）

class Singleton {
  private static Singleton instance = null;
  private Singleton(){}
  public static Singleton getInstance(){
    if(instance==null){
      synchronized(
        Singleton.class
            if(instance == null){
              instance=new Singleton();
            }
         }
        }
    return instance;
    }
}
public class SingletonTest{
  public static void main(String[]{
    Singleton s1=Singleton.getInstance();
    Singleton s2=Singleton.getInstance();
    System.out.println(s1==s2);
    }
}

5）死锁

• 多个线程各自占有一些共享资源，并且互相等待其他线程占有的资源才能运行，而导致两个或多个线程都在等待对方释放资源，都停止执行的情形。某一同步块同时拥有“两个以上对象的锁”时，就可能发生“死锁”问题。
  • 出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续
• 解决方法
  • 专门的算法、原则
  • 尽量减少同步资源的定义
  • 尽量避免嵌套同步

死锁避免方法

• 产生死锁的四个必要条件：
  • 互斥条件：一个资源每次只能被一个进程使用。
  • 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。
  • 不剥夺条件 : 进程已获得的资源，在末使用完之前，不能强行剥夺。
  • 循环等待条件 : 若干进程之间形成一种头尾相接的循环等待资源关系。
• 上面死锁的四个必要条件，只要想办法破其中的任意一个或多个条件就可以避免死锁发生 ```java package com.wang.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;//使用化妆品的人
Makeup(int choice, String girlName) {
    this.choice = choice;
    this.girlName = girlName;
}
@Override
public void run() {
    //化妆
    try {
        makeup();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}
//化妆：互相持有对方的锁，就是需要拿到对方的资源
public 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 + "获得口红的锁");
            }
        }
    }
}