Java多线程

最新推荐文章于 2025-07-14 21:00:27 发布
原创 最新推荐文章于 2025-07-14 21:00:27 发布 · 707 阅读 · 16 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#开发语言 #java #数据结构 #多线程

一、多线程基础概念

1. 什么是线程？

线程是程序中执行的最小单位，一个进程可以包含多个线程。例如，浏览器可以同时下载文件、播放视频和渲染页面，这些都是通过不同线程实现的。

2. 为什么需要多线程？
  • 提高 CPU 利用率：当一个线程等待 IO 操作时，其他线程可以继续执行。
  • 改善响应性：例如 GUI 应用中，主线程负责界面响应，后台线程处理耗时任务。
  • 充分利用多核 CPU：现代处理器通常有多核，多线程可以并行执行在不同核心上。

二、Java 中创建线程的方式

1. 继承 Thread 类
public class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("线程执行中: " + Thread.currentThread().getName());
    }

    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start(); // 启动线程，JVM会调用run()方法
        System.out.println("主线程: " + Thread.currentThread().getName());
    }
}
2. 实现 Runnable 接口
public class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("线程执行中: " + Thread.currentThread().getName());
    }

    public static void main(String[] args) {
        Thread thread = new Thread(new MyRunnable());
        thread.start();
        System.out.println("主线程: " + Thread.currentThread().getName());
    }
}
3. 实现 Callable 接口（带返回值）
import java.util.concurrent.*;

public class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        Thread.sleep(1000);
        return "任务执行完成: " + Thread.currentThread().getName();
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService executor = Executors.newSingleThreadExecutor();
        Future<String> future = executor.submit(new MyCallable());
        System.out.println(future.get()); // 获取返回值，会阻塞直到任务完成
        executor.shutdown();
    }
}

三、线程的生命周期

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

  1. NEW：线程刚被创建，但还未调用start()方法。
  2. RUNNABLE：线程正在 Java 虚拟机中执行，或者准备执行（等待 CPU 时间片）。
  3. BLOCKED：线程被阻塞，等待获取监视器锁（例如进入synchronized块 / 方法）。
  4. WAITING：线程无限期等待另一个线程执行特定操作（例如调用wait()、join()）。
  5. TIMED_WAITING：线程在指定时间内等待（例如调用Thread.sleep(1000)）。
  6. TERMINATED：线程执行完毕或因异常终止。

四、线程同步与锁

1. synchronized 关键字

用于实现线程同步，确保同一时间只有一个线程可以执行被保护的代码块或方法。

public class Counter {
    private int count = 0;

    // 同步方法
    public synchronized void increment() {
        count++;
    }

    // 同步代码块
    public void decrement() {
        synchronized (this) {
            count--;
        }
    }
}
2. ReentrantLock

java.util.concurrent.locks包中的显式锁，功能比synchronized更强大。

import java.util.concurrent.locks.ReentrantLock;

public class Counter {
    private final ReentrantLock lock = new ReentrantLock();
    private int count = 0;

    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock(); // 必须在finally中释放锁
        }
    }
}
3. 原子操作类

java.util.concurrent.atomic包提供了原子操作类，基于 CAS（Compare-and-Swap）实现无锁并发。

import java.util.concurrent.atomic.AtomicInteger;

public class Counter {
    private AtomicInteger count = new AtomicInteger(0);

    public void increment() {
        count.incrementAndGet(); // 原子操作
    }
}

五、线程间通信

1. wait()、notify()、notifyAll()

这些方法是 Object 类的一部分，用于线程间协作。

public class ProducerConsumer {
    private static final Object lock = new Object();
    private static boolean ready = false;

    public static void main(String[] args) {
        // 生产者线程
        new Thread(() -> {
            synchronized (lock) {
                System.out.println("生产者准备数据...");
                ready = true;
                lock.notify(); // 通知等待的线程
            }
        }).start();

        // 消费者线程
        new Thread(() -> {
            synchronized (lock) {
                while (!ready) {
                    try {
                        lock.wait(); // 等待数据准备好
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                    }
                }
                System.out.println("消费者处理数据");
            }
        }).start();
    }
}
2. Condition 接口

