多线程详解

1. 线程简介

程序：程序时指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念
进程：执行程序的一次执行过程，或是正在运行的一个程序，是一个动态的过程。由它自身的产生、存在和消亡的过程
线程是由进程创建的，是进程的一个实体。通常在一个进程中可以包含若干个线程，当然一个进程中至少有一个线程，不然没有存在的意义。线程是CPU调度和执行的单位
很多多线程是模拟出来的，真正多线程实现并行，是有多个CPU，即多核。一个CPU统一时间点只能执行一个代码，因为切换快，所以就有同时执行的错觉。 宏观并行，微观串行

1. public static void main(String[] args) {
2.     Runtime runtime = Runtime.getRuntime();
3.     //获取当前电脑的CPU数量
4.     int i = runtime.availableProcessors();
5.     System.out.println(i);
6. }

复制代码

2. 线程实现（重点）

2.1 实现方式一：继承Thread类

实现步骤：

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

1. package com.ThreadStudy;
3. /**
4. * @ClassName ThreadDemo01
5. * @Description TODO 创建线程方式一：继承Thread类
6. * @Author Mark
7. * @Date 2022/6/23 13:40
8. * @Version 1.0
9. */
10. //创建线程方式一：继承Thread类，重写run方法，调用start开始线程
11. public class ThreadDemo01 {
12.     public static void main(String[] args) {
13.         Cat cat = new Cat();    //new Cat() .var/ctrl+alt+v/alt+enter导入前半部分
14.         cat.start();//启动线程
15.         //当main线程启动一个子线程 Thread-0 主线程不会阻塞，会继续执行
17.         /*
18.         * 源码：
19.         * public synchronized void start() {
20.         *     start0();
21.         * }
22.         *
23.         * private native void start0();//start0是本地方法，是JVM调用，底层由C/C++实现的
24.         * //真正实现多线程效果由start0()实现
25.         * */
26.     }
27. }
29. //Thread实现了Runnable接口的run方法
30.     /*
31.     @Override
32.     public void run() {
33.         if (target != null) {
34.             target.run();
35.         }
36.     }
37.     */
38. class Cat extends Thread {//Cat继承于Thread类，该类可当作线程使用
39.     int times = 0;
41.     @Override
42.     public void run() {//重写run方法，写入自己的业务代码
43.         while (true) {
44.             //每隔一秒输出一次“喵喵”
45.             System.out.println("喵喵 " + (++times)+" 线程名："+Thread.currentThread().getName());
46.             //sleep:使线程休眠 ctrl+alt+t写入try-catch,或者鼠标指向要抛出异常的方法，ctrl+alt+enter
47.             try {
48.                 Thread.sleep(1000);
49.             } catch (InterruptedException e) {
50.                 e.printStackTrace();
51.             }
52.             if (times == 80)
53.                 break;//当times=8，线程停止
54.         }
55.     }
56. }

复制代码

进程启动--->创建main线程--->在主线程中创建一个新的子线程Thread-0
可以使用控制台jconsole打开Java监视和管理控制台查看线程执行情况，当所有的线程结束后，进程才会结束（当主线程结束，主线程的子线程还未结束，进程并不会关闭，而是等待子线程结束后关闭）
案例：多线程下载图片

