一文搞懂【线程】

已于 2024-12-07 14:17:43 修改
阅读量712 收藏 9
点赞数 20
CC 4.0 BY-SA版权
文章标签： java 线程
于 2024-12-07 14:16:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/bufangbufang/article/details/144293546

文章目录

前言

本文将详细介绍【线程】相关内容，包括，线程的结构、状态、调度等

一、线程

1.线程的基本结构

线程主要由线程 ID、程序计数器、寄存器集合和栈组成。

1.1线程 ID

线程ID是线程的唯一标识符，操作系统通过线程 ID 来区分不同的线程，可以通过线程 ID 来跟踪特定线程的执行情况。

1.2程序计数器

记录线程当前执行的指令位置。由于线程是可以暂停和恢复执行的，程序计数器可以保证线程在暂停后能够从正确的位置继续执行。
如：一个线程在执行一个包含多个循环的函数时被中断，当它再次获得执行权时，程序计数器会指示它从上次中断的循环位置继续执行。

1.3寄存器集合

用于存储线程执行过程中的临时数据，如操作数、计算结果等。这些寄存器可以加快线程的运算速度，因为数据存储在寄存器中比存储在内存中访问速度更快。不同的 CPU 架构有不同数量和类型的寄存器，线程会根据需要使用这些寄存器。

1.4栈

每个线程都有自己的栈空间，用于存储局部变量、函数调用信息等。当一个函数被调用时，函数的参数、局部变量和返回地址等信息都会被压入栈中。

2.线程的状态

2.1新建状态new

当通过编程语言提供的线程创建方法（如 Java 中的Thread类的构造函数）创建一个线程后，线程就处于新建状态。此时，线程只是一个对象，还没有开始执行，就像一个刚刚被制造出来还没有启动的机器。

2.2就绪状态runnable

当线程对象调用start()方法后，线程就进入就绪状态。处于就绪状态的线程已经具备了运行的条件，等待 CPU 分配时间片来运行。可以把它想象成运动员已经在起跑线上做好了准备，就等裁判发令（CPU 分配时间片）。

2.3运行状态running

当线程获得 CPU 时间片后，就进入运行状态，开始执行线程中的代码。在运行过程中，线程可能会因为时间片用完或者被更高优先级的线程抢占 CPU 而暂停运行。
如：在一个多任务操作系统中，多个线程会竞争 CPU 时间片，一个线程可能在运行了一小段时间后，时间片用完，就会暂停运行进入blocked状态，让其他线程运行。

2.4阻塞状态blocked

线程在运行过程中可能会因为等待某些事件而进入阻塞状态。
如：当一个线程需要读取一个尚未准备好的数据时，它会暂停执行，进入阻塞状态，等待数据可用。
常见的导致线程阻塞的情况包括等待 I/O 操作完成（如读取文件、网络通信等）、等待获取锁（用于同步多个线程对共享资源的访问）等。

2.5死亡状态dead

当线程执行完了它的任务或者因为出现异常等原因提前结束时，线程就进入死亡状态。处于死亡状态的线程不再占用 CPU 资源，也不能再被重新启动。例如，一个线程的任务是计算从 1 加到 100，当它完成这个计算后，就会进入死亡状态。

3.线程的同步与互斥

3.1同步

同步是指多个线程在访问共享资源时，通过一定的机制来协调它们的执行顺序，以确保共享资源的正确使用。
如：在一个银行账户管理系统中，有两个线程，一个线程负责存款操作，另一个线程负责取款操作。如果没有同步机制，可能会出现取款线程在存款线程还没有更新账户余额之前就读取了旧的余额信息，导致数据错误。常见的同步机制包括信号量、条件变量等。

3.2互斥

互斥是一种特殊的同步，主要是为了防止多个线程同时访问共享资源。互斥通常通过互斥锁来实现。
如：在一个多线程的文件写入系统中，为了防止多个线程同时写入同一个文件而导致文件内容混乱，会使用互斥锁。当一个线程需要写入文件时，它首先获取互斥锁，独占文件的写入权，其他线程在这个线程释放互斥锁之前无法获取写入权。

4.线程的调度

线程调度是指操作系统决定哪个线程可以获得 CPU 时间片并运行的过程。

4.1抢占式调度

