AI 助理
备案控制台
开发者社区 大数据 文章 正文

深入解析Java多线程：源码级别的分析与实践

2024-08-16 160
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 深入解析Java多线程：源码级别的分析与实践

Java的多线程机制是其并发编程的核心，对于高性能和高并发应用的开发至关重要。

一、Java多线程的基础

1.1 创建线程的几种方式

在Java中，有几种创建线程的方式：

  1. 继承Thread类：
class MyThread extends Thread {
    public void run() {
        System.out.println("MyThread is running");
    }
}
 
public class Main {
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start();
    }
}

实现Runnable接口：

class MyRunnable implements Runnable {
    public void run() {
        System.out.println("MyRunnable is running");
    }
}
 
public class Main {
    public static void main(String[] args) {
        Thread thread = new Thread(new MyRunnable());
        thread.start();
    }
}

使用Callable接口和FutureTask：

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
 
class MyCallable implements Callable<String> {
    public String call() throws Exception {
        return "MyCallable is running";
    }
}
 
public class Main {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        FutureTask<String> futureTask = new FutureTask<>(new MyCallable());
        Thread thread = new Thread(futureTask);
        thread.start();
        System.out.println(futureTask.get());
    }
}

1.2 线程的生命周期

线程的生命周期主要包括以下几个阶段：

  • 新建（New）：创建线程对象但未调用start()方法。
  • 就绪（Runnable）：调用start()方法，线程进入就绪队列，等待CPU调度。
  • 运行（Running）：线程被CPU调度执行其run()方法。
  • 阻塞（Blocked）：线程因某种原因进入阻塞状态，如等待I/O操作完成。
  • 死亡（Terminated）：线程执行完run()方法或被异常中断。

二、Java线程安全问题

2.1 线程安全问题的根源

线程安全问题主要源于多个线程同时访问和修改共享资源，而这些访问和修改没有进行适当的同步，导致数据不一致。例如，下面的代码可能会出现线程安全问题：

public class Counter {
    private int count = 0;
 
    public void increment() {
        count++;
    }
 
    public int getCount() {
        return count;
    }
}
 
public class Main {
    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        });
 
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        });
 
        t1.start();
        t2.start();
 
        t1.join();
        t2.join();
 
        System.out.println("Final count: " + counter.getCount());
    }
}

由于count++操作不是原子操作，多个线程可能会同时读取和更新count，导致最终结果不准确。

2.2 解决线程安全问题的方法

2.2.1 同步代码块
public class Counter {
    private int count = 0;
 
    public synchronized void increment() {
        count++;
    }
 
    public synchronized int getCount() {
        return count;
    }
}
2.2.2 使用ReentrantLock
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
 
public class Counter {
    private int count = 0;
    private Lock lock = new ReentrantLock();
 
    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }
 
    public int getCount() {
        lock.lock();
        try {
            return count;
        } finally {
            lock.unlock();
        }
    }
}
2.2.3 使用Atomic变量
import java.util.concurrent.atomic.AtomicInteger;
 
public class Counter {
    private AtomicInteger count = new AtomicInteger();
 
    public void increment() {
        count.getAndIncrement();
    }
 
    public int getCount() {
        return count.get();
    }
}

三、深入解析Java多线程的实现

3.1 synchronized关键字的底层实现

synchronized关键字用于实现同步，它可以应用于方法或代码块。其底层实现依赖于JVM中的对象监视器（Monitor），每个对象都有一个监视器与之关联。

当一个线程进入synchronized方法或代码块时，它必须获得该对象的监视器锁。其他线程如果试图进入同一个代码块，则会被阻塞，直到当前线程释放监视器锁。

3.2 ReentrantLock的实现

ReentrantLock是一个灵活的锁实现，比synchronized提供了更多的功能。它是基于AQS（AbstractQueuedSynchronizer）实现的，AQS通过FIFO队列管理获取锁的线程。

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

