【Java 线程系列】Java 天生就是多线程

举报
半身风雪 发表于 2022/06/24 11:37:24 2022/06/24
【摘要】 作者:半身风雪上一篇:线程之间的共享和协作@[TOC](Java 天生就是多线程) 前言 一、Java 中的线程一个Java 程序从main() 方法开始执行,然后按照既定的代码逻辑执行,看似没有其他线程参与,但实际上Java程序天生就是多线程程序,因为执行main() 方法的是一个名称为main 的线程。 public static void main(String[] args) ...

作者:半身风雪
上一篇:线程之间的共享和协作


@[TOC](Java 天生就是多线程)


前言

请添加图片描述


一、Java 中的线程

一个Java 程序从main() 方法开始执行,然后按照既定的代码逻辑执行,看似没有其他线程参与,但实际上Java
程序天生就是多线程程序,因为执行main() 方法的是一个名称为main 的线程。

    public static void main(String[] args) {

//        java 虚拟机线程系统的管理接口
        ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();
//        不需要获取同步的monitor 和synchronizer 信息,仅仅获取线程和线程堆栈信息
        ThreadInfo[] threadInfos = threadMXBean.dumpAllThreads(false, false);
//        遍历线程,仅打印线程ID 和线程名称信息
        for (ThreadInfo threadInfo : threadInfos) {
            System.out.println("线程ID" + threadInfo.getThreadId() + "线程名" + threadInfo.getThreadName());
        }
    }

上面代码输出的结果:

在这里插入图片描述

  1. M o n i t o r C t r l B r e a k \textcolor{red}{Monitor Ctrl-Break} 监控 Ctrl-Break 中断信号的
  2. S i g n a l D i s p a t c h e r \textcolor{red}{Signal Dispatcher} 分发处理发送给 JVM 信号的线程
  3. F i n a l i z e r \textcolor{red}{ Finalizer } 调用对象 finalize 方法的线程
  4. R e f e r e n c e H a n d l e r \textcolor{red}{Reference Handler} 清除 Reference 的线程
  5. m a i n \textcolor{red}{ main } main 线程,用户程序入口

从上面的例子中,我们能发现,在Java中短短的几行代码,就给我们启动了5个线程,当然,不同的版本,启动的线程数量也不一样,由此我们可以得出:Java
天生就是多线程的

1、启动

线程的启动方式有两种(源码中的注释是这么写的)参见代码:cn.enjoyedu.ch1.base.NewThread:

  1. X extends Thread;,然后 X.start
  2. X implements Runnable;然后交给 Thread 运行

示例代码:(派生自Thread 类,来实现我们的两种线程启动方式)

 /**
     * 扩展自Thread 类
     */
    private static class UserThread extends Thread{
        @Override
        public void run() {
            System.out.println("UserThread.run");
        }
    }

    /**
     * 扩展自 Runnable 类
     */
    private static class UserRunnable implements Runnable {

        @Override
        public void run() {
            System.out.println("UserRunnable.run");
        }
    }

    public static void main(String[] args) {

        UserThread userThread = new UserThread();
        userThread.start();

        UserRunnable userRunnable = new UserRunnable();

        new Thread(userRunnable).start();

    }

Thread 和 Runnable 的区别:

  • Thread 是Java 里对线程的唯一抽象。
  • Runnable 是Java对任务(业务逻辑)的抽象。
  • Thread 可以接受任意一个 Runnable 的实例并执行。