1. package com.ThreadStudy;
3. import org.apache.commons.io.FileUtils;
5. import java.io.File;
6. import java.io.IOException;
7. import java.net.URL;
10. /**
11. * @ClassName ThreadDemo02
12. * @Description TODO 练习Thread，实现多线程同步下载图片
13. * @Author Mark
14. * @Date 2022/6/23 19:09
15. * @Version 1.0
16. */
17. public class ThreadDemo02 extends Thread {
18.     private String url;//网络地址
19.     private String name;//保存的文件名
21.     public ThreadDemo02(String url, String name) {
22.         this.url = url;
23.         this.name = name;
24.     }
26.     //下载图片线程的执行体
27.     @Override
28.     public void run() {
29.         WebDownloader webDownloader = new WebDownloader();
30.         webDownloader.downloader(url, name);
31.         System.out.println("下载了的文件名为：" + name);
32.     }
34.     public static void main(String[] args) {
35.         ThreadDemo02 thread1 = new ThreadDemo02("https://pics0.baidu.com/feed/1b4c510fd9f9d72a803a1a357e5dae3e349bbb3a.jpeg", "fpx.jpeg");
36.         ThreadDemo02 thread2 = new ThreadDemo02("https://pics0.baidu.com/feed/0d338744ebf81a4c46cbca834bc6e653272da6f1.png", "mgn.jpeg");
37.         ThreadDemo02 thread3 = new ThreadDemo02("https://pic.rmb.bdstatic.com/bjh/down/e2cbad3b771358fec7de7727ca450426.png", "edg.png");
39.         thread1.start();
40.         thread2.start();
41.         thread3.start();
43.         //下载了的文件名为：mgn.jpeg     --thread2
44.         //下载了的文件名为：fpx.jpeg     --thread1
45.         //下载了的文件名为：edg.png      --thread3
46.     }
47. }
49. //下载器
50. class WebDownloader {
51.     //下载方法
52.     public void downloader(String url, String name) {
53.         try {
54.             FileUtils.copyURLToFile(new URL(url), new File("myThread\\src\\com\" + name));
55.         } catch (IOException e) {
56.             e.printStackTrace();
57.             System.out.println("IO异常，downloader方法出现异常");
58.         }
59.     }
60. }

复制代码

2.2 实现方式二：实现Runnable接口

java是单继承的，在某些情况下一个类可能已经继承了某个父类，这时再用继承Thread类创建线程显然不可行了，因此我们通过实现Runnable接口来创建线程
实现步骤：

• 定义MyRunnable类实现Runnable接口
  
• 实现run()方法，编写线程执行体
  
• 创建线程对象，调用start()方法启动线程
  ​        ThreadDemo03 threadDemo03=new ThreadDemo03();
  ​        new Thread(threadDemo03).start();
  

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

1. package com.ThreadStudy;
3. /**
4. * @ClassName TheardDemo03
5. * @Description TODO 创建线程方式二：实现Runnable接口
6. * @Author Mark
7. * @Date 2022/6/23 20:54
8. * @Version 1.0
9. */
10. public class ThreadDemo03 {
11.     public static void main(String[] args) {
12. //        Dog dog = new Dog();
13. //        //dog.start;    dog不能调用start
14. //        //创建Thread对象，把dog对象(实现Runnable的对象)放入Thread
15. //        new Thread(dog).start();
16. //        //这里底层使用了设计模式：代理模式
17.         Tiger tiger = new Tiger();
18.         Proxy proxy = new Proxy(tiger);
19.         proxy.start();
22.     }
23. }
25. class Animal{
27. }
29. class Tiger extends Animal implements Runnable{
30.     @Override
31.     public void run() {
32.         System.out.println("嗷嗷");
33.     }
34. }
36. //线程代理类,模拟一个极简的Thread类
37. class Proxy implements Runnable { //这里可以把Proxy类当作Thread
38.     private Runnable target = null;//属性、类型是Runnable
41.     @Override
42.     public void run() {
43.         if (target != null) {
44.             target.run();//动态绑定
45.         }
46.     }
48.     public Proxy(Runnable target) {
49.         this.target = target;
50.     }
52.     public void start() {
53.         start0();//⭐⭐⭐⭐⭐
54.     }
56.     private void start0() {
57.         run();
58.     }
59. }
61. class Dog implements Runnable {
62.     int times = 0;
64.     @Override
65.     public void run() {
66.         while (true) {
67.             System.out.println("汪汪" + (++times) + " 线程名：" + Thread.currentThread().getName());
69.             try {
70.                 Thread.sleep(1000);
71.             } catch (InterruptedException e) {
72.                 e.printStackTrace();
73.             }
74.             if (times == 8) {
75.                 break;
76.             }
77.         }
78.     }
79. }

复制代码

代理是为了不改变原来代码的基础上增强代码
静态代理：

1. package com.ThreadStudy;
3. /**
4. * @ClassName StaticProxy
5. * @Description TODO 静态代理
6. * @Author Mark
7. * @Date 2022/6/24 16:10
8. * @Version 1.0
9. */
10. public class StaticProxy {
11.     public static void main(String[] args) {
12.         //代理是为了不改变原来代码的基础上增强代码
13.         //在原来只能”嘿嘿嘿“的基础上增加了”准备婚礼“和”付尾款“
14. //        WeddingCompany weddingCompany=new WeddingCompany(new You());//WeddingCompany代理You
15. //        weddingCompany.Marry();
16.         You you=new You();
18.         new Thread(()-> System.out.println("我爱你")).start();
20.         new WeddingCompany(you).Marry();
21.     }
23. }
25. //功能接口
26. interface  Marry{
27.     //结婚方法
28.     void Marry();
29. }
31. //You：真实对象，实现结婚接口
32. class You implements Marry{
33.     @Override
34.     public void Marry() {
35.         System.out.println("嘿嘿嘿");
36.     }
37. }
39. //WeddingCompany:代理角色，帮助You
40. class WeddingCompany implements Marry{
42.     //帮助对象
43.     private Marry target;
45.     public WeddingCompany(Marry target) {
46.         this.target = target;
47.     }
49.     @Override
50.     public void Marry() {
51.         before();
52.         this.target.Marry();
53.         after();
54.     }
56.     private void after() {
57.         System.out.println("付尾款");
58.     }
60.     private void before() {
61.         System.out.println("准备婚礼");
62.     }
63. }

复制代码

方式一和方式二对比：
继承Thread类实现Runnable接口子类继承Thread类具备多线程能力实现接口Runnable具有多线程能力启动线程：子类对象.start()启动线程：线程对象(目标对象).start()不建议使用：避免OOP单继承局限性建议使用：避免单继承，灵活方便，方便同一个对象被多个线程使用案例：售票
通过继承Thread实现：

1. public class SellTicket {
2.     public static void main(String[] args) {
3.         SellTicket01 sellTicket01 = new SellTicket01();
4.         SellTicket01 sellTicket02 = new SellTicket01();
5.         SellTicket01 sellTicket03 = new SellTicket01();
7.         sellTicket01.start();
8.         sellTicket02.start();
9.         sellTicket03.start();
11.     }
12. }
14. class SellTicket01 extends Thread {
15.     private static int ticketNum = 100;//让多个线程共享ticketNum
17.     @Override
18.     public void run() {
19.         while (true) {
20.             if (ticketNum <= 0) {
21.                 System.out.println("售票结束");
22.                 break;
23.             }
25.             //休眠50ms
26.             try {
27.                 Thread.sleep(50);
28.             } catch (InterruptedException e) {
29.                 e.printStackTrace();
30.             }
32.             System.out.println("窗口 " + Thread.currentThread().getName() + "售出一张票" +
33.                     " 剩余票数：" + (--ticketNum));
34.         }
35.     }
36. }

复制代码

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

1. public class SellTicket02 {
2.     public static void main(String[] args) {
3.         SellTicketWindow sellTicketWindow=new SellTicketWindow();
4.         new Thread(sellTicketWindow).start();
5.         new Thread(sellTicketWindow).start();
6.         new Thread(sellTicketWindow).start();
7.     }
8. }
10. class SellTicketWindow implements Runnable {
11.     private int ticketNum = 100;
13.     @Override
14.     public void run() {
15.         while (true) {
16.             if (ticketNum <= 0) {
17.                 System.out.println("end...");
18.                 break;
19.             }
21.             try {
22.                 Thread.sleep(50);
23.             } catch (InterruptedException e) {
24.                 e.printStackTrace();
25.             }
27.             System.out.println("窗口 " + Thread.currentThread().getName() + "售出一张票" +
28.                     " 剩余票数：" + (--ticketNum));
29.         }
30.     }
31. }

复制代码

lambda简化：

1. public class ThreadDemo05 implements Runnable {
2.     private static String winner;
4.     @Override
5.     public void run() {
6.         for (int i = 0; i <= 100; i++) {
7.             //模拟兔子睡觉
8.             if(Thread.currentThread().getName().equals("小兔子") && i%10==0){
9.                 try {
10.                     Thread.sleep(1);
11.                 } catch (InterruptedException e) {
12.                     e.printStackTrace();
13.                 }
14.             }
16.             //判断比赛是否结束
17.             boolean flag = gameOver(i);
18.             //如果比赛结束了，就停止程序
19.             if (flag) {
20.                 break;
21.             }
23.             System.out.println(Thread.currentThread().getName() + "跑了" + i + "步");
24.         }
25.     }
27.     //判断比赛是否结束
28.     private boolean gameOver(int steps) {
29.         if (winner != null) {
30.             return true;
31.         } else if (steps >= 100) {
32.             winner = Thread.currentThread().getName();
33.             System.out.println("winner is" + winner);
34.             return true;
35.         } else {
36.             return false;
37.         }
38.     }
40.     public static void main(String[] args) {
41.         ThreadDemo05 threadDemo05 = new ThreadDemo05();
43.         new Thread(threadDemo05, "小兔子").start();
44.         new Thread(threadDemo05, "老乌龟").start();
45.     }
46. }

复制代码

3. 线程状态



线程方法：
方法说明void setName(String name)将此线程的名称更改为等于参数 namevoid getName()返回此线程的名称void start()导致此线程开始执行; Java虚拟机调用此线程的run方法void run()调用该Runnable对象的run方法void setPriority(int newPeiority)更改此线程的优先级void getPriority()返回此线程的优先级void join()等待这个线程死亡。static void sleep(long millis)导致正在执行的线程以指定的毫秒数加上指定的纳秒数来暂停void interrupt()中断这个线程boolean isAilve()测试这个线程是否活着static void yield()暂停当前正在执行的线程对象，并执行其他线程3.1 停止线程

• 不推荐使用JDK提供的stop()、destory()方法（@Deprecated(since="1.2")：已废弃）
  
• 推荐线程自己停止下来:将线程体写到循环内，利用次数终止循环，不建议死循环
  
• 建议用一个标志位进行终止变量。当flag=false，终止线程运行：通知方式
  1. package com.ThreadCallable;
  3. import org.apache.commons.io.FileUtils;
  5. import java.io.File;
  6. import java.io.IOException;
  7. import java.net.URL;
  8. import java.util.concurrent.*;
  10. /**
  11. * @ClassName ThreadCallableDemo
  12. * @Description TODO 线程创建方式三：实现Callable接口
  13. * @Author Mark
  14. * @Date 2022/6/23 22:06
  15. * @Version 1.0
  16. */
  17. //①实现Callable接口，需要返回值类型
  18. public class ThreadCallableDemo implements Callable {
  19.     private String url;//网络地址
  20.     private String name;//保存的文件名
  22.     public ThreadCallableDemo(String url, String name) {
  23.         this.url = url;
  24.         this.name = name;
  25.     }
  27.     //②重写call方法，下载图片线程的执行体
  28.     @Override
  29.     public Boolean call() {
  30.         WebDownloader webDownloader = new WebDownloader();
  31.         webDownloader.downloader(url, name);
  32.         System.out.println("下载了的文件名为：" + name);
  33.         return true;
  34.     }
  36.     public static void main(String[] args) throws ExecutionException, InterruptedException {
  37.         //③创建目标对象
  38.         ThreadCallableDemo thread1 = new ThreadCallableDemo("https://pics0.baidu.com/feed/1b4c510fd9f9d72a803a1a357e5dae3e349bbb3a.jpeg", "fpx.jpeg");
  39.         ThreadCallableDemo thread2 = new ThreadCallableDemo("https://pics0.baidu.com/feed/0d338744ebf81a4c46cbca834bc6e653272da6f1.png", "mgn.jpeg");
  40.         ThreadCallableDemo thread3 = new ThreadCallableDemo("https://pic.rmb.bdstatic.com/bjh/down/e2cbad3b771358fec7de7727ca450426.png", "edg.png");
  42.         //④创建执行服务：
  43.         ExecutorService ser= Executors.newFixedThreadPool(1);
  45.         //⑤提交执行：
  46.         Future<Boolean> result1= ser.submit(thread1);
  47.         Future<Boolean> result2= ser.submit(thread2);
  48.         Future<Boolean> result3= ser.submit(thread3);
  50.         //⑥获取结果：
  51.         boolean rs1=result1.get();
  52.         boolean rs2=result2.get();
  53.         boolean rs3=result3.get();
  55.         //⑦关闭服务：
  56.         ser.shutdown();
  57.     }
  58. }
  60. //下载器
  61. class WebDownloader {
  62.     //下载方法
  63.     public void downloader(String url, String name) {
  64.         try {
  65.             FileUtils.copyURLToFile(new URL(url), new File("myThread\\src\\com\" + name));
  66.         } catch (IOException e) {
  67.             e.printStackTrace();
  68.             System.out.println("IO异常，downloader方法出现异常");
  69.         }
  70.     }
  71. }

  复制代码

3.2 线程中断

1. public interface Runnable{
2.     public abstract void run();
3. }

复制代码

3.3 线程休眠

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

[code]package com.ThreadStudy;import java.text.SimpleDateFormat;import java.util.Date;/** * @ClassName SleepThread2 * @Description TODO 倒计时+打印系统时间 * @Author Mark * @Date 2022/6/24 21:16 * @Version 1.0 */public class SleepThread2 {    public static void main(String[] args) {//        try {//            timeDown();//        } catch (InterruptedException e) {//            e.printStackTrace();//        }        Date startTime =new Date(System.currentTimeMillis());        while(true){            try {                System.out.println(new SimpleDateFormat("HH:mm:ss").format(startTime));                startTime =new Date(System.currentTimeMillis());//更新当前时间                Thread.sleep(1000);            } catch (InterruptedException e) {                e.printStackTrace();            }        }    }    //计时器//    public static void timeDown() throws InterruptedException {//        int num=10;//        while(true){//            Thread.sleep(1000);//            System.out.println(num--);//            if (num