在上面的代码中，lock.lock()获取锁，如果其他线程已经持有该锁，当前线程将被阻塞。lock.unlock()释放锁，使其他线程有机会获取锁。

四、深入了解Java线程池

4.1 线程池的核心配置

线程池是Java并发包中一个非常重要的工具。它通过重用线程来避免频繁创建和销毁线程的开销，提升系统性能。Java中的ExecutorService接口提供了对线程池的支持，而ThreadPoolExecutor类则是其具体实现。


ThreadPoolExecutor有以下几个核心配置：

  • corePoolSize：核心线程数，即使这些线程处于空闲状态，也不会被销毁。
  • maximumPoolSize：线程池中允许的最大线程数。
  • keepAliveTime：当线程数超过corePoolSize时，多余空闲线程的存活时间。
  • unit：keepAliveTime的时间单位。
  • workQueue：用于存放等待执行任务的队列。
  • threadFactory：用于创建新线程的工厂。
  • handler：当线程池和队列都满时，处理被拒绝任务的策略。
import java.util.concurrent.*;
 
public class ThreadPoolExample {
    public static void main(String[] args) {
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
                5,          // corePoolSize
                10,         // maximumPoolSize
                60,         // keepAliveTime
                TimeUnit.SECONDS,
                new LinkedBlockingQueue<>(100),  // workQueue
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy()  // handler
        );
 
        for (int i = 0; i < 200; i++) {
            executor.execute(() -> {
                System.out.println("Thread " + Thread.currentThread().getName() + " is running");
            });
        }
 
        executor.shutdown();
    }
}

4.2 线程池的应用场景

  1. CPU密集型任务：
  • 核心线程数应设置为CPU核心数。
  • 例子：图像处理、科学计算等。
  1. I/O密集型任务：
  • 核心线程数应设置为CPU核心数的2倍或更多。
  • 例子：文件读写、网络通信等。
  1. 混合型任务：
  • 需要根据具体任务类型进行调整，通常可以使用多线程任务拆分技术，如Fork/Join框架。

4.3 线程池的种类

Java的Executors类提供了一些工厂方法来创建常用的线程池：

FixedThreadPool：固定大小的线程池，适用于需要限制并发线程数的场景。

ExecutorService fixedThreadPool = Executors.newFixedThreadPool(10);

CachedThreadPool：根据需要创建新线程的线程池，适用于短期异步任务多的场景。

ExecutorService cachedThreadPool = Executors.newCachedThreadPool();

SingleThreadExecutor：单线程执行任务的线程池，适用于需要按顺序执行任务的场景。

ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();

ScheduledThreadPool：支持定时和周期性任务执行的线程池。

ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);

4.4 线程池的拒绝策略

当线程池和工作队列都满时，需要对新任务进行处理，ThreadPoolExecutor提供了四种拒绝策略：

  1. AbortPolicy（默认）：抛出RejectedExecutionException异常。
  2. CallerRunsPolicy：由调用线程处理该任务。
  3. DiscardPolicy：直接丢弃任务，不抛异常。
  4. DiscardOldestPolicy：丢弃最早的未处理任务，然后尝试重新提交任务。
ThreadPoolExecutor executor = new ThreadPoolExecutor(
        5,
        10,
        60,
        TimeUnit.SECONDS,
        new LinkedBlockingQueue<>(100),
        Executors.defaultThreadFactory(),
        new ThreadPoolExecutor.CallerRunsPolicy()
);

五、实战：如何在实际场景中更好地使用多线程

5.1 使用线程池提高性能

线程池通过重用线程来提高性能，避免了频繁创建和销毁线程的开销。Java提供了多种线程池实现，例如Executors类中的newFixedThreadPool、newCachedThreadPool等。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
 
public class ThreadPoolExample {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(10);
 
        for (int i = 0; i < 100; i++) {
            executor.submit(() -> {
                System.out.println("Thread " + Thread.currentThread().getName() + " is running");
            });
        }
 
        executor.shutdown();
    }
}


5.2 Fork/Join框架

