【Java 多线程】线程实现，线程的状态

超、凢脫俗 2022-12-17 07:08 395阅读 0赞

文章目录

    • 前言
    • 线程的创建方式
    • 静态代理模式
    • Lambda 表达式
    • 停止线程
    • 线程休眠
    • 观察线程状态
    • 线程优先级
    • 守护线程

前言

之前线程的概念已经有总结过，这里主要总结 Java 线程类的创建方式，以及实现同步和互斥

另外也会剖析一些源码

线程的创建方式

  • Thread class (继承 Thread 类)
  • Runnable 接口 (实现Runnable 接口)
  • Callable 接口 (实现 Callable 接口)

1、继承 Thread 类创建线程

start 用于启动线程，当调用 start 后，线程并不会马上运行，而是处于就绪状态，是否要运行取决于cpu给的时间片

run用于子类重写来实现线程的功能，我们一般调用的是start方法，系统调用的是run方法

应用：下面我们实现一个多线程的应用，同时从网络上下载三张图片

需要一个工具包，网上搜索下载到本地，然后导入到 idea 项目中

在这里插入图片描述

在 IDEA 中创建一个 package,命名为 lib ，然后右击 lib ，选择 add as 属性，最后点击确定就可以了

在这里插入图片描述

下面是线程代码

  1. package myPthread;
  2. import org.apache.commons.io.FileUtils;
  3. import java.io.File;
  4. import java.io.IOException;
  5. import java.net.URL;
  7. /** * @Title: * @Package * @Description: 实现一个下载器 * @author: maze * @date 2020/10/22下午 15:18 */
  8. public class myPthread2 extends Thread{ 
  9.     private String url; //网络地址
  10.     private String name; //保存的文件名
  12.     public myPthread2(String url,String name){ 
  13.         this.name = name;
  14.         this.url = url;
  15.     }
  16.     @Override
  17.     public void run() { 
  18.         WebDownloader webDownloader = new WebDownloader();
  19.         webDownloader.downloader(url,name);
  20.         System.out.println("下载了文件名为:"+name);
  21.     }
  23.     public static void main(String[] args) { 
  24.         myPthread2 mypthread1 = new myPthread2("https://ss1.bdstatic.com/70cFvXSh_Q1YnxGkpoWK1HF6hhy/it/u=172771859,2215530038&fm=26&gp=0.jpg","小姐姐1.jpg");
  25.         myPthread2 mypthread2 = new myPthread2("https://ss1.bdstatic.com/70cFvXSh_Q1YnxGkpoWK1HF6hhy/it/u=214719225,1330378216&fm=26&gp=0.jpg","小姐姐2.jpg");
  26.         myPthread2 mypthread3 = new myPthread2("https://ss0.bdstatic.com/70cFuHSh_Q1YnxGkpoWK1HF6hhy/it/u=3584899235,2312422629&fm=26&gp=0.jpg","小姐姐3.jpg");
  28.         mypthread1.start();
  29.         mypthread2.start();
  30.         mypthread3.start();
  31.     }
  32. }
  34. // 下载器
  35. class WebDownloader{ 
  36.      // 下载方法
  37.      public void downloader(String url,String name){ 
  38.          try{ 
  39.              FileUtils.copyURLToFile(new URL(url),new File(name));
  40.          }
  41.          catch (IOException e){ 
  42.              e.printStackTrace();
  43.              System.out.println("io异常,downloader方法出现异常");
  44.          }
  45.      }
  46. }

运行完之后，我们可以看到红色框内多了三种图片， idea 也是可以打开的

在这里插入图片描述
在这里插入图片描述

作为一个程序猿，就应该多去看美女，才有动力学习！！

另外我们发现，黄色框内的下载顺序并不是我们代码的顺序

这个是和 CPU 调度有关的，说明：多线程之间是并发执行的，这个和进程的优先级有关，当然也和图片大小有关，比如有的图片大，所以需要更多的时间才能下载好…

小总结
1、自定义线程继承 Thread 类
2、重写 run 方法，编写线程执行体
3、创建线程对象，调用 start 方法启动线程

2、 实现 Runnable 接口来创建线程

