Disruptor与Netty实现百万级（十）

实体对象：

import java.io.Serializable;

public class TranslatorData implements Serializable {

	private static final long serialVersionUID = 8763561286199081881L;

	private String id;

	private String name;

	private String message;	//传输消息体内容

	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 String getMessage() {

		return message;

	}

	public void setMessage(String message) {

		this.message = message;

	}

}

import com.bfxy.codec.MarshallingCodeCFactory;

import io.netty.bootstrap.ServerBootstrap;

import io.netty.buffer.PooledByteBufAllocator;

import io.netty.channel.AdaptiveRecvByteBufAllocator;

import io.netty.channel.ChannelFuture;

import io.netty.channel.ChannelInitializer;

import io.netty.channel.ChannelOption;

import io.netty.channel.EventLoopGroup;

import io.netty.channel.nio.NioEventLoopGroup;

import io.netty.channel.socket.SocketChannel;

import io.netty.channel.socket.nio.NioServerSocketChannel;

import io.netty.handler.logging.LogLevel;

import io.netty.handler.logging.LoggingHandler;

public class NettyServer {

	public NettyServer() {

		//1. 创建两个工作线程组: 一个用于接受网络请求的线程组. 另一个用于实际处理业务的线程组

		EventLoopGroup bossGroup = new NioEventLoopGroup();

		EventLoopGroup workGroup = new NioEventLoopGroup();

		//2 辅助类

		ServerBootstrap serverBootstrap = new ServerBootstrap();

		try {

			serverBootstrap.group(bossGroup, workGroup)

			.channel(NioServerSocketChannel.class)

			.option(ChannelOption.SO_BACKLOG, 1024)

			//表示缓存区动态调配（自适应）

			.option(ChannelOption.RCVBUF_ALLOCATOR, AdaptiveRecvByteBufAllocator.DEFAULT)

			//缓存区 池化操作

			.option(ChannelOption.ALLOCATOR, PooledByteBufAllocator.DEFAULT)

			//日志

			.handler(new LoggingHandler(LogLevel.INFO))

			.childHandler(new ChannelInitializer<SocketChannel>() {

				@Override

				protected void initChannel(SocketChannel sc) throws Exception {

					//向管道中添加拦截器

					sc.pipeline().addLast(MarshallingCodeCFactory.buildMarshallingDecoder());

					sc.pipeline().addLast(MarshallingCodeCFactory.buildMarshallingEncoder());

					sc.pipeline().addLast(new ServerHandler());

				}

			});

			//绑定端口，同步等等请求连接

			ChannelFuture cf = serverBootstrap.bind(8765).sync();

			System.err.println("Server Startup...");

			cf.channel().closeFuture().sync();

		} catch (InterruptedException e) {

			e.printStackTrace();

		} finally {

			//优雅停机

			bossGroup.shutdownGracefully();

			workGroup.shutdownGracefully();

			System.err.println("Sever ShutDown...");

		}

	}

}

import com.bfxy.disruptor.MessageProducer;

import com.bfxy.disruptor.RingBufferWorkerPoolFactory;

import com.bfxy.entity.TranslatorData;

import io.netty.channel.ChannelHandlerContext;

import io.netty.channel.ChannelInboundHandlerAdapter;

public class ServerHandler extends ChannelInboundHandlerAdapter {

    @Override

    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {

    	/**

    	TranslatorData request = (TranslatorData)msg;

    	System.err.println("Sever端: id= " + request.getId()

    					+ ", name= " + request.getName()

    					+ ", message= " + request.getMessage());

    	//数据库持久化操作 IO读写 ---> 交给一个线程池 去异步的调用执行

    	TranslatorData response = new TranslatorData();

    	response.setId("resp: " + request.getId());

    	response.setName("resp: " + request.getName());

    	response.setMessage("resp: " + request.getMessage());

    	//写出response响应信息:

    	ctx.writeAndFlush(response);

    	*/

    	TranslatorData request = (TranslatorData)msg;

    	//自已的应用服务应该有一个ID生成规则

    	String producerId = "code:sessionId:001";

    	MessageProducer messageProducer = RingBufferWorkerPoolFactory.getInstance().getMessageProducer(producerId);

    	messageProducer.onData(request, ctx);

    }

}