Fork/Join框架用于处理可以递归拆分的任务，例如大规模数据处理。它基于工作窃取算法，能够充分利用多核处理器的优势。

import java.util.concurrent.RecursiveTask;
import java.util.concurrent.ForkJoinPool;
 
public class ForkJoinExample extends RecursiveTask<Long> {
    private final long threshold = 10_000;
    private final long start;
    private final long end;
 
    public ForkJoinExample(long start, long end) {
        this.start = start;
        this.end = end;
    }
 
    @Override
    protected Long compute() {
        if (end - start <= threshold) {
            long sum = 0;
            for (long i = start; i <= end; i++) {
                sum += i;
            }
            return sum;
        } else {
            long mid = (start + end) / 2;
            ForkJoinExample leftTask = new ForkJoinExample(start, mid);
            ForkJoinExample rightTask = new ForkJoinExample(mid + 1, end);
            leftTask.fork();
            rightTask.fork();
            return leftTask.join() + rightTask.join();
        }
    }
 
    public static void main(String[] args) {
        ForkJoinPool pool = new ForkJoinPool();
        ForkJoinExample task = new ForkJoinExample(1, 1_000_000);
        long result = pool.invoke(task);
        System.out.println("Sum: " + result);
    }
}

结语

Java多线程编程不仅涉及基本的线程创建与管理，更需要深入理解底层实现和线程安全机制。在实际开发中，合理使用多线程技术可以显著提升应用性能，但不当的使用也可能导致复杂的并发问题。通过对线程池、synchronized、ReentrantLock以及Fork/Join框架的掌握和实践，能够有效地解决这些问题，构建高效可靠的并发程序。

文章标签：
云解析DNS
Java
调度
数据处理
安全
算法
关键词：
Java分析
Java线程
Java实践
解析Java
Java多线程
william.zhang(张)
目录
相关文章
凉凉心.
|
1月前
|
JSON 网络协议 安全
【Java】（10）进程与线程的关系、Tread类；讲解基本线程安全、网络编程内容；JSON序列化与反序列化
几乎所有的操作系统都支持进程的概念，进程是处于运行过程中的程序，并且具有一定的独立功能，进程是系统进行资源分配和调度的一个独立单位一般而言，进程包含如下三个特征。独立性动态性并发性。
凉凉心.
150 2
凉凉心.
|
1月前
|
JSON 网络协议 安全
【Java基础】（1）进程与线程的关系、Tread类；讲解基本线程安全、网络编程内容；JSON序列化与反序列化
几乎所有的操作系统都支持进程的概念，进程是处于运行过程中的程序，并且具有一定的独立功能，进程是系统进行资源分配和调度的一个独立单位一般而言，进程包含如下三个特征。独立性动态性并发性。
凉凉心.
166 1
小白学大数据
|
2月前
|
数据采集 存储 弹性计算
高并发Java爬虫的瓶颈分析与动态线程优化方案
高并发Java爬虫的瓶颈分析与动态线程优化方案
小白学大数据
214 1
游客4v3gpgavlizks
|
2月前
|
存储 小程序 Java
热门小程序源码合集：微信抖音小程序源码支持PHP/Java/uni-app完整项目实践指南
小程序已成为企业获客与开发者创业的重要载体。本文详解PHP、Java、uni-app三大技术栈在电商、工具、服务类小程序中的源码应用，提供从开发到部署的全流程指南，并分享选型避坑与商业化落地策略，助力开发者高效构建稳定可扩展项目。
游客4v3gpgavlizks
686 0
Java 数据库 Spring
138 0
站大爷
|
1月前
|
Java 调度 数据库
Python threading模块：多线程编程的实战指南
本文深入讲解Python多线程编程，涵盖threading模块的核心用法：线程创建、生命周期、同步机制（锁、信号量、条件变量）、线程通信（队列）、守护线程与线程池应用。结合实战案例，如多线程下载器，帮助开发者提升程序并发性能，适用于I/O密集型任务处理。
站大爷
242 0
啦啦啦191
|
1月前
|
Java
如何在Java中进行多线程编程
Java多线程编程常用方式包括：继承Thread类、实现Runnable接口、Callable接口（可返回结果）及使用线程池。推荐线程池以提升性能，避免频繁创建线程。结合同步与通信机制，可有效管理并发任务。
啦啦啦191
148 6
蓝易云
|
2月前
|
算法 Java
Java多线程编程：实现线程间数据共享机制
以上就是Java中几种主要处理多线程序列化资源以及协调各自独立运行但需相互配合以完成任务threads 的技术手段与策略。正确应用上述技术将大大增强你程序稳定性与效率同时也降低bug出现率因此深刻理解每项技术背后理论至关重要.
蓝易云
225 16
欲揽西江月
|
4月前
|
Java API 微服务
为什么虚拟线程将改变Java并发编程？
为什么虚拟线程将改变Java并发编程？
欲揽西江月
306 83
摘星.
|
6月前
|
机器学习/深度学习 消息中间件 存储
【高薪程序员必看】万字长文拆解Java并发编程！(9-2)：并发工具-线程池
🌟 ​大家好，我是摘星！​ 🌟今天为大家带来的是并发编程中的强力并发工具-线程池，废话不多说让我们直接开始。
摘星.
254 0