ReentrantLock的高级替代方案，提供更灵活的等待 / 通知机制。

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class ProducerConsumer {
    private final ReentrantLock lock = new ReentrantLock();
    private final Condition condition = lock.newCondition();
    private boolean ready = false;

    public void produce() {
        lock.lock();
        try {
            System.out.println("生产者准备数据...");
            ready = true;
            condition.signal(); // 唤醒等待的线程
        } finally {
            lock.unlock();
        }
    }

    public void consume() {
        lock.lock();
        try {
            while (!ready) {
                condition.await(); // 等待数据准备好
            }
            System.out.println("消费者处理数据");
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        } finally {
            lock.unlock();
        }
    }
}

六、高级主题

1. 线程池（Executor 框架）

线程池管理一组工作线程，避免频繁创建和销毁线程的开销。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadPoolExample {
    public static void main(String[] args) {
        // 创建固定大小的线程池
        ExecutorService executor = Executors.newFixedThreadPool(5);

        // 提交任务
        for (int i = 0; i < 10; i++) {
            final int taskId = i;
            executor.submit(() -> {
                System.out.println("执行任务: " + taskId + " 线程: " + Thread.currentThread().getName());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            });
        }

        // 关闭线程池
        executor.shutdown();
    }
}
2. 并发集合类

java.util.concurrent包提供了多种线程安全的集合类：

  • ConcurrentHashMap：高效的线程安全哈希表
  • CopyOnWriteArrayList：写时复制的列表，适合读多写少的场景
  • BlockingQueue：阻塞队列，常用于生产者 - 消费者模式
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

public class BlockingQueueExample {
    public static void main(String[] args) {
        BlockingQueue<String> queue = new LinkedBlockingQueue<>(10);

        // 生产者线程
        new Thread(() -> {
            try {
                queue.put("数据1");
                queue.put("数据2");
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }).start();

        // 消费者线程
        new Thread(() -> {
            try {
                System.out.println("消费: " + queue.take());
                System.out.println("消费: " + queue.take());
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }).start();
    }
}
3. Future 和 CompletableFuture

用于异步计算和处理结果。

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

public class CompletableFutureExample {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 创建异步任务
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            return "异步任务结果";
        });

        // 任务完成后执行回调
        future.thenAccept(result -> System.out.println("处理结果: " + result));

        // 阻塞等待结果
        System.out.println(future.get());
    }
}
4. 原子变量与 CAS

AtomicInteger、AtomicLong等原子类基于 CAS 实现无锁并发。

import java.util.concurrent.atomic.AtomicInteger;

public class AtomicExample {
    private static AtomicInteger counter = new AtomicInteger(0);

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.incrementAndGet();
            }
        });

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.incrementAndGet();
            }
        });

        t1.start();
        t2.start();
        t1.join();
        t2.join();

        System.out.println("计数器值: " + counter.get()); // 输出2000，无竞争问题
    }
}

七、线程安全实践建议

  1. 不可变对象：优先使用不可变对象（如String、Integer），它们天生线程安全。
  2. 最小化共享状态：尽量减少多线程共享的变量和资源。
  3. 使用线程安全类：优先使用java.util.concurrent包中的类，而非自己实现同步。
  4. 避免死锁：
    • 按固定顺序获取锁
    • 使用带超时的锁获取方法（如tryLock）
  5. 正确处理中断：在线程中正确响应interrupt()请求，避免资源泄漏。

八、性能调优与监控

  1. 线程池大小优化：

    • CPU 密集型任务：线程数 = CPU 核心数 + 1
    • IO 密集型任务：线程数 = CPU 核心数 × (1 + 平均等待时间 / 平均处理时间)

  2. 工具与监控：

    • jstack：打印线程堆栈信息，用于分析死锁和阻塞问题
    • VisualVM：可视化监控工具，查看线程状态、CPU 使用率等
    • ThreadMXBean：Java 代码中获取线程信息的 API
