java核心类库（八）多线程

最新推荐文章于 2023-03-09 17:04:40 发布

VIP文章是你得不到的人

最新推荐文章于 2023-03-09 17:04:40 发布

阅读量230

点赞数

分类专栏： JavaSE 文章标签：多线程 java

本文链接：https://blog.csdn.net/weixin_43835305/article/details/108411752

版权

八、多线程

8.1 基本概念

程序和进程的概念

程序 = 数据结构 + 算法，其实程序主要指存放在硬盘上的可执行文件
进程 - 主要指运行在内存中的可执行文件（即运行起来的程序）
目前主流的操作系统都支持多进程，为了让操作系统同时可以执行多个任务，但进程是重量级的，也就是新建一个进程会消耗CPU和内存空间等系统资源，因此进程的数量比较局限

线程的概念

为了解决上述问题就提出线程的概念，线程就是进程内部的程序流，也就是说操作系统内部支持多进程的，而每个进程的内部又是支持多线程的，线程是轻量的，新建线程会共享所在进程的系统资源，因此目前主流的开发都是采用多线程
多线程是采用时间片轮转法来保证多个线程的并发执行，所谓并发就是指宏观并行 微观串行的机制

8.2 线程的创建

8.2.1 Thread类

基本概念

java.lang.Thread类代表线程，任何线程对象都是Thread类(子类)的实例
Thread类是线程的模板，封装了复杂的线程开启等操作，封装了操作系统的差异性

创建方式

自定义类继承Thread类并重写run方法，然后创建该类的对象调用start方法(Thread类也实现了Runnable接口)
自定义类实现Runnable接口并重写run方法，创建该类的对象作为实参来构造Thread类型的对象，然后使用Thread类型的对象调用start方法

方法声明	功能介绍
Thread()	使用无参的方式构造对象
Thread(String name)	根据参数指定的名称来构造对象
Thread(Runnable target)	根据参数指定的引用来构造对象，其中Runnable是个接口类型
Thread(Runnable target, String name)	根据参数指定引用和名称来构造对象
void run()	若使用Runnable引用构造了线程对象，调用该方法时最终调用接口中的版本若没有使用Runnable引用构造线程对象，调用该方法时则啥也不做
void start()	用于启动线程，Java虚拟机会自动调用该线程的run方法

用法举例

public class ThreadTest {
   

    public static void main(String[] args) {
   

        // 1.使用无参方式构造Thread类型的对象
        // 由源码可知：Thread类中的成员变量target的数值为null。
        Thread t1 = new Thread();
        // 2.调用run方法进行测试
        // 由源码可知：由于成员变量target的数值为null，因此条件if (target != null)不成立，跳过{}         // 中的代码不执行
        //  而run方法中除了上述代码再无代码，因此证明run方法确实啥也不干
        t1.run();
        // 3.打印一句话
        System.out.println("我想看看你到底是否真的啥也不干！");
    }
}

线程创建和启动方式一



//-------------------------------------------------------------------------

public class SubThreadRun extends Thread {
   

    @Override
    public void run() {
   
        // 打印1 ~ 20之间的所有整数
        for (int i = 1; i <= 20; i++) {
   
            System.out.println("run方法中：i = " + i); // 1 2 ... 20
        }
    }
}

public class SubThreadRunTest {
   

    public static void main(String[] args) {
   

        // 1.声明Thread类型的引用指向子类类型的对象
        Thread t1 = new SubThreadRun();
        // 2.调用run方法测试，本质上就是相当于对普通成员方法的调用，因此执行流程就是run方法的代码执行         //   完毕后才能继续向下执行
        //t1.run();
        // 用于启动线程，Java虚拟机会自动调用该线程类中的run方法
        // 相当于又启动了一个线程，加上执行main方法的线程是两个线程
        t1.start();

        // 打印1 ~ 20之间的所有整数
        for (int i = 1; i <= 20; i++) {
   
            System.out.println("-----------------main方法中：i = " + i); // 1 2 ... 20
        }
    }
}

注意

调用run方法时，本质上就是对普通成员方法的调用，因此执行流程就是run方法执行完成后才可继续向下执行
调用start方法时，Java虚拟机会自动调用改类线程中的run方法，相当于又启动了一个线程运行run方法，加上执行main方法的线程就是两个线程，两个线程间会交替占用资源

