JAVA-多线程

原创 已于 2025-07-29 23:36:31 修改 · 322 阅读 · 9 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #开发语言

于 2025-07-01 00:08:45 首次发布

Java 多线程是 Java 编程中实现并发的重要特性，允许程序同时执行多个任务。Java 多线程通过 java.lang.Thread 类和 java.util.concurrent 包实现。线程是程序执行的最小单位，多线程允许程序同时执行多个任务。

1.多线程基础概念

多线程指一个进程中存在多个并发执行的线程，共享进程资源（内存、文件等），每个线程拥有独立的栈空间。优势包括：

1.1 线程与进程的区别

进程(Process)：

  • 操作系统资源分配的基本单位

  • 拥有独立的地址空间

  • 进程间通信(IPC)成本高（管道、消息队列、共享内存等）

  • 创建和销毁开销大

线程(Thread)：

  • CPU调度的基本单位

  • 共享进程的地址空间和资源

  • 线程间通信成本低（共享内存）

  • 创建和销毁开销小

类比解释：

  • 进程就像一家公司，拥有独立的办公空间和资源

  • 线程就像公司里的员工，共享办公空间但各自独立工作

1.2 为什么需要多线程？

  1. 提高CPU利用率：

    • 单线程在IO操作时CPU处于等待状态

    • 多线程可以在一个线程等待时运行其他线程

  2. 提升吞吐量：

    • Web服务器可以同时处理多个请求

    • 数据库系统可以并行执行查询

  3. 改善响应时间：

    • GUI程序主线程保持响应

    • 后台线程处理耗时任务

  4. 利用多核CPU：

    • 现代CPU都是多核架构

    • 单线程无法充分利用硬件资源

1.3 多线程的挑战

  1. 线程安全问题：

    • 竞态条件(Race Condition)

    • 数据竞争(Data Race)

  2. 死锁问题：

    • 多个线程互相等待对方释放锁

  3. 性能问题：

    • 上下文切换开销

    • 锁竞争导致的性能下降

  4. 调试困难：

    • 问题难以复现

    • 执行顺序不确定

2. Java多线程实现

2.1 继承 Thread 类

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

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

2.2 实现 Runnable 接口

class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("线程执行: " + Thread.currentThread().getName());
    }
}

public class Main {
    public static void main(String[] args) {
        Thread thread = new Thread(new MyRunnable());
        thread.start();
    }
}

优势：避免单继承限制，更适合资源共享。

2.3 实现 Callable 接口（带返回值）

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        return "线程执行结果: " + Thread.currentThread().getName();
    }
}

public class Main {
    public static void main(String[] args) throws Exception {
        FutureTask<String> task = new FutureTask<>(new MyCallable());
        Thread thread = new Thread(task);
        thread.start();
        System.out.println(task.get()); // 获取返回值
    }
}

2.4 使用线程池（推荐方式）：

ExecutorService executor = Executors.newFixedThreadPool(4);
executor.execute(() -> {
    System.out.println("Task running in thread pool");
});
executor.shutdown();

3.线程的生命周期

Java线程有以下6种状态（Thread.State枚举）：

  1. NEW：已创建但未启动

  2. RUNNABLE：正在运行或可运行

  3. BLOCKED：等待获取监视器锁（synchronized）

  4. WAITING：无限期等待（wait()、join()）

  5. TIMED_WAITING：有限期等待（sleep()、wait(timeout)）

  6. TERMINATED：线程已终止

状态转换：

NEW → start() → RUNNABLE
RUNNABLE → 获取锁 → BLOCKED
RUNNABLE → wait()/join() → WAITING
RUNNABLE → sleep(timeout)/wait(timeout) → TIMED_WAITING
WAITING/TIMED_WAITING → notify()/interrupt()/超时 → RUNNABLE
BLOCKED → 获取锁 → RUNNABLE
RUNNABLE → 运行结束 → TERMINATED

4.线程同步机制

synchronized 关键字

对象锁：

class Counter {
    private int count = 0;
    
    public synchronized void increment() {
        count++;
    }
    
    public synchronized int getCount() {
        return count;
    }
}

类锁：

class StaticCounter {
    private static int count = 0;
    
    public static synchronized void increment() {
        count++;
    }
}

 同步代码块：

