线程基础知识点

news2024/11/18 16:43:31

1. 线程和进程的区别？

程序由指令和数据组成，但这些指令要运行，数据要读写，就必须将指令加载至 CPU，数据加载至内存。在指令运行过程中还需要用到磁盘、网络等设备。进程就是用来加载指令、管理内存、管理 IO 的。
当一个程序被运行，从磁盘加载这个程序的代码至内存，这时就开启了一个进程。
一个线程就是一个指令流，将指令流中的一条条指令以一定的顺序交给 CPU 执行
一个进程之内可以分为一到多个线程。

二者对比

  • 进程是正在运行程序的实例，进程中包含了线程，每个线程执行不同的任务
  • 不同的进程使用不同的内存空间，在当前进程下的所有线程可以共享内存空间。
  • 线程更轻量，线程的上下文切换成本一般上要比进程上下文切换低（上下文切换指的是从一个线程切换到另一个线程）

2. 并行与并发的区别？

单核 CPU

  • 单核 CPU 下线程实际还是串行执行的
CPU时间片 1时间片 2时间片 3
core线程 1线程 2线程 3

每个时间片只能由 1 个线程执行。

  • 操作系统中有一个组件叫做任务调度器，将 cpu 的时间片（windows 下时间片最小约为 15 毫秒）分给不同的程序使用，只是由于 cpu 在线程间（时间片很短）的切换非常快，人类感觉是同时运行的。
  • 总结为一句话就是：微观串行，宏观并行。（感觉是并行，实际是串行）
  • 一般会将这种线程轮流使用 CPU 的做法称为并发（concurrent）

多核 CPU

每个核（core）都可以调度运行线程，这时候线程可以是并行的。

区别

并发（concurrent）是同一时间应对（dealing with）多件事情的能力
并行（parallel）是同一时间动手做（doing）多件事情的能力

3. 线程创建的方式有哪些？

共有 4 种方式可以创建线程，分别是：

  1. 继承 Thread 类
  2. 实现 runnable 接口
  3. 实现 Callable 接口
  4. 线程池创建线程

继承 Thread 类

public class MyThread extends Thread{
    @Override
    public void run(){
        System.out.println("run");
    }
    public static void main(String[] args){
        // 创建MyThread对象
        MyThread t = new MyThread();
        // 调用start方法启动线程
        t.start();
    }
}

实现 Runnable 接口

public class MyRunnable implements Runnable{
    @Override
    public void run(){
        System.out.println("run");
    }
    public static void main(String[] args){
        // 创建MyRunnable对象
        MyRunnable mr = new MyRunnable();
        // 创建Thread对象
        MyThread t = new MyThread(mr);
        // 调用start方法启动线程
        t.start();
    }
}

实现 Callable 接口

public class MyCallable implements Callable<String>{
    @Override
    public String call()throws Exception{
        System.out.println("run");
        return "ok";
    }
    public static void main(String[] args) throws ExecutionException,InterruptedException{
        // 创建MyRunnable对象
        MyCallable mr = new MyCallable();
        // 创建Future Task
        FutureTask<String> ft = new FutureTask<String>(mr);
        // 创建Thread对象
        MyThread t = new MyThread(mr);
        // 调用start方法启动线程
        t.start();
        // 调用ft的get方法获取线程执行结果；
        String result = ft.get();
    }
}

注意：

  • 接口后面的泛型和 call 方法的返回值一样。
  • call 方法内就是线程要执行的内容。
  • 这种方式对于需要线程返回结果的很合适。

线程池创建线程

public class MyExecutors implements Runnable{
    @Override
    public void run(){
        System.out.println("run");
    }
    public static void main(String[] args){
        // 创建线程池对象
        ExecutorService threadPool = Executors.newFixedPool(3);
        threadPool.submit(new MyExecutors());
        // 关闭线程池
        threadPool.shutdown();
    }
}

追问：Runnable 和 Callable 的区别

  1. Runnable 接口 run 方法没有返回值。
  2. Callable 接口 call 方法有返回值，是个泛型，和 Future、FutureTask 配合可以用来获取异步执行的结果。
  3. Callable 接口的 call 方法允许抛出异常；而 Runnable 接口的 run 方法的异常只能在内部消化，不能继续上抛。

追问：在启动线程的时候，可以使用 run 方法吗？run() 和 start()有什么区别？