在这种调度方式下，操作系统可以在任何时候中断正在运行的线程，并将 CPU 分配给其他线程。这种调度方式的优点是可以保证高优先级的线程能够及时获得 CPU 资源，但是也可能导致低优先级的线程长时间得不到运行。
如：在一个实时操作系统中，高优先级的任务（如紧急的安全监控任务）可以抢占低优先级的任务（如常规的数据备份任务）的 CPU 时间片。

4.2非抢占式调度

在这种调度方式下，一个线程会一直运行，直到它主动放弃 CPU（如因为等待某个事件或者执行完毕）。这种调度方式相对简单，但是可能会导致某些线程长时间占用 CPU，而其他线程等待时间过长。

bufangbufang
关注
【java】一文搞懂 Java 线程中断
九师兄
09-04 318
一文搞懂 Java 线程中断
Java线程详解大全
08-03
Java线程Java线程Java线程Java线程Java线程Java线程Java线程Java线程Java线程Java线程Java线程Java线程Java线程Java线程Java线程
线程详解
M________123的博客
03-25 344
线程 线程，有时被称为轻量级进程(Lightweight Process，LWP），是程序执行流的最小单元。一个标准的线程由线程ID，当前指令指针(PC），寄存器集合和堆栈组成。另外，线程是进程中的一个实体，是被系统独立调度和分派的基本单位，线程自己不拥有系统资源，只拥有一点儿在运行中必不可少的资源，但它可与同属一个进程的其它线程共享进程所拥有的全部资源。一个线程可以创建和撤消另一个线程，同一进...
线程-Thread
fzc2022的博客
05-28 900
本文介绍了线程的基本概念及其相关操作。线程是轻量级进程，与进程共享资源但拥有独立运行状态，相比进程更易通信但安全性较低。重点讲解了线程的创建(pthread_create)、退出(pthread_exit)、资源回收(pthread_join/detach)等核心函数接口，以及同步机制的实现方法。通过信号量(sem_init/wait/post)实现线程间同步，并附有主线程与子线程通过信号量通信的代码示例。文章系统性地涵盖了线程管理的各个方面，为理解多线程编程提供了基础指导。
嵌入式面经：一文搞懂线程进程的常见问题
include_joker的博客
07-04 930
嵌入式面经：一文搞懂线程进程的常见问题
一文搞懂线程和线程的区别
xk4848123的博客
04-26 1357
该题应该从下面四个角度来回答 调度 并发性 系统开销 拥有资源 开头（一句废话）：进程和线程的主要差别在于它们是不同的操作系统资源管理方式 1. 进程拥有资源、CPU调度单位是线程 在传统的操作系统中，CPU调度和分派的基本单位是进程。而在引入线程的操作系统中，则把线程作为CPU调度和分派的基本单位，进程则作为资源拥有的基本单位，从而使传统进程的两个属性分开，线程便能轻装运行，这样可以显著地提高系统的并发性。同一进程中线程的切换不会引起进程切换，从而避免了昂贵的系统调用。但是在由一个进程中的线程切换到另
Java多线程详解+代码实例 一文搞懂.pdf
08-22
Java多线程详解+代码实例 一文搞懂.pdf
一文搞懂Linux线程间通信，看完秒懂！
大雨的博客
04-12 1284
这个函数的工作方式比较特殊，它会先释放传入的互斥锁（这是为了避免死锁，因为如果不释放锁，其他线程无法修改条件变量所依赖的共享资源，也就无法唤醒等待的线程），然后将线程阻塞，直到条件变量被其他线程唤醒。互斥锁，作为线程同步中最常用的工具之一，其原理就像是一扇门的钥匙，在任何时刻，这把钥匙只能被一个线程持有，持有钥匙的线程才能进入被保护的区域 —— 临界区，对共享资源进行操作。例如，线程 A 持有锁 1，试图获取锁 2，而线程 B 持有锁 2，同时试图获取锁 1，这样就会导致死锁。
线程的详解
weixin_58473601的博客
06-04 236
线程的详解
线程
漠影的博客
01-09 3898
在传统操作系统中，每个进程有一个地址空间和一个控制线程，这是进程的定义，经常存在在一个地址空间中准并行运行多个控制线程的情形，这些线程像分离的进程。
线程相关的类及方法请给出解释和代码示例
最新发布
07-13
<think>首先，用户的问题是关于线程相关的类和方法解释及代码示例。用户引用了三个来源：一个是关于Java多线程的，一个是关于Java BIO模型的，另一个是关于QT多线程的。用户似乎主要关注Java，因为引用[1]和[2]都是Java相关的，而引用[3]是QT的。所以，我应该优先关注Java线程。 用户要求：解释线程相关的类和方法，并提供代码示例。结构要清晰，逐步解决问题。 关键点： - 使用中文回答。 - 行内数学表达式用$...$，但这里可能不需要数学，因为主题是线程编程。 - 独立公式用$$...$$，但同样，可能不适用。 - 回答中引用的段落末尾添加引用标识，如[^1]。 - 生成相关问题。 - 回答结构清晰，帮助用户逐步解决问题。 用户的问题："请问线程相关的类和方法解释及代码示例" 从引用中： - 引用[1]：展示了Java中通过继承Thread类或实现Runnable接口来创建线程。 - 引用[2]：讨论了Java BIO模型，涉及阻塞I/O和线程。 - 引用[3]：关于QT多线程，但用户说"上述引用仅供参考"，所以我应该基于用户的需求，而不是严格依赖这些引用。用户说"我想用户想要了解与线程相关的类及方法，并希望获得解释和代码示例"，所以我需要覆盖Java线程的核心类和方法。 核心Java线程类和方法： - Thread类：创建线程的基本方式。 - 方法：start(), run(), join(), interrupt(), etc. - Runnable接口：实现run()方法，然后传递给Thread实例。 - 其他：Executor框架，Callable, Future, synchronized keyword, Lock接口等。 用户提到了"代码示例"，所以我需要提供代码片段。 结构回答： 1. 介绍线程的基本概念。 2. 解释主要类和方法。 3. 提供代码示例。 4. 生成相关问题。 确保回答真实可靠：基于标准Java知识。 步骤： - 先解释Thread类和Runnable接口。 - 然后讨论其他相关概念如线程同步。 - 提供代码示例。 代码示例格式：使用代码块，如示例中的Python代码。 最后，生成相关问题。 添加引用标识：由于用户提供了引用，我可以在解释时引用它们。例如，当提到继承Thread类时，引用[^1]。 用户说"引用[1]:【JavaSE】一文搞懂Java多线程...", 所以我可以使用[^1]来引用这个。 类似地，引用[2]和[3]。 但引用[3]是QT的，可能不相关，除非用户指定。用户说"上述引用仅供参考"，所以我应该主要基于Java。 计划回答： 1. 介绍线程概念。 2. 解释创建线程的两种主要方式： a. 继承Thread类。 b. 实现Runnable接口。 3. 提供代码示例。 4. 简要讨论其他方法或类。 5. 生成相关问题。 代码示例使用Java，因为引用是Java的。</think>### Java线程相关的类和方法解释及代码示例 在Java中，线程是实现并发编程的核心机制。它允许程序同时执行多个任务，提高效率。Java提供了多种类和接口来管理线程，包括`Thread`类、`Runnable`接口、`Executor`框架等。下面我将逐步解释这些核心类和方法，并提供代码示例。所有代码都基于标准Java SE API，确保真实可靠[^1][^2]。 #### 1. **创建线程的基本方式** Java中创建线程主要有两种方法：**继承Thread类**和**实现Runnable接口**。这两种方法都要求重写`run()`方法，其中包含线程要执行的任务。 - **继承Thread类**： - 通过继承`Thread`类并重写`run()`方法，然后调用`start()`方法启动线程。 - 优点：简单直观。 - 缺点：Java是单继承语言，如果类已继承其他类，则无法使用此方法。 - 关键方法： - `start()`: 启动线程，JVM会自动调用`run()`方法。 - `run()`: 定义线程执行的任务。 - `join()`: 等待线程终止。 - `interrupt()`: 中断线程。 代码示例： ```java public class ThreadExample extends Thread { @Override public void run() { for (int i = 0; i < 5; i++) { System.out.println("Thread执行: " + i); try { Thread.sleep(100); // 模拟耗时操作 } catch (InterruptedException e) { e.printStackTrace(); } } } public static void main(String[] args) { ThreadExample thread = new ThreadExample(); thread.start(); // 启动线程 for (int i = 0; i < 5; i++) { System.out.println("Main执行: " + i); } } } ``` 输出示例： ``` Main执行: 0 Thread执行: 0 Main执行: 1 Thread执行: 1 ... ``` 说明：`main`线程和自定义线程交替执行，展示了并发性[^1]。 - **实现Runnable接口**： - 通过实现`Runnable`接口并重写`run()`方法，然后将实例传递给`Thread`对象。 - 优点：避免单继承限制，更灵活；同一个`Runnable`对象可被多个线程共享。 - 关键方法：与Thread类类似，但`Runnable`本身只定义`run()`方法。 代码示例： ```java public class RunnableExample implements Runnable { @Override public void run() { for (int i = 0; i < 5; i++) { System.out.println("Runnable执行: " + i); } } public static void main(String[] args) { Runnable runnable = new RunnableExample(); Thread thread = new Thread(runnable); thread.start(); // 启动线程 for (int i = 0; i < 5; i++) { System.out.println("Main执行: " + i); } } } ``` 输出类似继承Thread方式，但代码结构更灵活，适用于多线程共享任务[^1]。 #### 2. **线程同步与控制** 当多个线程访问共享资源时，可能导致数据不一致（如竞态条件）。Java提供同步机制确保线程安全： - **synchronized关键字**：用于方法或代码块，保证同一时间只有一个线程访问。 - **Lock接口**：更灵活的锁机制，如`ReentrantLock`。 - 关键方法： - `wait()`: 使线程等待，直到其他线程调用`notify()`。 - `notify()`: 唤醒等待的线程。 - `notifyAll()`: 唤醒所有等待线程。 代码示例（使用synchronized）： ```java public class SynchronizedExample { private int count = 0; public synchronized void increment() { count++; } public static void main(String[] args) throws InterruptedException { SynchronizedExample example = new SynchronizedExample(); Thread t1 = new Thread(() -> { for (int i = 0; i < 1000; i++) { example.increment(); } }); Thread t2 = new Thread(() -> { for (int i = 0; i < 1000; i++) { example.increment(); } }); t1.start(); t2.start(); t1.join(); // 等待t1结束 t2.join(); // 等待t2结束 System.out.println("最终计数: " + example.count); // 应为2000 } } ``` 说明：`synchronized`确保`increment()`方法原子性，避免计数错误[^1][^2]。 #### 3. **高级线程管理：Executor框架** Java 5+引入了`Executor`框架，简化线程池管理，提高性能： - **ExecutorService接口**：管理线程池。 - **Callable和Future**：支持有返回值的线程任务。 - 关键方法： - `submit()`: 提交任务。 - `shutdown()`: 关闭线程池。 - `awaitTermination()`: 等待所有任务完成。 代码示例（使用线程池）： ```java import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.Callable; import java.util.concurrent.Future; public class ExecutorExample { public static void main(String[] args) { ExecutorService executor = Executors.newFixedThreadPool(2); // 创建固定大小线程池 Callable<Integer> task = () -> { int sum = 0; for (int i = 0; i < 5; i++) { sum += i; Thread.sleep(100); } return sum; }; Future<Integer> future = executor.submit(task); try { System.out.println("任务结果: " + future.get()); // 获取返回值 } catch (Exception e) { e.printStackTrace(); } finally { executor.shutdown(); // 关闭线程池 } } } ``` 输出：`任务结果: 10` 说明：线程池减少了线程创建开销，`Callable`允许返回计算结果[^1][^2]。 #### 4. **线程优先级和状态** 线程优先级影响调度顺序（但不保证），状态包括NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, TERMINATED。 - 方法：`setPriority(int priority)`设置优先级（1-10），`getState()`获取状态。 - 注意：优先级依赖于JVM实现，不是绝对可靠。 代码示例： ```java public class PriorityExample { public static void main(String[] args) { Thread lowPriorityThread = new Thread(() -> { for (int i = 0; i < 5; i++) { System.out.println("低优先级线程"); } }); Thread highPriorityThread = new Thread(() -> { for (int i = 0; i < 5; i++) { System.out.println("高优先级线程"); } }); lowPriorityThread.setPriority(Thread.MIN_PRIORITY); // 优先级1 highPriorityThread.setPriority(Thread.MAX_PRIORITY); // 优先级10 lowPriorityThread.start(); highPriorityThread.start(); } } ``` 输出可能高优先级线程先执行更多次，但非绝对[^3]。 #### 总结 - **核心类**：`Thread`, `Runnable`, `ExecutorService`, `Lock`。 - **关键方法**：`start()`, `run()`, `join()`, `synchronized`, `submit()`。 - **最佳实践**：优先使用`Runnable`或`Executor`框架，避免直接继承`Thread`；使用同步机制处理共享资源[^1][^2]。 以上解释和代码基于Java标准库，适用于大多数场景。如果您有特定需求（如QT多线程），可进一步说明[^3]。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值