java链路调用_JAVA线程Disruptor核心链路应用（八）

最新推荐文章于 2023-08-07 14:06:35 发布
最新推荐文章于 2023-08-07 14:06:35 发布
阅读量279 收藏
点赞数
文章标签： java链路调用
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_36087469/article/details/114841285
版权

16795abc0cdae8dafbeaf81239f91bd2.png

0400c45c1079338dd49554799abf6684.png

57743eddd47228b181186c4ee68c261a.png

e83201654f4540f6535c448ed92503c5.png

e44e16d7a41754daa612ddcfd7d3b8e6.png

ac7d50fa7ac24e1b1a8dabc5514fdd25.png

9a1c40c882e6f25ed571c5874e5c9197.png

import java.util.concurrent.atomic.AtomicInteger;

/**

* Disruptor中的 Event

* @author Alienware

*

*/

public class Trade {

private String id;

private String name;

private double price;

//在并发时实现线程安全

private AtomicInteger count = new AtomicInteger(0);

public Trade() {

}

public String getId() {

return id;

}

public void setId(String id) {

this.id = id;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public double getPrice() {

return price;

}

public void setPrice(double price) {

this.price = price;

}

public AtomicInteger getCount() {

return count;

}

public void setCount(AtomicInteger count) {

this.count = count;

}

}

import java.util.Random;

import java.util.concurrent.CountDownLatch;

import com.lmax.disruptor.EventTranslator;

import com.lmax.disruptor.dsl.Disruptor;

public class TradePushlisher implements Runnable {

private Disruptor disruptor;

private CountDownLatch latch;

private static int PUBLISH_COUNT = 1;

public TradePushlisher(CountDownLatch latch, Disruptor disruptor) {

this.disruptor = disruptor;

this.latch = latch;

}

public void run() {

TradeEventTranslator eventTranslator = new TradeEventTranslator();

for(int i =0; i < PUBLISH_COUNT; i ++){

//新的提交任务的方式

disruptor.publishEvent(eventTranslator);

}

latch.countDown();

}

}

class TradeEventTranslator implements EventTranslator {

private Random random = new Random();

public void translateTo(Trade event, long sequence) {

this.generateTrade(event);

}

private void generateTrade(Trade event) {

event.setPrice(random.nextDouble() * 9999);

}

}

import com.lmax.disruptor.EventHandler;

import com.lmax.disruptor.WorkHandler;

public class Handler1 implements EventHandler, WorkHandler{

//EventHandler

public void onEvent(Trade event, long sequence, boolean endOfBatch) throws Exception {

this.onEvent(event);

}

//WorkHandler

public void onEvent(Trade event) throws Exception {

System.err.println("handler 1 : SET NAME");

Thread.sleep(1000);

event.setName("H1");

}

}

import java.util.UUID;

import com.lmax.disruptor.EventHandler;

public class Handler2 implements EventHandler {

public void onEvent(Trade event, long sequence, boolean endOfBatch) throws Exception {

System.err.println("handler 2 : SET ID");

Thread.sleep(2000);

event.setId(UUID.randomUUID().toString());

}

}

import com.lmax.disruptor.EventHandler;

public class Handler3 implements EventHandler {

public void onEvent(Trade event, long sequence, boolean endOfBatch) throws Exception {

System.err.println("handler 3 : NAME: "

+ event.getName()

+ ", ID: "

+ event.getId()

+ ", PRICE: "

+ event.getPrice()

+ " INSTANCE : " + event.toString());

}

}

import com.lmax.disruptor.EventHandler;

public class Handler4 implements EventHandler {

public void onEvent(Trade event, long sequence, boolean endOfBatch) throws Exception {

System.err.println("handler 4 : SET PRICE");

Thread.sleep(1000);

event.setPrice(17.0);

}

}

import com.lmax.disruptor.EventHandler;

public class Handler5 implements EventHandler {

public void onEvent(Trade event, long sequence, boolean endOfBatch) throws Exception {

System.err.println("handler 5 : GET PRICE: " + event.getPrice());

Thread.sleep(1000);

event.setPrice(event.getPrice() + 3.0);

}

}

import java.util.concurrent.CountDownLatch;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import com.lmax.disruptor.BusySpinWaitStrategy;

import com.lmax.disruptor.EventFactory;

import com.lmax.disruptor.RingBuffer;

import com.lmax.disruptor.dsl.Disruptor;

import com.lmax.disruptor.dsl.EventHandlerGroup;

import com.lmax.disruptor.dsl.ProducerType;

public class Main {

@SuppressWarnings("unchecked")

public static void main(String[] args) throws Exception {

//构建一个线程池用于提交任务

ExecutorService es1 = Executors.newFixedThreadPool(1);

ExecutorService es2 = Executors.newFixedThreadPool(5);

//1 构建Disruptor

Disruptor disruptor = new Disruptor(

new EventFactory() {

public Trade newInstance() {

return new Trade();

}

},

1024*1024,

es2,

ProducerType.SINGLE,

new BusySpinWaitStrategy());

//2 把消费者设置到Disruptor中 handleEventsWith

//2.1 串行操作：

disruptor

.handleEventsWith(new Handler1())

.handleEventsWith(new Handler2())

.handleEventsWith(new Handler3());

//2.2 并行操作: 可以有两种方式去进行

//1 handleEventsWith方法 添加多个handler实现即可

//2 handleEventsWith方法 分别进行调用

disruptor.handleEventsWith(new Handler1(), new Handler2(), new Handler3());

disruptor.handleEventsWith(new Handler2());

disruptor.handleEventsWith(new Handler3());

//2.3 菱形操作 (一)

disruptor.handleEventsWith(new Handler1(), new Handler2())

.handleEventsWith(new Handler3());

//2.3 菱形操作 (二)

EventHandlerGroup ehGroup = disruptor.handleEventsWith(new Handler1(), new Handler2());

ehGroup.then(new Handler3());

//2.4 六边形操作

Handler1 h1 = new Handler1();

Handler2 h2 = new Handler2();

Handler3 h3 = new Handler3();

Handler4 h4 = new Handler4();

Handler5 h5 = new Handler5();

disruptor.handleEventsWith(h1, h4);

disruptor.after(h1).handleEventsWith(h2);

disruptor.after(h4).handleEventsWith(h5);

disruptor.after(h2, h5).handleEventsWith(h3);

//3 启动disruptor

RingBuffer ringBuffer = disruptor.start();

//设置唤醒的次数

CountDownLatch latch = new CountDownLatch(1);

long begin = System.currentTimeMillis();

es1.submit(new TradePushlisher(latch, disruptor));

latch.await();//进行向下

disruptor.shutdown();

es1.shutdown();

es2.shutdown();

System.err.println("总耗时: " + (System.currentTimeMillis() - begin));

}

}

多生产者模型：

6e4e532ee62c47b83b6d2fa437853d94.png

多消费者：

149ca490e39bae43eb3850feab5021fe.png

24e94883e3fe720920ba41883eec66cc.png

import java.util.concurrent.atomic.AtomicInteger;

public class Order {

private String id;

private String name;

private double price;

public Order() {

}

public String getId() {

return id;

}

public void setId(String id) {

this.id = id;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public double getPrice() {

return price;

}

public void setPrice(double price) {

this.price = price;

}

}

import com.lmax.disruptor.RingBuffer;

public class Producer {

private RingBuffer ringBuffer;

public Producer(RingBuffer ringBuffer) {

this.ringBuffer = ringBuffer;

}

public void sendData(String uuid) {

long sequence = ringBuffer.next();

try {

Order order = ringBuffer.get(sequence);

order.setId(uuid);

} finally {

ringBuffer.publish(sequence);

}

}

}

import java.util.Random;

import java.util.concurrent.atomic.AtomicInteger;

import com.lmax.disruptor.WorkHandler;

//消费者实现多消费的接口

public class Consumer implements WorkHandler {

private String comsumerId;

private static AtomicInteger count = new AtomicInteger(0);

private Random random = new Random();

public Consumer(String comsumerId) {

this.comsumerId = comsumerId;

}

public void onEvent(Order event) throws Exception {

Thread.sleep(1 * random.nextInt(5));

System.err.println("当前消费者: " + this.comsumerId + ", 消费信息ID: " + event.getId());

count.incrementAndGet();

}

public int getCount(){

return count.get();

}

}

import java.util.UUID;

import java.util.concurrent.CountDownLatch;

import java.util.concurrent.Executors;

import com.lmax.disruptor.EventFactory;

import com.lmax.disruptor.ExceptionHandler;

import com.lmax.disruptor.RingBuffer;

import com.lmax.disruptor.SequenceBarrier;

import com.lmax.disruptor.WorkerPool;

import com.lmax.disruptor.YieldingWaitStrategy;

import com.lmax.disruptor.dsl.ProducerType;

public class Main {

//1 创建RingBuffer

RingBuffer ringBuffer =

RingBuffer.create(ProducerType.MULTI,

new EventFactory() {

public Order newInstance() {

return new Order();

}

},

1024*1024,

new YieldingWaitStrategy());

//2 通过ringBuffer 创建一个屏障

SequenceBarrier sequenceBarrier = ringBuffer.newBarrier();

//3 创建多个消费者数组:

Consumer[] consumers = new Consumer[10];

for(int i = 0; i < consumers.length; i++) {

consumers[i] = new Consumer("C" + i);

}

//4 构建多消费者工作池

WorkerPool workerPool = new WorkerPool(

ringBuffer,

sequenceBarrier,

new EventExceptionHandler(), //在失败的时候怎么处理

consumers);

//5 设置多个消费者的sequence序号 用于单独统计消费进度, 并且设置到ringbuffer中

ringBuffer.addGatingSequences(workerPool.getWorkerSequences());

//6 启动workerPool

workerPool

.start(Executors.newFixedThreadPool(5));

final CountDownLatch latch = new CountDownLatch(1);

for(int i = 0; i < 100; i++) {

final Producer producer = new Producer(ringBuffer);

new Thread(new Runnable() {

public void run() {

try {

latch.await();

} catch (Exception e) {

e.printStackTrace();

}

for(int j = 0; j<100; j++) {

producer.sendData(UUID.randomUUID().toString());

}

}

}).start();

}

Thread.sleep(2000);

System.err.println("----------线程创建完毕，开始生产数据----------");

latch.countDown();

Thread.sleep(10000);

System.err.println("任务总数:" + consumers[2].getCount());

}

static class EventExceptionHandler implements ExceptionHandler {

@Override

public void handleEventException(Throwable ex, long sequence, Order event) {

}

@Override

public void handleOnStartException(Throwable ex) {

}

@Override

public void handleOnShutdownException(Throwable ex) {

}

}

}

e3816a390cf21df08513d870c4e64c80.png

645319e767227bb120a3146cccf2028c.png

756219fdc0f3f2024adf626e0322dccf.png

b92bb2c526021a188c273f48796ffa23.png

2df51998d1678e0f8f1724261f7631b0.png

633fc86db5983aab367437ffacb73a26.png

b8752b9f08e7a11ec73c4cde970b8522.png

0d6d8134b8eb6b4010950ade1d05aa43.png

4c1008144aa2238b9db3ae2392838179.png

120cfba7813b4dc464f9d3f85309b277.png

4f67b1c0a934e078ab849740c7b94131.png

1723fbce94bf69c7ecf2733f3162ac76.png

63950e0b2892655007be96e621036700.png

ee3df41a28ff0c27bd1ae1a7efeefedd.png

1d43a4d3476e55591063642cc89d2e14.png

c4c29492c2b54faa83524bb78a47b32e.png

读读共享、读写互斥、写写互斥

c37227330944924ce87f6d6ea63b340f.png

b1b9d56c2a9663230497a9393cac7558.png

LockSupport :

Thread A = new Thread(new Runnable() {

@Override

public void run() {

int sum = 0;

for(int i =0; i < 10; i ++){

sum += i;

}

try {

Thread.sleep(4000);

} catch (InterruptedException e) {

e.printStackTrace();

}

LockSupport.park();//后执行

System.err.println("sum: " + sum);

}

});

A.start();

Thread.sleep(1000);

LockSupport.unpark(A);//先执行

Executors.newCachedThreadPool();

Executors.newFixedThreadPool(10);

ThreadPoolExecutor pool = new ThreadPoolExecutor(5,

Runtime.getRuntime().availableProcessors() * 2,

60,

TimeUnit.SECONDS,

new ArrayBlockingQueue<>(200),

new ThreadFactory() {

@Override

public Thread newThread(Runnable r) {

Thread t = new Thread(r);

t.setName("order-thread");

if(t.isDaemon()) {

t.setDaemon(false);

}

if(Thread.NORM_PRIORITY != t.getPriority()) {

t.setPriority(Thread.NORM_PRIORITY);

}

return t;

}

},

new RejectedExecutionHandler() {

@Override

public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {

System.err.println("拒绝策略:" + r);

}

});

ReentrantLock reentrantLock = new ReentrantLock(true);

线程池：

ThreadPoolExecutor pool=new ThreadPoolExecutor(

5,

Runtime.getRuntime().availableProcessors()*2,

60,

TimeUnit.SECONDS,

new ArrayBlockingQueue<>(200),

new ThreadFactory() {

@Override

public Thread newThread(Runnable r) {

Thread thread=new Thread(r);

thread.setName("order-thread");

if(thread.isDaemon()){

thread.setDaemon(false);

}

if(Thread.NORM_PRIORITY!=thread.getPriority()){

thread.setPriority(Thread.NORM_PRIORITY);

}

return thread;

}

},

new RejectedExecutionHandler() {

@Override

public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {

System.err.println("拒绝策略："+r);

}

});

AQS架构：

16101613f5562654b406e01e2c1a039f.png

ad8cd0d6b9987ee3b69edf8228630c74.png

8d55161085b916348b625397f4db5d48.png

3748e999ebf5b4b3c1a0e90d60907bbc.png

f04d4c2debfc52c79bc8e91f9e3a77ee.png

ce69b262a88cd12e38608b082c9f8148.png

18a0c1ee9b5b3e39227f811cb739bcea.png

9f369c1ab38a18db9ef7abc645ba625d.png

7c1efcfb2463cd87658039ccff89114e.png

f9197e64b5c03c34198161aef93b5f3f.png

4f1f9de0545fd102f9a4e01994f63f68.png

922afb78cd347e78e84d67f79896940e.png

f82a157f39780e8dcc3cf8e519b8b5b5.png

8279622945e5379c7240cf945def9768.png

966c1e2196f8508e94e51df6957a964b.png

唐晓山
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java工具：高性能并发工具Disruptor简单使用
05-03
Java工具：高性能并发工具Disruptor简单使用
jvm之java程序从编写到执行的结构链路
xuehuagongzi000的博客
04-11 653
jvm之java程序从编写到执行的结构链路 1.java前端编译器负责将java源代码编译为字节码-->前端编译器 2.java虚拟机负责将编译好的字节码装载进内部-->java类加载步骤和运行时区域 3.最后解释/编译为对应平台上的机器指令执行-->jvm执行引擎和垃圾回收GC
java链路调用_面试官：SpringBoot如何实现全链路调用日志跟踪？
weixin_32770297的博客
02-27 535
点击上方蓝色字体，选择“标星公众号”优质文章，第一时间送达作者：何甜甜在吗juejin.im/post/5e79bce5e51d4527235b8878MDC介绍简介：MDC(Mapped Diagnostic Context，映射调试上下文)是 log4j 、logback及log4j2 提供的一种方便在多线程条件下记录日志的功能。MDC 可以看成是一个与当前线程绑定的哈希表，可以往其中添加键值...
Java的链式调用
听海边涛声
08-07 912
Java的链式调用
java调用全链路追踪_Net和Java基于zipkin的全链路追踪
weixin_39785081的博客
02-23 349
在各大厂分布式链路跟踪系统架构对比中已经介绍了几大框架的对比，如果想用免费的可以用zipkin和pinpoint还有一个忘了介绍：SkyWalking，具体介绍可参考：https://github.com/apache/incubator-skywalking/blob/master/README_ZH.md由于追踪的要求是Net平台和Java平台都要支持，对于java平台各组件都是天生的支持的，...
java 链式调用原理
weixin_55029563的博客
11-20 890
首先来看这么一段代码： 这串代码可以这样使用链式调用： 最后打印的结果是：其实就是函数调用，的时候返回一个Chain类型数据，然后这个数据类型中是存在put方法的，所以第一次调用put是成功的，put方法中还存在一个，这个this指针指向当前类，也就是返回了一个类对象，所以还是可以调用put方法，来再多的都是可以调用的。
disruptor高性能Java线程间通讯库
08-06
disruptor：高性能Java线程间通讯库
rxmax:LMAX Disruptor使Rx Java最大化
05-11
最大值 LMAX Disruptor使Rx Java最大化
java_learning_practice：java进阶之路：面试高频算法，akka，多线程，NIO，Netty，SpringBoot，Spark && Flink等
01-30
不定期更新pdf一些算法，语言方面的练习算法：leetcode，nowcoder，swordoffer，以及算法红皮书等语言技术：kotlin，java8函数式，多线程等框架：akka，zookeeper，Disruptor等核心网springboot相关练习球衣封装...
tiny_disruptor:简化的[disruptor]（https
05-16
tiny_disruptor 简化的实践破坏者
java中链式方法,JAVA中实现链式操作（方法链）的简单例子
weixin_33838896的博客
03-13 575
在使用jQuery时候，我们经常会看到或者使用到方法链，例如：$("#p1").css("color","red").slideUp(2000).slideDown(2000);这段代码的意思是选择器选择id为p1的html标签，颜色变红，之后slideup，再slidedown。自然是可以将这几个方法分开写，但是不分开的话不仅有很好的易读性，代码量也会有减少，那么何乐而不为？这种调用函数的方式在...
RxJava(一) — 链路调用流程分析
Elson的博客
05-30 860
RxJava 是一个响应式编程框架，里面代码比较复杂，本系列文章将从以下几个角度来分析这个框架。 1. RxJava 的链路调用流程。 2. RxJava 的常用操作符 map、flatmap。 3. RxJava 的线程调度。 4. 自己实现一个简易版的响应式框架。
android手机应用源码Imsdroid语音视频通话源码.rar
05-20
android手机应用源码Imsdroid语音视频通话源码.rar
营销计划汇报PPT，市场品牌 推广渠道 产品 营销策略tbb.pptx
05-20
营销计划汇报PPT，市场品牌 推广渠道 产品 营销策略tbb.pptx
JavaScript_超过100种语言的纯Javascript OCR.zip
05-20
JavaScript
JavaScript_跨平台React UI包.zip
05-20
JavaScript
node-v16.17.0-headers.tar.xz
最新发布
05-20
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外，Node.js使用了模块化的架构，通过npm（Node package manager，Node包管理器）,社区成员可以共享和复用代码，极大地促进了Node.js生态系统的发展和扩张。 Node.js不仅用于服务器端开发。随着技术的发展，它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等，因此，开发者可以用JavaScript编写全栈应用程序，这一点大大提高了开发效率和便捷性。 在实践中，许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台，如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
520表白代码.rar
05-20
520表白html5爱心代码
一个简单的HTML5和CSS代码示例，用于创建一个动态的爱心形状，并在网页上展示一个类似520表白的消息 这个示例使用了CSS的
05-20
520表白html5爱心代码 一个简单的HTML5和CSS代码示例，用于创建一个动态的爱心形状，并在网页上展示一个类似520表白的消息。这个示例使用了CSS的动画效果和HTML的结构。
disruptor框架为什么不流行_Java并发编程框架Disruptor
06-07
Disruptor框架之所以没有像其他一些Java并发编程框架那样流行，可能有以下几个原因： 1. 学习曲线较陡峭：Disruptor框架的设计思路比较独特，需要一定的时间和精力去理解和掌握，对于不熟悉该框架的开发者来说，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值