import java.lang.management.ManagementFactory;
import java.lang.management.ThreadInfo;
import java.lang.management.ThreadMXBean;

public class ThreadMonitor {
    public static void main(String[] args) {
        ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();
        long[] threadIds = threadMXBean.getAllThreadIds();
        ThreadInfo[] threadInfos = threadMXBean.getThreadInfo(threadIds, 10);

        for (ThreadInfo info : threadInfos) {
            System.out.println("线程: " + info.getThreadName() + " 状态: " + info.getThreadState());
        }
    }
}

hqxstudying
关注
java多线程 文件夹_java多线程读同一个文件
weixin_42177768的博客
02-20 1947
java多线程同时读取一个文件，这个方法可行吗？不可行。 多线程能够提高效率是因为现在的cpu普遍是多核cpu, 多条线程可以在多个内核中同时执行来提高计算效率。但是计算机磁盘的磁头只有一个，即使多条线程去读也并不能提高读取效率，反而因为多线程的上下文切换问题会耗时更久。“java”中多线程按行读取txt且每个线程读的内容不能你把原来程序中直接读的地方，改成调用上面的函数，由该函数统一读行。这样，...
java多线程事务处理
m0_49804107的博客
03-28 5936
多线程事务
Java多线程实战-实现多线程文件下载，支持断点续传、日志记录等功能
热门推荐
qq_35716689的博客
03-10 25万+
本文将介绍如何通过Java来实现一个多线程下载器。作者：牵着猫散步的鼠鼠
Java多线程实战-从零手搓一个简易线程池(一)定义任务等待队列
qq_35716689的博客
03-25 25万+
开个新坑-手搓简易线程池。本系列文章将从零开始,一步步手工编码实现一个简单但功能完备的线程池。我们将逐步介绍线程池的各个核心组件,并分析它们的作用和实现思路。通过这个过程,我们可以更好地掌握多线程编程的技巧,并培养编码能力和系统性思维。
java多线程（超详细）
zdl66的博客
08-14 10万+
进程就是正在运行中的程序（进程是驻留在内存中的）是系统执行资源分配和调度的独立单位每一进程都有属于自己的存储空间和系统资源注意：进程A和进程B的内存独立不共享。
Java多线程详解
坏蛋阿土的博客
11-06 6692
线程(thread)是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。进程(Process)是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。在早期面向进程设计的计算机结构中，进程是程序的基本执行实体；在当代面向线程设计的计算机结构中，进程是线程的容器。程序是指令、数据及其组织形式的描述，进程是程序的实体。
Java多线程与并发
lydms的博客
06-21 1万+
假设线程A已经拥有了某个对象（不是类）的锁，而其它线程B、C想要调用这个对象的某个 synchronized方法（或者块），由于B、C线程在进入对象的 synchronized方法（或者块）之前必须先获得该对象锁的拥有权，而恰巧该对象的锁目前正被线程A所占用，此时B、C线程就会被阻塞，进入一个地方去等待锁的释放，这个地方便是该对象的锁池。假设线程A调用了某个对象的wat（）方法，线程A就会释放该对象的锁，同时线程A就进入到了该对象的等待池中，进入到等待池中的线程不会去竞争该对象的锁。
Java多线程案例之线程池
trong_ 的烂笔头
01-30 5938
介绍线程池的原理和简单实现, 进一步提高并发编程的效率.
JAVA多线程处理for循环
子衿的博客
12-28 9155
public static void main(String[] args) { long start = System.currentTimeMillis(); List<Integer> list = new ArrayList(); for (int i = 0; i < 1000; i++) { list.add(i); } //定义线程数量为20，可根据服务器配置适当调整大小
Java多线程（面试篇）
qq_64264364的博客
06-19 2436
java多线程
详解Java多线程处理List数据
08-26
详解Java多线程处理List数据 Java多线程处理List数据是指在Java编程中，使用多线程技术来处理List数据的操作。这种操作可以提高程序的执行效率和性能，特别是在处理大规模数据时。下面将详细介绍Java多线程处理List...
JAVA多线程的使用场景与注意事项总结
08-26
JAVA多线程的使用场景与注意事项总结 Java多线程是Java语言中的一种重要机制，允许程序同时执行多个任务，以提高程序的执行效率和响应速度。在Java中，多线程可以通过继承Thread类、实现Runnable接口或使用线程池来...
java多线程实现大批量数据导入源码
09-29
本项目以"java多线程实现大批量数据导入源码"为题，旨在通过多线程策略将大量数据切分，并进行并行处理，以提高数据处理速度。 首先，我们需要理解Java中的线程机制。Java通过`Thread`类来创建和管理线程。每个线程...
Java多线程Executors批量执行数据实现限流
05-20
Java多线程实现数据切割批量执行，实现限流操作。 java线程池Executors实现数据批量操作。 批量异步Executors处理数据，实现限流操作，QPS限流。 线程池调用第三方接口限流实现逻辑。 案例适合： 1.批量处理大数据。...
实战指南：理解 ThreadLocal 原理并用于Java 多线程上下文管理
张彦峰的博客
12-01 10万+
探讨如何基于实现一个高效的上下文管理组件，以解决多线程环境下的数据共享和上下文管理这些问题。通过具体的代码示例和实战展示如何为多线程编程提供一种简洁而高效的上下文管理方案。
各种开发语言主要语法对比
qq_39980997的博客
07-14 680
主流编程语言语法差异对比：本文对比了Python、JavaScript、Java等11种主流编程语言的核心语法差异，主要包含五个方面： 变量与类型：分为显式类型（C++/Java等）和隐式类型（Python/JS等）两类语言的声明方式 常量声明：展示了各语言定义常量的不同语法和特性 控制结构：详细比较if条件语句和for/while循环的语法差异 函数定义：从函数声明方式和返回值要求两方面进行对比 面向对象：列举了各语言定义类和构造函数的典型语法 这些差异反映了不同语言的设计哲学、应用场景和运行机制。
使用SpringAOP自定义权限控制注解
青衫客36的博客
07-10 499
本文通过自定义注解对 Controller 层的方法实现访问控制，其核心原理是基于 Spring AOP 的面向切面编程机制。系统在运行时由 Spring 生成目标类的动态代理对象，在方法执行前织入权限校验逻辑，从而实现对用户访问权限的统一拦截与验证，确保接口调用符合预设的安全规则。
Java Stream流详解
最新发布
Broken_x的博客
07-14 824
Java Stream流详解：从基础到原理 摘要 Java 8引入的Stream流是集合操作的函数式抽象，通过无存储、惰性计算等特性，构建高效的数据处理流水线。Stream解决了传统集合操作的三大痛点：简化代码（消除迭代样板）、提升可读性（声明式编程）、支持并行计算（Fork/Join框架）。使用流程分为创建Stream、中间操作（如filter/map）和终端操作（如collect/reduce）三步，支持链式调用和延迟执行。Stream API统一了不同数据源的处理方式，其底层通过Spliterator
WebLogic 作用，以及漏洞原理，流量特征与防御
LIU6636LIU的博客
07-10 386
WebLogic作为企业级Java应用服务器，提供应用部署、事务管理、集群负载等核心功能，广泛应用于金融、电信等关键领域。该服务器存在T3/IIOP反序列化、未授权访问等高危漏洞，攻击者可实现远程代码执行、服务器控制（删库/后门）、数据窃取、挖矿及内网渗透等危害。典型攻击流量具有特定协议特征。防御建议包括：禁用高危协议、及时补丁更新、配置WAF、加强流量监控和实施最小权限原则，以保障系统安全。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值