JAVA----Thread

大尾巴草鞋

已于 2024-07-05 18:18:25 修改

阅读量596

点赞数 12

分类专栏： Java 文章标签： java 开发语言

于 2024-04-21 17:32:56 首次发布

本文链接：https://blog.csdn.net/weixin_74357505/article/details/137403560

版权

Java 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

Thread

这里写目录标题

Thread
- 线程

线程

本身是操作系统提供的, 操作系统提供了 API 以让我们操作线程, JVM 就对操作系统 API 进行了封装.
线程这里, 则提供了 Thread 类, 表示线程. 利用类中的创建的实例, 以及实例里面创建的一系类方法, 我们就可以完成多线程编程了.

Thread 第 1 种写法

代码示例

package thread;
class MyThread extends Thread{
    //注解: 相当于是 提示编译器, 进行更严格的检查
    @Override
    public void run() {
        //run(): 描述线程的工作
        System.out.println("hello thread");
    }
}

public class Demo1 {
    public static void main(String[] args) {
        Thread t = new MyThread();
        t.start();
    }
}

结果

hello thread

Process finished with exit code 0//进程结束

上述代码中, 有 2 个线程:

t 线程;
main 方法所在的线程 (主线程).

但以上执行, 无法很直观的看见两个线程的执行, 我们再对其进行修改.
代码如下

package thread;
class MyThread extends Thread{
    //注解: 相当于是 提示编译器, 进行更严格的检查
    @Override
    public void run() {
        //run(): 描述线程的工作
        while(true){
            System.out.println("hello thread");
        }
    }
}

public class Demo1 {
    public static void main(String[] args) {
        Thread t = new MyThread();
        t.start();
        while(true){
            System.out.println("hello main");
        }
    }
}

运行结果是两者交替并发执行.

我们可以使用 jdk 中包含的 jconsole 工具来观察线程.

在这里插入图片描述
thread.Demo1则是我们创建的线程, 选中连接.

在这里插入图片描述
再点击线程

在这里插入图片描述
我们可以看到, 执行一个文件, 有 15 个线程, 并且在下方能看见 main 和 Thread-0 两个线程.

我们分别点击main 与 Thread线程
在这里插入图片描述

如图, 我们可以看到线程的调用栈, main 在调用sleep() 方法, Thread 有一个run() 方法在调用sleep().

我们同样可以打开任务管理器

在这里插入图片描述

我们可以看见这一个循环, 吃了很多的CPU资源

故而我们利用 sleep() 方法, 来让线程主动进入"阻塞状态", 主动离开 CPU, 睡眠 / 休眠一段时间.

try {
    Thread.sleep(1000);//休眠1秒(单位 ms)
} catch (InterruptedException e) {
    throw new RuntimeException(e);
}

等时间到了之后, 线程就会解除 “阻塞状态”, 重新被调度到 CPU 上执行.

package thread;
class MyThread extends Thread{
    //注解: 相当于是 提示编译器, 进行更严格的检查
    @Override
    public void run() {
        //run(): 描述线程的工作
        while(true){
            System.out.println("hello thread");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}
public class Demo1 {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new MyThread();
        t.start();
        while(true){
            System.out.println("hello main");
            try{
                Thread.sleep(1000);
            }catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

在这里插入图片描述
此时的 CPU 占用率大幅降低.

此时涉及到一个问题
在未来实际开发中, 发现服务器程序, 消耗 CPU 资源超出预期, 如何排查这个问题.

则先需要确认哪个线程消耗的 CPU 比较高: 利用第三方工具找到此线程, 确定以后, 进一步排查线程中是否有类似 “非常快速” 的循环.
然后确认此循环是否应该这么快, 若应该, 则升级 CPU. 若不应该, 则需要在循环中引入 等待操作(不一定是sleep() ).

然而
每个线程打印可能是 main 在前, 也可能是 thread 在前, 多个线程的调度是无序的, 在操作系统内部也称为 “抢占式执行”. 充满了随机性, 正是如此, 使用多线程是难以预测的.

此外, t.start()的作用

package thread;
class MyThread extends Thread{
    //注解: 相当于是 提示编译器, 进行更严格的检查
    @Override
    public void run() {
        //run(): 描述线程的工作
        while(true){
            System.out.println("hello thread");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}
public class Demo1 {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new MyThread();
//      t.start();
        
        t.run();
        //这里则是没有创建线程, 就是在主线程中执行上述 run 中的循环打印.
        while(true){
            System.out.println("hello main");
            try{
                Thread.sleep(1000);
            }catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

t.start() (Thread类中自带的方法):
调用操作系统提供的"创建线程" api,
在内核创建对应的 pcb 加入到链表中,
进一步的系统调度到这个线程了之后,
就会执行上述 run 方法中的逻辑.

当我们运行时, 只能看见起循环 Thread线程内的打印操作, 而看不见 main线程的打印操作.
此时的 run 和主线程的循环是串行执行, 不是 “并发执行”. 必须要求 run 中的循环结束, 才能继续执行到下一个循环.

像以上的 run, 定义好,而不去手动调用, 把这个方法交给系统/其他的库/其他框架调用.这样的方法称为: “回调函数”(callback function).

java数据结构, 谈到了比较强, 类似于回调函数的效果. PriorityQueue 优先级队列.

多线程 run 方法, 和上述两个情况本质一样, 都是回调函数.

Thread 第 2 种写法

package thread;
//Runnable: 描述一个任务
class MyRunnable implements Runnable{
    @Override
    public void run() {
        while(true){
            System.out.println("hello thread");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
public class Demo2 {
    public static void main(String[] args){
        Thread t = new Thread(new MyRunnable());
        t.start();
        while (true){
            System.out.println("hello main");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

第一种写法, 是 Thread 自己记录自己的操作.
第二种写法, 是 Runnable 记录操作, Thread 负责执行.

当运行内容与执行两个操作分离开, 实现了解耦合操作.
在java中解耦合使用接口实现.

解耦合的作用: 简单来讲, 就是使代码的维护难度降低.

Thread 第 3 种写法

package thread;

public class Demo3 {
    public static void main(String[] args) {
        Thread t = new Thread(){
            /*这里的 new Thread 并非是 new 一个 Thread, 而是几个操作融合在了一起
            1. 创建了一个 Thread的子类(匿名的)
            2. 同时创建了一个该子类id实例, 对于匿名内部类只能创建这一个实例,
            这个实例创建完之后, 再也拿不到这个匿名内部类了.
            3. 此处的子类内部重写了父类 run 方法.
            */
            @Override
            public void run() {
                System.out.println("hello thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        t.start();
        while(true){
            System.out.println("hello main");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

Thread 第 4 种写法

package thread;

public class Demo4 {
    public static void main(String[] args) {
        //Runnable 匿名内部类,
        //此处匿名内部类,只针对 Rnunable,与 Thread 无关
        //把 Runnable 实例, 作为参数传入到 Thread 的构造方法内
        Thread t = new Thread(new Runnable() {
            /*1.创建新的类, 实现Runnable.但类名是匿名的.
            2.同时创建了这个新类的实例(一次性)
            3.重写run方法*/
            @Override
            public void run() {
                while(true){
                    System.out.println("hello thread");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
            }
        });
            t.start();
            while(true){
                System.out.println("hello main");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }

Thread 第 5 种写法

lambda 表达式

package thread;
//使用 lambda 表达式
public class Demo5 {
    public static void main(String[] args) {
        //此处的 lambda 就是要代替Demo4重写的 run方法
        Thread t = new Thread(() -> {
            System.out.println("hello Thread");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });
        t.start();
        while(true){
            System.out.println("hello main");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}