线程基础知识点

最新推荐文章于 2024-09-14 21:48:00 发布
最新推荐文章于 2024-09-14 21:48:00 发布
阅读量387 收藏 8
点赞数 9
分类专栏： JAVA 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shxguozhq/article/details/135702745
版权
本文详细解释了线程与进程的区别，进程与线程的并发与并行概念，线程的四种创建方式，线程状态及其转换，join、notify和notifyAll的使用，wait和sleep的区别，以及停止线程的方法。
摘要由CSDN通过智能技术生成

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
一只快乐的融合怪
关注
专栏目录
c# 面试必备线程基础知识点
12-16
程池中运行任务，这更适合长时间运行的工作。线程同步与通信线程同步是为了避免多个线程同时访问共享资源导致数据不一致的问题。...在面试中，对线程基础的扎实掌握能展示开发者对系统级编程的理解和实践经验。
Java多线程知识点总结
08-19
了解线程池的概念也是Java多线程编程中的一个重要知识点。线程池是一种多线程处理形式，它将线程和任务的概念分离开来，能够有效管理线程资源，减少线程创建和销毁的开销，提高程序性能。Java中可以通过Executors类...
多线程基础知识点
qq_41854398的博客
08-15 116
多线程基础知识点 多线程基础必要知识点！看了学习多线程事半功倍
Java多线程的知识点
weixin_59796310的博客
05-28 4899
Java多线程的知识点
Java 线程 基础知识总结
Zhangguohao666的博客
07-27 6298
文章目录线程基础生产消费者模型，synchronizedjoin方法+死锁（哲学家进餐问题）join和锁死锁有趣的Timer类Timer多线程的一个运行实例 初步认识下线程，线程怎么去实现（通过继承Thread或者实现Runnable接口） 线程基础 很不严谨的说，线程是什么？线程就是为了让很多个东东并发执行，大大的提高程序执行的效率啊 三个非常重要的概念： 程序：一组写好了的静态代码块（就我...
多线程重点知识归纳总结。
yzh2776680982的博客
06-08 2022
一、线程相关概念 1、程序 程序是一个指令序列。是为完成特定任务、 用某种语言编写的一组指令的集合。简单的说:就是我们写的代码 它以某些程序设计语言编写，运行于某种目标结构体系上。打个比方，程序就如同以英语（程序设计语言）写作的文章，要让一个懂得英语的人（编译器）同时也会阅读这篇文章的人（结构体系）来阅读、理解、标记这篇文章。一般的，以英语文本为基础的计算机程序要经过编译、链接而成为人难以解读，但可轻易被计算机所解读的数字格式，然后放入运行。 2、进程 ............
线程基础知识
qwertf123的博客
04-23 1092
线程基础知识
java多线程基础知识点总结
Chandler的博客
02-03 518
我们知道应用程序是以进程为单位运行，那应用程序内部如何多个子任务同时执行呢，这就引入了多线程，这里我们就可以得出，线程是进程的运行单位； java实现多线程的的方式主要有以下三种： （1）继承Thread类，重写run方，这种方式的缺点就是java只能单继承，如果继承了Thread则不能继承其他的类； （2）实现Runnable接口，相较于（1），这种方式更为可取，因为是实现接口，可以更好的...
Java线程基础知识和使用
weixin_52633911的博客
02-22 1018
Java中线程的基础概念和使用
多线程基础知识点死锁 通信 线程池 线程组 定时器
Lemon_JK的博客
09-15 145
java多线程基础知识点 lock 概述 ： 可以更加清晰的加锁和释放锁，JDK5之后就提供了新的锁对象LOCK 方法： void lock（ ） 获取锁 void unlock （ ） 释放锁 实现类： ReentrantLock 类 死锁问题 概述 ： 是指两个或者两个以上的线程在执行过程中，因为争夺资源产生的一种相互等待现象 同步弊端： 效率低、如果出现了同步嵌套，就容易产生死锁问题 ’ 线程之间的通信问题 不同种类之间针对
Java多线程-知识点梳理和总结-超详细-面试知识点.docx
12-17
"Java多线程-知识点梳理和总结-超详细-面试知识点" Java多线程是Java编程语言中最基本也是最重要的概念之一。多线程编程可以提高程序的执行效率、改善用户体验和提高系统的可扩展性。但是，多线程编程也存在一些...
Java-网络
2301_81543552的博客
09-14 718
Java中的网络编程主要涉及使用Socket类进行网络通信，以及理解各种网络协议。以下是一些关键概念和示例代码，帮助您入门。
自动生成不重复的订单id
ClaireCheney的博客
09-13 305
【代码】自动生成不重复的订单id。
【学习笔记】手写 Tomcat 三
LearnTech_123的博客
09-12 1164
响应动态资源不需要写文件名了，只需要写功能的名称即可。比如登录功能，可以定义名称为 doLogin
Java项目: 基于SpringBoot+mybatis+maven课程答疑系统(含源码+数据库+毕业论文)
weixin_43860634的博客
09-14 761
Java项目: 基于SpringBoot+mybatis+maven课程答疑系统(含源码+数据库+毕业论文)
面试题篇: 跨域问题如何处理(Java和Nginx处理方式)
最新发布
m0_66572126的博客
09-14 699
最常见的解决方案是在服务器端配置 CORS 头。服务器需要在响应中添加适当的 Access-Control-Allow-头来允许跨域请求。
多线程异步操作与线程基础知识
下面将详细介绍线程和异步调用的相关知识点。 一、进程 进程通常描述为一个正在运行的程序的实例，由两部分组成：（1）从系统管理的角度，进程包含一个由操作系统管理的内核对象，该内核对象也是系统用来存放与...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值