public void doSomething() {
    // 非同步代码
    synchronized(this) {
        // 同步代码块
    }
}

同步方法: 

public synchronized void synchronizedMethod() {
    // 临界区代码
}

volatile关键字

作用：

  • 保证变量的可见性

  • 禁止指令重排序

  • 不保证原子性

适用场景：

class VolatileExample {
    private volatile boolean flag = false;
    
    public void start() {
        new Thread(() -> {
            while (!flag) {
                // 循环直到flag变为true
            }
            System.out.println("Flag is now true");
        }).start();
    }
    
    public void stop() {
        flag = true;
    }
}

 Lock接口

基本用法：

class LockExample {
    private final Lock lock = new ReentrantLock();
    private int count = 0;
    
    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }
}

高级特性：

// 尝试获取锁
if (lock.tryLock(1, TimeUnit.SECONDS)) {
    try {
        // 获取锁成功
    } finally {
        lock.unlock();
    }
} else {
    // 获取锁超时
}

// 可中断锁
lock.lockInterruptibly();

 

原子类

java.util.concurrent.atomic包提供原子操作类：

AtomicInteger counter = new AtomicInteger(0);

// 原子递增
counter.incrementAndGet();

// CAS操作
boolean updated = counter.compareAndSet(expect, update);

 同步工具类

  1. CountDownLatch：

    CountDownLatch latch = new CountDownLatch(3);

// 工作线程
new Thread(() -> {
    // 工作
    latch.countDown();
}).start();

// 主线程等待
latch.await();

  2. CyclicBarrier：

    CyclicBarrier barrier = new CyclicBarrier(3, () -> {
    System.out.println("All threads reached barrier");
});

new Thread(() -> {
    // 工作
    barrier.await();
}).start();

  3. Semaphore：

    Semaphore semaphore = new Semaphore(3); // 允许3个线程同时访问

semaphore.acquire();
try {
    // 访问资源
} finally {
    semaphore.release();
}

5.线程间通信

1. 共享变量 + synchronized（同步锁） 
class SharedResource {
    private int value;
    private boolean available = false;

    public synchronized void produce(int val) {
        while (available) {
            try {
                wait(); // 释放锁，等待消费
            } catch (InterruptedException e) { /*...*/ }
        }
        value = val;
        available = true;
        notifyAll(); // 唤醒消费线程
    }

    public synchronized int consume() {
        while (!available) {
            try {
                wait(); // 等待生产
            } catch (InterruptedException e) { /*...*/ }
        }
        available = false;
        notifyAll(); // 唤醒生产线程
        return value;
    }
}

2. Lock + Condition（更灵活）
class SharedResource {
    private final Lock lock = new ReentrantLock();
    private final Condition notFull = lock.newCondition();
    private final Condition notEmpty = lock.newCondition();
    private int value;
    private boolean available = false;

    public void produce(int val) {
        lock.lock();
        try {
            while (available) {
                notFull.await(); // 等待非满条件
            }
            value = val;
            available = true;
            notEmpty.signal(); // 通知非空条件
        } finally {
            lock.unlock();
        }
    }

    public int consume() {
        lock.lock();
        try {
            while (!available) {
                notEmpty.await(); // 等待非空条件
            }
            available = false;
            notFull.signal(); // 通知非满条件
            return value;
        } finally {
            lock.unlock();
        }
    }
}
3. 阻塞队列 BlockingQueue（推荐）
BlockingQueue<Integer> queue = new ArrayBlockingQueue<>(10);

// 生产者
Runnable producer = () -> {
    try {
        queue.put(1); // 队列满时自动阻塞
    } catch (InterruptedException e) { /*...*/ }
};

// 消费者
Runnable consumer = () -> {
    try {
        int value = queue.take(); // 队列空时自动阻塞
    } catch (InterruptedException e) { /*...*/ }
};

new Thread(producer).start();
new Thread(consumer).start();
4. wait() / notify() 机制

  • wait()：释放锁并进入等待状态

  • notify()：随机唤醒一个等待线程

  • notifyAll()：唤醒所有等待线程

必须配合 synchronized 使用，否则抛出 IllegalMonitorStateException。

6.关键概念

