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 ...

随机推荐

Cocos CreatorUI系统上
若本号内容有做得不到位的地方(比如:涉及版权或其他问题),请及时联系我们进行整改即可,会在第一时间进行处理. 请点赞!因为你们的赞同/鼓励是我写作的最大动力! 欢迎关注达叔小生的简书! 这是一个有质量 ...
mysql ，with rollup的用法
如下,可以看到使用后,也统计了null的个数. mysql> select * from table1; +----------+------------+-----+------------- ...
Luogu3379 【模板】最近公共祖先（LCA）
题面题解这里讲一种硬核做法. 首先\(\mathrm{dfs}\)整棵树,求出这棵树的欧拉序,然后\(\mathrm{LCA}\)问题就变成了\(\pm 1\mathrm{RMQ}\)问题. 考虑 ...
Kubernetes Pod 生命周期
一. Pod Hook Kubernetes 为我们提供了生命周期钩子,就是我们所说的Pod Hook,Pod Hook是由kubelet发起的,当容器中的进程启动前或者容器中的进程终止之前运行.这是 ...
SpringMVC（上）
一.SpringMVC简介 (1)springMVC概述 Spring MVC属于SpringFrameWork的后续产品,Spring 框架提供了构建 Web 应用程序的全功能 MVC 模块. 使用 ...
网络营销CPA、CPS、CPM、CPT、CPC 是什么
网络营销之所以越来越受到重视一个主要的原因就是因为“精准”.相比较传统媒体的陈旧广告形式,网络营销能为广告主带来更为确切的效果与回报,更有传统媒体所没有的即时互动性.很多企业借助于精准的网络营销成为人 ...
NamedPipeStream的使用
NamedPipeStream的使用具体案例如下: using System; using System.Data; using System.Data.SQLite; using System.IO ...
Weblogic部署web项目获取项目根目录为null
写在前面图片上传功能, web项目部署在本地Tomcat上并没有问题, 但是打成war包部署到Linux服务器Weblogic下却出现如题问题, 导致图片上传失败. 问题代码 String real ...
Partition-wise join
什么是“partition-wise join”呢?我们将用一个比喻来解释它的好处. 假设两个人,Logan和Shannon,决定住在一起.如果他们每个人都已经有了自己的住所,他们就会拥有很多你在任何 ...
electron---项目打包
创建一个应用目录:app,里面需要有必要的三个文件: index.html <!DOCTYPE html> <html> <head> <meta chars ...

Disruptor与Netty实现百万级（十）

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

随机推荐

热门专题