2、中止

  • 线程自然终止:要么是run 执行完成了,要么是抛出了一个未处理的异常导致线程提前结束。
  • stop:暂停、恢复和停止操作对应在线程ThreadAPI 就是 suspend()、resume() 和 stop()。但是这些API 都是过期的,不再建议使用。不建议使用的主要原因有:以suspend()方法为例,在调用后,线程不会释放已占有的资源(比如锁),而是占有资源进入睡眠状态,这样容易引发死锁问题。同样,stop() 方法在终结一个线程时,不会保证线程的资源正常释放,通常是没有给予线程完成资源释放的机会,因此会到导致程序可能工作在不确定的状态下。整因为suspend()、resume() 和 stop() 方法带来的副作用,这些方法才会被标注为不建议使用的过期方法中。
  • 中断:安全的中止则是其它线程通过调用线程A的interrupt() 方法对其进行中止操作,中断代表着其它线程对A线程打了个招呼,“A, 你要中断了”,不代表线程A 会立即停止自己的工作,同样A线程可以不理会这种请求。因为Java 中的线程是协作式的,不是抢占式。线程通过检查自身的中断标志位是否被置为true来进行响应。
 private static class UserThread extends Thread{

       public UserThread(String name){
            super(name);
        }

        @Override
        public void run() {
            String threadName = Thread.currentThread().getName();
            System.out.println(threadName + "interrupt flag = " + isInterrupted());

            while (!isInterrupted()){
//            while (!Thread.interrupted()){
//            while (true){
                System.out.println(threadName+ "is running");
                System.out.println(threadName+ "inner interrupt flag = "+ isInterrupted());
            }
            System.out.println(threadName+ "interrupt flag = " + isInterrupted());
        }
    }


    public static void main(String[] args) {
        Thread endTread = new UserThread("endTread");
        endTread.start();
        try {
            Thread.sleep(20);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
//        中断线程, 其实设置线程的标识位
        endTread.interrupt();
    }

运行上面的代码:

在这里插入图片描述

  • 我们发现,在使用isInterrupted() 进行线程中断的之后,isInterrupted()会返回一个true。我们一起来看一下 isInterrupted() 方法的源码:

在这里插入图片描述

  • 我们再使用一下静态的 interrupted() 方法,他返回的也是一个bool 值,先看一下这个方法的源码:

在这里插入图片描述

  • 从源码中我们发现,它返回也是中断标识符,但是,它把中断标识符给重新赋值成了true。我们来看一下运行效果

在这里插入图片描述

由此我们可以总结出:线程通过方法 isInterrupted()来进行判断是否被中断,也可以调用静态方法 Thread.interrupted()来进行判断当前线程是否被中断,不过 Thread.interrupted() 会同时将中断标识位改写为 false

3、阻塞

  • 如果一个线程处于阻塞状态(如线程调用了 thread.sleep、thread.join、 thread.wait 等),则线程在检查中断标识时,如果发现中断标识位true,则会在这些阻塞方法调用处抛出 InterruptedException 异常,并且在抛出异常后会立即将线程的中断标识位清除,即重新设置为true

    private static class UserThread extends Thread{

       public UserThread(String name){
            super(name);
        }

        @Override
        public void run() {
            String threadName = Thread.currentThread().getName();
            System.out.println(threadName + "interrupt flag = " + isInterrupted());

            while (!isInterrupted()){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    System.out.println(threadName+ "inner interrupt flag = "+ isInterrupted());
                    e.printStackTrace();
                }

                System.out.println(threadName+ "is running");

            }
            System.out.println(threadName+ "interrupt flag = " + isInterrupted());
        }
    }


    public static void main(String[] args) {
        Thread endTread = new UserThread("endTread");
        endTread.start();
        try {
            Thread.sleep(20);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
//        中断线程, 其实设置线程的标识位
        endTread.interrupt();
    }

上面代码运行结果:

在这里插入图片描述

  • 那么像这种,我们该怎么去中中断操作呢?只需要在catch 中调用 interrupt() 方法就可以了

在这里插入图片描述

代码运行结果:

在这里插入图片描述

4、深入理解run 和 start

image.png

  • Thread 类是Java 里对线程概念的抽象,可以这样理解:我们通过new Thread() 其实只是new 出一个thread 的实例,还没有和操作系统中真正的线程挂起勾来。只有执行了start() 方法后,才实现了真正意义上的启动线程。
  • start() 方法让一个线程进入就绪队列等待分配CPU,分到CPU 后才调用run()方法,start() 方法不能重复调用,如果重复调用,就会抛出异常。
  • run() 方法是业务逻辑实现的地方,本质上和任意一个类的任意一个成员方法并没有任何区别,可以重复执行,也可以单独调用。

那么start() 和 run() 有什么区别呢?请看代码:

    private static class UserThread extends Thread{


        @Override
        public void run() {
            int i = 90;
            while (i > 0){
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                System.out.println("I am "+Thread.currentThread().getName()+"and now the i="+ i--);
            }
        }
    }


    public static void main(String[] args) {
        Thread endTread = new UserThread();
        endTread.setName("threadRun");
        endTread.start();

    }

代码运行结果:(观察运行结果,我们可以得出,调用start() 方法的时候,执行start() 方法的是子线程)

在这里插入图片描述

我们修改一下代码,调用run() 方法

 public static void main(String[] args) {
        Thread endTread = new UserThread();
        endTread.setName("threadRun");
        endTread.run();

    }

查看运行结果:(观察运行结果,我们可以得出,调用run() 方法的时候,执行run() 方法的是主线程)

在这里插入图片描述

5、join 方法

  • join() 方法是把指定的线程加入到当前线程,可以将两个交替执行的线程合并为顺序执行。
  static class Students implements Runnable {

        private Thread thread;

        public Students(Thread thread) {
            this.thread = thread;
        }

        public Students() {
        }

        @Override
        public void run() {
            System.out.println("学生开始排队打饭。。。。。");
            try {
                if (thread != null) thread.join();
                //            休眠2 秒
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println("学生打饭完成");
        }
    }

    static class Teacher implements Runnable {


        @Override
        public void run() {


            try {
                //  休眠2 秒
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println("老师开始打饭、、、、、");
            System.out.println(Thread.currentThread().getName() + "老师打饭完成。");
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Teacher teacher = new Teacher();
        Thread teaThread = new Thread(teacher);
        Students students = new Students(teaThread);
        Thread stuThread = new Thread(students);
        stuThread.start();
        teaThread.start();

        System.out.println("我开始打饭、、、、、");
        stuThread.join();
//         让主线程休眠2 秒
        Thread.sleep(2000);
        System.out.println(Thread.currentThread().getName()+"我打饭完成");
    }

代码运行结果如下:

在这里插入图片描述

由上代码运行结果,我们可以得出:在线程B中调用了线程A的join() 方法,只到线程A 执行完毕后,才会继续执行线程B的。

6、线程优先级

  • 在 Java 线程中,通过一个整型成员变量 priority 来控制优先级,优先级的范 围从 1~10,在线程构建的时候可以通过 setPriority(int)方法来修改优先级,默认 优先级是 5,优先级高的线程分配时间片的数量要多于优先级低的线程。
  • 设置线程优先级时,针对频繁阻塞(休眠或者 I/O 操作)的线程需要设置较 高优先级,而偏重计算(需要较多 CPU 时间或者偏运算)的线程则设置较低的 优先级,确保处理器不会被独占。在不同的 JVM 以及操作系统上,线程规划会 存在差异,有些操作系统甚至会忽略对线程优先级的设定。

7、守护线程

  • Daemon(守护)线程是一种支持型线程,因为它主要被用作程序中后台调 度以及支持性工作。这意味着,当一个 Java 虚拟机中不存在非 Daemon 线程的 时候,Java 虚拟机将会退出。可以通过调用 Thread.setDaemon(true)将线程设置 为 Daemon 线程。我们一般用不上,比如垃圾回收线程就是 Daemon 线程。
  • Daemon 线程被用作完成支持性工作,但是在 Java 虚拟机退出时 Daemon 线 程中的 finally 块并不一定会执行。在构建 Daemon 线程时,不能依靠 finally 块中 的内容来确保执行关闭或清理资源的逻辑。

8、synchronized 内置锁

  • 线程开始运行,拥有自己的栈空间,就如同一个脚本一样,按照既定的代码 一步一步地执行,直到终止。但是,每个运行中的线程,如果仅仅是孤立地运行, 那么没有一点儿价值,或者说价值很少,如果多个线程能够相互配合完成工作, 包括数据之间的共享,协同处理事情。这将会带来巨大的价值。
  • Java 支持多个线程同时访问一个对象或者对象的成员变量,关键字 synchronized 可以修饰方法或者以同步块的形式来进行使用,它主要确保多个线 程在同一个时刻,只能有一个线程处于方法或者同步块中,它保证了线程对变量 访问的可见性和排他性,又称为内置锁机制。

下面我们看一段代码,在main 方法中启动两个线程,每个线程的count 值都是10000,两个线程的和应该就是20000。

public class OnlyMain {
 private long count = 0;
    private Object object = new Object();

    public long getCount() {
        return count;
    }

    public void incCount() {
        count++;
    }

    //    线程
    private static class Count extends Thread {
        private OnlyMain onlyMain;

        public Count(OnlyMain onlyMain) {
            this.onlyMain = onlyMain;
        }

        @Override
        public void run() {
            for (int i = 0; i < 10000; i++) {
//            count = count++ = 10000
                onlyMain.incCount();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        OnlyMain onlyMain = new OnlyMain();
//        启动两个线程
        Count count1 = new Count(onlyMain);
        Count count2 = new Count(onlyMain);

        count1.start();
        count2.start();

        Thread.sleep(50);

        System.out.println(onlyMain.count);
    }

}

代码的运行结果是:

在这里插入图片描述

经过多次运行,每次运行的结果都不一样,只有在很少很少的几率的情况下,才会出现正确的20000结果值,这是为什么呢?

  • 这是因为,两个线程同时对count 成员变量进行访问,才导致输出结果的错误。怎么解决呢?使用synchronized 内置锁。

修改上面代码中的incCount() 方法,添加一个内锁:


    public synchronized void incCount() {
        count++;
    }

这样我们就能保证每次运行的正确结果了:

在这里插入图片描述

9、对象锁和类锁

在这里插入图片描述

在这里插入图片描述

  • 对象锁是用于对象实例方法的锁,或者一个对象实例上,类锁 是用于类的静态方法或一个类的class 上的,我们知道,类的对象实例可以有很多个,但是每个类只有一个class对象,所有不同对象实例的对象锁是互不干扰的,但是每个类只有一个类锁。
  • 但是有一点必须要注意的是,其实类锁只是一个概念上的东西,并不是真实存在的,类锁其实锁的是每个类的对应的class 对象。类锁和对象锁之间也是互不干扰的。

总结

🎉 原创不易,还希望各位大佬支持一下 \textcolor{blue}{原创不易,还希望各位大佬支持一下}

👍 点赞,你的认可是我创作的动力! \textcolor{green}{点赞,你的认可是我创作的动力!}

🌟 收藏,你的青睐是我努力的方向! \textcolor{green}{收藏,你的青睐是我努力的方向!}

✏️ 评论,你的意见是我进步的财富! \textcolor{green}{评论,你的意见是我进步的财富!}

【版权声明】本文为华为云社区用户原创内容,转载时必须标注文章的来源(华为云社区)、文章链接、文章作者等基本信息, 否则作者和本社区有权追究责任。如果您发现本社区中有涉嫌抄袭的内容,欢迎发送邮件进行举报,并提供相关证据,一经查实,本社区将立刻删除涉嫌侵权内容,举报邮箱: cloudbbs@huaweicloud.com
  • 点赞
  • 收藏
  • 关注作者

评论(0

0/1000
抱歉,系统识别当前为高风险访问,暂不支持该操作

全部回复

上滑加载中

设置昵称

在此一键设置昵称,即可参与社区互动!

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。