由于 thread 继承了 runnable 接口，所以使用 Runnable 接口创建线程，首先需要先创建 runnbale 对象，然后把对象丢到 thread 中进行创建线程

  1. public class myPhread3 implements Runnable{ 
  3.     public static void main(String[] args) { 
  4.         // 创建实现类对象
  5.         myPhread3 phread3 = new myPhread3();
  6.         // 创建代理类对象
  7.         Thread thread = new Thread(phread3);
  8.         thread.start();
  9.         for(int i = 0;i<20;++i){ 
  10.             System.out.println("我在写代码--"+i);
  11.         }
  12.     }
  14.     @Override
  15.     public void run() { 
  16.         for(int i = 0;i<20;++i){ 
  17.             System.out.println("我在听课!-------"+i);
  18.         }
  19.     }
  20. }

小总结
1、不建议使用继承 Thread 类创建对象，因为 java 是单继承的
2、建议使用 Runnable 接口，灵活方便，避免单继承的局限性，方便同一个对象被多个线程使用
3、启动方式：Thread 是子对象.start , Runnable 是传入一个目标对象+Thread对象.start 来启动线程

下面模拟龟兔赛跑，设计一个程序实现 Runnable 接口，如何让乌龟赢

  1. public class myPthread5 implements Runnable{ 
  2.     // 胜利者
  3.     private static String winner;
  5.     public static void main(String[] args) { 
  6.         myPthread5 pthread5 = new myPthread5();
  8.         new Thread(pthread5,"乌龟").start();
  9.         new Thread(pthread5,"兔子").start();
  10.     }
  12.     // 判断比赛是否结束
  13.     private boolean gameOver(int steps){ 
  14.         if(winner != null){ 
  15.             return true;
  16.         }
  17.         if(steps >= 100){ 
  18.             winner = Thread.currentThread().getName();
  19.             System.out.println("winner is"+winner);
  20.             return true;
  21.         }
  22.         return false;
  23.     }
  25.     @Override
  26.     public void run() { 
  27.         for(int i = 1;i<=101;++i) { 
  28.             if(Thread.currentThread().getName().equals("兔子") && i%10==0){ 
  29.                 try { 
  30.                     Thread.sleep(1);
  31.                 } catch (InterruptedException e) { 
  32.                     e.printStackTrace();
  33.                 }
  34.             }
  35.             System.out.println(Thread.currentThread().getName()+"-->跑了"+i+"步");
  36.             //判断比赛是否结束
  37.             boolean flag = gameOver(i);
  38.             if(flag){ 
  39.                 break;
  40.             }
  41.         }
  42.     }
  43. }