import com.bfxy.disruptor.MessageConsumer;

import com.bfxy.entity.TranslatorData;

import com.bfxy.entity.TranslatorDataWapper;

import io.netty.channel.ChannelHandlerContext;

public class MessageConsumerImpl4Server extends MessageConsumer {

	public MessageConsumerImpl4Server(String consumerId) {

		super(consumerId);

	}

	public void onEvent(TranslatorDataWapper event) throws Exception {

		TranslatorData request = event.getData();

		ChannelHandlerContext ctx = event.getCtx();

		//1.业务处理逻辑:

    	System.err.println("Sever端: id= " + request.getId()

		+ ", name= " + request.getName()

		+ ", message= " + request.getMessage());

    	//2.回送响应信息:

    	TranslatorData response = new TranslatorData();

    	response.setId("resp: " + request.getId());

    	response.setName("resp: " + request.getName());

    	response.setMessage("resp: " + request.getMessage());

    	//写出response响应信息:

    	ctx.writeAndFlush(response);

	}

}

　　客户端：

import com.bfxy.codec.MarshallingCodeCFactory;

import com.bfxy.entity.TranslatorData;

import io.netty.bootstrap.Bootstrap;

import io.netty.bootstrap.ServerBootstrap;

import io.netty.buffer.PooledByteBufAllocator;

import io.netty.channel.AdaptiveRecvByteBufAllocator;

import io.netty.channel.Channel;

import io.netty.channel.ChannelFuture;

import io.netty.channel.ChannelInitializer;

import io.netty.channel.ChannelOption;

import io.netty.channel.EventLoopGroup;

import io.netty.channel.nio.NioEventLoopGroup;

import io.netty.channel.socket.SocketChannel;

import io.netty.channel.socket.nio.NioServerSocketChannel;

import io.netty.channel.socket.nio.NioSocketChannel;

import io.netty.handler.logging.LogLevel;

import io.netty.handler.logging.LoggingHandler;

public class NettyClient {

	public static final String HOST = "127.0.0.1";

	public static final int PORT = 8765;

	//扩展 完善 池化: ConcurrentHashMap<KEY -> String, Value -> Channel>

	private Channel channel;	

	//1. 创建工作线程组: 用于实际处理业务的线程组

	private EventLoopGroup workGroup = new NioEventLoopGroup();

	private ChannelFuture cf;

	public NettyClient() {

		this.connect(HOST, PORT);

	}

	private void connect(String host, int port) {

		//2 辅助类(注意Client 和 Server 不一样)

		Bootstrap bootstrap = new Bootstrap();

		try {

			bootstrap.group(workGroup)

			.channel(NioSocketChannel.class)

			//表示缓存区动态调配（自适应）

			.option(ChannelOption.RCVBUF_ALLOCATOR, AdaptiveRecvByteBufAllocator.DEFAULT)

			//缓存区 池化操作

			.option(ChannelOption.ALLOCATOR, PooledByteBufAllocator.DEFAULT)

			.handler(new LoggingHandler(LogLevel.INFO))

			.handler(new ChannelInitializer<SocketChannel>() {

				@Override

				protected void initChannel(SocketChannel sc) throws Exception {

					sc.pipeline().addLast(MarshallingCodeCFactory.buildMarshallingDecoder());

					sc.pipeline().addLast(MarshallingCodeCFactory.buildMarshallingEncoder());

					sc.pipeline().addLast(new ClientHandler());

				}

			});

			//绑定端口，同步等等请求连接

			this.cf = bootstrap.connect(host, port).sync();

			System.err.println("Client connected...");

			//接下来就进行数据的发送, 但是首先我们要获取channel:

			this.channel = cf.channel();

		} catch (InterruptedException e) {

			e.printStackTrace();

		}

	}

