Java 阻塞与非阻塞性能简单对比思考

最新推荐文章于 2026-01-26 20:52:10 发布
原创 最新推荐文章于 2026-01-26 20:52:10 发布 · 340 阅读 · 1 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文通过两个Java程序示例对比了在不同线程运行时间下，使用wait和不使用wait进行线程同步的性能差异。在线程执行时间较短时，自旋锁（不使用wait）具有较快的响应速度和较低的CPU使用率；而在线程需要长时间运行的情况下，两者性能接近，但wait方法的CPU使用率更低。这表明在设计多线程同步策略时，应根据线程执行时间选择合适的同步机制，以平衡资源消耗和效率。

使用三个线程分别打印a、b、c三个字母，要求三个字母按照顺序打印指定次数，通过模拟线程不同的消耗时间来对比使用wait和不使用wait的性能的差异。

模拟每个线程只执行短暂时间

public class Test1 {
    private static int status = 1;
    private static int times = 100000;
    private static Object obj = new Object();

    public static void main(String[] args) throws InterruptedException {
        Thread thread1 =  new Thread(() -> {
            while (times > 1) {
                while (status != 1) {
                }
                System.out.print("A");
//                try {
//                    Thread.sleep(10);
//                } catch (InterruptedException e) {
//                    e.printStackTrace();
//                }
                status = 2;
            }
        });

        Thread thread2 = new Thread(() -> {
            while (times > 1) {
                while (status != 2) {
                }
                System.out.print("B");
//                try {
//                    Thread.sleep(10);
//                } catch (InterruptedException e) {
//                    e.printStackTrace();
//                }
                status = 3;
            }
        });

        Thread thread3 = new Thread(() -> {
            while (times > 0) {
                while (status != 3) {
                }
                System.out.println("C");
//                try {
//                    Thread.sleep(10);
//                } catch (InterruptedException e) {
//                    e.printStackTrace();
//                }
                status = 1;
                times--;
            }
        });

        long start = System.currentTimeMillis();
        thread1.start();
        thread2.start();
        thread3.start();

        thread1.join();
        thread2.join();
        thread3.join();
        long end = System.currentTimeMillis();
        System.out.println(end - start);
    }
}

在这里插入图片描述

public class Test2 {

    private static int status = 1;
    private static int times = 100000;
    private static Object obj = new Object();