3、实现 Callable 接口（了解即可）

  • 实现接口，需要返回值类型
  • 重写 call 接口，需要抛出异常
  • 创建目标对象
  • 创建执行服务
  • 提交执行
  • 获取结果

  • 关闭服务

    package myPthread;

    import org.apache.commons.io.FileUtils;
    import java.io.File;
    import java.io.IOException;
    import java.net.URL;
    import java.util.concurrent.*;

  1. /** * @Title: myPthread6 * @Package myPthread * @Description: * @author: maze * @date 2020/10/22下午 22:38 */
  2. public class myPthread6 implements Callable<Boolean> { 
  3.     private String url; //网络地址
  4.     private String name; //保存的文件名
  6.     public myPthread6(String url,String name){ 
  7.         this.name = name;
  8.         this.url = url;
  9.     }
  10.     @Override
  11.     public Boolean call() { 
  12.         WebDownloader webDownloader = new WebDownloader();
  13.         webDownloader.downloader(url,name);
  14.         System.out.println("下载了文件名为:"+name);
  15.         return true;
  16.     }
  18.     public static void main(String[] args) throws ExecutionException, InterruptedException { 
  19.         myPthread6 mypthread1 = new myPthread6("https://ss1.bdstatic.com/70cFvXSh_Q1YnxGkpoWK1HF6hhy/it/u=172771859,2215530038&fm=26&gp=0.jpg","小姐姐1.jpg");
  20.         myPthread6 mypthread2 = new myPthread6("https://timgsa.baidu.com/timg?image&quality=80&size=b9999_10000&sec=1603387219628&di=dd7f0c62bcd9f2c3a7af43e5dd1fc6fe&imgtype=0&src=http%3A%2F%2Fattach.bbs.miui.com%2Fforum%2F201110%2F28%2F084714m51zkooi5omrcinx.jpg","小姐姐2.jpg");
  21.         myPthread6 mypthread3 = new myPthread6("https://timgsa.baidu.com/timg?image&quality=80&size=b9999_10000&sec=1603387219625&di=0d053377748ed62367bb5565656a3d42&imgtype=0&src=http%3A%2F%2F5b0988e595225.cdn.sohucs.com%2Fimages%2F20181209%2F38467a58f9264ca68eefa37719b4b739.jpeg","小姐姐3.jpeg");
  23.         //创建执行服务
  24.         ExecutorService pool = Executors.newFixedThreadPool(3);
  26.         //提交执行
  27.         Future<Boolean> submit1 = pool.submit(mypthread1);
  28.         Future<Boolean> submit2 = pool.submit(mypthread2);
  29.         Future<Boolean> submit3 = pool.submit(mypthread3);
  30.         // 获取结果
  31.         boolean res1 = submit1.get();
  32.         boolean res2 = submit2.get();
  33.         boolean res3 = submit3.get();
  34.         //关闭服务
  35.         pool.shutdown();
  36.     }
  37. }
  39. // 下载器
  40. class WebDownloader { 
  41.     // 下载方法
  42.     public void downloader(String url, String name) { 
  43.         try { 
  44.             FileUtils.copyURLToFile(new URL(url), new File(name));
  45.         } catch (IOException e) { 
  46.             e.printStackTrace();
  47.             System.out.println("io异常,downloader方法出现异常");
  48.         }
  49.     }
  50. }

静态代理模式

要求：真实角色，代理角色；真实角色和代理角色要实现同一个接口，代理角色要持有真实角色的引用

在 Java 中线程的设计就使用了静态代理设计模式，其中自定义线程类实现 Runable 接口，Thread 类也实现了 Runalbe 接口，在创建子线程的时候，传入了自定义线程类的引用，再通过调用 start()方法，调用自定义线程对象的 run()方法实现了线程的并发执行

  1. package myPthread;
  3. /** * @Title: myPthread7Static * @Package * @Description: 静态代理模式:真实对象和代理对象都要实现同一个接口 * 好处：(1)代理对象对象可以做很多真实对象做不了的事情 (2) 真实对象专注做自己的事情 * @author: maze * @date 2020/10/22下午 23:24 */
  4. public class myPthread7Static { 
  5.     public static void main(String[] args) { 
  7.         // 这个也相当于一个代理, Thread 实现了 Runnable 接口
  8.         new Thread(()-> System.out.println("我爱你")).start();
  10.         // You 传入给代理 WeddingCompay 类
  11.         new WeddingCompay(new You()).HappyMarry();
  12.     }
  13. }
  15. interface Marry{ 
  16.     void HappyMarry();
  17. }
  19. // 真实角色
  20. class You implements Marry{ 
  21.     @Override
  22.     public void HappyMarry() { 
  23.         System.out.println("要结婚了，超开心");
  24.     }
  25. }
  27. // 代理角色
  28. class WeddingCompay implements Marry{ 
  29.     //要结婚的对象
  30.     private Marry marry;
  32.     public WeddingCompay(Marry marry) { 
  33.         this.marry = marry;
  34.     }
  36.     @Override
  37.     public void HappyMarry() { 
  38.         before();
  39.         this.marry.HappyMarry();
  40.         after();
  41.     }
  43.     private void after() { 
  44.         System.out.println("结婚之后,收尾款");
  45.     }
  47.     private void before() { 
  48.         System.out.println("结婚之前布置现场");
  49.     }
  50. }

Lambda 表达式

把函数作为参数传递到方法中,使用 lambda 可以是代码简洁紧凑

lambda 表达式特点

  • 不需要声明参数类型，编译器可识别
  • 一个参数不需要定义圆括号，但是多个参数必须定义圆括号
  • 主体中如何有一行语句，可以省略大括号，否则不可省略
  • 如果主体只有一个表达式返回值，则编译器会自动返回值，大括号需要指明表达式返回一个数值