	//发送数据

	public void sendData(){

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

			TranslatorData request = new TranslatorData();

			request.setId("" + i);

			request.setName("请求消息名称 " + i);

			request.setMessage("请求消息内容 " + i);

			this.channel.writeAndFlush(request);

		}

	}

	public void close() throws Exception {

		cf.channel().closeFuture().sync();

		//优雅停机

		workGroup.shutdownGracefully();

		System.err.println("Sever ShutDown...");

	}

}

vimport com.bfxy.disruptor.MessageProducer;

import com.bfxy.disruptor.RingBufferWorkerPoolFactory;

import com.bfxy.entity.TranslatorData;

import io.netty.channel.ChannelHandlerContext;

import io.netty.channel.ChannelInboundHandlerAdapter;

import io.netty.util.ReferenceCountUtil;

public class ClientHandler extends ChannelInboundHandlerAdapter {

    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {

    	/**

    	try {

    		TranslatorData response = (TranslatorData)msg;

    		System.err.println("Client端: id= " + response.getId()

    				+ ", name= " + response.getName()

    				+ ", message= " + response.getMessage());

		} finally {

			//一定要注意 用完了缓存 要进行释放

			ReferenceCountUtil.release(msg);

		}

		*/

    	TranslatorData response = (TranslatorData)msg;

    	String producerId = "code:seesionId:002";

    	MessageProducer messageProducer = RingBufferWorkerPoolFactory.getInstance().getMessageProducer(producerId);

    	messageProducer.onData(response, ctx);

    }

}

import com.bfxy.disruptor.MessageConsumer;

import com.bfxy.entity.TranslatorData;

import com.bfxy.entity.TranslatorDataWapper;

import io.netty.channel.ChannelHandlerContext;

import io.netty.util.ReferenceCountUtil;

public class MessageConsumerImpl4Client extends MessageConsumer {

	public MessageConsumerImpl4Client(String consumerId) {

		super(consumerId);

	}

	public void onEvent(TranslatorDataWapper event) throws Exception {

		TranslatorData response = event.getData();

		ChannelHandlerContext ctx = event.getCtx();

		//业务逻辑处理:

		try {

    		System.err.println("Client端: id= " + response.getId()

			+ ", name= " + response.getName()

			+ ", message= " + response.getMessage());

		} finally {

			ReferenceCountUtil.release(response);

		}

	}

}

工厂类的封装：

import java.io.Serializable;

public class TranslatorData implements Serializable {

	private static final long serialVersionUID = 8763561286199081881L;

	private String id;

	private String name;

	private String message;	//传输消息体内容

	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 String getMessage() {

		return message;

	}

	public void setMessage(String message) {

		this.message = message;

	}

}

import io.netty.channel.ChannelHandlerContext;

//dis内部需要传输的对象

public class TranslatorDataWapper {

     //实际的数据

	private TranslatorData data;

	//ctx对象

	private ChannelHandlerContext ctx;

	public TranslatorData getData() {

		return data;

	}

	public void setData(TranslatorData data) {

		this.data = data;

	}

	public ChannelHandlerContext getCtx() {

		return ctx;

	}

	public void setCtx(ChannelHandlerContext ctx) {

		this.ctx = ctx;

	}

}

import com.bfxy.entity.TranslatorDataWapper;

import com.lmax.disruptor.WorkHandler;

//抽象的让子类实现

public abstract class MessageConsumer implements WorkHandler<TranslatorDataWapper> {

	protected String consumerId;

	public MessageConsumer(String consumerId) {

		this.consumerId = consumerId;

	}

	public String getConsumerId() {

		return consumerId;

	}

	public void setConsumerId(String consumerId) {

		this.consumerId = consumerId;

	}

}

import com.bfxy.entity.TranslatorData;

