• 第二十三章 多线程(一)

    1. 多线程相关概念

    1.1 并发(Concurrent)

            在操作系统中，是指一个时间段中有几个程序都处于已启动运行到运行完毕之间，且这几个程序都是在同一个处理机上运行；

            同一时刻只能有一条指令执行，但多个进程指令被快速的轮换执行，使得在宏观上具有多个进程同时执行的效果，但在微观上并不是同时执行的，只是把CPU时间分成若干段，使多个进程快速交替的执行。

    1.2 并行(Parallel)

             当系统有一个以上CPU时，当一个CPU执行一个进程时，另一个CPU可以执行另一个进程，两个进程互不抢占CPU资源，可以同时进行，称之为并行；决定并行的因素是CPU核心数量，一个CPU多个核心也可以并行。

    1.3 进程(Process)

            正在运行的程序实体，并且包括这个运行的程序中占据的所有系统资源(CPU(寄存器)、IO、内存、网络资源等)；同一个程序，同一时刻被两次运行，那么他们就是两个独立的进程。

     1.4 线程(Thread)

            操作系统能够进行运算调度的最小单位；它被包含在进程中，是进程中的实际运作单位，一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。

    1.5 多线程的优缺点

    优点：

            ①可以让程序运行速度更快，用户在频繁切换运行进程的界面，界面下运行进程底层都有多个线程不断运行着，CPU一直处于运行状态；

            ②提高CPU利用率，大量线程同时处于运行状态，让CPU不间断运行；

    缺点： 

            ①多线程情况，多个线程可能共享一个资源，如果资源数量有限，多线程竞争会产生等待问题；

            ②多线程，不断进行线程(上下文)切换，线程切换消耗资源；

            ③多线程，可能造成死锁。

    2. 多线程实现方式

    2.1 继承Thread类

    1. public class MyThread extends Thread{
    2.     private int ticket = 20;
    3.     String name;
    4.  
    5.     public MyThread(String name) {
    6.         this.name = name;
    7.     }
    8.  
    9.     /**
    10.      * 重写run方法，实现多线程执行业务的方法
    11.      */
    12.     @Override
    13.     public void run() {
    14.         while(ticket>0){
    15.             System.out.println(Thread.currentThread().getName()+"  "+this.name+"卖出一张票，剩余:\t^"+(--ticket)+"^\t"+ LocalDateTime.now());
    16.         }
    17.     }
    18. }

    2.2 实现Runnable接口

    Runnable接口可由任何类实现，其实例将由线程执行；必须定义无参方法run。

    1. public class MyRunnable implements Runnable{
    2.     private int ticket=20;
    3.     @Override
    4.     public void run() {
    5.         while (ticket>0){
    6.             System.out.println(Thread.currentThread().getName()+"卖出一张票，剩余:\t^"+(--ticket)+"^\t"+ LocalDateTime.now());
    7.         }
    8.     }
    9. }

    2.3 实现Callable接口

    类似于Runnable接口，但Runnable不能返回结果，也不能抛出被检查的异常。

    1. public class MyCallable implements Callable {
    2.     /**
    3.      * 线程的业务方法
    4.      * @return
    5.      * @throws Exception
    6.      */
    7.     @Override
    8.     public Object call() throws Exception {
    9.         int sum = 0;
    10.         for (int i = 0; i < 5; i++) {
    11.             System.out.println(Thread.currentThread().getName()+"\t^"+i+"^\t"+ LocalDateTime.now());
    12.             sum+=i;
    13.         }
    14.         return sum;
    15.     }
    16. }

     测试类：

    1. public class MyTest {
    2.     public static void main(String[] args) throws ExecutionException, InterruptedException {
    3.         MyThread myThread = new MyThread("张三");
    4.         myThread.start();
    5.  
    6.         MyRunnable myRunnable = new MyRunnable();
    7.         Thread thread = new Thread(myRunnable);
    8.         thread.start();
    9.  
    10.         MyCallable myCallable = new MyCallable();
    11.         FutureTask ft = new FutureTask(myCallable);
    12.         new Thread(ft).start();
    13.         int res = (int)ft.get();
    14.         System.out.println("++++++"+res+"+++++");
    15.     }
    16. }

    2.4 线程池实现多线程

            Executors工厂和工具类Executor,ExecutorService,ScheduleExecutorService,ThreadFactory和Callable在此包中定义的类支持以下几种方法：

    ①创建并返回一个ExecutorService设置的常用的配置设置的方法；

    ②创建并返回一个ScheduledExecutorService的方法，其中设置了常用的配置设置；

    ③创建并返回"包装"ExecutorService的方法，通过使实现特定的方法无法访问来禁用重新配置；

    ④创建并返回将新创建的线程设置为已知状态的ThreadFactory的方法；

    ⑤创建并返回一个方法Callable出的其他闭包形式，这样就可以在需要的执行方法使用Callable。

    1. public class MyTest2 {
    2.     public static void main(String[] args) {
    3.         MyThread myThread1 = new MyThread("张三");
    4.         MyThread myThread2 = new MyThread("李四");
    5.         MyThread myThread3 = new MyThread("王五");
    6.  
    7.         //启动多线程
    8.         ExecutorService executorService = Executors.newFixedThreadPool(3);
    9.         executorService.execute(myThread1);
    10.         executorService.execute(myThread2);
    11.         executorService.execute(myThread3);
    12.  
    13.         //关闭线程池
    14.         executorService.shutdown();
    15.     }
    16. }

    2.5 实现runnable和继承thread的区别

            受Java单继承影响，继承thread无法实现成员变量(不使用特殊手段，加static)，实现Runnable接口时，线程运行可以共享成员变量。

    2.6 多线程常用方法

    currentThread():返回对当前正在执行的线程对象的引用；

    getName():返回此线程的名称；

    run():当前启动的线程，执行业务的地方；

    start():启动线程，让线程处于就绪状态；

    setPriority():更改此线程的优先级，优先级是1~10之间的任意数字，默认值是5。

    1. public class MyTest3 {
    2.     public static void main(String[] args) {
    3.         IA ia =new IA() {
    4.             @Override
    5.             public void test() {
    6.                 System.out.println("wan ^^");
    7.             }
    8.         };
    9.         ia.test();
    10.  
    11.         Thread thread1 = new Thread("t1"){
    12.             @Override
    13.             public void run() {
    14.                 for (int i = 0; i < 10; i++) {
    15.                     System.out.println(Thread.currentThread().getName()+"对所有的烦恼说拜拜!"+"^"+i+"^");
    16.                     if(i==5){
    17.                         Thread.yield();
    18.                     }
    19.                 }
    20.             }
    21.         };
    22.         Thread thread2 = new Thread("t2"){
    23.             @Override
    24.             public void run() {
    25.                 for (int i = 0; i < 10; i++) {
    26.                     System.out.println(Thread.currentThread().getName()+"对所有的烦恼说拜拜!"+"^"+i+"^");
    27.                     if(i%2==0){
    28.  
    29.                         Thread.yield();
    30.                     }
    31.                 }
    32.             }
    33.         };
    34.         Thread thread3 = new Thread("t3"){
    35.             @Override
    36.             public void run() {
    37.                 for (int i = 0; i < 10; i++) {
    38.                     System.out.println(Thread.currentThread().getName()+"对所有的烦恼说拜拜!"+"^"+i+"^");
    39.                     if(i>0){
    40.                         Thread.yield();
    41.                     }
    42.                 }
    43.             }
    44.         };
    45.         thread2.setPriority(Thread.MIN_PRIORITY);
    46.         thread3.setPriority(Thread.MAX_PRIORITY);
    47.         thread1.start();
    48.         thread2.start();
    49.         thread3.start();
    50.  
    51.     }
    52. }

     2.7 多线程的状态

    五种状态：

            新建(程序还没有开始运行线程中的代码)

            就绪(start方法返回之后就处于就绪状态,不一定直接运行run需要同其他线程竞争CPU时间)

            运行(线程获得CPU时间后，进入运行状态，执行run)

            阻塞(等待wait、带超时的等待sleep)

           终止(死亡，正常退出或者异常终止)

    3. 综合练习

            使用Java程序，ping ip， 查看每个ip是否可以ping通;

    1. package com.util;
    2.  
    3. import java.io.BufferedReader;
    4. import java.io.IOException;
    5. import java.io.InputStream;
    6. import java.io.InputStreamReader;
    7. import java.nio.Buffer;
    8.  
    9. /**
    10.  * @author :muxiaowen
    11.  * @date : 2022/9/16 16:45
    12.  */
    13. public class PingUtil {
    14.     public static long pingIp(String ip){
    15.         long start = System.currentTimeMillis();
    16.         System.out.println("------------");
    17.         System.out.println(Thread.currentThread().getName());
    18.         System.out.println("start:"+start);
    19.         long end = 0;
    20.         InputStream inputStream = null;
    21.         BufferedReader br =null;
    22.         try {
    23.             //程序运行是的工具类
    24.             Runtime runtime = Runtime.getRuntime();
    25.             //执行cmd命令
    26.             Process exec = runtime.exec("ping " + ip);
    27.             //获取字节流
    28.             inputStream = exec.getInputStream();
    29.             //构建缓冲字符流
    30.             br = new BufferedReader(new InputStreamReader(inputStream));
    31.             String str= "";
    32.             while ((str=br.readLine())!=null){
    33.                 System.out.println(str);
    34.                 if(str.contains("TTL")){
    35.                     end = System.currentTimeMillis();
    36.                     System.out.println(ip+"可以ping通");
    37.                     System.out.println("end:"+end);
    38.                     return end-start;
    39.                 }
    40.                 if(str.contains("Destination host unreachable")||str.contains("Request timed out")){
    41.                     System.out.println(ip+"不可以ping通");
    42.                     end = System.currentTimeMillis();
    43.                     System.out.println("end:"+end);
    44.                     return end-start;
    45.                 }
    46.             }
    47.             end = System.currentTimeMillis();
    48.             System.out.println("end:"+end);
    49.         } catch (IOException e) {
    50.             e.printStackTrace();
    51.         }finally {
    52.             if(inputStream!=null){
    53.                 try {
    54.                     inputStream.close();
    55.                 } catch (IOException e) {
    56.                     e.printStackTrace();
    57.                 }
    58.             }
    59.             if(br!=null){
    60.                 try {
    61.                     br.close();
    62.                 } catch (IOException e) {
    63.                     e.printStackTrace();
    64.                 }
    65.             }
    66.         }
    67.         return end-start;
    68.     }
    69. }
    1. public class MyPing implements Callable {
    2.     private String ip;
    3.  
    4.     public MyPing(String ip) {
    5.         this.ip = ip;
    6.     }
    7.  
    8.     @Override
    9.     public Object call() throws Exception {
    10.         return PingUtil.pingIp(ip);
    11.     }
    12. }

    测试类：

    1. public class MyTest6 {
    2.     public static void main(String[] args) throws ExecutionException, InterruptedException {
    3.         long sum =  0;
    4.         ExecutorService executorService = Executors.newFixedThreadPool(10);
    5.  
    6.         for (int i = 0; i <= 120; i++) {
    7.             MyPing myPing = new MyPing("192.168.0."+i);
    8.             FutureTask ft = new FutureTask(myPing);
    9.             executorService.execute(ft);
    10.             sum += (long)ft.get();
    11.         }
    12.         System.out.println("+++++++++++++++++");
    13.         System.out.println(sum);
    14.         executorService.shutdown();
    15.     }
    16. }

    不使用多线程速度会非常慢!

  • 相关阅读:
    MySQL之短时间提高性能的措施
    FPGA设计时序约束九、others类约束之Group Path
    WPF使用TextBlock实现查找结果高亮显示
    个人散户如何参与程序化交易？
    Linux 文件系统Ramfs, rootfs and initramfs
    vue3——element-plus 实现页面刷新之后，保持菜单的激活状态
    搭建私有Git服务器：GitLab部署详解
    shell脚本数组
    自学WEB后端01-安装Express+Node.js框架完成Hello World!
    [HDLBits] Exams/2014 q3fsm
  • 原文地址：https://blog.csdn.net/m0_71674778/article/details/126889873