    public static void main(String[] args) throws InterruptedException {
        Thread thread1 =  new Thread(() -> {
            while (times > 1) {
                while (status != 1) {
                    synchronized (obj) {
                        try {
                            obj.notifyAll();
                            obj.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
                System.out.print("A");
//                try {
//                    Thread.sleep(10);
//                } catch (InterruptedException e) {
//                    e.printStackTrace();
//                }
                status = 2;
            }
            synchronized (obj) {
                obj.notifyAll();
            }
        });

        Thread thread2 = new Thread(() -> {
            while (times > 1) {
                while (status != 2) {
                    synchronized (obj) {
                        try {
                            obj.notifyAll();
                            obj.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
                System.out.print("B");
//                try {
//                    Thread.sleep(10);
//                } catch (InterruptedException e) {
//                    e.printStackTrace();
//                }
                status = 3;
            }
            synchronized (obj) {
                obj.notifyAll();
            }
        });

        Thread thread3 = new Thread(() -> {
            while (times > 0) {
                while (status != 3) {
                    synchronized (obj) {
                        try {
                            obj.notifyAll();
                            obj.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
                System.out.println("C");
//                try {
//                    Thread.sleep(10);
//                } catch (InterruptedException e) {
//                    e.printStackTrace();
//                }
                status = 1;
                times--;
            }
        });

        long start = System.currentTimeMillis();
        thread1.start();
        thread2.start();
        thread3.start();

        thread1.join();
        thread2.join();
        thread3.join();
        long end = System.currentTimeMillis();
        System.out.println(end - start);
    }
}

在这里插入图片描述

在这里插入图片描述

Test1与Test2的运行时间进行对比可以发现Test2使用wait需要更长的运行时间，而Test1循环等待需要耗费更少的时间，在CPU使用率图上左边为运行Test1时的CPU使用率，右边为Test2的CPU使用率，虽然不是百分百准确，但是总体上可以看出二者的运行时CPU使用率相差不大。

线程需要运行相对较长时间情况

通过在两个线程运行中间加入睡眠时间，模拟线程需要长时间运行的情况

public class Test1 {
    private static int status = 1;
    private static int times = 1000;
    private static Object obj = new Object();

    public static void main(String[] args) throws InterruptedException {
        Thread thread1 =  new Thread(() -> {
            while (times > 1) {
                while (status != 1) {
                }
                System.out.print("A");
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                status = 2;
            }
        });

        Thread thread2 = new Thread(() -> {
            while (times > 1) {
                while (status != 2) {
                }
                System.out.print("B");
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                status = 3;
            }
        });

        Thread thread3 = new Thread(() -> {
            while (times > 0) {
                while (status != 3) {
                }
                System.out.println("C");
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                status = 1;
                times--;
            }
        });

        long start = System.currentTimeMillis();
        thread1.start();
        thread2.start();
        thread3.start();

        thread1.join();
        thread2.join();
        thread3.join();
        long end = System.currentTimeMillis();
        System.out.println(end - start);
    }
}

在这里插入图片描述

public class Test2 {

    private static int status = 1;
    private static int times = 1000;
    private static Object obj = new Object();

    public static void main(String[] args) throws InterruptedException {
        Thread thread1 =  new Thread(() -> {
            while (times > 1) {
                while (status != 1) {
                    synchronized (obj) {
                        try {
                            obj.notifyAll();
                            obj.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
                System.out.print("A");
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                status = 2;
            }
            synchronized (obj) {
                obj.notifyAll();
            }
        });

        Thread thread2 = new Thread(() -> {
            while (times > 1) {
                while (status != 2) {
                    synchronized (obj) {
                        try {
                            obj.notifyAll();
                            obj.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
                System.out.print("B");
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                status = 3;
            }
            synchronized (obj) {
                obj.notifyAll();
            }
        });

        Thread thread3 = new Thread(() -> {
            while (times > 0) {
                while (status != 3) {
                    synchronized (obj) {
                        try {
                            obj.notifyAll();
                            obj.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
                System.out.println("C");
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                status = 1;
                times--;
            }
        });

        long start = System.currentTimeMillis();
        thread1.start();
        thread2.start();
        thread3.start();

        thread1.join();
        thread2.join();
        thread3.join();
        long end = System.currentTimeMillis();
        System.out.println(end - start);
    }
}

在这里插入图片描述
在这里插入图片描述
通过对比我们可以看出当线程需要运行长时间的时候使用wait和不使用wait进行循环的运行时间相差不多，但是从CPU使用率来看，Test2需要的CPU几乎是Test1的一半。

思考

1.当线程运行时间较短能较块释放锁时使用自旋锁需要的资源相对较少同时响应较块，当线程需要运行较长时间时，通过获取锁的方式让线程调用wait方法让线程进行等待，减少自旋时对资源的过度消耗。
2.java中synchronize对锁进行分级，分为无锁状态、偏向锁状态、轻量级锁状态、重量级锁状态，当调用的线程数增加时对锁进行升级。偏向锁：当只有一个线程访问该类时不进行加锁操作。轻量级：当有两个线程访问同一个类时，对锁进行升级，轻量级锁使用自选的方式进行等待。重量级锁：当多个线程访问同一个类时需要线程阻塞等待。java对锁的分级的原理也是类似，当两个线程访问同一个类时使用自选可以快速获得类的使用权，当多个线程访问同一个类时不能快速获得类的使用权，所以根据情况对锁进行升级，提高运行速度。

标签
#java
生产环境请求阻塞，系统瘫痪
xumiaojava的博客
09-07 626
原因：阻塞的线程导致系统卡死的原因并不是因为线程数量过多，而是因为阻塞的线程占用了系统资源，导致其他线程无法正常运行。如果系统中有很多阻塞的线程，这些线程会一直占用CPU资源，导致其他线程无法正常运行。为了避免这种情况，可以考虑使用线程池、异步调用等技术来管理线程，避免阻塞线程导致系统卡死的情况发生。3、异步调用：可以使用异步调用，将请求放到队列，由专门的线程处理队列中的请求，避免执行线程阻塞。在调用某个接口时，如果这个接口超时了，线程会阻塞等待结果，这个阻塞的线程会导致系统卡死。
Redis五大影响性能原因（一）：Redis实例内部的阻塞操作
skye_fly的博客
08-25 624
思路： 1.建立一张redis主从切片集群图 ->-> 2.以一个切片节点为中心考虑其与周围节点会造成阻塞的情况 ->-> 3.对每一个阻塞情况考虑其是否是客户端需要的返回数据决定是否可以用异步子线程处理 一、Redis实例内部阻塞的四大原因 客户端：网络 IO，键值对增删改查操作，数据库操作； 磁盘：生成 RDB 快照，记录 AOF 日志，AOF 日志重写； 主从节点：主库生成、传输 RDB 文件，从库接收 RDB 文件、清空数据库、加载 RDB 文件； 切片集群实例：向
各种阻塞的优缺点、区别、关系以及转换
weixin_54248927的博客
08-21 875
互相之间的转换可以通过线程池、异步回调、异步框架等实现，具体根据需求选择合适的转换方式。5.4 异步非阻塞通过回调函数或事件驱动的方式实现高并发处理，但编程模型复杂。5.1 线程阻塞是基础，可以在IO阻塞、同步阻塞以及异步非阻塞中运用。5.2 IO阻塞适用于低并发场景，简单易用，但可能造成整个程序的阻塞。5.3 同步阻塞通过加锁等方式来避免资源竞争，但会降低程序的并发性能。需要有效地处理异常，防止IO阻塞导致的程序异常退出。阻塞的线程会占用系统资源，降低系统的并发能力。可以实现高并发、高吞吐量的处理能力。
深入理解阻塞队列：提高并发性能的利器
2301_76608621的博客
07-22 252
同样地，当队列已满时，生产者线程会进入等待状态，直到队列中有空位，然后唤醒生产者线程继续生产数据。一直阻塞：当阻塞队列满时，如果生产者线程往队列里put元素，队列会一直阻塞生产者线程，直到拿到数据，或者响应中断退出。当队列空时，消费者线程试图从队列里take元素，队列也会阻塞消费者线程，直到队列可用。阻塞队列是一种特殊的队列，它支持在队列为空时等待队列非空，或者在队列已满时等待队列非满。超时退出：当阻塞队列满时，队列会阻塞生产者线程一段时间，如果超过一定的时间，生产者线程就会退出。阻塞队列的常见应用场景。
线程的阻塞模式好，还是非阻塞模式好呢？
weixin_33943347的博客
05-29 487
2019独角兽企业重金招聘Python工程师标准>>> ...
HttpServer带阻塞性能比较
weixin_30877227的博客
06-23 341
服务端在返回hello,world! 之前先阻塞一秒钟，模拟访问DB等耗时操作。 Netty 我直接在 WorkerGroup 里头sleep，用同步阻塞线程模型的方式来编程，所以性能暴降。 Jooby 自称可直接阻塞访问主线程，但可看到性能也暴降了。这个框架是模组化的，覆盖率和代码质量也很高。但活跃开发人员只有一个，并且生态不完善，很难自由组合，对项目中其它组件的选型带来一定的难度，个人建议...
java synchronized lock 原理 对比
vmaps的博客
03-03 571
和Lock（通常指的是接口的实现，如）在Java中都是用来控制并发访问共享资源的机制，但它们的工作原理和使用方式有很大的不同。以下是对它们之间以及它们相关特性的对比。
weblogic线程阻塞性能调优（图解）
weixin_30379531的博客
08-13 2272
转自：http://blog.csdn.net/z69183787/article/details/12647539 声明：出现这个问题有程序方面、网络方面、weblogic设置方面等等原因，此文章主要讲述由于weblogic设置而导致的解决办法。 因为： 1.程序问题，需要项目自己去解决，weblogic在做优化处理也于事无补。 2.网络中断或者认为关闭交互这种情况也不能用webl...
weblogic线程阻塞性能调优
u011104972的博客
05-08 1491
声明：出现这个问题有程序方面、网络方面、weblogic设置方面等等原因，此文章主要讲述由于weblogic设置而导致的解决办法。 因为： 1.程序问题，需要项目自己去解决，weblogic在做优化处理也于事无补。 2.网络中断或者认为关闭交互这种情况也不能用weblogic处理（这点我是这么认为的） 一、说明： ,"weblogic.kernel.Default"是从客户端...
java多线程异步和阻塞性调用方式
huangdi1309的博客
04-26 1161
java多线程可以直接通过ExecutorService接口的execute方法提交任务，也可以通过invokeAll方法让多个任务一起提交，前者execute是异步提交，也就是说不会阻塞主线程，后则会阻塞主线程，等待所有任务执行完成主线程才回继续执行。其实不管是execute还是invokeAll，它们最终都会去执行Executor接口的execute（Runnable run）方法，下面是截取...
java future get阻塞_验证Future.get阻塞性，阻塞的是什么
weixin_39915668的博客
02-19 718
packagecom.fengjr.p2passet.riskcontrol.web.loan;importcom.fengjr.p2passet.service.auto.thread.pool.ProcessRejectedExecutionHandler;importcom.fengjr.p2passet.service.auto.thread.pool.ThreadPool;importc...
阻塞队列-ArrayBlockingQueue
左灯右行的爱情
04-21 1047
(JUC) 包提供了多种阻塞队列的实现，其中以其有界基于数组和线程安全的特性，在需要精确控制资源和流量的场景中扮演着重要角色。是包提供的一个有界阻塞队列。顾名思义，它的内部实现基于数组结构，并且在创建时必须指定一个固定的容量，这个容量在队列创建后不可改变。这个管道的长度在你创建它的时候就定死了，比如只能同时容纳 10 个物品。不能多也不能少，长度无法动态调整。物品（元素）从管道的一端放入（入队），从另一端取出（出队），遵循先进先出 (FIFO)的原则，就像排队一样。
[JavaEE]阻塞队列_java队列取阻塞
2401_89225213的博客
12-18 772
那么如果我们使用"生产者消费者模型" , 生产者和消费者彼此之间不进行通信 , 而是通过一个阻塞队列来通信 , 所以生成者生成完数据不用直接给消费者 , 而是直接扔给阻塞队列.消费者也不再向生产者所要数据 , 而是直接从阻塞队列中取. 这样生产者和消费者之间的耦合程度就大大降低了.比如一家人过年包饺子 , 这个流程需要由明确的分工 , 擀饺子皮的人是"生产者" , 包饺子的人是"消费者" , 擀饺子皮的人不必关心谁包饺子 , 包饺子的人也不必关心谁擀饺子皮.
Spring WebFlux和Spring MVC的对比
IT利刃出鞘的博客
06-20 1061
本文介绍Spring WebFlux和Spring MVC的区别。Webflux：是异步非阻塞的（IO多路复用），基于Netty。适合网络转发类的应用，比如：网关。MVC：是同步阻塞的，基于Servlet。适合阻塞性的业务应用，比如：读写数据库等普通业务。Webflux和MVC功能性Spring MVC 和 WebFlux 可以共存。
阻塞队列与消费者生产者模型
yc_xym的博客
09-27 1098
阻塞队列是在普通的先进先出队列的基础上进行了扩充a）如果队列没空进行出队列操作，此时就会出现阻塞；一直阻塞到其他线程往队列添加元素b）如果队列为满进行入列操作，此时也会出现阻塞；一直阻塞到其他线程从队列取走元素基于阻塞队列，最大的应用场景就是实现“生产者消费者模型”。
java https请求SSE，数据流不返回前端，后端没有阻塞性问题,前端就是接收不到信息
qq_44430410的博客
04-22 1301
通过本次问题的排查，我们可以得出以下几点经验：对于实时推送的 SSE 接口，务必检查 nginx 的缓冲配置，确保数据能即时下发。HTTPS 环境下可能会因为 SSL/TLS 的额外处理而引入延迟，配置上应特别留意相关参数。排查问题时，应综合使用 nginx 日志和浏览器开发者工具（如 Network 面板），对比各个阶段的耗时，从而准确定位问题原因。
BIO（阻塞 I/O）和 NIO（非阻塞 I/O，Java 中也常称 New I/O）
最新发布
weixin_53050448的博客
01-26 589
核心区别：BIO 是同步阻塞、一连接一线程；NIO 是同步非阻塞，通过 Selector 实现一个线程处理多连接，并发性能远优于 BIO。适用场景：BIO 适合连接少且长连接的场景，NIO 适合高并发、短连接的网络场景（如互联网服务器）。关键组件：NIO 的核心是Selector（多路复用）、Channel（双向通道）和Buffer（缓冲区），这是它能实现高并发的核心。
说一说你对同步和异步的理解?
weixin_43249298的博客
08-13 1103
同步和异步的理解
【Java多线程】【阻塞队列】
OTO233的博客
08-01 1177
从名字上 可以看出，它是队列的一种，那肯定是 先进先出（FIFO）的数据结构。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值