import com.bfxy.entity.TranslatorDataWapper;

import com.lmax.disruptor.RingBuffer;

import io.netty.channel.ChannelHandlerContext;

//生产者

public class MessageProducer {

	private String producerId;

	private RingBuffer<TranslatorDataWapper> ringBuffer;

	public MessageProducer(String producerId, RingBuffer<TranslatorDataWapper> ringBuffer) {

		this.producerId = producerId;

		this.ringBuffer = ringBuffer;

	}

	//发送实际的对象和ctx

	public void onData(TranslatorData data, ChannelHandlerContext ctx) {

		long sequence = ringBuffer.next();

		try {

			TranslatorDataWapper wapper = ringBuffer.get(sequence);

			wapper.setData(data);

			wapper.setCtx(ctx);

		} finally {

			ringBuffer.publish(sequence);

		}

	}

}

import java.util.Map;

import java.util.concurrent.ConcurrentHashMap;

import java.util.concurrent.Executors;

import com.bfxy.entity.TranslatorDataWapper;

import com.lmax.disruptor.EventFactory;

import com.lmax.disruptor.ExceptionHandler;

import com.lmax.disruptor.RingBuffer;

import com.lmax.disruptor.SequenceBarrier;

import com.lmax.disruptor.WaitStrategy;

import com.lmax.disruptor.WorkerPool;

import com.lmax.disruptor.dsl.ProducerType;

//环形缓存工作池子工厂

public class RingBufferWorkerPoolFactory {

    //静态内部类的单例模式

	private static class SingletonHolder {

		static final RingBufferWorkerPoolFactory instance = new RingBufferWorkerPoolFactory();

	}

	//对外不能暴露的接口

	private RingBufferWorkerPoolFactory(){

	}

	//对外创建

	public static RingBufferWorkerPoolFactory getInstance() {

		return SingletonHolder.instance;

	}

    //生产者池

	private static Map<String, MessageProducer> producers = new ConcurrentHashMap<String, MessageProducer>();

	//消费者池

	private static Map<String, MessageConsumer> consumers = new ConcurrentHashMap<String, MessageConsumer>();

	private RingBuffer<TranslatorDataWapper> ringBuffer;

	private SequenceBarrier sequenceBarrier;

	private WorkerPool<TranslatorDataWapper> workerPool;

	//ProducerType  生产者类型是多生产还是单生产

	public void initAndStart(ProducerType type, int bufferSize, WaitStrategy waitStrategy, MessageConsumer[] messageConsumers) {

		//1. 构建ringBuffer对象

		this.ringBuffer = RingBuffer.create(type,

				new EventFactory<TranslatorDataWapper>() {

					public TranslatorDataWapper newInstance() {

						return new TranslatorDataWapper();

					}

				},

				bufferSize,

				waitStrategy);

		//2.设置序号栅栏

		this.sequenceBarrier = this.ringBuffer.newBarrier();

		//3.设置工作池

		this.workerPool = new WorkerPool<TranslatorDataWapper>(

				this.ringBuffer,

				this.sequenceBarrier,

				new EventExceptionHandler(), messageConsumers);

		//4 把所构建的消费者置入池中

		for(MessageConsumer mc : messageConsumers){

			this.consumers.put(mc.getConsumerId(), mc);

		}

		//5 添加我们的sequences

		this.ringBuffer.addGatingSequences(this.workerPool.getWorkerSequences());

		//6 启动我们的工作池

		this.workerPool.start(

				Executors.newFixedThreadPool

				(Runtime.getRuntime().availableProcessors()/2));

	}

	//生产者

	public MessageProducer getMessageProducer(String producerId){

		MessageProducer messageProducer = this.producers.get(

				producerId);

		if(null == messageProducer) {

			messageProducer = new MessageProducer(producerId, this.ringBuffer);

			this.producers.put(producerId, messageProducer);

		}

		return messageProducer;

	}

	/**

	 * 异常静态类

	 */

