Java游戏服务器入门11 - 单线程设计

上篇文章我们讲解了攻击消息处理存在的问题和解决问题的方式：消息处理串行化，那这篇文章我们来使用这一思路修改一下我们的代码
核心思路:把所有类型的消息处理放在同一个线程中执行
串行化的优缺点分析：
1.虽然cpu利用率变低，但是由于我们的消息处理是在内存中进行的，所以速度是有保证的
2.省去了多线程上下文切换的过程，也是变相的加速
3.从代码编写的角度考虑，使用串行化使我们的代码更简单了，使得大多数程序员只需要关注于业务的处理，并不用关注线程的处理，毕竟当所有程序员都需要去关注线程处理时，可能会出现更多的问题
4.解决速度问题要比解决线程问题简单的多

代码编写：

1.增加主消息处理器Class:MainMsgProcessor

一.使用单例模式使得MainMsgProcessor只有一个实例，这里我们使用最简单的饿汉模式即可

创建过程：
1.创建静态变量_instance = new MainMsgProcessor()

static private final MainMsgProcessor _instance = new MainMsgProcessor();

2.私有化构造器

private MainMsgProcessor(){};

3.提供getInstance方法获取对象

static public MainMsgProcessor getInstance(){
        return _instance;
    }

二.创建一个只有一个核心线程的线程池，并且给他起一个名字

 private final ExecutorService _es = Executors.newSingleThreadExecutor((newRunnable) -> {
        //给线程命名，方便查看
        Thread newThread = new Thread(newRunnable);
        newThread.setName("MainMsgProcessor");
        return newThread;
    });

三.添加process方法，并使用线程池_es的submit方法执行，执行的方法就是把之前GameMsgHandler中的channelRead方法中的内容粘贴过来即可，具体需要修改的是消息处理的核心方法使用_es执行

 public void process(ChannelHandlerContext ctx, Object msg){
        if (null == ctx || null == msg) {
            return;
        }

        LOGGER.info("收到客户端消息, msgClzz={},msgBody = {}",
                msg.getClass().getName(),msg);

        _es.submit( () ->{
            /**
             * 根据消息类型作对应处理
             */
            try {
                ICmdHandler<? extends GeneratedMessageV3> cmdHandler = CmdHandlerFactory.create(msg.getClass());
                System.out.println(cmdHandler.toString());
                if (null != cmdHandler) {
                    cmdHandler.handle(ctx, cast(msg));
                }
            } catch (Exception ex) {
                // 记录错误日志
                LOGGER.error(ex.getMessage(), ex);
            }
        });

四.MainMsgProcessor完整代码

package com.tk.tinygame.herostory;

import com.google.protobuf.GeneratedMessageV3;
import com.tk.tinygame.herostory.cmdhandler.CmdHandlerFactory;
import com.tk.tinygame.herostory.cmdhandler.ICmdHandler;
import io.netty.channel.ChannelHandlerContext;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * 主消息处理器
 */
public final class MainMsgProcessor {

    /**
     * 日志对象
     */
    static private final Logger LOGGER = LoggerFactory.getLogger(MainMsgProcessor.class);

    /**
     * 单例对象
     */
    static private final MainMsgProcessor _instance = new MainMsgProcessor();

    /**
     * 创建一个单线程的线程池，直接用工具类创建，也可以自己指定参数创建
     */
    private final ExecutorService _es = Executors.newSingleThreadExecutor((newRunnable) -> {
        //给线程命名，方便查看
        Thread newThread = new Thread(newRunnable);
        newThread.setName("MainMsgProcessor");
        return newThread;
    });

    /**
     * 私有化默认构造器
     */
    private MainMsgProcessor(){};

    /**
     * 获取单例对象
     */
    static public MainMsgProcessor getInstance(){
        return _instance;
    }

    /**
     * 处理消息
     */
    public void process(ChannelHandlerContext ctx, Object msg){
        if (null == ctx || null == msg) {
            return;
        }

        LOGGER.info("收到客户端消息, msgClzz={},msgBody = {}",
                msg.getClass().getName(),msg);

        _es.submit( () ->{
            /**
             * 根据消息类型作对应处理
             */
            try {
                ICmdHandler<? extends GeneratedMessageV3> cmdHandler = CmdHandlerFactory.create(msg.getClass());
                System.out.println(cmdHandler.toString());
                if (null != cmdHandler) {
                    cmdHandler.handle(ctx, cast(msg));
                }
            } catch (Exception ex) {
                // 记录错误日志
                LOGGER.error(ex.getMessage(), ex);
            }
        });
        
    }

    /**
     * 转型为命令对象
     *
     * @param msg
     * @param <TCmd>
     * @return
     */
    static private <TCmd extends GeneratedMessageV3> TCmd cast(Object msg) {
        if (null == msg) {
            return null;
        } else {
            return (TCmd) msg;
        }
    }

}

2.修改消息处理器GameMsgHandler

处理思路：观察GameMsgHandler，所有的消息处理都是通过channelRead0执行的，由于GameMsgHandler是多例的，所以channelRead0是多线程执行的，那么我们的思路就是把channelRead0方法中的实现变为单线程执行。

修改channelRead0

 @Override
    protected void channelRead0(ChannelHandlerContext ctx, Object msg) throws Exception {
        if (null == ctx || null == msg) {
            return;
        }
        //调用MainMsgProcessor的process
        MainMsgProcessor.getInstance().process(ctx,msg);
    }

3.测试地址

http://cdn0001.afrxvk.cn/hero_story/demo/step020/index.html?serverAddr=127.0.0.1:12345&userId=1

4.使用单例模式的解释

这里我们的之所以是使用单例模式创建MainMsgProcessor对象，是因为我们希望的是使用同一个线程处理消息，然而如果MainMsgProcessor是多例的，那么其实我们相当于创建了多个单线程的线程池，那么其实消息也不是在一个同一个线程中执行的，这个如果有疑问的话大家也可以自己测试。当然还有一种方法就是把我们创建出来的线程池单例，也是可以的
或者有的朋友学习了设计模式，比如说单例模式，在项目里不知道怎么用，这个也可以算是一个单例模式的使用案例