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

最新推荐文章于 2024-06-21 17:14:47 发布
最新推荐文章于 2024-06-21 17:14:47 发布
阅读量880 收藏 7
点赞数 21
分类专栏： 后端 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zcs_978176963/article/details/139414906
版权

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();
    }
}

  2. 实现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();
    }
}

  3. 使用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核心数。
    • 例子：图像处理、科学计算等。

  2. I/O密集型任务：

    • 核心线程数应设置为CPU核心数的2倍或更多。
    • 例子：文件读写、网络通信等。

  3. 混合型任务：

    • 需要根据具体任务类型进行调整，通常可以使用多线程任务拆分技术，如Fork/Join框架。

4.3 线程池的种类

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

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

    ExecutorService fixedThreadPool = Executors.newFixedThreadPool(10);

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

    ExecutorService cachedThreadPool = Executors.newCachedThreadPool();

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

    ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();

  4. 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框架的掌握和实践，能够有效地解决这些问题，构建高效可靠的并发程序。

william.zhang(张)
关注
  • 21
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
深入Java多线程之synchronized方法锁：源码解析与实战应用
m0_51176516的博客
06-07 988
本文对Java多线程中的synchronized修饰方法进行了深入解析，包括其原理、源码以及实战应用。通过了解synchronized方法的底层实现机制和工作原理，可以更好地理解其在使用过程中的限制和性能影响，从而更加合理地使用它来确保多线程程序的正确性和性能。
Java多线程start（）方法原理解析
08-25
Java多线程start（）方法原理解析 Java多线程start（）方法是Java多线程编程中的核心方法之一，它负责启动线程并执行相应的任务。然而，很多开发者对start（）方法的原理和实现机制不甚了解，本文将深入探究Java多...
多线程学习（三）---Thread源码解读
一个胖子IT男的博客
06-15 500
参考文章： Thread源码剖析 jdk版本：1.8.0_201 1. 线程名 我们在使用多线程的时候，想要查看线程名是很简单的，调用Thread.currentThread().getName()即可。 如果没有做什么的设置，我们会发现线程的名字是这样子的：主线程叫做main，其他线程是Thread-x. 下面来看它的实现方法： /** * Allocates a new {@co...
多线程Thread源码分析
weixin_62436573的博客
10-20 274
对多线程的源码分析
多线程与高并发学习：ThreadPoolExecutor源码解析
猪大肠的博客
05-18 388
线程池在工作中的应用非常广泛，学习其源码可以更好掌握并发相关的思想。
java多线程总结：原理结合源码详细讲解 - 简单实用
清风明月独相伴
08-09 1万+
执行策略：线程执行的方式 串行执行 比如：医院给病人看病的时候，可以让所有的病人都拍成一个队形，让一个医生统一的看病。医生：线程。病人看病：任务 这种一个医生给一群站好队形的病人看病--映射到java就相当于：单线程串行执行任务 映射到我们java中的话就相当于线程执行任务。 串行执行的缺点很明显。 例如：就是假设前面有一个病人非常的慢，是一个话唠，本来就是一个小感冒，就和医生唠了一天...
多线程进阶与源码分析--线程池相关（一）
timothy316的博客
10-14 898
现代多核处理器的发展以及业务规模的扩大，使多线程得到越来越广泛的应用，本篇文章主要以实战以及源码的角度进行分析，提升大家的多线程认知，有不对的地方还请海涵，指正。 源码分析： 多线程初级阶段我们知道简单的写一个多线程需要实现Runable或Callable接口，简单点的new一个Thread去跑，更多的是使用线程池，避免频繁创建销毁线程，通常都是用Executors提供的几个静态方法，大概分为
Java多线程实战-实现多线程文件下载，支持断点续传、日志记录等功能
热门推荐
qq_35716689的博客
03-10 10万+
本文将介绍如何通过Java来实现一个多线程下载器。作者：牵着猫散步的鼠鼠
Android多线程：手把手带你源码解析HandlerThread
Carson带你学Android
02-08 9123
前言 多线程的应用在Android开发中是非常常见的，常用方法主要有： 继承Thread类 实现Runnable接口 Handler AsyncTask HandlerThread IntentService 今天，我将全面解析多线程中 HandlerThread的源码 由于本文涉及多线程知识和Handler源码解析，所以阅读本文前建议先看： Android开发：Handle...
Java虚拟机：深入详细分析Java ClassLoader原理与源码
张维鹏的博客
04-13 3016
一、什么是ClassLoader? ClassLoader就是类加载器，当我们写好一个Java程序之后，都是由若干个.class文件组成的一个完整的Java应用程序，当程序在运行时，即会调用该程序的一个入口函数来调用系统的相关功能，而这些功能都被封装在不同的class文件当中，所以经常要从这个class文件中要调用另外一个class文件中的方法，如果另外一个文件不存在的，...
深入理解Java之HashMap源码剖析
08-31
深入理解Java中的HashMap源码，有助于我们更好地掌握这个常用数据结构的工作原理。HashMap是Java集合框架的重要组成部分，它实现了Map接口，提供了一种快速查找、插入和删除元素的方式。本文将详细解析HashMap的内部...
Java源码解析TreeMap简介
08-26
Java源码解析TreeMap简介 TreeMap是Java中的一种常用的排序树，实现了NavigableMap接口。下面是对TreeMap的详细介绍： 1. TreeMap的实现机制 TreeMap是基于Red-Black树的数据结构，红黑树是一种自平衡的二叉查找...
Java源码解析CopyOnWriteArrayList的讲解
08-26
在本文中，我们将深入探讨CopyOnWriteArrayList的实现机制、成员变量、主要方法，并分析其在多线程环境下的应用场景。 成员变量 CopyOnWriteArrayList中只有两个成员变量，一个是基本数据结构array，用于保存数据...
Java源码解析ConcurrentHashMap的初始化
08-26
Java源码解析ConcurrentHashMap的初始化 在Java并发编程中，ConcurrentHashMap是一个非常重要的数据结构，它可以在多线程环境下提供高效的哈希表操作。今天，我们将深入探讨ConcurrentHashMap的初始化过程，并分析...
数据结构与算法-差分数组及应用
qq_36115196的博客
06-20 724
差分数组： 其实差分数组是创建一个一个辅助数组，用来表示给定数组的变化，一般用来对数组进行区间修改的操作。
Day43
m0_67496588的博客
06-20 990
JSON，Ajax
Homebrew使用
最新发布
gghh2015的博客
06-21 204
具体参考：https://blog.csdn.net/m0_67402970/article/details/126434901。简介：https://www.jianshu.com/p/f4c9cf0733ea。2、查看安装路径：brew list maven。官网：https://brew.sh/
Java面试八股之简述JVM内存结构
u012151345的博客
06-20 808
在Java 8之前，永久代（Permanent Generation）是方法区的实现，之后被元空间（Metaspace）取代。总结来说，JVM内存结构设计精巧，通过区分线程私有和共享区域，以及细致划分各个区域的功能，确保了Java程序的高效、安全运行。每个线程都有自己的栈，用于存储方法调用时的信息，包括局部变量表、操作数栈、动态链接、方法出口等。方法区的一部分，存放编译期生成的各种字面量和符号引用，如字符串字面量、类名、方法名等。JVM中最大的一块内存区域，用于存储几乎所有的对象实例和数组。
Geoserver源码解读三 GeoServerBasePage
Yuanben_wuxin的博客
06-19 979
GeoServerBasePage 登录
讲解一下java多线程的源码
06-01
Java多线程的源码非常庞大，涉及到很多的类和接口，这里简要介绍一下Java多线程的核心类和接口。 1. Thread类 Thread类是Java多线程的核心类，它表示一个线程。Thread类的源码非常庞大，主要包含以下几个方法： - start()：启动线程 - run()：线程执行的代码 - sleep()：使线程睡眠一段时间 - yield()：暂停当前线程，让出CPU执行权 - join()：等待线程执行完毕 - interrupt()：中断线程 - isAlive()：判断线程是否还活着 2. Runnable接口 Runnable接口表示一个线程执行的代码块，它只有一个run()方法。在Java中，一个线程可以通过实现Runnable接口来指定执行的代码。例如： ```java public class MyRunnable implements Runnable { public void run() { // 线程执行的代码 } } ``` 3. Callable接口 Callable接口也表示一个线程执行的代码块，它比Runnable接口更强大，可以返回一个值。在Java中，一个线程可以通过实现Callable接口来指定执行的代码，并返回一个值。例如： ```java public class MyCallable implements Callable<Integer> { public Integer call() throws Exception { // 线程执行的代码 return 0; } } ``` 4. Executor接口 Executor接口表示一个异步执行的任务，它把任务和执行器分离开来，使得任务可以独立于执行器进行测试和开发。Executor接口提供了一些方法来执行任务，例如： - execute(Runnable command)：执行一个Runnable任务 - submit(Callable task)：执行一个Callable任务，并返回一个Future对象 5. ExecutorService接口 ExecutorService接口继承自Executor接口，它提供了一些扩展的方法来管理和控制执行器。例如： - shutdown()：关闭执行器 - submit(Runnable task)：执行一个Runnable任务，并返回一个Future对象 - submit(Callable task)：执行一个Callable任务，并返回一个Future对象 6. Future接口 Future接口表示一个异步执行的任务的结果。它提供了一些方法来查询任务是否已经完成、获取任务的结果等。例如： - isDone()：判断任务是否已经完成 - get()：获取任务的结果 以上是Java多线程的一些核心类和接口，它们构成了Java多线程的基础框架。除此之外，Java还提供了许多其他的类和接口，例如Lock、Condition、Semaphore等，用于实现更加高级的多线程功能。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

william.zhang(张)

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值