皮皮网

1.多线程并发文件（附源码）
2.七天杀上GitHub榜首！多线a多Java并发编程深度解析实战，程源JUC底层原理揭秘
3.Java多线程中join、线程yield、源码sleep方法详解
4.Java中Runnable和Thread的区别
5.Java线程池实现原理及其在美团业务中的实现实践
6.7个连环问题揭开java多线程背后的核心原理！

多线程并发文件（附源码）

       RandomAccessFile是多线a多猪猪帝国源码一个Java类，支持随机访问文件的程源读写操作，其文件指针允许访问文件的线程任意位置，无需从头至尾顺序读写，源码极大地便利了文件操作。实现特别适用于网络请求中的多线a多多线程文件下载和断点续传。RandomAccessFile包含记录指针，程源用于标识当前读写位置，线程当创建对象时，源码指针位于文件头，实现通过读/写操作后，指针会后移相应字节数。此外，RandomAccessFile还提供了两个特殊方法移动记录指针，实现随机访问功能。

       RandomAccessFile的使用场景广泛，比如多线程下载文件。以下载多兆的文件为例，仅需ms，效率极高。实现基本多线程读写功能的代码提供了一个简单的示例，但仍有许多优化空间，如使用NIO进行读写，对文件读写加锁等。有兴趣的开发者可参考代码并进行改进。

       总结，RandomAccessFile因其支持随机访问和高效操作文件的能力，是实现多线程下载和断点续传的理想工具。通过优化代码，如引入NIO技术或对文件操作进行加锁处理，可以进一步提升性能和稳定性。欢迎关注公众号：南山的架构笔记，获取更多技术分享和互联网架构经验。

七天杀上GitHub榜首！Java并发编程深度解析实战，JUC底层原理揭秘

       在多核CPU和多线程技术普及的当今，我们面对的java项目的源码不再是多年前对于线程开启时机的问题。如今，无论是开发人员还是技术开发者，都需要深入了解多线程技术的方方面面。本文将从操作系统原理的角度，全面解析多线程技术，涵盖基础知识到高级进阶，分享作者多年的工作经验和踩坑后的教训。

       多线程编程技术已经成为现代软件开发不可或缺的部分。然而，对于很多开发者来说，尽管有各种库和运行环境对操作系统多线程接口的封装，他们仍然面对着复杂的多线程逻辑，甚至只是简单调用库的“业务”程序员。本文旨在从基础出发，深入浅出地讲解多线程技术的各个层面。

       本文分为章，从Java线程的实践及原理揭秘开始，逐步深入到synchronized实现原理、volatile解决可见性和有序性问题、J.U.C中的重入锁和读写锁、线程通信中的条件等待机制、J.U.C并发工具集实战、并发编程必备工具、阻塞队列设计原理及实现、并发安全集合原理及源码、线程池设计原理、以及Java并发编程中的异步编程特性。每一章节都基于作者的经验总结和踩坑后的教训，为读者提供全面而深入的指导。

       如果您对这份手册感兴趣并希望深入学习，欢迎您点赞并关注。获取完整内容的方式非常简单，只需点击下方链接即可。让我们一起探索多线程技术的奥秘，提升编程技能，迈向技术的高峰。

Java多线程中join、yield、sleep方法详解

       在Java多线程编程中，Thread类扮演关键角色。掌握Thread中join、网页制作1.4源码yield、sleep方法，是多线程代码开发的基础。以下总结这3个方法的含义及应用。

       sleep方法，静态本地方法，调用底层C库实现睡眠。接收毫秒参数，让当前线程睡眠指定时间。睡眠期间，线程不会释放锁。会抛出InterruptedException异常。示例代码显示，多个运行结果可能不同，但始终一个线程运行完全后另一个开始。

       yield方法，向调度器表示愿意让出CPU执行权，但调度器可能忽略此请求。适用于在多个线程间提升相对进度，需结合性能分析和基准测试。使用较少，对调试、测试或并发控制结构设计可能有用。

       join方法有3个重载版本。主要关注第二个方法，用于等待目标线程指定时间后消亡。无参数join方法等效于等待目标线程完全结束。源码中通过while循环和isAlive()方法判断，确保线程等待目标线程执行完毕。

       以刷抖音为例，假设刷抖音线程运行秒，而睡觉线程运行时间仅为毫秒。通过join方法，睡觉线程需等待刷完抖音后，才能开始执行，展示join方法使等待线程挂起直至目标线程结束的特性。

       至此，join、yield、sleep方法的使用理解加深，它们在多线程编程中分别用于线程睡眠、飞车刷级源码让出CPU执行权和等待其他线程结束，是实现并发控制和优化的关键。