类的实现方式有，外部实现类，静态内部类，局部内部类，匿名内部类

下面是通过 lambda 表达式来实现

  1. public class Test1Lambda { 
  2.    public static void main(String[] args) { 
  3.        ILike like = new Like();
  4.         // lambda 表达式
  5.         like = ()->{ 
  6.             System.out.println("i like lambda5");
  7.         };
  8.         like.lambda();
  9.     }
  10. }
  12. interface ILike{ 
  13.     void lambda();
  14. }
  16. class Like implements ILike{ 
  17.     @Override
  18.     public void lambda() { 
  19.         System.out.println("i like lambda1");
  20.     }
  21. }

停止线程

不推介使用 JDK 提供的 stop ,destroy 方法来停止线程，更好的办法是自己写一个标志位来让线程主动停止

  1. public class myPthread8 implements Runnable{ 
  2.     private boolean flag = true;
  4.     public static void main(String[] args) throws InterruptedException { 
  5.         myPthread8 pthread8 = new myPthread8();
  6.         new Thread(pthread8).start();
  8.         for(int i = 0;i<1000;++i){ 
  9.             System.out.println("main"+i);
  10.             if(i == 900){  // 调用 stop
  11.                 pthread8.stopPthread();
  12.                 System.out.println("线程停止...");
  13.             }
  14.         }
  15.     }
  17.     @Override
  18.     public void run() { 
  19.         int num = 0;
  20.         while(flag){ 
  21.             System.out.println("run....thread"+num++);
  22.         }
  23.     }
  24.     public void stopPthread(){ 
  25.         this.flag = false;
  26.     }
  27. }

思考：为什么 JDK 文档不建议使用 stop ,destroy 方法来停止线程呢？
答：stop 方法是从外部强行 终止一个线程，是一种粗暴的线程终止行为，在线程终止之前没有对其做任何的清除操作，例如：使用IO流时不能关流，或者会有其它不可预知的错误

线程休眠

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

下面我们模拟网络延时和倒计时

  1. public class myPthread9Sleep implements Runnable{ 
  2.     private int ticknum = 10;
  4.     public static void main(String[] args) { 
  5.         myPthread9Sleep pthread9Sleep = new myPthread9Sleep();
  6.         new Thread(pthread9Sleep,"小明").start();
  7.         new Thread(pthread9Sleep,"小亮").start();
  8.         new Thread(pthread9Sleep,"小铭").start();
  9.     }
  11.     @Override
  12.     public void run() { 
  13.         while(true){ 
  14.             if(ticknum < 0){ 
  15.                 break;
  16.             }
  17.             //模拟延时
  18.             try { 
  19.                 Thread.sleep(200);
  20.             } catch (InterruptedException e) { 
  21.                 e.printStackTrace();
  22.             }
  23.             System.out.println(Thread.currentThread().getName() + "-->拿到了第" + ticknum-- + "票");
  24.         }
  25.     }
  26. }

倒计时

  1. public class myPthread9Sleep2 { 
  2.     private int num = 10;
  4.     public void tendo() throws InterruptedException { 
  5.         while(true){ 
  6.             if(num <=0){ 
  7.                 break;
  8.             }
  9.             Thread.sleep(1000);
  10.             System.out.println(num--);
  11.         }
  12.     }
  13.     public static void main(String[] args) { 
  14.         try { 
  15.             new myPthread9Sleep2().tendo();
  16.         } catch (InterruptedException e) { 
  17.             e.printStackTrace();
  18.         }
  19.     }
  20. }
  22. public class myPthread9Sleep2 { 
  23.     // 打印系统当前时间
  24.     public static void main(String[] args) { 
  25.         Date startime = new Date(System.currentTimeMillis());
  26.         while(true){ 
  27.             try { 
  28.                 Thread.sleep(1000);
  29.                 System.out.println(new SimpleDateFormat("HH:mm:ss").format(startime));
  30.             } catch (InterruptedException e) { 
  31.                 e.printStackTrace();
  32.             }
  33.             startime = new Date(System.currentTimeMillis());
  34.         }
  36.     }
  37. }