	static class EventExceptionHandler implements ExceptionHandler<TranslatorDataWapper> {

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

		}

		public void handleOnStartException(Throwable ex) {

		}

		public void handleOnShutdownException(Throwable ex) {

		}

	}

}

import io.netty.handler.codec.marshalling.DefaultMarshallerProvider;

import io.netty.handler.codec.marshalling.DefaultUnmarshallerProvider;

import io.netty.handler.codec.marshalling.MarshallerProvider;

import io.netty.handler.codec.marshalling.MarshallingDecoder;

import io.netty.handler.codec.marshalling.MarshallingEncoder;

import io.netty.handler.codec.marshalling.UnmarshallerProvider;

import org.jboss.marshalling.MarshallerFactory;

import org.jboss.marshalling.Marshalling;

import org.jboss.marshalling.MarshallingConfiguration;

/**

 * Marshalling工厂

 */

public final class MarshallingCodeCFactory {

    /**

     * 创建Jboss Marshalling解码器MarshallingDecoder

     * @return MarshallingDecoder

     */

    public static MarshallingDecoder buildMarshallingDecoder() {

    	//首先通过Marshalling工具类的精通方法获取Marshalling实例对象 参数serial标识创建的是java序列化工厂对象。

		final MarshallerFactory marshallerFactory = Marshalling.getProvidedMarshallerFactory("serial");

		//创建了MarshallingConfiguration对象，配置了版本号为5

		final MarshallingConfiguration configuration = new MarshallingConfiguration();

		configuration.setVersion(5);

		//根据marshallerFactory和configuration创建provider

		UnmarshallerProvider provider = new DefaultUnmarshallerProvider(marshallerFactory, configuration);

		//构建Netty的MarshallingDecoder对象，俩个参数分别为provider和单个消息序列化后的最大长度

		MarshallingDecoder decoder = new MarshallingDecoder(provider, 1024 * 1024 * 1);

		return decoder;

    }

    /**

     * 创建Jboss Marshalling编码器MarshallingEncoder

     * @return MarshallingEncoder

     */

    public static MarshallingEncoder buildMarshallingEncoder() {

		final MarshallerFactory marshallerFactory = Marshalling.getProvidedMarshallerFactory("serial");

		final MarshallingConfiguration configuration = new MarshallingConfiguration();

		configuration.setVersion(5);

		MarshallerProvider provider = new DefaultMarshallerProvider(marshallerFactory, configuration);

		//构建Netty的MarshallingEncoder对象，MarshallingEncoder用于实现序列化接口的POJO对象序列化为二进制数组

		MarshallingEncoder encoder = new MarshallingEncoder(provider);

		return encoder;

    }

}

　　生产者的逻辑：

import com.bfxy.disruptor.MessageConsumer;

import com.bfxy.entity.TranslatorData;

import com.bfxy.entity.TranslatorDataWapper;

import io.netty.channel.ChannelHandlerContext;

public class MessageConsumerImpl4Server extends MessageConsumer {

	public MessageConsumerImpl4Server(String consumerId) {

		super(consumerId);

	}

	public void onEvent(TranslatorDataWapper event) throws Exception {

		TranslatorData request = event.getData();

		ChannelHandlerContext ctx = event.getCtx();

		//1.业务处理逻辑:

    	System.err.println("Sever端: id= " + request.getId()

		+ ", name= " + request.getName()

		+ ", message= " + request.getMessage());

    	//2.回送响应信息:

    	TranslatorData response = new TranslatorData();

    	response.setId("resp: " + request.getId());

    	response.setName("resp: " + request.getName());

    	response.setMessage("resp: " + request.getMessage());

    	//写出response响应信息:

    	ctx.writeAndFlush(response);

	}

}

　　消费者的逻辑：

import com.bfxy.disruptor.MessageConsumer;

import com.bfxy.entity.TranslatorData;

import com.bfxy.entity.TranslatorDataWapper;