Java中Runnable和Thread的区别

       nable和thread的区别（多线程必须用Runable）

       Java中有两种实现多线程的方式以及两种方式之间的区别

       çœ‹åˆ°ä¸€ä¸ªé¢è¯•é¢˜.问两种实现多线程的方法.没事去网上找了找答案.

       ç½‘上流传很广的是一个网上售票系统讲解.转发过来.已经不知道原文到底是出自哪里了.

       Java中有两种实现多线程的方式。一是直接继承Thread类，二是实现Runnable接口。那么这两种实现多线程的方式在应用上有什么区别呢？

       ä¸ºäº†å›žç­”这个问题，我们可以通过编写一段代码来进行分析。我们用代码来模拟铁路售票系统，实现通过四个售票点发售某日某次列车的张车票，一个售票点用一个线程表示。

       é¦–先这样编写这个程序：

       Java代码

       class ThreadTest extends Thread{

        private int ticket = ;

        public void run(){

        while(true){

        if(ticket > 0){

        System.out.println(Thread.currentThread().getName() +

        "is saling ticket" + ticket--);

        }else{

        break;

        }

        }

        }

       }

       æºç æ‰“印？

       class ThreadTest extends Thread{

        private int ticket = ;

        public void run(){

        while(true){

        if(ticket > 0){

        System.out.println(Thread.currentThread().getName() +

        "is saling ticket" + ticket--);

        }else{

        break;

        }

        }

        }

       }

       main测试类:

       Java代码

       public class ThreadDome1{

        public static void main(String[] args){

        ThreadTest t = new ThreadTest();

        t.start();

        t.start();

        t.start();

        t.start();

        }

       }

       æºç æ‰“印？

       public class ThreadDome1{

        public static void main(String[] args){

        ThreadTest t = new ThreadTest();

        t.start();

        t.start();

        t.start();

        t.start();

        }

       }

       ä¸Šé¢çš„代码中，我们用ThreadTest类模拟售票处的售票过程，run方法中的每一次循环都将总票数减1，模拟卖出一张车票，同时该车票号打印出来，直接剩余的票数到零为止。在ThreadDemo1类的main方法中，我们创建了一个线程对象，并重复启动四次，希望通过这种方式产生四个线程。从运行的结果来看我们发现其实只有一个线程在运行，这个结果 告诉我们：一个线程对象只能启动一个线程，无论你调用多少遍start()方法，结果只有一个线程。

        我们接着修改ThreadDemo1，在main方法中创建四个Thread对象：

       Java代码

       public class ThreadDemo1{

        public static void main(String[] args){

        new ThreadTest().start();

        new ThreadTest().start();

        new ThreadTest().start();

        new ThreadTest().start();

        }

       }

       æºç æ‰“印？

       public class ThreadDemo1{

        public static void main(String[] args){

        new ThreadTest().start();

        new ThreadTest().start();

        new ThreadTest().start();

        new ThreadTest().start();

        }

       }

       Java代码

       class ThreadTest extends Thread{

        private int ticket = ;

        public void run(){

        while(true){

        if(ticket > 0){

        System.out.println(Thread.currentThread().getName() +

        " is saling ticket" + ticket--);

        }else{

        break;

        }

        }

        }

       }

       æºç æ‰“印？

       class ThreadTest extends Thread{

        private int ticket = ;

        public void run(){

        while(true){

        if(ticket > 0){

        System.out.println(Thread.currentThread().getName() +

        " is saling ticket" + ticket--);

        }else{

        break;

        }

        }

        }

       }

       è¿™ä¸‹è¾¾åˆ°ç›®çš„了吗？

        从结果上看每个票号都被打印了四次，即 四个线程各自卖各自的张票，而不去卖共同的张票。这种情况是怎么造成的呢？我们需要的是，多个线程去处理同一个资源，一个资源只能对应一个对象，在上面的程序中，我们创建了四个ThreadTest对象，就等于创建了四个资源，每个资源都有张票，每个线程都在独自处理各自的资源。

        经过这些实验和分析，可以总结出，要实现这个铁路售票程序，我们只能创建一个资源对象，但要创建多个线程去处理同一个资源对象，并且每个线程上所运行的是相同的程序代码。在回顾一下使用接口编写多线程的过程。

       Java代码

       public class ThreadDemo1{

        public static void main(String[] args){

        ThreadTest t = new ThreadTest();

        new Thread(t).start();

        new Thread(t).start();

        new Thread(t).start();

        new Thread(t).start();

        }

       }

       æºç æ‰“印？

       public class ThreadDemo1{

        public static void main(String[] args){

        ThreadTest t = new ThreadTest();

        new Thread(t).start();

        new Thread(t).start();

        new Thread(t).start();

        new Thread(t).start();

        }

       }

       Java代码

       class ThreadTest implements Runnable{

        private int tickets = ;

        public void run(){

        while(true){

        if(tickets > 0){

        System.out.println(Thread.currentThread().getName() +

        " is saling ticket " + tickets--);

        }

        }

        }

       }

       æºç æ‰“印？

       class ThreadTest implements Runnable{

        private int tickets = ;

        public void run(){

        while(true){

        if(tickets > 0){

        System.out.println(Thread.currentThread().getName() +

        " is saling ticket " + tickets--);

        }

        }

        }

       }

       ä¸Šé¢çš„程序中，创建了四个线程， 每个线程调用的是同一个ThreadTest对象中的run()方法，访问的是同一个对象中的变量（tickets）的实例，这个程序满足了我们的需求。在Windows上可以启动多个记事本程序一样，也就是多个进程使用同一个记事本程序代码。

        可见， 实现Runnable接口相对于继承Thread类来说，有如下显著的好处：

       (1)适合多个相同程序代码的线程去处理同一资源的情况，把虚拟CPU（线程）同程序的代码，数据有效的分离，较好地体现了面向对象的设计思想。

       (2)可以避免由于Java的单继承特性带来的局限。我们经常碰到这样一种情况，即当我们要将已经继承了某一个类的子类放入多线程中，由于一个类不能同时有两个父类，所以不能用继承Thread类的方式，那么，这个类就只能采用实现Runnable接口的方式了。

       (3)有利于程序的健壮性，代码能够被多个线程共享，代码与数据是独立的。当多个线程的执行代码来自同一个类的实例时，即称它们共享相同的代码。多个线程操作相同的数据，与它们的代码无关。当共享访问相同的对象是，即它们共享相同的数据。当线程被构造时，需要的代码和数据通过一个对象作为构造函数实参传递进去，这个对象就是一个实现了Runnable接口的类的实例。 Java中Runnable和Thread的区别更详细的资料参考：/course/course_id-.html