启动的线程的时候不可以使用 run 方法。

  • start(): 用来启动线程，通过该线程调用 run 方法执行 run 方法中所定义的逻辑代码。start 方法只能被调用一次。
  • run()：封装了要被线程执行的代码，就是一个普通的方法，可以被调用多次。

4. 线程包括哪些状态，状态之间是如何变化的？

线程的状态可以参考 JDK 中的 Thread 类中的枚举 State

public enum State {
        /**
         * Thread state for a thread which has not yet started.
         */
        // 尚未启动的线程的线程状态
        NEW,

        /**
         * Thread state for a runnable thread.  A thread in the runnable
         * state is executing in the Java virtual machine but it may
         * be waiting for other resources from the operating system
         * such as processor.
         */
        // 可运行线程的线程状态
        RUNNABLE,

        /**
         * Thread state for a thread blocked waiting for a monitor lock.
         * A thread in the blocked state is waiting for a monitor lock
         * to enter a synchronized block/method or
         * reenter a synchronized block/method after calling
         * {@link Object#wait() Object.wait}.
         */
        // 线程阻塞等待监视器锁的线程状态
        BLOCKED,

        /**
         * Thread state for a waiting thread.
         * A thread is in the waiting state due to calling one of the
         * following methods:
         * <ul>
         *   <li>{@link Object#wait() Object.wait} with no timeout</li>
         *   <li>{@link #join() Thread.join} with no timeout</li>
         *   <li>{@link LockSupport#park() LockSupport.park}</li>
         * </ul>
         *
         * <p>A thread in the waiting state is waiting for another thread to
         * perform a particular action.
         *
         * For example, a thread that has called <tt>Object.wait()</tt>
         * on an object is waiting for another thread to call
         * <tt>Object.notify()</tt> or <tt>Object.notifyAll()</tt> on
         * that object. A thread that has called <tt>Thread.join()</tt>
         * is waiting for a specified thread to terminate.
         */
        // 等待线程的线程状态
        WAITING,

        /**
         * Thread state for a waiting thread with a specified waiting time.
         * A thread is in the timed waiting state due to calling one of
         * the following methods with a specified positive waiting time:
         * <ul>
         *   <li>{@link #sleep Thread.sleep}</li>
         *   <li>{@link Object#wait(long) Object.wait} with timeout</li>
         *   <li>{@link #join(long) Thread.join} with timeout</li>
         *   <li>{@link LockSupport#parkNanos LockSupport.parkNanos}</li>
         *   <li>{@link LockSupport#parkUntil LockSupport.parkUntil}</li>
         * </ul>
         */
        // 具有指定等待时间的等待线程的线程状态
        TIMED_WAITING,

        /**
         * Thread state for a terminated thread.
         * The thread has completed execution.
         */
        // 已终止线程的线程状态，线程已完成执行
        TERMINATED;
    }


面试回答参考

  1. 线程包括哪些状态？

新建（NEW）、可执行（RUNNABLE）、阻塞（BLOCKED）、等待（WAITING）、时间等待（TIMED_WAITING）、终止（TERMINATED）

  1. 线程状态之间是如何变化的
  • 创建线程对象是新建状态
  • 调用了 start() 方法转变为可执行状态
  • 线程获取到了 CPU 的执行权，执行结束是终止状态
  • 在可执行状态的过程中，如果没有获取 CPU 的执行权，可能会切换其他状态
    • 如果没有获取锁（synchronized 或 lock）进入**阻塞状态，**获得锁再切换为可执行状态
    • 如果线程调用了 wait() 方法进入等待状态，其他线程调用 notify() 唤醒后可切换为可执行状态
    • 如果线程调用了 sleep(50)方法，进入计时等待状态，到时间后可切换为可执行状态

5. 线程按顺序执行 join、notify 和 notifyall 的区别？

新建 T1、T2、T3 三个线程，如何保证它们按照顺序执行？

可以使用线程中的 join 方法解决。
join() 等待线程运行结束。例如，调用 t.join()，阻塞调用此方法的线程，使其进入 timed_waiting 状态，直到线程 t 执行完成后，此线程再继续执行。

