[置顶]Java同步工具类总结

作者：Jacky麦麦9 | 来源：互联网 | 2023-10-13 11:34

先谈谈闭锁和栅栏的区别：1.关键区别在于，所有线程必须同时到达栅栏位置，才能继续执行。2.闭锁用于等待某一个事件的发生，

先谈谈闭锁和栅栏的区别&＃xff1a;

1.关键区别在于&＃xff0c;所有线程必须同时到达栅栏位置&＃xff0c;才能继续执行。

2.闭锁用于等待某一个事件的发生&＃xff0c;举例&＃xff1a;CountDownLatch中await方法等待计数器为零时&＃xff0c;所有事件才可继续执行。而栅栏是等待其他线程到位&＃xff0c;所有事件才可继续下一步。例如&＃xff1a;几个家庭决定在某个地方集合&＃xff1a;“所有人6:00在麦当劳碰头&＃xff0c;到了以后要等其他人&＃xff0c;之后再讨论下一步要做的事情”。

Semaphore&＃xff08;闭锁&＃xff09;

这个东西和之前的synchronized干的事差不多。
synchronized保证了,我管理的那部分代码同一时刻只有一个线程能访问
Semaphore保证了,我管理的那部分代码同一时刻最多可以有n个线程访问

import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.Semaphore; public class SemaphoreTest { public static void main(String[] args) { ExecutorService service &＃61; Executors.newCachedThreadPool(); final Semaphore sp &＃61; new Semaphore(3); for(int i&＃61;0;i<10;i&＃43;&＃43;){ Runnable runnable &＃61; new Runnable(){ public void run(){ try { sp.acquire(); } catch (InterruptedException e1) { e1.printStackTrace(); } System.out.println("线程" &＃43; Thread.currentThread().getName() &＃43; "进入&＃xff0c;当前已有" &＃43; (3-sp.availablePermits()) &＃43; "个并发"); try { Thread.sleep((long)(Math.random()*10000)); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("线程" &＃43; Thread.currentThread().getName() &＃43; "即将离开"); sp.release(); //下面代码有时候执行不准确&＃xff0c;因为其没有和上面的代码合成原子单元 System.out.println("线程" &＃43; Thread.currentThread().getName() &＃43; "已离开&＃xff0c;当前已有" &＃43; (3-sp.availablePermits()) &＃43; "个并发"); } }; service.execute(runnable); } } }

运行结果如下&＃xff1a;

线程pool-1-thread-2进入&＃xff0c;当前已有2个并发线程pool-1-thread-1进入&＃xff0c;当前已有2个并发线程pool-1-thread-3进入&＃xff0c;当前已有3个并发线程pool-1-thread-1即将离开线程pool-1-thread-1已离开&＃xff0c;当前已有2个并发线程pool-1-thread-4进入&＃xff0c;当前已有3个并发线程pool-1-thread-3即将离开线程pool-1-thread-3已离开&＃xff0c;当前已有2个并发线程pool-1-thread-5进入&＃xff0c;当前已有3个并发线程pool-1-thread-2即将离开线程pool-1-thread-2已离开&＃xff0c;当前已有2个并发线程pool-1-thread-6进入&＃xff0c;当前已有3个并发线程pool-1-thread-4即将离开线程pool-1-thread-4已离开&＃xff0c;当前已有2个并发线程pool-1-thread-7进入&＃xff0c;当前已有3个并发线程pool-1-thread-5即将离开线程pool-1-thread-5已离开&＃xff0c;当前已有2个并发线程pool-1-thread-8进入&＃xff0c;当前已有3个并发线程pool-1-thread-8即将离开线程pool-1-thread-9进入&＃xff0c;当前已有3个并发线程pool-1-thread-8已离开&＃xff0c;当前已有3个并发线程pool-1-thread-6即将离开线程pool-1-thread-6已离开&＃xff0c;当前已有2个并发线程pool-1-thread-10进入&＃xff0c;当前已有3个并发线程pool-1-thread-10即将离开线程pool-1-thread-10已离开&＃xff0c;当前已有2个并发线程pool-1-thread-7即将离开线程pool-1-thread-7已离开&＃xff0c;当前已有1个并发线程pool-1-thread-9即将离开线程pool-1-thread-9已离开&＃xff0c;当前已有0个并发

参考链接&＃xff1a;http://www.cnblogs.com/nullzx/archive/2016/03/12/5270233.html

CountDownLatch &＃xff08;闭锁&＃xff09;

它保证了什么功能呢?其实和CycliBarrier也类似。

看下面这个图

这就是CycleBarrier,线程自己管理自己,大家看到人都到齐了,才继续走。

这个是CountDownLatch,由他人来协调进度。

例如跑步的时候,有个裁判,等所有的人都到齐了,他吹哨,然后大家开始跑,等所有人都跑完了,他才公布成绩。

import java.util.concurrent.CountDownLatch; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class CountdownLatchTest { public static void main(String[] args) { ExecutorService service &＃61; Executors.newCachedThreadPool(); final CountDownLatch cdOrder &＃61; new CountDownLatch(1); final CountDownLatch cdAnswer &＃61; new CountDownLatch(3); for(int i&＃61;0;i<3;i&＃43;&＃43;){ Runnable runnable &＃61; new Runnable(){ public void run(){ try { System.out.println("线程" &＃43; Thread.currentThread().getName() &＃43; "正准备接受命令"); cdOrder.await(); System.out.println("线程" &＃43; Thread.currentThread().getName() &＃43; "已接受命令"); Thread.sleep((long)(Math.random()*10000)); System.out.println("线程" &＃43; Thread.currentThread().getName() &＃43; "回应命令处理结果"); cdAnswer.countDown(); } catch (Exception e) { e.printStackTrace(); } } }; service.execute(runnable); } try { Thread.sleep((long)(Math.random()*10000)); System.out.println("线程" &＃43; Thread.currentThread().getName() &＃43; "即将发布命令"); cdOrder.countDown(); System.out.println("线程" &＃43; Thread.currentThread().getName() &＃43; "已发送命令&＃xff0c;正在等待结果"); cdAnswer.await(); System.out.println("线程" &＃43; Thread.currentThread().getName() &＃43; "已收到所有响应结果"); } catch (Exception e) { e.printStackTrace(); } service.shutdown(); } }

运行结果如下

线程pool-1-thread-3正准备接受命令线程pool-1-thread-1正准备接受命令线程pool-1-thread-2正准备接受命令线程main即将发布命令线程main已发送命令&＃xff0c;正在等待结果线程pool-1-thread-3已接受命令线程pool-1-thread-2已接受命令线程pool-1-thread-1已接受命令线程pool-1-thread-3回应命令处理结果线程pool-1-thread-1回应命令处理结果线程pool-1-thread-2回应命令处理结果线程main已收到所有响应结果

CountDownLatch里面有个计数器,初始值就是new countdownlatch时传入的

wait方法会一直等待,直到计数器的值变为0

coutdown方法可以让计数器的值减一

CycleBarrier&＃xff08;栅栏&＃xff09;

CycleBarrier 能做到让n个线程互相等待,当n个线程都做到某一步后,再继续下一步。

例如下面的例子,5个人去旅游,设置abc三个中途节点,所有人都到达a之后在继续走向b,所有人都到达b,然后才继续走向c。

import java.util.concurrent.CyclicBarrier; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class CyclicBarrierTest { public static void main(String[] args) { ExecutorService service &＃61; Executors.newCachedThreadPool(); final CyclicBarrier cb &＃61; new CyclicBarrier(3); for(int i&＃61;0;i<3;i&＃43;&＃43;){ Runnable runnable &＃61; new Runnable(){ public void run(){ try { Thread.sleep((long)(Math.random()*10000)); System.out.println("线程" &＃43; Thread.currentThread().getName() &＃43; "即将到达集合地点1&＃xff0c;当前已有" &＃43; (cb.getNumberWaiting()&＃43;1) &＃43; "个已经到达&＃xff0c;" &＃43; (cb.getNumberWaiting()&＃61;&＃61;2?"都到齐了&＃xff0c;继续走啊":"正在等候")); cb.await(); Thread.sleep((long)(Math.random()*10000)); System.out.println("线程" &＃43; Thread.currentThread().getName() &＃43; "即将到达集合地点2&＃xff0c;当前已有" &＃43; (cb.getNumberWaiting()&＃43;1) &＃43; "个已经到达&＃xff0c;" &＃43; (cb.getNumberWaiting()&＃61;&＃61;2?"都到齐了&＃xff0c;继续走啊":"正在等候")); cb.await(); Thread.sleep((long)(Math.random()*10000)); System.out.println("线程" &＃43; Thread.currentThread().getName() &＃43; "即将到达集合地点3&＃xff0c;当前已有" &＃43; (cb.getNumberWaiting() &＃43; 1) &＃43; "个已经到达&＃xff0c;" &＃43; (cb.getNumberWaiting()&＃61;&＃61;2?"都到齐了&＃xff0c;继续走啊":"正在等候")); cb.await(); } catch (Exception e) { e.printStackTrace(); } } }; service.execute(runnable); } service.shutdown(); } }

运行结果如下&＃xff1a;

线程pool-1-thread-2即将到达集合地点1&＃xff0c;当前已有1个已经到达&＃xff0c;正在等候线程pool-1-thread-1即将到达集合地点1&＃xff0c;当前已有2个已经到达&＃xff0c;正在等候线程pool-1-thread-3即将到达集合地点1&＃xff0c;当前已有3个已经到达&＃xff0c;都到齐了&＃xff0c;继续走啊线程pool-1-thread-1即将到达集合地点2&＃xff0c;当前已有1个已经到达&＃xff0c;正在等候线程pool-1-thread-3即将到达集合地点2&＃xff0c;当前已有2个已经到达&＃xff0c;正在等候线程pool-1-thread-2即将到达集合地点2&＃xff0c;当前已有3个已经到达&＃xff0c;都到齐了&＃xff0c;继续走啊线程pool-1-thread-1即将到达集合地点3&＃xff0c;当前已有1个已经到达&＃xff0c;正在等候线程pool-1-thread-2即将到达集合地点3&＃xff0c;当前已有2个已经到达&＃xff0c;正在等候线程pool-1-thread-3即将到达集合地点3&＃xff0c;当前已有3个已经到达&＃xff0c;都到齐了&＃xff0c;继续走啊

Exchange&＃xff08;栅栏&＃xff09;

A线程有数据1,它需要与B线程的数据2做交换
B线程有数据2,它需要与A线程的数据1做交换

那么什么时候交换呢?得等AB都做好准备才行。

import java.util.concurrent.Exchanger; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class ExchangerTest { public static void main(String[] args) { ExecutorService service &＃61; Executors.newCachedThreadPool(); final Exchanger exchanger &＃61; new Exchanger(); service.execute(new Runnable(){ public void run() { try { String data1 &＃61; "zxx"; System.out.println("线程" &＃43; Thread.currentThread().getName() &＃43; "正在把数据" &＃43; data1 &＃43;"换出去"); Thread.sleep((long)(Math.random()*10000)); String data2 &＃61; (String)exchanger.exchange(data1); System.out.println("线程" &＃43; Thread.currentThread().getName() &＃43; "换回的数据为" &＃43; data2); }catch(Exception e){ } } }); service.execute(new Runnable(){ public void run() { try { String data1 &＃61; "lhm"; System.out.println("线程" &＃43; Thread.currentThread().getName() &＃43; "正在把数据" &＃43; data1 &＃43;"换出去"); Thread.sleep((long)(Math.random()*10000)); String data2 &＃61; (String)exchanger.exchange(data1); System.out.println("线程" &＃43; Thread.currentThread().getName() &＃43; "换回的数据为" &＃43; data2); }catch(Exception e){ } } }); } }

运行结果如下&＃xff1a;

线程pool-1-thread-1正在把数据zxx换出去线程pool-1-thread-2正在把数据lhm换出去线程pool-1-thread-2换回的数据为zxx 线程pool-1-thread-1换回的数据为lhm

推荐阅读

int
Java并发编程：LinkedBlockingQueue的实际应用

本文介绍了Java并发库中的阻塞队列（BlockingQueue）及其典型应用场景。通过具体实例，展示了如何利用LinkedBlockingQueue实现线程间高效、安全的数据传递，并结合线程池和原子类优化性能。 ... [详细]

蜡笔小新 2024-12-27 18:51:49
int
Java面试题解析

本文详细介绍了Java编程语言中的核心概念和常见面试问题，包括集合类、数据结构、线程处理、Java虚拟机（JVM）、HTTP协议以及Git操作等方面的内容。通过深入分析每个主题，帮助读者更好地理解Java的关键特性和最佳实践。 ... [详细]

蜡笔小新 2024-12-27 13:55:14
int
深入理解org.neo4j.helpers.collection.Iterators.single()方法及其应用

本文详细介绍了Java中org.neo4j.helpers.collection.Iterators.single()方法的功能、使用场景及代码示例，帮助开发者更好地理解和应用该方法。 ... [详细]

蜡笔小新 2024-12-28 10:51:55
int
PyCharm下载与安装指南

本文详细介绍如何从官方渠道下载并安装PyCharm集成开发环境（IDE），涵盖Windows、macOS和Linux系统，同时提供详细的安装步骤及配置建议。 ... [详细]

蜡笔小新 2024-12-28 09:42:41
go
Handling Null Object Encoding in OAuth 1.0a API Implementation

Explore a common issue encountered when implementing an OAuth 1.0a API, specifically the inability to encode null objects and how to resolve it. ... [详细]

蜡笔小新 2024-12-28 08:54:34
go
如何使用JavaScript或jQuery检测文本框焦点状态和鼠标悬停事件

本文介绍了如何利用JavaScript或jQuery来判断网页中的文本框是否处于焦点状态，以及如何检测鼠标是否悬停在指定的HTML元素上。 ... [详细]

蜡笔小新 2024-12-27 21:33:33
int
Java 中的 BigDecimal pow()方法，示例

Java 中的 BigDecimal pow()方法，示例 ... [详细]

蜡笔小新 2024-12-27 20:54:03
require
JQuery基础：省市联动与表单验证

本文介绍了如何使用JQuery实现省市二级联动和表单验证。首先，通过change事件监听用户选择的省份，并动态加载对应的城市列表。其次，详细讲解了使用Validation插件进行表单验证的方法，包括内置规则、自定义规则及实时验证功能。 ... [详细]

蜡笔小新 2024-12-27 17:10:48
int
Linux 自动化安装脚本详解

本文介绍了一款用于自动化部署 Linux 服务的 Bash 脚本。该脚本不仅涵盖了基本的文件复制和目录创建，还处理了系统服务的配置和启动，确保在多种 Linux 发行版上都能顺利运行。 ... [详细]

蜡笔小新 2024-12-27 16:33:32
request
使用 Azure Service Principal 和 Microsoft Graph API 获取 AAD 用户列表

本文介绍了一段通用代码示例，该代码不仅能够操作 Azure Active Directory (AAD)，还可以通过 Azure Service Principal 的授权访问和管理 Azure 订阅资源。Azure 的架构可以分为两个层级：AAD 和 Subscription。 ... [详细]

蜡笔小新 2024-12-27 16:07:12
int
深入解析Spring Cloud Ribbon负载均衡机制

本文详细介绍了Spring Cloud中的Ribbon组件如何实现服务调用的负载均衡。通过分析其工作原理、源码结构及配置方式，帮助读者理解Ribbon在分布式系统中的重要作用。 ... [详细]

蜡笔小新 2024-12-27 16:01:25
go
分页插件3指定到某一页

前言--页数多了以后需要指定到某一页（只做了功能，样式没有细调）html ... [详细]

蜡笔小新 2024-12-27 15:19:01
go
DNN Community 和 Professional 版本的主要差异

本文详细解析了 DotNetNuke (DNN) 的两种主要版本：Community 和 Professional。通过对比两者的功能和附加组件，帮助用户选择最适合其需求的版本。 ... [详细]

蜡笔小新 2024-12-27 13:14:08
go
Transforming the Future of Virtual Worlds

Explore how Matterverse is redefining the metaverse experience, creating immersive and meaningful virtual environments that foster genuine connections and economic opportunities. ... [详细]

蜡笔小新 2024-12-28 09:44:49
go
网络链路质量监控：Smokeping部署与配置

本文详细介绍了如何在Linux系统上安装和配置Smokeping，以实现对网络链路质量的实时监控。通过详细的步骤和必要的依赖包安装，确保用户能够顺利完成部署并优化其网络性能监控。 ... [详细]

蜡笔小新 2024-12-27 19:31:05

Jacky麦麦9

这个家伙很懒，什么也没留下！

Tags | 热门标签

RankList | 热门文章