线程创建和启动方式二


public class SubRunnableRun implements Runnable {
   
    @Override
    public void run() {
   
        // 打印1 ~ 20之间的所有整数
        for (int i = 1; i <= 20; i++) {
   
            System.out.println("run方法中：i = " + i); // 1 2 ... 20
        }
    }
}

public class SubRunnableRunTest {
   

    public static void main(String[] args) {
   

        // 1.创建自定义类型的对象，也就是实现Runnable接口类的对象
        SubRunnableRun srr = new SubRunnableRun();
        // 2.使用该对象作为实参构造Thread类型的对象
        // 由源码可知：经过构造方法的调用之后，Thread类中的成员变量target的数值为srr。
        Thread t1 = new Thread(srr);
        // 3.使用Thread类型的对象调用start方法
        // 若使用Runnable引用构造了线程对象，调用该方法(run)时最终调用接口中的版本
        // 由run方法的源码可知：if (target != null) {
   
        //                         target.run();
        //                    }
        // 此时target的数值不为空这个条件成立，执行target.run()的代码，也就是srr.run()的代码
        t1.start();
        //srr.start();  Error

        // 打印1 ~ 20之间的所有整数
        for (int i = 1; i <= 20; i++) {
   
            System.out.println("-----------------main方法中：i = " + i); // 1 2 ... 20
        }
    }
}

注意

start方法是Thread类中的方法，必须创建Thread类的引用去调用，而实现Runnable接口的自定义类和Thread类之间没有任何关系，所以要用自定义类的对象作为实参来创建Thread类的引用对象去调用start方法

执行流程

执行main方法的线程叫做主线程，执行run方法的线程叫做新线程/子线程
main方法是程序的入口，对于start方法之前的代码来说，由主线程执行一次，当start方法调用成功后线程的个数由1个变成了2个，新启动的线程去执行run方法的代码，主线程继续向下执行，两个线程各自独立运行互不影响
当run方法执行完毕后子线程结束，当main方法执行完毕后主线程结束
两个线程执行没有明确的先后执行次序，由操作系统调度算法来决定

方式的比较

继承Thread类的方式代码简单，但是若该类继承Thread类后则无法继承其它类，不利于后续代码的维护和升级
而 实现Runnable接口的方式 代码复杂，但不影响该类继承其它类以及实现其它接口，因此以后的开发中推荐使用第二种方式

匿名内部类的方式

public class ThreadNoNameTest {
   

    public static void main(String[] args) {
   

        // 匿名内部类的语法格式：父类/接口类型 引用变量名 = new 父类/接口类型() { 方法的重写 };
        // 1.使用继承加匿名内部类的方式创建并启动线程
        /*Thread t1 = new Thread() {
            @Override
            public void run() {
                System.out.println("张三说：在吗？");
            }
        };
        t1.start();*/
        new Thread() {
   
            @Override
            public void run() {
   
                System.out.println("张三说：在吗？");
            }
        }.start();

        // 2.使用实现接口加匿名内部类的方式创建并启动线程
        /*Runnable ra = new Runnable() {
            @Override
            public void run() {
                System.out.println("李四说：不在。");
            }
        };
        Thread t2 = new Thread(ra);
        t2.start();*/
        // 优化1
        /*new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("李四说：不在。");
            }
        }).start();*/
        // 优化2
        // Java8开始支持lambda表达式： (形参列表)->{方法体；}
        /*Runnable ra = ()-> System.out.println("李四说：不在。");
        new Thread(ra).start();*/

        new Thread(()-> System.out.println("李四说：不在。")).start();
    }
}

8.3 线程的生命周期

在这里插入图片描述

新建状态 - 使用new关键字创建之后进入的状态，此时线程并没有开始执行
就绪状态 - 调用start方法后进入的状态，此时线程还是没有开始执行
运行状态 - 使用线程调度器调用该线程后进入的状态，此时线程开始执行，当线程的时间片执行完毕后任务没有完成时回到就绪状态
消亡状态 - 当线程的任务执行完成后进入的状态，此时线程已经终止。
阻塞状态 - 当线程执行的过程中发生了阻塞事件进入的状态，如：sleep方法
阻塞状态解除后进入就绪状态(而不是立即执行)

8.4 线程的编号和名称