方法/类作用说明
synchronized保证代码块/方法的原子性访问
volatile确保变量可见性（不保证原子性）
Thread.join()等待线程终止
Thread.yield()让出CPU时间（不释放锁）
Thread.sleep()休眠指定时间（不释放锁）

 7.总结

  1. 优先用 Runnable/Callable：避免继承局限性

  2. 使用线程池：管理线程生命周期（Executors 工具类）

  3. 避免死锁：按固定顺序获取锁，设置超时（tryLock()）

  4. 同步最小化：缩小 synchronized 范围提升性能

通过合理使用多线程，可显著提升程序性能，但务必谨慎处理线程安全与协调问题！

Java-多线程线程状态转换图
07-22
多线程线程状态转换图
java-多线程 test
06-11
java-多线程 test
java 多线程
c.......p
03-28 389
文章目录多线程1 多线程demo2 Thread的方法2.1 获取线程的名字2.2 设置线程的名字2.3 sleep()2.4 Runnable接口实现多线程2.5 匿名内部类方法实现线程创建3 多线程4 线程与进程5 线程调度 多线程 1 多线程demo code public class MyThredDo { public static class MyThred extends T...
Java多线程（超详解）
热门推荐
m0_52896041的博客
10-26 1万+
Java多线程（超详解）
编程必备：JAVA多线程详解
拾一二的博客
06-14 9270
多线程已经成为一种常见的编程模式，广泛应用于各种不同类型的应用程序中。本篇博客文章中，我们将会探讨多线程编程的相关知识和技巧。通过代码示例和实际应用案例来深入了解多线程的具体实现和应用方法，帮助更好地掌握多线程编程技术，提高程序效率和性能。后期随学习深入还会补充修改。以上就是我对多线程的个人简介，后续会不断完善更新，与大家共勉。
java：多线程
zz_study
05-17 302
线程与进程线程是一个轻量级的子进程，线程类属于java.lang.包。是利用机器多个cpu的一种方式。例如 一个任务用一个线程需要100毫秒完成，那么可以使用10个线程让时间减少到10毫秒。一个进程可以有多个线程。线程可以执行进程的任何部分。进程的同个部分可以由多个线程执行。进程有自己的地址，由进程创建的线程可以共享进程的地址空间。线程在进程中有自己的堆栈，所有线程共享一个常见的系统资源，如堆内存...
Java-多线程连接池模型
07-22
多线程连接池模型
14.java-多线程.md
08-18
14.java-多线程
java - juc - 多线程 - 学习 -思维导图
12-16
java - juc - 多线程 - 学习 -思维导图
JAVA多线程
Csdn_NeverGU的博客
08-02 166
多线程 前言：学完多线程，感觉有点难
java多线程
m0_46702681的博客
06-19 2630
javajava。
Java--多线程
qq_40722284的博客
03-24 701
线程基础线程，程序运行的基本单元。操作系统中运行的任何程序都至少有一个主线程作为这个程序运行的入口点。进程与线程操作系统中可以有多个进程，包括系统进程和用户进程，一个进程可以有一个或多个线程。进程之间不共享内存，在各自独立的内存空间中运行。一个进程中的线程可以共享系统分派给这个进程的内存空间。线程不仅可以共享进程内存，还拥有一个属于自己的内存空间--线程栈，在建立线程时由系统分配，主要用来保存线程...
Java多线程
最新发布
m0_61925586的博客
01-02 1800
概述生产者消费者模式是一个十分经典的多线程协作的模式，弄懂生产者-消费者问题能够让我们对多线程编程的理解更加深刻。所谓生产者消费者问题，实际上主要是包含了两类线程：一类是生产者线程：用于生产数据一类是消费者线程：用于消费数据为了解耦生产者和消费者的关系，通常会采用共享的数据区域，就像是一个仓库生产者生产数据之后直接放置在共享数据区中，并不需要关心消费者的行为消费者只需要从共享数据区中去获取数据，并不需要关心生产者的行为。
Java多线程进度条实现技巧
### 知识点：Java多线程进度条的实现与应用 在现代软件开发中，多线程技术是提升应用程序性能和响应能力的关键技术之一。而进度条作为一种界面元素，可以向用户直观展示长时间运行任务的完成情况，提高用户体验。当...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值