Disruptor实际应用示例
简介
Disruptor它是一个开源的并发框架,并获得2011 Duke’s 程序框架创新奖,能够在无锁的情况下实现Queue并发操作。同学们代码中是否会使用到BlockingQueue<?> queue用于缓存通知消息呢?本文介绍的Disruptor则可以完全取代BlockingQueue,带来更快的速度。其它简单内容可能参考百度,熟悉此类需求的同学知道,我们需要两类核心概念功能,一类是事件,一类是针对事件的处理器。
下图为比较常用的的一类使用:
告警处理需求
如果你用过ODL,那你应该知道ODL中串联起整个系统的神经是notification,ODL使用的正是disruptor。我们的原始需求为,一个系统中有很多告警信息,如资源不足、数据异常、业务异常等,系统中需要针对上述的这些异常有对应的处理逻辑。
分析后需明确的是:
- 告警信息
- 处理逻辑
告警信息
在disruptor中实例化的构造函数中,需要指定消息的类型或工厂,如下:
disruptor = new Disruptor<Event>(Event.FACTORY,
4 * 4, executor, ProducerType.SINGLE,
new BlockingWaitStrategy());
为了能够通用,毕竟系统的disruptor是想处理任务消息的,而不仅仅是告警信息。所以定义了一个通用的消息结构,而不同的具体消息封装在其中。如下:
package com.zte.sunquan.demo.disruptor.event;
import com.lmax.disruptor.EventFactory;
public class Event<T> {
public static final EventFactory<Event> FACTORY = new EventFactory<Event>() {
@Override
public Event newInstance() {
return new Event();
}
};
private T value;
private Event() {
}
public Event(T value) {
this.value = value;
}
public void setValue(T value) {
this.value = value;
}
public T getValue() {
return value;
}
}
而告警消息的结构则为:
package com.zte.sunquan.demo.disruptor.main;
public class AlarmEvent {
private AlarmType value;
public AlarmEvent(AlarmType value) {
this.value = value;
}
enum AlarmType {
NO_POWER, HARDWARE_DAMAGE, SOFT_DAMAGE;
}
public AlarmType getValue() {
return value;
}
}
在构建往disruptor发送的消息时,进行AlarmEvent的封装。
Event commEvent = new Event(event);
处理器
在完成了消息的定义后,下面则需要定义消息的处理器,这里利用了**@Handler**注解用于定义处理器。
package com.zte.sunquan.demo.disruptor.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* Created by 10184538 on 2018/9/10.
*/
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface Handler {
String value() default "toString";
}
通过注解可以方便地在系统的各个地方定义消息处理模块。示例处理逻辑如下:
package com.zte.sunquan.demo.disruptor.main;
import com.zte.sunquan.demo.disruptor.annotation.Handler;
import com.zte.sunquan.demo.disruptor.handler.AbstractEventHandler;
@Handler
public class AlarmEventHandler extends AbstractEventHandler<AlarmEvent> {
@Override
public void handler(AlarmEvent alarmEvent) {
AlarmEvent.AlarmType alarmType = alarmEvent.getValue();
System.out.println("Got alarm:" + alarmType.name());
switch (alarmType) {
case NO_POWER:
System.out.println("charging");
break;
case HARDWARE_DAMAGE:
System.out.println("repair");
break;
case SOFT_DAMAGE:
System.out.println("reinstall");
break;
default:
System.out.println("ignore");
break;
}
}
}
调度
至此有了消息和消息处理逻辑,如何将两者通过disruptor串联起来?
DisruptorApplication
定义该类,作为调试的核心,继承了AbstractApplication
代码参考:
package com.zte.sunquan.demo.disruptor;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.Set;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import com.lmax.disruptor.BlockingWaitStrategy;
import com.lmax.disruptor.EventHandler;
import com.lmax.disruptor.dsl.Disruptor;
import com.lmax.disruptor.dsl.ProducerType;
import com.zte.sunquan.demo.disruptor.event.Event;
import com.zte.sunquan.demo.disruptor.handler.EventHandlerProcess;
import com.zte.sunquan.demo.thread.UserThreadFactory;
public class AbstractApplication {
private static final int CPUS = Runtime.getRuntime().availableProcessors();
private static final UserThreadFactory threadFactory = UserThreadFactory.build("disruptor-test");
private ExecutorService executor;
protected Disruptor<Event> disruptor;
private EventHandlerProcess process = new EventHandlerProcess();
private Class eventClass;
public AbstractApplication(Class eventClass) {
this.eventClass = eventClass;
init();
try {
process();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}
public void init() {
executor = Executors.newFixedThreadPool(CPUS * 2, threadFactory);
disruptor = new Disruptor<Event>(Event.FACTORY,
4 * 4, executor, ProducerType.SINGLE,
new BlockingWaitStrategy());
}
private void process() throws InstantiationException, IllegalAccessException {
Set<EventHandler> eventHandlers = process.scanHandlers();
for (EventHandler handler : eventHandlers) {
// if (filterHandler(handler)) {
disruptor.handleEventsWith(handler);
// }
}
disruptor.start();
}
private boolean filterHandler(EventHandler handler) {
if (handler != null) {
//继承类
Type genericSuperclass = handler.getClass().getGenericSuperclass();
if(genericSuperclass==Object.class)
return false;
ParameterizedType parameterizedType = (ParameterizedType) genericSuperclass;
//实现接口handler.getClass().getGenericInterfaces()
Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
return actualTypeArguments[0] == eventClass;
}
return false;
}
public void close() {
disruptor.shutdown();
executor.shutdown();
}
}
package com.zte.sunquan.demo.disruptor;
import com.zte.sunquan.demo.disruptor.event.Event;
/**
* Created by 10184538 on 2018/9/10.
*/
public class DisruptorApplication extends AbstractApplication {
public DisruptorApplication(Class eventClass) {
super(eventClass);
}
public <T> void publishEvent(T event) {
Event commEvent = new Event(event);
final long seq = disruptor.getRingBuffer().next();
Event userEvent = (Event) disruptor.get(seq);
userEvent.setValue(commEvent.getValue());
disruptor.getRingBuffer().publish(seq);
}
}
EventHandlerProcess
需要注意的是在AbstractApplicaton的process中借助EventHandlerProcess处理**@Handler**注解,具体逻辑如下:
package com.zte.sunquan.demo.disruptor.handler;
import java.lang.annotation.Annotation;
import java.util.Arrays;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;
import com.google.common.base.Preconditions;
import com.lmax.disruptor.EventHandler;
import com.zte.sunquan.demo.disruptor.annotation.Handler;
import com.zte.sunquan.demo.disruptor.util.ClassUtil;
/**
* Created by 10184538 on 2018/9/10.
*/
public class EventHandlerProcess {
public Set<EventHandler> scanHandlers(){
List<Class<?>> clsList = ClassUtil
.getAllClassByPackageName("com.zte.sunquan.demo.disruptor");
return clsList.stream()
.filter(p->p.getAnnotation(Handler.class)!=null)
.map(c-> {
try {
return (EventHandler)c.newInstance();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
return null;
})
.collect(Collectors.toSet());
}
public EventHandler scanJavaClass(Class cls) throws IllegalAccessException, InstantiationException {
Annotation annotation = cls.getAnnotation(Handler.class);
if (annotation != null) {
Object instance = cls.newInstance();
//是否可以做成动态字节码生成,框架内部完成接口类的实现
Preconditions.checkState(instance instanceof EventHandler);
return (EventHandler) instance;
}
return null;
}
public static void main(String[] args) throws InstantiationException, IllegalAccessException {
String classPath = (String) System.getProperties().get("java.class.path");
List<String> packages = Arrays.stream(classPath.split(";")).filter(p -> p.contains("demo-disruptor-project")).collect(Collectors.toList());
//List<Class<?>> clsList = ClassUtil.getAllClassByPackageName(BlackPeople.class.getPackage());
List<Class<?>> clsList = ClassUtil.getAllClassByPackageName("com.zte.sunquan.demo.disruptor");
System.out.println(clsList);
// EventHandlerProcess process = new EventHandlerProcess();
// EventHandler eventHandler = process.scanJavaClass(LogEventHandler.class);
// System.out.println(eventHandler);
// Properties properties = System.getProperties();
// System.out.println(properties);
}
}
ClassUtil
用于查找加了@Handler注解类,该方式可以进一步优先,直接搜索class路径下的所有类,而不是指定文件夹里的。
package com.zte.sunquan.demo.disruptor.util;
import java.io.File;
import java.io.FileFilter;
import java.io.IOException;
import java.net.JarURLConnection;
import java.net.URL;
import java.net.URLDecoder;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.List;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;
public class ClassUtil {
public static List<Class<?>> getAllClassByPackageName(String packageName) {
// 获取当前包下以及子包下所以的类
List<Class<?>> returnClassList = getClasses(packageName);
return returnClassList;
}
/**
* 通过包名获取包内所有类
*
* @param pkg
* @return
*/
public static List<Class<?>> getAllClassByPackageName(Package pkg) {
String packageName = pkg.getName();
// 获取当前包下以及子包下所以的类
List<Class<?>> returnClassList = getClasses(packageName);
return returnClassList;
}
/**
* 通过接口名取得某个接口下所有实现这个接口的类
*/
public static List<Class<?>> getAllClassByInterface(Class<?> c) {
List<Class<?>> returnClassList = null;
if (c.isInterface()) {
// 获取当前的包名
String packageName = c.getPackage().getName();
// 获取当前包下以及子包下所以的类
List<Class<?>> allClass = getClasses(packageName);
if (allClass != null) {
returnClassList = new ArrayList<Class<?>>();
for (Class<?> cls : allClass) {
// 判断是否是同一个接口
if (c.isAssignableFrom(cls)) {
// 本身不加入进去
if (!c.equals(cls)) {
returnClassList.add(cls);
}
}
}
}
}
return returnClassList;
}
/**
* 取得某一类所在包的所有类名 不含迭代
*/
public static String[] getPackageAllClassName(String classLocation, String packageName) {
// 将packageName分解
String[] packagePathSplit = packageName.split("[.]");
String realClassLocation = classLocation;
int packageLength = packagePathSplit.length;
for (int i = 0; i < packageLength; i++) {
realClassLocation = realClassLocation + File.separator + packagePathSplit[i];
}
File packeageDir = new File(realClassLocation);
if (packeageDir.isDirectory()) {
String[] allClassName = packeageDir.list();
return allClassName;
}
return null;
}
/**
* 从包package中获取所有的Class
*
* @param pack
* @return
*/
private static List<Class<?>> getClasses(String packageName) {
// 第一个class类的集合
List<Class<?>> classes = new ArrayList<Class<?>>();
// 是否循环迭代
boolean recursive = true;
// 获取包的名字 并进行替换
String packageDirName = packageName.replace('.', '/');
// 定义一个枚举的集合 并进行循环来处理这个目录下的things
Enumeration<URL> dirs;
try {
dirs = Thread.currentThread().getContextClassLoader().getResources(packageDirName);
// 循环迭代下去
while (dirs.hasMoreElements()) {
// 获取下一个元素
URL url = dirs.nextElement();
// 得到协议的名称
String protocol = url.getProtocol();
// 如果是以文件的形式保存在服务器上
if ("file".equals(protocol)) {
// 获取包的物理路径
String filePath = URLDecoder.decode(url.getFile(), "UTF-8");
// 以文件的方式扫描整个包下的文件 并添加到集合中
findAndAddClassesInPackageByFile(packageName, filePath, recursive, classes);
} else if ("jar".equals(protocol)) {
// 如果是jar包文件
// 定义一个JarFile
JarFile jar;
try {
// 获取jar
jar = ((JarURLConnection) url.openConnection()).getJarFile();
// 从此jar包 得到一个枚举类
Enumeration<JarEntry> entries = jar.entries();
// 同样的进行循环迭代
while (entries.hasMoreElements()) {
// 获取jar里的一个实体 可以是目录 和一些jar包里的其他文件 如META-INF等文件
JarEntry entry = entries.nextElement();
String name = entry.getName();
// 如果是以/开头的
if (name.charAt(0) == '/') {
// 获取后面的字符串
name = name.substring(1);
}
// 如果前半部分和定义的包名相同
if (name.startsWith(packageDirName)) {
int idx = name.lastIndexOf('/');
// 如果以"/"结尾 是一个包
if (idx != -1) {
// 获取包名 把"/"替换成"."
packageName = name.substring(0, idx).replace('/', '.');
}
// 如果可以迭代下去 并且是一个包
if ((idx != -1) || recursive) {
// 如果是一个.class文件 而且不是目录
if (name.endsWith(".class") && !entry.isDirectory()) {
// 去掉后面的".class" 获取真正的类名
String className = name.substring(packageName.length() + 1, name.length() - 6);
try {
// 添加到classes
classes.add(Class.forName(packageName + '.' + className));
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
}
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
} catch (IOException e) {
e.printStackTrace();
}
return classes;
}
/**
* 以文件的形式来获取包下的所有Class
*
* @param packageName
* @param packagePath
* @param recursive
* @param classes
*/
private static void findAndAddClassesInPackageByFile(String packageName, String packagePath, final boolean recursive, List<Class<?>> classes) {
// 获取此包的目录 建立一个File
File dir = new File(packagePath);
// 如果不存在或者 也不是目录就直接返回
if (!dir.exists() || !dir.isDirectory()) {
return;
}
// 如果存在 就获取包下的所有文件 包括目录
File[] dirfiles = dir.listFiles(new FileFilter() {
// 自定义过滤规则 如果可以循环(包含子目录) 或则是以.class结尾的文件(编译好的java类文件)
public boolean accept(File file) {
return (recursive && file.isDirectory()) || (file.getName().endsWith(".class"));
}
});
// 循环所有文件
for (File file : dirfiles) {
// 如果是目录 则继续扫描
if (file.isDirectory()) {
findAndAddClassesInPackageByFile(packageName + "." + file.getName(), file.getAbsolutePath(), recursive, classes);
} else {
// 如果是java类文件 去掉后面的.class 只留下类名
String className = file.getName().substring(0, file.getName().length() - 6);
try {
// 添加到集合中去
classes.add(Class.forName(packageName + '.' + className));
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
}
}
测试
用例为:
package com.zte.sunquan.demo.disruptor.main;
import org.junit.After;
import org.junit.Before;
import com.zte.sunquan.demo.disruptor.DisruptorApplication;
public class Test {
private DisruptorApplication application;
@Before
public void setUp() {
application = new DisruptorApplication(AlarmEvent.class);
}
@org.junit.Test
public void testDisruptor() throws InterruptedException {
//1.准备AlarmEvent
AlarmEvent event = new AlarmEvent(AlarmEvent.AlarmType.HARDWARE_DAMAGE);
//2.发送AlarmEvent
application.publishEvent(event);
}
@org.junit.Test
public void testDisruptor2() throws InterruptedException {
for (int i = 0; i < 100; i++) {
AlarmEvent event = new AlarmEvent(AlarmEvent.AlarmType.NO_POWER);
application.publishEvent(event);
}
}
@After
public void after() throws InterruptedException {
Thread.sleep(1000);
application.close();
}
}
在AbstractApplication中filterHandler用于对消息过滤,因为按上面的实现一个disruptor只能处理一类消息,相关泛型被擦出,无法匹配判断。所以用例中使用
new DisruptorApplication(AlarmEvent.class);
将类型信息显示的传入。
如果做到这一步,虽然满足了要求,但功能太过封闭。其它的消息类型如果增加?按上述方式,只能重新定义DisruptorApplication。
AbstractEventHandler
在该类中增加了filter方法
public abstract class AbstractEventHandler<T> implements EventHandler<Event<T>> {
@Override
public void onEvent(Event<T> tEvent, long l, boolean b) throws Exception {
if(filter(tEvent)) {
T t = tEvent.getValue();
handler(t);
}
}
public boolean filter(Event event){
return false;
}
public abstract void handler(T t);
}
这就要求每个消息处理类,都要显示的指定自身能处理的消息
@Handler
public class UnknownEventHandler extends AbstractEventHandler<OtherEvent> {
@Override
public boolean filter(Event event) {
if (event.getValue().getClass() == OtherEvent.class) {
return true;
}
return false;
}
在AlarmEventHandler中增加filter
@Handler
public class AlarmEventHandler extends AbstractEventHandler<AlarmEvent> {
@Override
public boolean filter(Event event) {
if (event.getValue().getClass() == AlarmEvent.class) {
return true;
}
return false;
}
新的测试用例为:
@org.junit.Test
public void testDisruptorSuper() throws InterruptedException {
application = new DisruptorApplication();
//1.准备AlarmEvent
AlarmEvent event = new AlarmEvent(AlarmEvent.AlarmType.HARDWARE_DAMAGE);
//2.发送AlarmEvent
application.publishEvent(event);
}
看到构造函数DisruptorApplication中去掉了入参,同时AlarmEventHandler正确处理了消息。
也许你会好奇ODL中是如何做的,他系统范围内也只有一个Disruptor,在ODL中,disruptor的Handler只是作了转发Handler,该Handler的工作才是寻找对应的EventHandler。
ODL实现
private DOMNotificationRouter(final ExecutorService executor, final int queueDepth, final WaitStrategy strategy) {
this.executor = Preconditions.checkNotNull(executor);
disruptor = new Disruptor<>(DOMNotificationRouterEvent.FACTORY, queueDepth, executor, ProducerType.MULTI, strategy);
disruptor.handleEventsWith(DISPATCH_NOTIFICATIONS);
disruptor.after(DISPATCH_NOTIFICATIONS).handleEventsWith(NOTIFY_FUTURE);
disruptor.start();
}
而Handler的onEvent为
private static final EventHandler<DOMNotificationRouterEvent> DISPATCH_NOTIFICATIONS = new EventHandler<DOMNotificationRouterEvent>() {
@Override
public void onEvent(final DOMNotificationRouterEvent event, final long sequence, final boolean endOfBatch) throws Exception {
event.deliverNotification();
onEvnetCount.incrementAndGet();
}
};
默认先执行了** event.deliverNotification()**,注意是event中的方法,具体实现:
void deliverNotification() {
LOG.trace("Start delivery of notification {}", notification);
for (ListenerRegistration<? extends DOMNotificationListener> r : subscribers) {
final DOMNotificationListener listener = r.getInstance();
if (listener != null) {
try {
LOG.trace("Notifying listener {}", listener);
listener.onNotification(notification);
LOG.trace("Listener notification completed");
} catch (Exception e) {
LOG.error("Delivery of notification {} caused an error in listener {}", notification, listener, e);
}
}
}
LOG.trace("Delivery completed");
}
可以看到其在一个subscribers的列表中寻找对应的Listenen进行方法调用执行。
看到这,应该明白了ODL的handler只简单负责转换,真正的选择执行对象在** event.deliverNotification()**,那一个事件,如何知道有哪些定阅者呢?必然要存在一个定阅或注册的过程。代码如下:
@Override
public synchronized <T extends DOMNotificationListener> ListenerRegistration<T> registerNotificationListener(final T listener, final Collection<SchemaPath> types) {
final ListenerRegistration<T> reg = new AbstractListenerRegistration<T>(listener) {
@Override
protected void removeRegistration() {
final ListenerRegistration<T> me = this;
synchronized (DOMNotificationRouter.this) {
replaceListeners(ImmutableMultimap.copyOf(Multimaps.filterValues(listeners, new Predicate<ListenerRegistration<? extends DOMNotificationListener>>() {
@Override
public boolean apply(final ListenerRegistration<? extends DOMNotificationListener> input) {
if (input == me) {
logDomNotificationChanges(listener, null, "removed");
}
return input != me;
}
})));
}
}
};
if (!types.isEmpty()) {
final Builder<SchemaPath, ListenerRegistration<? extends DOMNotificationListener>> b = ImmutableMultimap.builder();
b.putAll(listeners);
for (final SchemaPath t : types) {
b.put(t, reg);
logDomNotificationChanges(listener, t, "added");
}
replaceListeners(b.build());
}
return reg;
}
根据YANG中定义的scheam进行了注册。这样在Notification注册时,则绑定好了事件类型与处理逻辑的对应关系。而在封装消息时,将subscribe传递给了event如下:
private ListenableFuture<Void> publish(final long seq, final DOMNotification notification, final Collection<ListenerRegistration<? extends DOMNotificationListener>> subscribers) {
final DOMNotificationRouterEvent event = disruptor.get(seq);
final ListenableFuture<Void> future = event.initialize(notification, subscribers);
logDomNotificationExecute(subscribers, notification, seq, "publish");
disruptor.getRingBuffer().publish(seq);
publishCount.incrementAndGet();
return future;
}
与上文的实现方式相比,避免了每一个消息,都进行全范围的Handler的filter判断。