当前位置： 首页 > ai >正文

【Java多线程-----复习】

ai 2025/7/21 8:09:58

1. 什么是多线程

多线程是指在一个程序中同时运行多个执行线程的编程技术。

基本概念：

  • 线程是程序执行的最小单位，比进程更轻量级
  • 同一个进程内的多个线程共享内存空间、文件句柄等系统资源
  • 每个线程有自己独立的执行栈和程序计数器

主要优势：

  • 提高效率：充分利用多核CPU，实现真正的并行处理
  • 响应性好：用户界面线程可以保持响应，而其他线程处理后台任务
  • 资源共享：线程间通信比进程间通信更高效

2. 线程基础

2.1 创建一个线程

2.1.1 创建一个简单线程

创建一个新线程可以通过实例化一个Thread实例，然后调用start()方法。
但是这个线程启动后实际上什么也不做就立刻结束了。

public class Main {public static void main(String[] args) {Thread t = new Thread();t.start(); // 启动新线程}
}

2.1.2 希望新线程能够执行制定代码

需要重写run()方法，通常可以继承Thread类或实现Runnable接口

// 方法1：从Thread派生一个自定义类，然后覆写run()方法：
public class Main {public static void main(String[] args) {Thread t = new MyThread();t.start(); // 启动新线程}
}class MyThread extends Thread {@Overridepublic void run() {System.out.println("start new thread!");}
}
// 方法2：创建Thread实例时，传入一个Runnable实例：
public class Main {public static void main(String[] args) {Thread t = new Thread(new MyRunnable());t.start(); // 启动新线程}
}class MyRunnable implements Runnable {@Overridepublic void run() {System.out.println("start new thread!");}
}
// 方法3：用Java 8引入的lambda语法进一步简写为：
// 多线程
public class Main {public static void main(String[] args) {Thread t = new Thread(() -> {System.out.println("start new thread!");});t.start(); // 启动新线程}
}

2.2 Java线程的状态

Java线程有6种状态，定义在Thread.State枚举中：

