[置顶]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

推荐阅读

window
PHP与MySQL实现高效分页查询

本文探讨了如何在PHP与MySQL环境中实现高效的分页查询，包括基本的分页实现、性能优化技巧以及高级的分页策略。 ... [详细]

蜡笔小新 2024-11-22 05:45:48
io
Struts2 + json+ jquery 实现三级联动action和jsp代码竟然有小红叉，提示缺双引号，检查了转义符号也没缺啊，求解

publicclassBindActionextendsActionSupport{privateStringproString;privateStringcitString; ... [详细]

蜡笔小新 2024-11-21 16:25:41
less
Java Socket编程指南：构建多客户端支持的服务端

本文基于Java官方文档进行了适当修改，旨在介绍如何实现一个能够同时处理多个客户端请求的服务端程序。在前文中，我们探讨了单客户端访问的服务端实现，而本篇将深入讲解多客户端环境下的服务端设计与实现。 ... [详细]

蜡笔小新 2024-11-22 23:16:34
io
Java程序设计复习题

1、编写一个Java程序在屏幕上输出“你好！”。programmenameHelloworld.javapublicclassHelloworld{publicst ... [详细]

蜡笔小新 2024-11-22 20:05:03
io
深入理解线程池及其基本实现

本文探讨了线程池的概念、优势及其在Java中的应用。通过实例分析不同类型的线程池，并指导如何构建一个简易的线程池。 ... [详细]

蜡笔小新 2024-11-22 18:52:32
object
解析 .NET 中的 AJAX 技术

Asynchronous JavaScript and XML (AJAX) 的流行很大程度上得益于 Google 在其产品如 Google Suggest 和 Google Maps 中的应用。本文将深入探讨 AJAX 在 .NET 环境下的工作原理及其实现方法。 ... [详细]

蜡笔小新 2024-11-22 18:18:57
search
WPF菜单控件前景与背景颜色设置指南

尽管在WPF中工作了一段时间，但在菜单控件的样式设置上遇到了一些基础问题，特别是关于如何正确配置前景色和背景色。 ... [详细]

蜡笔小新 2024-11-22 15:30:54
io
Android 中的布局方式之线性布局

nsitionalENhttp:www.w3.orgTRxhtml1DTDxhtml1-transitional.dtd ... [详细]

蜡笔小新 2024-11-22 11:20:34
usb
Java TCP 并发处理：连接数、请求数与用户数解析

本文详细探讨了在Java TCP编程中，如何理解和测量并发连接数、请求数及并发用户数，并提供了实际应用中的测试方法和优化建议。 ... [详细]

蜡笔小新 2024-11-22 11:06:05
io
Zabbix自定义监控与邮件告警配置实践

本文详细介绍了如何在Zabbix中添加自定义监控项目，配置邮件告警功能，并解决测试告警时遇到的邮件不发送问题。 ... [详细]

蜡笔小新 2024-11-22 08:33:19
io
Maven + Spring + MyBatis + MySQL 环境搭建与实例解析

本文详细介绍如何使用MySQL数据库进行环境搭建，包括创建数据库表并插入示例数据。随后，逐步指导如何配置Maven项目，整合Spring框架与MyBatis，实现高效的数据访问。 ... [详细]

蜡笔小新 2024-11-21 18:39:23
object
如何使用 org.apache.tinkerpop.gremlin.structure.VertexProperty 的 key 方法

本文详细介绍了 `org.apache.tinkerpop.gremlin.structure.VertexProperty` 类中的 `key()` 方法，并提供了多个实际应用的代码示例。通过这些示例，读者可以更好地理解该方法在图数据库操作中的具体用途。 ... [详细]

蜡笔小新 2024-11-21 17:38:10
io
Beetl模板引擎初探

Beetl是一款先进的Java模板引擎，以其丰富的功能、直观的语法、卓越的性能和易于维护的特点著称。它不仅适用于高响应需求的大型网站，也适合功能复杂的CMS管理系统，提供了一种全新的模板开发体验。 ... [详细]

蜡笔小新 2024-11-21 16:57:10
import
Java 中的十进制样式 getZeroDigit()方法，示例

Java 中的十进制样式 getZeroDigit()方法，示例 ... [详细]

蜡笔小新 2024-11-21 16:53:03
include
Singleton单例模式和DoubleChecked Locking双重检查锁定模式

问题描述现在，不管开发一个多大的系统（至少我现在的部门是这样的），都会带一个日志功能；在实际开发过程中 ... [详细]

蜡笔小新 2024-11-21 15:14:45

Jacky麦麦9

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

Tags | 热门标签

RankList | 热门文章