public class JoinTest {
    public static void main(String[] args) {
        // 创建线程对象
        Thread t1 = new Thread(()->{
            System.out.println("t1");
        });
        Thread t2 = new Thread(()->{
            try {
                t1.join();  // 加入线程t1，只有t1线程执行完毕后，再次执行该线程
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("t2");
        });
        Thread t3 = new Thread(()->{
            try {
                t2.join();  // 加入线程t2，只有t2线程执行完毕后，再次执行该线程
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("t3");
        });
        // 启动线程
        t3.start();
        t2.start();
        t1.start();
    }
}
// 执行结果
t1
t2
t3

notify 和 notifyAll 有什么区别？

  • notifyAll：唤醒所有 wait 的线程
  • notify：只随机唤醒一个 wait 线程

6. Java 中 wait 和 sleep 方法的不同？

共同点
wait()，wait(long) 和 sleep(long) 的效果都是让当前线程暂时放弃 CPU 的使用权，进入阻塞状态。
不同点

  1. 方法归属不同
  • sleep(long) 是 Thread 的静态方法
  • 而 wait()，wait(long)都是 Object 的成员方法，每个对象都有
  1. 醒来时机不同
  • 执行 sleep(long) 和 wait(long) 的线程都会在等待相应的毫秒后醒来
  • wait(long) 和 wait() 还可以被 notify 唤醒，wait() 如果不唤醒就一直等下去
  • 它们都可以被打断唤醒
  1. 锁特性不同（重点）
  • wait 方法的调用必须先获取 wait 对象的锁（比如配合 synchronized 锁使用），而 sleep 则无此限制
  • wait 方法执行后会释放对象锁，允许其它线程获得该对象锁
  • sleep 方法如果在 synchronized 代码块中执行，并不会释放对象锁

7. 如何停止一个正在运行的线程？

有三种方式可以停止线程

  • 使用退出标志，使线程正常退出，也就是当 run 方法完成后线程终止
public class MyInterrupt1 extends Thread{
    volatile boolean flag = false;  // 线程执行的退出标记

    @Override
    public void run(){
        while(!flag){
            System.out.println("MyThread...run...");
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        // 创建MyThread对象
        MyInterrupt1 t1 = new MyInterrupt1();
        t1.start();

        // 主线程休眠6秒
        Thread.sleep(6000);

        // 更改标记为true
        t1.flag = true;
    }
}
// 执行结果
MyThread...run...
MyThread...run...
  • 使用 stop 方法强行终止（不推荐，已作废）
  • 使用 interrupt 方法中断线程
    • 打断阻塞的线程（sleep、wait、join）的线程，线程会抛出 InterruptedException 异常
    • 打断正常的线程，可以根据打断状态来标记是否退出线程
public class MyInterrupt3 {
    public static void main(String[] args) throws InterruptedException {
        // 1. 打断阻塞的线程
        Thread t1 = new Thread(()->{
            System.out.println("t1 正在运行。。。");
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }, "t1");
        t1.start();
        Thread.sleep(500);
        t1.interrupt();
        System.out.println(t1.isInterrupted());
        // 2. 打断正常的线程
//        Thread t2 = new Thread(()->{
//            while(true){
//                Thread current = Thread.currentThread();
//                boolean interrupted = current.isInterrupted();
//                if(interrupted){
//                    System.out.println("打断状态："+ interrupted);
//                    break;
//                }
//            }
//        },"t2");
//        t2.start();
//        Thread.sleep(500);
//        t2.interrupt();
    }
}
//1执行结果
t1 正在运行。。。
false
Exception in thread "t1" java.lang.RuntimeException: java.lang.InterruptedException: sleep interrupted
	at MyInterrupt3.lambda$main$0(MyInterrupt3.java:9)
	at java.lang.Thread.run(Thread.java:750)
Caused by: java.lang.InterruptedException: sleep interrupted
	at java.lang.Thread.sleep(Native Method)
	at MyInterrupt3.lambda$main$0(MyInterrupt3.java:7)
	... 1 more
//2执行结果
打断状态：true

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1396355.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

自动驾驶概述

自动驾驶概述

自动驾驶技术主要解决的问题 无人驾驶分级 L1：巡航定速（ACC），巡航装置可以纵向控制车辆，可以加速减速 L2：车道保持辅助，系统可以纵向控制也可以横向控制汽车，但车是辅助，人才是主导。 L2.5：可以提供简单路况下的变道能力，比如特斯拉。 L3：L2的基础上提供变道能力，…
阅读更多...
[C语言]编译和链接

[C语言]编译和链接

一、翻译和运行 在ANSI C的任何⼀种实现中&#xff0c;存在两个不同的环境。 1&#xff09;翻译环境&#xff1a;将源代码被转换为可执行的机器指令 2&#xff09;执行环境&#xff1a;实际执行代码。 1.翻译环境 首先我们来将翻译环境 翻译环境是由 编译 和 链接 两个大的过程…
阅读更多...
龙哥的问题（积性函数，莫比乌斯反演）

龙哥的问题（积性函数，莫比乌斯反演）

题目路径&#xff1a; 221. 龙哥的问题 - AcWing题库 思路&#xff1a;
阅读更多...
5G消息一站式解决方案，实现全新“跳代”应用体验

5G消息一站式解决方案，实现全新“跳代”应用体验

随着5G技术的普及和深化&#xff0c;通信行业迎来发展的“红利期”。5G消息作为基础短信业务的升级&#xff0c;可通过手机一键开启。不仅支持在原生短信界面发送多种内容&#xff0c;如&#xff1a;语音、视频、图片、地理位置等。还可通过chatbot功能模拟人类智能对话&#x…
阅读更多...
2017年认证杯SPSSPRO杯数学建模A题(第一阶段)安全的后视镜全过程文档及程序

2017年认证杯SPSSPRO杯数学建模A题(第一阶段)安全的后视镜全过程文档及程序

2017年认证杯SPSSPRO杯数学建模 A题 安全的后视镜 原题再现&#xff1a; 汽车后视镜的视野对行车安全非常重要。一般来说&#xff0c;汽车的后视镜需要有良好的视野范围&#xff0c;以便驾驶员能够全面地了解车后方的道路情况。同时&#xff0c;后视镜也要使图像的畸变尽可能…
阅读更多...
Zoho Survey评价：功能全面，值得一试

Zoho Survey评价：功能全面，值得一试

通常来讲&#xff0c;我们在使用一款问卷调查制作工具制作问卷时会有哪些需求呢&#xff1f; 用户需求 1、操作简单&#xff0c;易上手。 2、能够满足用户个性化的需求。 3、提供多语言服务。 4、能够帮助发布以及数据收集。 5、简化数据分析 市面上的问卷调查制作工具都…
阅读更多...
【法如faro】法如三维激光扫描软件Scene2023下载与安装教程

【法如faro】法如三维激光扫描软件Scene2023下载与安装教程

FARO SCENE 2023是法如中国官方开发的一款相套配的三维数字化存档软件&#xff0c;该软件专门设计用于所有的Focus和第三方激光扫描仪&#xff0c;通过使用实时现场配准、自动对象识别、扫描图像配准和定位功能&#xff0c;能够帮助用户轻松而高效地处理和管理扫描后的数据。 文…
阅读更多...
HTTPS协议把什么加密了？

HTTPS协议把什么加密了？

HTTPS&#xff08;Hypertext Transfer Protocol Secure&#xff09;是一种用于在计算机网络上进行安全通信的协议。它的工作原理主要基于以下几个关键步骤&#xff1a; 1. 握手阶段&#xff08;Handshake&#xff09;&#xff1a; - 客户端向服务器发送一个请求&#xff0c…
阅读更多...
349. 两个数组的交集（力扣）（OJ题）

349. 两个数组的交集（力扣）（OJ题）

题目链接&#xff1a;349. 两个数组的交集 - 力扣&#xff08;LeetCode&#xff09; 个人博客主页&#xff1a;https://blog.csdn.net/2301_79293429?typeblog 专栏&#xff1a;https://blog.csdn.net/2301_79293429/category_12545690.html 给定两个数组 nums1 和 nums2 &a…
阅读更多...
十一、常用API——正则表达式

十一、常用API——正则表达式

目录 练习1&#xff1a; 正则表达式的作用 正则表达式 字符类&#xff08;只匹配一个字符&#xff09; 预定义字符&#xff08;只匹配一个字符&#xff09; 数量词 类 Pattern 正则表达式的构造摘要 反斜线、转义和引用 字符类 行结束符 组和捕获 Unicode 支持 与…
阅读更多...
Spring Boot整合MyBatis-Plus

Spring Boot整合MyBatis-Plus

引言 在现代软件开发中&#xff0c;我们经常需要处理大量的数据。为了有效地管理这些数据&#xff0c;我们需要使用一些强大的框架。其中&#xff0c;Spring Boot和MyBatis-Plus是两个非常流行的框架。Spring Boot是一个基于Spring的开源Java框架&#xff0c;可以用于创建独立…
阅读更多...
Java：选择哪个Java IDE好?

Java：选择哪个Java IDE好?

Java&#xff1a;选择哪个Java IDE好? 在开始前我有一些资料&#xff0c;是我根据网友给的问题精心整理了一份「java的资料从专业入门到高级教程」&#xff0c; 点个关注在评论区回复“888”之后私信回复“888”&#xff0c;全部无偿共享给大家&#xff01;&#xff01;&…
阅读更多...
动手搓一个kubernetes管理平台(3)-后端框架

动手搓一个kubernetes管理平台(3)-后端框架

后端框架的选择面比较大&#xff0c;由于不涉及复杂的调度/分布式管理等场景&#xff0c;所以后端选用一个标准的web server即可&#xff0c;比如gin, iris, beego等等&#xff0c;因为正好最近在看iris的一些项目&#xff0c;所以就选用了irsicorba的框架进行后端开发 。 通过…
阅读更多...
Kafka-消费者-KafkaConsumer分析-PartitionAssignor

Kafka-消费者-KafkaConsumer分析-PartitionAssignor

Leader消费者在收到JoinGroupResponse后&#xff0c;会按照其中指定的分区分配策略进行分区分配&#xff0c;每个分区分配策略就是一个PartitionAssignor接口的实现。图是PartitionAssignor的继承结构及其中的组件。 PartitionAssignor接口中定义了Assignment和Subscription两个…
阅读更多...
KubeSphere 社区双周报 | 2024.01.04-01.18

KubeSphere 社区双周报 | 2024.01.04-01.18

KubeSphere 社区双周报主要整理展示新增的贡献者名单和证书、新增的讲师证书以及两周内提交过 commit 的贡献者&#xff0c;并对近期重要的 PR 进行解析&#xff0c;同时还包含了线上/线下活动和布道推广等一系列社区动态。 本次双周报涵盖时间为&#xff1a;2024.01.04-01.18…
阅读更多...
【SpringBoot3】IDEA常用插件介绍Tabnine，GsonFormat，Maven Helper等

【SpringBoot3】IDEA常用插件介绍Tabnine，GsonFormat，Maven Helper等

文章目录 一、Tabnine二、Auto filling Java call arguments三、GsonFormat四、Rainbow Brackets五、Maven Helper 本文主要介绍一些比较实用的IDEA插件&#xff0c;帮助广大开发者提升开发效率&#xff0c;愉悦编码&#xff01; 一、Tabnine 官网地址&#xff1a;https://ww…
阅读更多...
C语言：预处理详解

C语言：预处理详解

创作不易&#xff0c;来个三连呗&#xff01; 一、预定义符号 C语⾔设置了⼀些预定义符号&#xff0c;可以直接使⽤&#xff0c;预定义符号也是在预处理期间处理的。 __FILE__ //进⾏编译的源⽂件 __LINE__ //⽂件当前的⾏号 __DATE__ //⽂件被编译的⽇期 __TIME__ //⽂件被编…
阅读更多...
从 GPT1 - GPT4 拆解

从 GPT1 - GPT4 拆解

从 GPT1 - GPT4 拆解 从 GPT1 - GPT4GPT1&#xff1a;更适用于文本生成领域GPT2&#xff1a;扩展数据集、模型参数&#xff0c;实现一脑多用&#xff08;多个任务&#xff09;GPT3&#xff1a;元学习 大力出奇迹InstructGPT&#xff1a;指示和提示学习 人工反馈强化学习 RLHF…
阅读更多...
视频直播新时代，低延时直播交互，Web,Android,WebRtc推流拉流测试

视频直播新时代，低延时直播交互，Web,Android,WebRtc推流拉流测试

直播现在已经深入了生活&#xff0c;学习&#xff0c;工作和娱乐方方面面&#xff0c;由于前些年的技术所限&#xff0c;传统rtmp,flv,m3u8 技术让直播快速启动项目产品&#xff0c;但也有很多不足&#xff0c;特别的交互式直播&#xff0c;一直是其中的痛点&#xff0c;延时较…
阅读更多...
【C++初阶】第二站:类与对象(上) -- 上部分

【C++初阶】第二站:类与对象(上) -- 上部分

前言: C学习的第二站&#xff1a;类和对象(上)文章的上半部分,知识点:面向过程和面向对象初步认识、类的引入、类的定义、类的访问限定符及封装、类的作用域、类的实例化. 目录 面向过程和面向对象初步认识 类的引入 类的定义 类的访问限定符及封装 访问限定符 封装 类的…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023