Java线程池实现原理及其在美团业务中的实践

       随着计算机行业的飞速发展，摩尔定律逐渐失效，多核CPU成为主流。使用多线程并行计算逐渐成为开发人员提升服务器性能的基本武器。J.U.C提供的线程池ThreadPoolExecutor类，帮助开发人员管理线程并方便地执行并行任务。了解并合理使用线程池，是一个开发人员必修的基本功。本文开篇简述了线程池概念和用途，接着结合线程池的源码，帮助大家领略线程池的设计思路，最后回归实践，通过案例讲述使用线程池遇到的问题，并给出了一种动态化线程池解决方案。

       一、写在前面

1.1 线程池是什么

       线程池（Thread Pool）是一种基于池化思想管理线程的工具，经常出现在多线程服务器中，如MySQL。线程过多会带来额外的开销，包括创建销毁线程的开销、调度线程的开销等，同时也降低了计算机的整体性能。线程池维护多个线程，等待监督管理者分配可并发执行的任务。这种做法一方面避免了处理任务时创建销毁线程开销的代价，另一方面避免了线程数量膨胀导致的过分调度问题，保证了对内核的充分利用。本文描述的线程池是JDK中提供的ThreadPoolExecutor类。

1.2 线程池解决的问题是什么

       线程池解决的核心问题就是资源管理问题。在并发环境下，系统不能确定在任意时刻有多少任务需要执行，有多少资源需要投入。这种不确定性将带来以下问题：资源分配问题、线程调度问题等。线程池采用了“池化”思想来解决这些问题。Pooling是将资源统一管理的一种思想，不仅能应用在计算机领域，还在金融、设备、delphi源码怎么用人员管理、工作管理等领域有相关应用。在计算机领域，表现为统一管理IT资源，包括服务器、存储、网络等，通过共享资源在低投入中获益。

       二、线程池核心设计与实现

       Java中的线程池核心实现类是ThreadPoolExecutor，本文基于JDK 1.8的源码来分析线程池的核心设计与实现。首先，我们通过ThreadPoolExecutor的UML类图了解其继承关系，然后深入探讨其设计与实现。