  1. New (新建状态)
    • 线程已创建但还未调用start()方法
  2. RUNNABLE (可运行状态)
    • 调用start()方法后进入此状态
    • 包含两个子状态：
      • Ready: 准备运行，等待CPU调度
      • Running: 正在CPU上执行
  3. BLOCKED (阻塞状态)
    • 线程被阻塞等待监视器锁
    • 通常发生在等待进入synchronized代码块/方法时
  4. WAITING (等待状态)
    • 线程无限期等待另一个线程的特定操作
    • 常见触发方式：
      • Object.wait()
      • Thread.join()
      • LockSupport.park()
  5. TIMED_WAITING (超时等待状态)
    • 线程等待指定时间后自动返回
    • 常见触发方式：
      • Thread.sleep(long)
      • Object.wait(long)
      • Thread.join(long)
  6. TERMINATED (终止状态)
    • 线程执行完毕或异常退出后的状态
    • 线程一旦进入此状态就无法再次启动

2.3 如何中断线程

如果线程需要执行一个长时间任务，就可能需要能中断线程。中断线程就是其他线程给该线程发一个信号，该线程收到信号后结束执行run()方法，使得自身线程能立刻结束运行。

2.3.1 中断线程

// 中断线程
public class Main {public static void main(String[] args) throws InterruptedException {Thread t = new MyThread();t.start();Thread.sleep(1); // 暂停1毫秒t.interrupt(); // 中断t线程t.join(); // 等待t线程结束System.out.println("end");}
}class MyThread extends Thread {public void run() {int n = 0;while (! isInterrupted()) {n ++;System.out.println(n + " hello!");}}
}

2.3.2 基于自己设置的标志位中断线程

// 中断线程
public class Main {public static void main(String[] args)  throws InterruptedException {HelloThread t = new HelloThread();t.start();Thread.sleep(1);t.running = false; // 标志位置为false}
}class HelloThread extends Thread {public volatile boolean running = true;public void run() {int n = 0;while (running) {n ++;System.out.println(n + " hello!");}System.out.println("end!");}
}

2.3.2 中断父线程

main线程通过调用t.interrupt()从而通知t线程中断，而此时t线程正位于hello.join()的等待中，此方法会立刻结束等待并抛出InterruptedException。

由于我们在t线程中捕获了InterruptedException，因此，就可以准备结束该线程。在t线程结束前，对hello线程也进行了interrupt()调用通知其中断。如果去掉这一行代码，可以发现hello线程仍然会继续运行，且JVM不会退出。

// 中断线程
public class Main {public static void main(String[] args) throws InterruptedException {Thread t = new MyThread();t.start();Thread.sleep(1000);t.interrupt(); // 中断t线程t.join(); // 等待t线程结束System.out.println("end");}
}class MyThread extends Thread {public void run() {Thread hello = new HelloThread();hello.start(); // 启动hello线程try {hello.join(); // 等待hello线程结束} catch (InterruptedException e) {System.out.println("interrupted!");}// 这段代码很重要,不然会导致hello线程无法结束，主线程也无法结束hello.interrupt();}
}class HelloThread extends Thread {public void run() {int n = 0;while (!isInterrupted()) {n++;System.out.println(n + " hello!");try {Thread.sleep(100);} catch (InterruptedException e) {break;}}}
}

3. 线程同步

3.1 synchronized

用synchronized修饰方法可以把整个方法变为同步代码块，synchronized方法加锁对象是this；通过合理的设计和数据封装可以让一个类变为“线程安全”；

public class Counter {private int count = 0;public void add(int n) {synchronized(this) {count += n;}}public void dec(int n) {synchronized(this) {count -= n;}}public int get() {return count;}
}

3.2 使用wait和notify

import java.util.*;class TaskQueue {Queue<String> queue = new LinkedList<>();public synchronized void addTask(String s) {this.queue.add(s);this.notifyAll();}public synchronized String getTask() throws InterruptedException {while (queue.isEmpty()) {this.wait();}return queue.remove();}
}

3.3 ReentrantLock

public class Counter {private final Lock lock = new ReentrantLock();private int count;public void add(int n) {lock.lock();try {count += n;} finally {lock.unlock();}}
}

3.4 Condition

使用ReentrantLock比直接使用synchronized更安全，可以替代synchronized进行线程同步。但是，synchronized可以配合wait和notify实现线程在条件不满足时等待，条件满足时唤醒，用ReentrantLock我们怎么编写wait和notify的功能呢？

答案是使用Condition对象来实现wait和notify的功能

class TaskQueue {private final Lock lock = new ReentrantLock();private final Condition condition = lock.newCondition();private Queue<String> queue = new LinkedList<>();public void addTask(String s) {lock.lock();try {queue.add(s);condition.signalAll();} finally {lock.unlock();}}public String getTask() {lock.lock();try {while (queue.isEmpty()) {condition.await();}return queue.remove();} finally {lock.unlock();}}
}

3.5 Semaphore信号量

本质上锁的目的是保护一种受限资源，保证同一时刻只有一个线程能访问（ReentrantLock），或者只有一个线程能写入（ReadWriteLock）。
还有一种受限资源，它需要保证同一时刻最多有N个线程能访问，比如同一时刻最多创建100个数据库连接，最多允许10个用户下载等。

public class AccessLimitControl {// 任意时刻仅允许最多3个线程获取许可:final Semaphore semaphore = new Semaphore(3);public String access() throws Exception {// 如果超过了许可数量,其他线程将在此等待:semaphore.acquire();try {// TODO:return UUID.randomUUID().toString();} finally {semaphore.release();}}
}

3.6 Concurrent集合

interfacenon-thread-safethread-safe
ListArrayListCopyOnWriteArrayList
SetHashSet / TreeSetCopyOnWriteArraySet
MapHashMapConcurrentHashMap
QueueArrayDeque / LinkedListArrayBlockingQueue / LinkedBlockingQueue
DequeArrayDeque / LinkedListLinkedBlockingDeque

Java的java.util.concurrent包除了提供底层锁、并发集合外，还提供了一组原子操作的封装类，它们位于java.util.concurrent.atomic包。

以AtomicInteger为例，它提供的主要操作有：

  • 增加值并返回新值：int addAndGet(int delta)
  • 加1后返回新值：int incrementAndGet()
  • 获取当前值：int get()
  • 用CAS方式设置：int compareAndSet(int expect, int update)
http://www.xdnf.cn/news/15807.html

相关文章：

  • 04训练windows电脑低算力显卡如何部署pytorch实现GPU加速
  • 标准制修订管理系统：制造业高质量发展的关键支撑
  • 【Java学习|黑马笔记|Day18】Stream流|获取、中间方法、终结方法、收集方法
  • python 装饰器的类型提示讲解
  • 下载win10的方法
  • Hiredis 构建 Redis 命令实战指南
  • 操作系统总结
  • XSS GAME靶场
  • 网络原理——IP
  • 深度神经网络原理学习记录
  • 微服务雪崩防护最佳实践之sentinel
  • Django ORM系统
  • SearchService 该类只运行在数据节点
  • 【文件IO】认识文件描述符和内核缓冲区
  • SSH开启Socks5服务
  • C++ STL容器
  • 金融大前端中的 AI 应用：智能投资顾问与风险评估
  • 【Nature Communications】GaN外延层中位错辅助的电子和空穴输运
  • 0401聚类-机器学习-人工智能
  • nvm、npm、pnpm、cnpm、yarn
  • 《深入C++多态机制：从虚函数表到运行时类型识别》​
  • 数据并表技术全面指南：从基础JOIN到分布式数据融合
  • Spring Boot 自动装配用法
  • Materials Studio学习笔记（二十九）——尿素的几何优化
  • 树同构（Tree Isomorphism）
  • [特殊字符] 小程序 vs 智能体：下一代应用开发，谁主沉浮？
  • 【Java项目安全基石】登录认证实战：Session/Token/JWT用户校验机制深度解析
  • 基于自定义数据集微调SigLIP2-分类任务
  • PDF 编辑器：多文件合并 拆分 旋转 顺序随便调 加水印 密码锁 页码背景
  • [学习] 深入理解傅里叶变换：从时域到频域的桥梁