热门文章

最新文章

  • 1
    Kali虚拟机间搭建iodine DNS隧道实验指南
  • 2
    百宝箱开放平台 ✖️ Java SDK
  • 3
    【Azure Storage Account】Java Code访问Storage Account File Share的上传和下载代码示例
  • 4
    Java 设计模式之策略模式：灵活切换算法的艺术
  • 5
    Java 设计模式之状态模式：让对象的行为随状态优雅变化
  • 6
    java零基础学习者入门课程
  • 7
    Java 设计模式之观察者模式：构建松耦合的事件响应系统
  • 8
    Java 设计模式之责任链模式：优雅处理请求的艺术
  • 9
    Python threading模块：多线程编程的实战指南
  • 10
    【JUC】（1）带你重新认识进程与线程！！让你深层次了解线程运行的睡眠与打断！！
  • 1
    深入理解Java并发编程：线程安全与性能优化移动应用开发的未来：跨平台框架与原生操作系统的融合
    180
  • 2
    从C语言到C++_40(多线程相关)C++线程接口+线程安全问题加锁(shared_ptr+STL+单例)（下）
    173
  • 3
    从C语言到C++_40(多线程相关)C++线程接口+线程安全问题加锁(shared_ptr+STL+单例)（中）
    166
  • 4
    从C语言到C++_40(多线程相关)C++线程接口+线程安全问题加锁(shared_ptr+STL+单例)（上）
    199
  • 5
    Java多线程基础-6：线程安全问题及解决措施，synchronized关键字与volatile关键字（一）
    252
  • 6
    Java多线程基础-18：线程安全的集合类与ConcurrentHashMap
    570
  • 7
    Java 多线程系列Ⅶ（线程安全集合类）
    157
  • 8
    Java 多线程系列Ⅳ（单例模式+阻塞式队列+定时器+线程池）
    213
  • 9
    Java 多线程系列Ⅰ（创建线程+查看线程+Thread方法+线程状态）
    141
  • 10
    进程与线程（概念、并行、并发）
    226

    • 相关课程

    更多
  • Java开发工具
  • Java 虚拟机原理
  • Java Web项目实战 - 图书商城
  • Java面试疑难点解析 - 面试技巧及语言基础
  • Java面试疑难点解析 - Java Web开发
  • Java面试疑难点解析 - 系统架构及项目设计

    • 相关电子书

    更多
  • 阿里云HBase产品体系架构及特性解析
  • ECS块存储产品全面解析
  • 云解析DNS在安全容灾场景下的应用分享

    • 推荐镜像

    更多
  • DNS
    • 下一篇
    阿里云负载均衡收费标准：ALB、NLB和CLB价格，包括LCU费用、实例费和公网带宽价格