2.1 总体设计

       ThreadPoolExecutor实现的顶层接口是Executor，提供了一种思想：将任务提交和任务执行进行解耦。用户只需提供Runnable对象，将任务的运行逻辑提交到执行器(Executor)中，由Executor框架完成线程的调配和任务的执行。ExecutorService接口增加了能力，如补充可以为一个或一批异步任务生成Future的方法以及提供管控线程池的方法，如停止线程池运行。

       AbstractExecutorService是上层的抽象类，将执行任务的流程串联起来，保证下层实现只需关注执行任务的方法。ThreadPoolExecutor作为最下层的实现类，实现最复杂的运行部分，负责维护自身的生命周期和管理线程与任务，使两者结合执行并行任务。

       ThreadPoolExecutor运行机制分为任务管理和线程管理两部分。任务管理充当生产者的角色，线程池会根据任务的流转决定执行流程。线程管理是消费者，维护线程池内的线程，根据任务请求进行线程分配。

2.2 生命周期管理

       线程池运行状态由内部维护，使用变量控制线程池的运行状态和有效线程数量。线程池内部使用AtomicInteger存储关键参数，实现线程池运行状态和线程数量的高效管理。线程池提供方法供用户获取当前运行状态和线程数量，通过位运算实现快速计算。

       ThreadPoolExecutor的运行状态有五种，包含生命周期转换。

2.3 任务执行机制

2.3.1 任务调度

       任务调度是线程池核心入口，用户提交任务后，决定任务执行流程。通过execute方法完成检查线程池状态、运行线程数和运行策略，决定执行流程，如直接申请线程执行或缓冲到队列执行，或直接拒绝任务。执行流程如下。

2.3.2 任务缓冲

       任务缓冲模块实现任务和线程的管理，通过生产者消费者模式和阻塞队列实现。阻塞队列缓存任务，工作线程从队列中获取任务。

2.3.3 任务申请

       任务执行有两种可能：直接由新创建的线程执行或从队列中获取任务执行。线程从任务缓存模块不断获取任务，通过getTask方法实现线程管理和任务管理之间的通信。

2.3.4 任务拒绝

       任务拒绝策略保护线程池，实现拒绝策略接口定制策略或选择JDK提供的四种已有策略。拒绝策略特点如下。

2.4 Worker线程管理

2.4.1 Worker线程

       Worker线程实现Runnable接口，持有线程和任务，通过构造方法创建。Worker线程执行任务模型如下，线程池通过AQS实现独占锁，控制线程生命周期，回收线程。

2.4.2 Worker线程增加

       Worker线程增加通过addWorker方法实现，增加线程时考虑线程池状态，策略在上一步完成，仅完成增加线程并运行，最后返回成功结果。方法参数包括firstTask和core，用于指定任务和线程策略。

2.4.3 Worker线程回收

       Worker线程回收依赖JVM自动回收，线程池维护线程引用，通过添加和移除引用控制线程生命周期。Worker被创建后，不断获取任务执行，核心线程无限等待，非核心线程限时获取。当无法获取任务时，循环结束，Worker主动移除自身引用。

2.4.4 Worker线程执行任务

       Worker线程执行任务通过runWorker方法实现，执行流程如下。