import io.netty.channel.ChannelHandlerContext;

import io.netty.util.ReferenceCountUtil;

public class MessageConsumerImpl4Client extends MessageConsumer {

	public MessageConsumerImpl4Client(String consumerId) {

		super(consumerId);

	}

	public void onEvent(TranslatorDataWapper event) throws Exception {

		TranslatorData response = event.getData();

		ChannelHandlerContext ctx = event.getCtx();

		//业务逻辑处理:

		try {

    		System.err.println("Client端: id= " + response.getId()

			+ ", name= " + response.getName()

			+ ", message= " + response.getMessage());

		} finally {

			ReferenceCountUtil.release(response);

		}

	}

}

import com.lmax.disruptor.dsl.ProducerType;

@SpringBootApplication

public class NettyServerApplication {

	public static void main(String[] args) {

		SpringApplication.run(NettyServerApplication.class, args);

		MessageConsumer[] conusmers = new MessageConsumer[4];

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

			MessageConsumer messageConsumer = new MessageConsumerImpl4Server("code:serverId:" + i);

			conusmers[i] = messageConsumer;

		}

		RingBufferWorkerPoolFactory.getInstance().initAndStart(ProducerType.MULTI,

				1024*1024,

				//new YieldingWaitStrategy(),

				new BlockingWaitStrategy(),

				conusmers);

		new NettyServer();

	}

}

import org.springframework.boot.SpringApplication;

import org.springframework.boot.autoconfigure.SpringBootApplication;

import com.bfxy.client.MessageConsumerImpl4Client;

import com.bfxy.client.NettyClient;

import com.bfxy.disruptor.MessageConsumer;

import com.bfxy.disruptor.RingBufferWorkerPoolFactory;

import com.lmax.disruptor.BlockingWaitStrategy;

import com.lmax.disruptor.YieldingWaitStrategy;

import com.lmax.disruptor.dsl.ProducerType;

@SpringBootApplication

public class NettyClientApplication {

	public static void main(String[] args) {

		SpringApplication.run(NettyClientApplication.class, args);

		MessageConsumer[] conusmers = new MessageConsumer[4];

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

			MessageConsumer messageConsumer = new MessageConsumerImpl4Client("code:clientId:" + i);

			conusmers[i] = messageConsumer;

		}

		RingBufferWorkerPoolFactory.getInstance().initAndStart(ProducerType.MULTI,

				1024*1024,

				//new YieldingWaitStrategy(),

				new BlockingWaitStrategy(),

				conusmers);

		//建立连接 并发送消息

		new NettyClient().sendData();

	}

}

Disruptor与Netty实现百万级（十）的更多相关文章

