• java---多线程编程一

    目录

    线程的创建

    1、继承Thread类，重写run（）方法

    start（）方法和run（）方法的区别

    2、实现Runnable接口，重写run（）方法

    3、实现callable接口，重写call（）方法，并使用Future来获取call（）方法的返回结果

    后台线程

     线程的生命周期和状态转化

    中断线程

    线程调度

    线程的优先级

    进程插队---join（）方法

     线程休眠---sleep（）方法

    多个线程并发执行，可以充分利用CPU资源 

    线程的创建

    java为多线程开发提供了技术支持，可以通过三种方式实现多线程

    1、继承Thread类，重写run（）方法

    Thread是java的一个线程类，用于实现多线程

    Thread实现多线程的主要步骤如下：

    1、创建Thread这个线程类的子类，并重写run（）方法

    2、创建该子类的实例对象，调用start（）方法启动线程

    1. //创建Thread类的子类,并重写run（）方法
    2. class Mythread extends Thread {
    3.     //构造方法
    4.     public Mythread(String name) {
    5.         super(name);
    6.     }
    7.  
    8.     @Override
    9.     public void run() {
    10.         int i = 0;
    11.         while (i++ < 5)
    12.             System.out.println(Thread.currentThread().getName() + "调用重写的run()方法");
    13.         //Thread类的currentThread()方法:静态方法，返回对当前正在执行的线程对象的引用。
    14.         //getName得到线程的名称
    15.     }
    16. }
    17. public class demo1 {
    18.     public static void main(String[] args) {
    19.         Mythread mythread=new Mythread("mythread"); //创建子类的实例
    20.         mythread.start();//调用start方法
    21.  
    22.         Mythread mythread1=new Mythread("mythread1"); //创建子类的实例
    23.         mythread1.start();//调用start方法
    24.     }
    25. }

    main方法中创建了两个线程，线程名称是mythread和mythread1，两个线程通过start方法开启了线程，观察结果发现，两个进程交叉执行run()方法,实现了并发运行

    缺点：java只支持单继承，如果一个类已经继承了一个父类，就无法继承Thread类

    start（）方法和run（）方法的区别

    重写run（）方法，run（）方法内部是线程执行的内容

    start（）方法是启动线程，调用这个方法，线程才会进入运行态

    1. public class demo7 {
    2.     public static void main(String[] args) {
    3.         Thread thread = new Thread() {
    4.             @Override
    5.             public void run() {
    6.                 while (true) {
    7.                     System.out.println("run方法执行");
    8.                 }
    9.             }
    10.         };
    11.         thread.start();
    12.         while (true) {
    13.             System.out.println("main方法执行");
    14.         }
    15.     }
    16. }

    结果：两个线程并发执行

    1. public class demo8 {
    2.     public static void main(String[] args) {
    3.         Thread thread=new Thread(()->{
    4.             while(true)
    5.                 System.out.println("run方法执行");
    6.         });
    7.  
    8.         thread.run();
    9.         while(true){
    10.             System.out.println("main方法执行");
    11.         }
    12.     }
    13. }

    结果：只有thread内的run（）方法执行：run方法不会创建新的线程，也就是run（）方法在main线程内运行，单线程情况下顺序执行，而run方法内是一个死循环的代码

    2、实现Runnable接口，重写run（）方法

    Runnable接口实现多线程的主要步骤如下：

    1、创建Runnable接口的实现类对象

    2、使用Thread类有参构造方法实现创建线程实例，并将Runnable接口的实现类对象作为参数传入

    3、调用线程的start（）方法启动线程

     

    1.  
    2. //1、创建Runnable的实现类
    3. class MyRunnable  implements Runnable{
    4.     @Override
    5.     public void run() {
    6.         int i=0;
    7.         while(i++<5){
    8.             System.out.println(Thread.currentThread().getName()+"正在调用run()方法");
    9.         }
    10.     }
    11. }
    12. public class demo2 {
    13.     public static void main(String[] args) {
    14.         MyRunnable myRunnable=new MyRunnable();      //2、创建Runnable的实现类对象
    15.         Thread thread=new Thread(myRunnable,"thread");//3、实例化Thread类
    16.         thread.start();//4、开启线程
    17.  
    18.         Thread thread1=new Thread(myRunnable,"thread1");//3、实例化Thread类
    19.         thread1.start();//4、开启线程
    20.     }
    21. }

    3、实现callable接口，重写call（）方法，并使用Future来获取call（）方法的返回结果

    使用以上两种办法，重写run()方法，但是这个方法没有返回值，使用callable接口还可以得到返回结果

    FutureTask类是Runnable类的子类，创建FutureTask类对象时，将callable接口的实现类作为参数，将运行这个参数

    callable接口实现多线程的主要步骤如下：

    1、创建callable接口的实现类，同时重写call（）方法

    2、创建callable接口的实现类对象

    3、创建FutureTask线程处理结果类的有参构造方法来封装Callable接口实现类对象

    4、使用参数是FutureTask类对象的Thred有参构造方法创建Thread线程实例

    5、调用start（）方法开启线程

    1.  
    2. //1、创建Callable接口的实现类,重写call（）方法
    3. class Mythread3 implements Callable<Object>{
    4.     @Override
    5.     public Object call() throws Exception {
    6.         int i=0;
    7.         while(i++<5){
    8.             System.out.println(Thread.currentThread().getName()+"正在调用run()方法");
    9.         }
    10.         return  i;
    11.     }
    12. }
    13. public class demo3 {
    14.     public static void main(String[] args) throws ExecutionException, InterruptedException {
    15.         //2、创建Callable接口的实现类的实例化对象
    16.         Mythread3 mythread3 = new Mythread3();
    17.         //3、使用FutureTask类封装Callable接口 FutureTask是泛型类
    18.         FutureTask<Object> futureTask = new FutureTask<Object>(mythread3);
    19. //4、使用Thread类的（Runnable,name)的构造方法创建线程
    20.         Thread thread = new Thread(futureTask, "thread");
    21.         //5、开启线程
    22.         thread.start();
    23.  
    24.         //FutureTask类的get()方法，在线程运行结束前一直阻塞，直到线程结束后返回结果
    25.  
    26.         FutureTask<Object> futureTask1 = new FutureTask<Object>(mythread3);
    27.         Thread thread2 = new Thread(futureTask1, "thread1");
    28.         thread2.start();
    29.         System.out.println("thread的返回结果：" + futureTask1.get());
    30.         System.out.println("thread的返回结果：" + futureTask.get());
    31.     }
    32. }

    后台线程

    后台线程不会影响到进程退出

    前台线程影响进程退出

    对于java程序来说，只要还有一个前台线程运行，这个进程就不会结束，如果一个进程中全都是后台进程，那么进程就会结束

    1. public class demo6 {
    2.     public static void main(String[] args) {
    3.         Thread thread = new Thread(() -> {
    4.             while(true)
    5.                 System.out.println(Thread.currentThread().getName() +"调用run（）方法");
    6.         });
    7.         
    8.         thread.start();
    9.  
    10.         for (int i = 0; i <5 ; i++) {
    11.             System.out.println("main方法正在运行");
    12.         }
    13.     }
    14. }

     主线程main，前台线程thread并发运行，因为thread是前台线程，前台线程不结束，进程不会退出，程序死循环

    1. public class demo6 {
    2.     public static void main(String[] args) {
    3.         Thread thread = new Thread(() -> {
    4.             while(true)
    5.                 System.out.println(Thread.currentThread().getName() +"调用run（）方法");
    6.         });
    7.  
    8.         thread.setDaemon(true);//在线程开启之前,设置线程是后台线程
    9.         thread.start();
    10.  
    11.         for (int i = 0; i <5 ; i++) {
    12.             System.out.println("main方法正在运行");
    13.         }
    14.     }
    15. }

     主线程main，后台线程thread并发运行，当主线程main运行结束，进程也就结束了，此时JVM通知后台线程结束，由于后台进程从接受指令到做出响应需要时间，因此后台线程thread执行一小段时间后结束

    运行结果的最后一部分：

     线程的生命周期和状态转化

    当Thread对象创建完成时，线程的生命周期就开始了，当线程任务中的代码运行结束或者抛出异常、错误时，线程的生命周期结束

    Java官方API将线程的整个生命周期分为六个状态，分别是NEW（新建状态），RUNNABLE（可运行状态），BLOCKED（阻塞状态），WAITING（等待状态），TIMED_WAITING(定时等待状态），TERMINATED(终止状态）

    1、NEW（新建状态）：创建Thread子类对象，就是完成了NEW（新建状态）

    2、RUNNABLE（可运行状态）：调用start方法，线程就会从NEW状态进入RUNNABLE（可运行状态），RUNNABLE（可运行状态）可以分为就绪态（没有得到CPU）和运行态（得到CPU）

    3、BLOCKED（阻塞状态）：处于运行状态的线程因为一些原因失去了CPU，暂时停止运行进入阻塞态

    线程一般会在两种情况下进入阻塞态：

    1. 线程A运行过程中，试图获取同步锁时，却被线程B截获，此时JVM把当前线程A锁到对象的锁池中，线程A就会进入阻塞态
    2. 线程A运行过程中，发出I/O请求时，线程A也会陷入阻塞态

    4、WAITING（等待状态）

    Thread类：

    Object类： 

    处于运行状态的线程因为调用了无时间参数限制的方法后如wait（），join（）等方法，就会转化为等待态

    处于等待状态的线程不能立即争夺CPU，必须等其他进程执行特定的操作后才可以争取CPU，进入运行态

    例如：调用wait（）方法而陷入等待状态的线程，必须等待其他线程调用notify（）方法或者notifyAll()方法唤醒当前等待中的线程；

    调用join（）方法而陷入等待状态的线程，必须等待其他加入的线程终止

    A线程中启动B线程，A、B线程并发运行，在线程A中执行B.jion(),那么A线程阻塞，让B线程插队运行

    5、TIMED_WAITING(定时等待状态）

    和等待状态一样，处于运行状态的线程只不过是调用了有时间参数限制的方法后陷入定时等待状态，如wait（long millis），join（long millis），sleep（long millis）

    处于定时等待状态的线程不能立即争夺CPU，必须等其他进程执行特定的操作后才可以争取CPU，进入运行态

    调用wait（long millis）方法而陷入等待状态的线程，必须等待其他线程调用notify（）方法或者notifyAll()方法唤醒当前等待中的线程，或者等待限定时间结束之后也可以进行状态转化

    6、TERMINATED(终止状态） 

    线程的run（）方法或者call()方法，正常运行结束或者抛出异常、错误时，线程进入终止态，线程的生命周期结束

    对于main这个主线程，就是main方法执行结束之后，main线程才结束

    中断线程

    1、设置标志

    1. public class demo9 {
    2.     static boolean isquit = true;
    3.  
    4.     public static void main(String[] args) throws InterruptedException {
    5.  
    6.         Thread thread = new Thread() {
    7.             @Override
    8.             public void run() {
    9.                 while (isquit) {
    10.                     System.out.println(Thread.currentThread().getName() + "正在运行");
    11.                 }
    12.             }
    13.         };
    14.  
    15.         thread.start();
    16.  
    17.         Thread.sleep(1000);
    18.         isquit = false;
    19.         System.out.println("终止thread线程");
    20.     }
    21. }

    但是这个方法并不严谨

    2、

    1. public class demo10 {
    2.     public static void main(String[] args) {
    3.         Thread thread = new Thread(() -> {
    4.             while (!Thread.currentThread().isInterrupted()) {//检查线程是否被中断
    5.                 try {
    6.                     Thread.sleep(1000);
    7.                 } catch (InterruptedException e) {
    8.                     e.printStackTrace();
    9.                 }
    10.                 System.out.println(Thread.currentThread().getName() + "正在运行");
    11.             }
    12.         });
    13.  
    14.         thread.start();
    15.  
    16.         //main线程
    17.         try {
    18.             Thread.sleep(5000);
    19.         } catch (InterruptedException e) {
    20.             e.printStackTrace();
    21.         }
    22.         thread.interrupt();
    23.     }
    24.  
    25. }

     抛出异常：

     调用这个方法：如果线程处于运行态，那么可以终止；如果线程已经处于阻塞态或则等待态，那么就无法终止线程，抛出异常

    捕捉到异常，就跳出循环

     

    1. public class demo11 {
    2.     public static void main(String[] args) {
    3.         Thread thread=new Thread(()->{
    4.             for (int i = 0; i < 5; i++) {
    5.                 System.out.println(Thread.interrupted());
    6.                 //调用类的静态方法，删除标志位
    7.             }
    8.         });
    9.         thread.start();
    10.         thread.interrupt();//设置线程中断
    11.  
    12.     }
    13. }

     

    1. public class demo12 {
    2.     public static void main(String[] args) {
    3.         Thread thread=new Thread(()->{
    4.             for (int i = 0; i < 5; i++) {
    5.                 System.out.println(Thread.currentThread().isInterrupted());
    6.                 //调用对象的方法，不删除标志位
    7.             }
    8.         });
    9.         thread.start();
    10.         thread.interrupt();//设置线程中断
    11.  
    12.     }
    13. }

     

    Thread.interrupted()是Thread类的static方法，一个程序有一个标志位
Thread.currentThread().isInterrupted()这个是每一个实例化对象都有自己的标志位，会更加安全

    线程调度

    java虚拟机默认抢占式的调度方式，优先级高的线程更容易得到CPU

    线程的优先级

    优先级越高，那么进程被调度的可能性越大

     Thread类中，设置了三个静态常量表示优先级：最高是10，中等是5，最低是1

    程序运行过程中，每一个线程都具有优先级，但是每一个线程的优先级不是固定不变的，可以通过setPriority（）方法设置

    1. public class demo14 {
    2.     public static void main(String[] args) {
    3.         Thread thread = new Thread(() -> {
    4.             for (int i = 0; i < 4; i++) {
    5.                 System.out.println(Thread.currentThread().getName());
    6.             }
    7.         });
    8.         thread.setName("a");
    9.  
    10.         Thread thread1 = new Thread(() -> {
    11.             for (int i = 0; i < 4; i++) {
    12.                 System.out.println(Thread.currentThread().getName());
    13.             }
    14.         });
    15.         thread1.setName("b");
    16.         thread.setPriority(10);//设置优先级10
    17.         thread1.setPriority(1);//设置优先级1
    18.         thread.start();
    19.         thread1.start();
    20.     }
    21. }
    22.

     可以发现，优先级越高，获取CPU的可能性就越大。但是，java中提供的10个优先级需要操作系统的支持，不同的操作系统对优先级的支持是不一样的，不能和提供的10个优先级一一对应

    因此：多线程的功能实现一定不能依赖于线程的优先级

    进程插队---join（）方法

    当在某一个线程中，调用其他线程的jion（）方法时，调用的线程将会被阻塞，直到被join（）方法加入的线程执行完成后，它才会继续运行

    A线程中启动B线程，A、B线程并发运行，在线程A中执行B.jion(),那么A线程阻塞，让B线程插队运行

    1. public class demo13 {
    2.     public static void main(String[] args) {
    3.         Thread thread = new Thread() {
    4.             @Override
    5.             public void run() {
    6.                 for (int i = 0; i < 5; i++) {
    7.                     System.out.println(Thread.currentThread().getName()+"正在运行"+i);
    8.                 }
    9.             }
    10.         };
    11.         thread.start();
    12.  
    13.         for (int i = 0; i < 5; i++) {
    14.             System.out.println("main（）方法执行"+i);
    15.             if(i==2) {
    16.                 try {
    17.                     thread.join();//thread线程调用join（）方法
    18.                 } catch (InterruptedException e) {
    19.                     e.printStackTrace();
    20.                 }
    21.             }
    22.         }
    23.     }
    24. }

     main线程内开启了一个thread线程，这两个线程并发运行

    当main线程中i=2时，thread线程执行jion方法，这时，main线程就会陷入阻塞，直到thread线程运行结束，main线程才可以继续执行

    1. public class demo13 {
    2.     public static void main(String[] args) {
    3.         Thread thread = new Thread("thread0") {
    4.             @Override
    5.             public void run() {
    6.                 for (int i = 0; i < 5; i++) {
    7.                     System.out.println(Thread.currentThread().getName() + "正在运行" + i);
    8.                 }
    9.             }
    10.         };
    11.         thread.start();
    12.  
    13.         Thread thread1 = new Thread("thread1") {
    14.             @Override
    15.             public void run() {
    16.                 for (int i = 0; i < 5; i++) {
    17.                     System.out.println(Thread.currentThread().getName() + "正在运行" + i);
    18.                     if(i==2) {
    19.                         try {
    20.                             thread.join();
    21.                         } catch (InterruptedException e) {
    22.                             e.printStackTrace();
    23.                         }
    24.                     }
    25.                 }
    26.             }
    27.         };
    28.         thread1.start();
    29.  
    30.  
    31.     }
    32. }

     main线程内有两个线程thread0和thread1，在thread1中当i=2时，调用thread0的join（）方法，那么thread1陷入阻塞，thread0这个线程插队运行，直到thread0这个线程结束之后，thread1才可以继续执行

     Thread类除了提供无参数的join（）方法外，还提供了带有时间参数的join（long millis）方法，表示最多等待线程多长时间

    jion（1000）表示1s内，如果线程结束了，直接结束这个线程；1s内没有结束，也直接结束线程，

     线程休眠---sleep（）方法

    如果想要人为地控制线程的执行顺序，让正在运行的线程暂停，从而其他线程就有了可以获取cpu的机会，就可以调用sleep（）方法

    sleep（200),哪怕其他线程在200ms内终止了，这个线程也仍需要等待至200ms结束后才可以转化为就绪态

    1. public class demo15 {
    2.     public static void main(String[] args) {
    3.         Thread thread=new Thread("A"){
    4.             @Override
    5.             public void run() {
    6.                 for (int i = 0; i <5 ; i++) {
    7.                     System.out.println(Thread.currentThread().getName()+":"+i);
    8.                 }
    9.             }
    10.         };
    11.  
    12.         Thread thread1=new Thread("B"){
    13.             @Override
    14.             public void run() {
    15.                 for (int i = 0; i <5 ; i++) {
    16.                     System.out.println(Thread.currentThread().getName()+":"+i);
    17.                     if(i==2){
    18.                         try {
    19.                             Thread.sleep(500);
    20.                         } catch (InterruptedException e) {
    21.                             e.printStackTrace();
    22.                         }
    23.                     }
    24.                 }
    25.             }
    26.         };
    27.  
    28.         thread.start();
    29.         thread1.start();
    30.     }
    31. }

     线程B在i=2时调用sleep（）方法，线程B陷入阻塞，线程A可以去获取CPU，在500ms过了之后，线程B进入就绪态，如果得到CPU，就可以运行

    
                
    
                    
    
                
    • 

                
  • 

                    相关阅读:
    
                    
算法练习|Leetcode49字母异位词分词 ，Leetcode128最长连续序列，Leetcode3无重复字符的最长子串，sql总结                            
    
python3.8 安装 ssl 模块 和 _ctypes 模块                            
    
watch()监听vue2项目角色权限变化更新挂载                            
    
JavaScript知识系列（5）每天10个小知识点                            
    
大数据技术之HBase+Redis详解                            
    
项目管理之知识管理                            
    
机器学习笔记 - 关于Contrastive Loss对比损失                            
    
宏转录组分析揭示不同土壤生境中氮循环基因的表达                            
    
c#字段和属性的区别                            
    
RabbitMQ—持久化机制与内存磁盘的监控                            
    
                        
                
    • 
                
  • 
                    原文地址：https://blog.csdn.net/m0_58342797/article/details/125346588
                
    •