三、线程池在业务中的实践

       业务实践中，线程池用于获取并发性，提供典型场景和问题解决方案。

3.1 业务背景

       互联网业界追求CPU多核性能，通过线程池管理线程获取并发性。常见场景包括快速响应用户请求和快速处理批量任务。

3.2 实际问题及方案思考

       线程池使用面临核心问题：参数配置困难。调研替代方案、参数设置合理性以及线程池参数动态化，动态化线程池提供简单有效的方法解决参数修改成本问题。

3.3 动态化线程池

       动态化线程池设计包括整体设计、功能架构，提供参数动态化、监控和告警能力。动态化线程池允许用户在管理平台上修改参数，实时生效，并监控线程池负载、任务执行情况，提供任务级别监控和运行时状态查看。

3.4 实践总结

       面对使用线程池的实际问题，动态化线程池提供成本效益平衡的解决方案，降低故障发生的概率，适用于业务需求。

       四、参考资料

       1. JDK 1.8 源码

       2. 维基百科-线程池

       3. 更好的使用Java线程池

       4. 维基百科Pooling(Resource Management)

       5. 深入理解Java线程池：ThreadPoolExecutor

       6. 《Java并发编程实践》

7个连环问题揭开java多线程背后的核心原理！

       摘要：很多java入门新人一想到java多线程， 就会觉得很晕很绕，什么可见不可见的，也不了解为什么sync怎么就锁住了代码。

       很多java入门新人一想到java多线程， 就会觉得很晕很绕，什么可见不可见的，也不了解为什么sync怎么就锁住了代码。

       因此我在这里会提多个问题，如果能很好地回答这些问题，那么算是你对java多线程的原理有了一些了解，也可以借此学习一下这背后的核心原理。

       Q: java中的主内存和工作内存是指什么？

       A:java中， 主内存中的对象引用会被拷贝到各线程的工作内存中， 同时线程对变量的修改也会反馈到主内存中。

       主内存对应于java堆中的对象实例部分（物理硬件的内存）

       工作内存对应于虚拟机栈中的部分区域（ 寄存器，高速缓存）

       工作内存中是拷贝的工作副本

       拷贝副本时，不会吧整个超级大的对象拷贝过来， 可能只是其中的某个基本数据类型或者引用。

       因此我们知道各线程使用内存数据时，其实是有主内存和工作内存之分的。并不是一定每次都从同一个内存里取数据。

       或者理解为大家使用数据时之间有一个缓存。

       Q: 多线程不可见问题的原因是什么？

       A:这里先讲一下虚拟机定义的内存原子操作：

       lock: 用于主内存， 把变量标识为一条线程独占的状态

       unlock : 主内存， 把锁定状态的变量释放

       read: 读取， 从主内存读到工作线程中

       load: 把read后的值放入到 工作副本中

       use： 使用工作内存变量， 传给工作引擎

       assign赋值: 把工作引擎的值传给工作内存变量

       store： 工作内存中的变量传到主内存

       write： 把值写入到主内存的变量中

       根据这些指令，看一下面这个图，　然后再看之后的流程解释，就好理解了。

       read和load、store、write是按顺序执行的， 但是中间可插入其他的操作。不可单独出现。

       assgin之后， 会同步后主内存。即只有发生过assgin，才会做工作内存同步到主内存的操作。

       新变量只能在主内存中产生

       工作内存中使用某个变量副本时，必须先经历过assign或者load操作。 不可read后马上就use

       lock操作可以被同一个线程执行多次，但相应地解锁也需要多次。

       执行lock时，会清空工作内存中该变量的值。 清空后如果要使用，必须重新做load或者assign操作

       unlock时，需要先把数据同步回主内存，再释放。

       因此多线程普通变量的读取和写入操作存在并发问题， 主要在于2点：

       只有assgin时， 才会更新主内存， 但由于指令重排序的情况，导致有时候某个assine指令先执行，然后这个提前被改变的变量就被其他线程拿走了，以至于其他线程无法及时看到更新后的内存值。

       assgin时从工作内存到主内存之间，可能存在延迟，同样会导致数据被提前取走存到工作线程中。

       Q: 那么volatile关键字为什么就可以实现可见性？可见性就是并发修改某个值后，这个值的修改对其他线程是马上可见的。

       A: java内存模型堆volatile定义了以下特殊规则：

       当一个线程修改了该变量的值时，会先lock住主存， 再立刻把新数据同步回内存。

       使用该值时，其他工作内存都要从主内存中刷新！

       这个期间会禁止对于该变量的指令重排序

       禁止指令重排序的原理是在给volatile变量赋值时，会加1个lock动作， 而前面规定的内存模型原理中， lock之后才能做load或者assine，因此形成了1个内存屏障。

       Q: 上面提到lock后会限制各工作内存要刷新主存的值load进来后才能用， 这个在底层是怎么实现的？

       A:利用了cpu的总线锁+ 缓存一致性+ 嗅探机制实现， 属于计算机组成原理部分的知识。

       这也就是为什么violate变量不能设置太多，如果设置太多，可能会引发总线风暴，造成cpu嗅探的成本大大增加。

       Q: 那给方法加上synchronized关键字的原理是什么？和volatie的区别是啥？

       A:

       synchronized的重量级锁是通过对象内部的监视器（monitor）实现

       monitor的线程互斥就是通过操作系统的mutex互斥锁实现的，而操作系统实现线程之间的切换需要从用户态到内核态的切换，所以切换成本非常高。

       每个对象都持有一个moniter对象

       具体流程如下：

       首先，class文件的方法表结构中有个访问标志access_flags， 设置ACC_SYNCHRONIZED标志来表示被设置过synchronized。

       线程在执行方法前先判断access_flags是否标记ACC_SYNCHRONIZED，如果标记则在执行方法前先去获取monitor对象。

       获取成功则执行方法代码且执行完毕后释放monitor对象

       如果获取失败则表示monitor对象被其他线程获取从而阻塞当前线程

       注意，如果是sync{ }代码块，则是通过在代码中添加monitorEnter和monitorExit指令来实现获取和退出操作的。

       如果对C语言有了解的，可以看看这个大哥些的文章Java精通并发-通过openjdk源码分析ObjectMonitor底层实现

       Q: synchronized每次加锁解锁需要切换内核态和用户态， jvm是否有对这个过程做过一些优化？

       A:jdk1.6之后， 引入了锁升级的概念，而这个锁升级就是针对sync关键字的

       锁的状态总共有四种，级别由低到高依次为：无锁、偏向锁、轻量级锁、重量级锁

       四种状态会随着竞争的情况逐渐升级，而且是不可逆的过程，只能进行锁升级（从低级别到高级别），不能锁降级（高级别到低级别）

       因此sync关键字不是一开始就直接使用很耗时的同步。而是一步步按照情况做升级

       当对象刚建立，不存在锁竞争的时候， 每次进入同步方法/代码块会直接使用偏向锁

       偏向锁原理： 每次尝试在对象头里设置当前使用这个对象的线程id， 只做一次，如果成功了就设置好threadId， 只要没有出现新的thread访问且markWord被修改，那么久）

       2. 当发现对象头的线程id要被修改时，说明存在竞争时。升级为轻量级锁

       轻量级锁采用的是自旋锁，如果同步方法/代码块执行时间很短的话，采用轻量级锁虽然会占用cpu资源但是相对比使用重量级锁还是更高效的。 CAS的对象是对象头的Mark Word， 此时仍然不会去调系统底层的方法做阻塞。

       3. 但是如果同步方法/代码块执行时间很长，那么使用轻量级锁自旋带来的性能消耗就比使用重量级锁更严重，这时候就会升级为重量级锁，也就是上面那个问题中提到的操作。

       Q: 锁只可以升级不可以降级, 确定是都不能降级吗？

       A:有可能被降级， 不可能存在共享资源竞争的锁。java存在一个运行期优化的功能需要开启server模式外加+DoEscapeAnalysis表示开启逃逸分析。

       如果运行过程中检测到共享变量确定不会逃逸，则直接在编译层面去掉锁

       举例：StringBuffer.append().append()

       例如如果发现stringBuffer不会逃逸，则就会去掉这里append所携带的同步

       而这种情况肯定只能发生在偏向锁上， 所以偏向锁可以被重置为无锁状态。

       本文分享自华为云社区，作者：breakDraw。