方法声明	功能介绍
long getId()	获取调用对象所表示线程的编号
String getName()	获取调用对象所表示线程的名称
void setName(String name)	设置/修改线程的名称为参数指定的数值
static Thread currentThread()	获取当前正在执行线程的引用

案例

自定义类继承Thread类并重写run方法，在run方法中先打印当前线程的编号和名称，然后将线程的名称修改为"zhangfei"后再次打印编号和名称
要求在main方法中也要打印主线程的编号和名

public class ThreadIdNameTest extends Thread {
   

    public ThreadIdNameTest(String name) {
   
        super(name); // 表示调用父类的构造方法
    }

    @Override
    public void run() {
   
        // 14  Thread-0 guanyu
        System.out.println("子线程的编号是：" + getId() + "，名称是：" + getName()); 
        // 修改名称为"zhangfei"
        setName("zhangfei");
        // 14  zhangfei
        System.out.println("修改后子线程的编号是：" + getId() + "，名称是：" + getName()); 
    }

    public static void main(String[] args) {
   

        ThreadIdNameTest tint = new ThreadIdNameTest("guanyu");
        tint.start();

        // 获取当前正在执行线程的引用，当前正在执行的线程是主线程，也就是获取主线程的引用
        Thread t1 = Thread.currentThread();
        System.out.println("主线程的编号是：" + t1.getId() + ", 名称是：" + t1.getName());
    }
}

//-----------------------------------------------

public class RunnableIdNameTest implements Runnable {
   
    @Override
    public void run() {
   
        // 获取当前正在执行线程的引用，也就是子线程的引用
        Thread t1 = Thread.currentThread();
        System.out.println("子线程的编号是：" + t1.getId() + "， 名称是：" + t1.getName()); // 14 guanyu
        t1.setName("zhangfei");
        System.out.println("修改后子线程的编号是：" + t1.getId() + "， 名称是：" + t1.getName()); // 14 zhangfei
    }

    public static void main(String[] args) {
   

        RunnableIdNameTest rint = new RunnableIdNameTest();
        //Thread t2 = new Thread(rint);
        Thread t2 = new Thread(rint, "guanyu");
        t2.start();

        // 获取当前正在执行线程的引用，当前正在执行的线程是主线程，也就是获取主线程的引用
        Thread t1 = Thread.currentThread();
        System.out.println("主线程的编号是：" + t1.getId() + ", 名称是：" + t1.getName());
    }
}

8.5 常用方法

方法声明	功能介绍
static void yield()	当前线程让出处理器（离开Running状态），使当前线程进入Runnable状态等待
static void sleep(times)	使当前线程从 Running 放弃处理器进入Block状态, 休眠times毫秒, 再返回到Runnable如果其他线程打断当前线程的Block(sleep), 就会发生 InterruptedException
int getPriority()	设置/修改线程的名称为参数指定的数值
void setPriority(int newPriority)	修改线程的优先级。优先级越高的线程不一定先执行，但该线程获取到时间片的机会会更多一些
void join()	等待该线程终止
void join(long millis)	等待参数指定的毫秒数
boolean isDaemon()	用于判断是否为守护线程
void setDaemon(boolean on)	用于设置线程为守护线程

sleep方法案例

import java.text.SimpleDateFormat;
import java.time.LocalDateTime;
import java.util.Date;

public class ThreadSleepTest extends Thread {
   
    // 声明一个布尔类型的变量作为循环是否执行的条件
    private boolean flag = true;

    // 子类中重写的方法不能抛出更大的异常
    @Override
    public void run() {
   
        // 每隔一秒获取一次系统时间并打印，模拟时钟的效果
        while (flag) {
   
            // 获取当前系统时间并调整格式打印
//            LocalDateTime.now();
            Date d1 = new Date();
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            System.out.println(sdf.format(d1));

            // 睡眠1秒钟
            try {
   
                Thread.sleep(1000);
            } catch (InterruptedException e) {
   
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
   

        ThreadSleepTest tst = new ThreadSleepTest();
        tst.start();

        // 主线程等待5秒后结束子线程
        System.out.println("主线程开始等待...");
        try {
   
            Thread.sleep(5000);
        } catch (InterruptedException e) {
   
            e.printStackTrace();
        }
        // 停止子线程  过时  不建议使用
        //tst.stop();
        tst.flag =