观察线程状态

new 状态：线程对象一旦被创建就进入到新生状态

当调用 start 方法，线程立即进入就绪状态，但不意味着立刻调度执行

线程进入运行状态，线程才真正的执行线程体的代码块

当调用 sleep ，wait 或者同步锁定时，线程进入阻塞状态，阻塞解除后，重新进入就绪态，等待 CPU 调度运行

线程运行完毕后，进入死亡状态，无法再次启动线程

  1. public class TestState { 
  2.     public static void main(String[] args) throws InterruptedException { 
  3.         Thread thread = new Thread(()->{ 
  4.             for (int i = 0; i < 5; i++) { 
  5.                 try { 
  6.                     Thread.sleep(100);
  7.                 } catch (InterruptedException e) { 
  8.                     e.printStackTrace();
  9.                 }
  10.             }
  11.             System.out.println("");
  12.         });
  14.         //观察状态
  15.         Thread.State state = thread.getState();
  16.         System.out.println(state); // NEW 新生
  18.         thread.start();
  19.         state = thread.getState();
  20.         System.out.println(state); // Run 启动
  22.         //只要线程不终止，就一直输出状态
  23.         while(state != Thread.State.TERMINATED){ 
  24.             Thread.sleep(100);
  25.             state = thread.getState();
  26.             System.out.println(state);
  27.         }
  28.     }
  29. }

线程优先级

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

  1. public class myPthreadPriority { 
  2.     public static void main(String[] args) { 
  3.         System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
  4.         MyPriority priority = new MyPriority();
  6.         Thread thread1 = new Thread(priority);
  7.         Thread thread2 = new Thread(priority);
  8.         Thread thread3 = new Thread(priority);
  10.         //设置优先级再启动
  11.         thread1.start();
  13.         thread2.setPriority(1);
  14.         thread2.start();
  16.         thread3.setPriority(10);
  17.         thread3.start();
  18.     }
  19. }
  21. class MyPriority implements Runnable{ 
  22.     @Override
  23.     public void run() { 
  24.         System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
  25.     }
  26. }

守护线程

  • 线程分为用户线程和守护线程
  • 虚拟机必须确保用户线程执行完毕
  • 虚拟机不用等待守护线程执行完毕

  • 守护线程有，后台记录操作日志，监控内存，垃圾回收等到

    public class myPthreadDaemon { 

    1. public static void main(String[] args) { 
    2.     God god = new God();
    3.     you you = new you();
    4.     Thread thread = new Thread(god);
    5.     // 默认是 false 表示用户线程，正常的线程都是用户线程
    6.     thread.setDaemon(true);
    7.     thread.start(); //上帝守护线程启动
    9.     new Thread(you).start();//用户线程启动
    10. }

    }

    class God implements Runnable{ 

    1. @Override
    2. public void run() { 
    3.     while (true){ 
    4.         System.out.println("上帝保佑着你");
    5.     }
    6. }

    }

    class you implements Runnable{ 

    1. @Override
    2. public void run() { 
    3.     for (int i = 0; i < 36500; i++) { 
    4.         System.out.println("你一生都开心的活着!");
    5.     }
    6.     System.out.println("========goodby world=======");
    7. }

    }

文章字数太多，线程的同步与安全在下一篇总结

发表评论

表情：
评论列表 （有 0 条评论，395人围观）

还没有评论，来说两句吧...

相关阅读

    相关 Java多线程 —— 线程状态迁移

    引言 线程状态迁移，又常被称作线程的生命周期，指的是线程从创建到终结需要经历哪些状态，什么情况下会出现哪些状态。 线程的状态直接关系着并发编程的各种问题，本文就线程的状

    悠悠悠悠/ 0 赞/ 394 阅读

    相关 多线程之——线程的状态

    线程状态 线程是相对独立的、可调度的执行单元，因为在线程的执行过程中，会分别处在不同的状态。通常而言，线程主要有下列几种运行状态： 1.就绪状态： 即线程已经具备了

    男娘i男娘i/ 0 赞/ 430 阅读