Netty系列之Netty百万级推送服务设计要点
1. 背景 1.1. 话题来源最近很多从事移动互联网和物联网开发的同学给我发邮件或者微博私信我,咨询推送服务相关的问题.问题五花八门,在帮助大家答疑解惑的过程中,我也对问题进行了总结,大概可以归纳为 ...
Netty_Netty系列之Netty百万级推送服务设计要点
1. 背景 1.1. 话题来源最近很多从事移动互联网和物联网开发的同学给我发邮件或者微博私信我,咨询推送服务相关的问题.问题五花八门,在帮助大家答疑解惑的过程中,我也对问题进行了总结,大概可以归纳为 ...
【netty】Netty系列之Netty百万级推送服务设计要点
1. 背景 1.1. 话题来源最近很多从事移动互联网和物联网开发的同学给我发邮件或者微博私信我,咨询推送服务相关的问题.问题五花八门,在帮助大家答疑解惑的过程中,我也对问题进行了总结,大概可以归纳为 ...
Netty系列之Netty百万级推送服务设计要点(转)
1. 背景 1.1. 话题来源最近很多从事移动互联网和物联网开发的同学给我发邮件或者微博私信我,咨询推送服务相关的问题.问题五花八门,在帮助大家答疑解惑的过程中,我也对问题进行了总结,大概可以归纳为 ...
Netty学习总结（3）——Netty百万级推送服务
1. 背景 1.1. 话题来源最近很多从事移动互联网和物联网开发的同学给我发邮件或者微博私信我,咨询推送服务相关的问题.问题五花八门,在帮助大家答疑解惑的过程中,我也对问题进行了总结,大概可以归纳为 ...
Netty Redis 亿级流量高并发实战（长文修正版）
目录疯狂创客圈 Java 分布式聊天室[ 亿级流量]实战系列之 -30[ 博客园总入口 ] 写在前面 1.1. 快速的能力提升,巨大的应用价值 1.1.1. 飞速提升能力,并且满足实际开发要求 1 ...
不仅仅是百万级TCP长连接框架 t-io
t-io: 不仅仅是百万级TCP长连接框架 t-io是基于jdk aio实现的易学易用.稳定.性能强悍.将多线程运用到极致.内置功能丰富的即时通讯框架(广义上的即时通讯,并非指im),字母 t 寓意t ...
MySQL 百万级分页优化
MySQL 百万级分页优化 http://www.jb51.net/article/31868.htm 一般刚开始学SQL的时候,会这样写 : , ; 但在数据达到百万级的时候,这样写会慢死 : , ...
MySQL 百万级分页优化(Mysql千万级快速分页)（转）
http://www.jb51.net/article/31868.htm 以下分享一点我的经验一般刚开始学SQL的时候,会这样写复制代码代码如下: SELECT * FROM table OR ...

随机推荐

hadoop jps不显示信息
使用kvm做了一个hadoop组件的镜像,使用该镜像启动,在使用jps的时候,没有任何信息显示. 解决: 删除/tmp下的hsper开头文件,哪个用户没有权限就删除对应的hsper**_usernam ...
全面解读Group Normalization，对比BN，LN，IN
前言 Face book AI research(FAIR)吴育昕-何恺明联合推出重磅新作Group Normalization(GN),提出使用Group Normalization 替代深度学习里 ...
JavaWeb项目启动过程与ServletContext
ServletContext的官方名称叫Servlet上下文,服务器会为每一个工程创建一个对象,这个对象就是ServletContext.一个项目只有一个ServletContext对象,工程内的所有 ...
maven依赖总结
1.依赖元素 groupId,必选,实际隶属项目 artifactId,必选,其中的模块 version必选,版本号 type可选,依赖类型,默认jar scope可选,依赖范围,默认compile ...
plsql 使用desc命令提示invalid sql statement
使用SQL WINDOW运行desc命令就报invalid sql statement错误!! 使用Command Window就可以!!!
Python模块安装方法
安装Python模块电子邮件 distutils-sig @ python .组织作为一个受欢迎的开源开发项目,Python具有活跃的贡献者和用户支持社区,并且根据开放源代码许可条款,其软件可供其 ...
linux centos7 防止暴力破解
系统 centos 7.4 系统, 不知道的可以用 cat /etc/redhat-release 查看利用到了linux 系统的日志,每次我们登陆服务器时,如果有登陆认证失败的情况,会在服务器的/ ...
Pytest单元测试框架-Pytest环境安装
unittest是python自带的单元测试框架,它封装好了一些校验返回的结果方法和一些用例执行前的初始化操作,使得单元测试易于开展,因为它的易用性,很多同学也拿它来做功能测试和接口测试,只需简单开发 ...
.Net Core个人笔记
目录前言 IOC注册三种生命周期如何注册一个IOC服务 .Net Core部署IIS之后500错误管道和中间件示意图管道方法中间件加日志观看使用MVC MVC服务注入 MVC管道调用 ...
[LeetCode] 555. Split Concatenated Strings 分割串联字符串
Given a list of strings, you could concatenate these strings together into a loop, where for each st ...

Disruptor与Netty实现百万级（十）

Disruptor与Netty实现百万级（十）的更多相关文章

随机推荐

热门专题