一文搞懂Reactor模型与实现

周六在公司写Reactor模型，

一女同事问我为啥都2023年了还在学习Reactor模型呀，

我问她为啥快30的年纪了，周六还在公司看我写Reactor呀，

一时间办公室里，男的，女的，都沉默了。

前言

在网络IO设计中，有两种高性能模型：Reactor模型和Proactor模型。Reactor基于同步IO模式，Proactor基于异步IO模式。

Netty网络框架，Redis等中间件中都有使用到Reactor模型。本文将对Reactor模型的如下三种分类进行学习和实现。

  1. 单Reactor单线程模型；
  2. 单Reactor多线程模型；
  3. 主从Reactor多线程模型。

正文

一. Reactor设计模式

Reactor翻译过来的意思是：反应堆，所以Reactor设计模式本质是基于事件驱动的。在Reactor设计模式中，存在如下几个角色。

  1. Handle（事件）。Reactor整体是基于Handle进行驱动，这里的Handle叫做事件，可以类比为BIO中的Socket，NIO中的Socket管道。比如当Socket管道有连接建立，或者有数据可读，那么此时就称作事件发生；
  2. EventHandler(事件处理器)。有事件发生，就需要有相应的组件来处理事件，那么这里的组件就叫做事件处理器。EventHandler是一个抽象概念，其会有不同的具体实现，因为事件会有不同的类型，那么不同类型的事件，肯定都需要有相应的具体处理逻辑，这里的具体处理逻辑，就由EventHandler的具体实现来承载；
  3. Concrete Event Handler（具体事件处理器）。是EventHandler的具体实现，用于处理不同类型的事件；
  4. Synchronous Event Demultiplexer（事件多路分解器）。（这里将Synchronous Event Demultiplexer简称为Demultiplexer）Demultiplexer用于监听事件并得到所有发生事件的集合，在监听的状态下是阻塞的，直到有事件发生为止。Demultiplexer有一个很好的类比，就是NIO中的多路复用器Selector，当调用Selector的select() 方法后，会进入监听状态，当从select() 方法返回时，会得到SelectionKey的一个集合，而每一个SelectionKey中就保存着有事件发生的Socket管道；
  5. Initiation Dispatcher（事件分发器）。现在已经有Concrete Event Handler（具体事件处理器）来处理不同的事件，也能通过Synchronous Event Demultiplexer（事件多路分解器）拿到发生的事件，那么最后需要做的事情，肯定就是将事件分发到正确的事件处理器上进行处理，而Initiation Dispatcher就是完成这个分发的事情。

Reactor设计模式的一个简单类图，如下所示。

通常，Reactor设计模式中的Reactor，可以理解为上述图中的Synchronous Event Demultiplexer + Initiation Dispatcher。

二. 单Reactor单线程模型

单Reactor单线程模型中，只有一个Reactor在监听事件和分发事件，并且监听事件，分发事件和处理事件都在一个线程中完成。示意图如下所示。

上述示意图中，一次完整的处理流程可以概括如下。

  1. Reactor监听到ACCEPT事件发生，表示此时有客户端建立连接；
  2. Reactor将ACCEPT事件分发给Acceptor处理；
  3. Acceptor会在服务端创建与客户端通信的client-socket管道，然后注册到IO多路复用器selector上，并监听READ事件；
  4. Reactor监听到READ事件发生，表示此时客户端数据可读；
  5. Reactor将ACCEPT事件分发给Handler处理，Handler处理READ事件就会基于client-socket管道完成客户端数据的读取。

下面将基于Java语言，实现一个简单的单Reactor单线程模型的服务端，整体代码实现完全符合上述示意图，大家可以进行参照阅读。

首先实现Reactor，如下所示。

public class Reactor implements Runnable {

    private final Selector selector;

    public Reactor(int port) throws IOException {
        // 开启多路复用
        selector = Selector.open();
        // 服务端创建listen-socket管道
        ServerSocketChannel listenSocketChannel = ServerSocketChannel.open();
        // 绑定端口
        listenSocketChannel.socket().bind(new InetSocketAddress(port));
        // 设置为非阻塞模式
        listenSocketChannel.configureBlocking(false);
        // ACCEPT事件的附加器是Acceptor
        listenSocketChannel.register(selector, SelectionKey.OP_ACCEPT,
                new Acceptor(selector, listenSocketChannel));
    }

    @Override
    public void run() {
        while (!Thread.interrupted()) {
            try {
                // 获取发生的事件
                selector.select();
                Set<SelectionKey> selectionKeys = selector.selectedKeys();
                Iterator<SelectionKey> iterable = selectionKeys.iterator();
                while (iterable.hasNext()) {
                    // 对事件进行分发
                    dispatch(iterable.next());
                    iterable.remove();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            LockSupport.parkNanos(1000 * 1000 * 1000);
        }
    }

    private void dispatch(SelectionKey selectionKey) {
        // 获取事件的附加器
        // ACCEPT事件的附加器是Acceptor，故由Acceptor来处理ACCEPT事件
        // READ事件的附加器是Handler，故由Handler来处理READ事件
        Runnable attachment = (Runnable) selectionKey.attachment();
        if (attachment != null) {
            attachment.run();
        }
    }

}
复制代码

已知Reactor会监听客户端连接的ACCEPT事件，还已知ACCEPT事件由Acceptor处理，所以在向多路复用器注册服务端用于监听客户端连接的listen-socket管道时，添加了一个Acceptor作为附加器，那么当发生ACCEPT事件时，就能够获取到作为ACCEPT事件附加器的Acceptor来处理ACCEPT事件。

下面看一下Acceptor的实现，如下所示。

public class Acceptor implements Runnable {

    private final Selector selector;
    private final ServerSocketChannel listenSocketChannel;

    public Acceptor(Selector selector, ServerSocketChannel listenSocketChannel) {
        this.selector = selector;
        this.listenSocketChannel = listenSocketChannel;
    }

    @Override
    public void run() {
        try {
            // 为连接的客户端创建client-socket管道
            SocketChannel clientSocketChannel = listenSocketChannel.accept();
            // 设置为非阻塞
            clientSocketChannel.configureBlocking(false);
            // READ事件的附加器是Handler
            clientSocketChannel.register(selector, SelectionKey.OP_READ,
                    new Handler(clientSocketChannel));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}
复制代码

在Acceptor中就是在服务端创建与客户端通信的client-socket管道，然后注册到多路复用器上并指定监听READ事件，同时又因为READ事件由Handler处理，所以还添加了一个Handler作为附加器，当READ事件发生时可以获取到作为READ事件附加器的Handler来处理READ事件。

下面看一下Handler的实现，如下所示。

public class Handler implements Runnable {

    private final SocketChannel clientSocketChannel;

    public Handler(SocketChannel clientSocketChannel) {
        this.clientSocketChannel = clientSocketChannel;
    }

    @Override
    public void run() {
        ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
        try {
            // 读取数据
            int read = clientSocketChannel.read(byteBuffer);
            if (read <= 0) {
                clientSocketChannel.close();
            } else {
                System.out.println(new String(byteBuffer.array()));
            }
        } catch (IOException e1) {
            try {
                clientSocketChannel.close();
            } catch (IOException e2) {
                e2.printStackTrace();
            }
            e1.printStackTrace();
        }
    }

}
复制代码

在Handler中就是简单的读取数据并打印，当读取数据为空或者发生异常时，需要及时将管道关闭。

最后编写一个主程序将Reactor运行起来，如下所示。

public class MainServer {

    public static void main(String[] args) throws IOException {
        Thread reactorThread = new Thread(new Reactor(8080));
        reactorThread.start();
    }

}
复制代码

现在来思考一下，单Reactor单线程模型有什么优点和缺点。优点其实就是模型简单，实现方便。缺点有两点，如下所示。

  1. 一个Reactor同时负责监听ACCEPT事件和READ事件；
  2. 只有一个线程在工作，处理效率低，无法利用多核CPU的优势。

但是尽管单Reactor单线程模型有上述的缺点，但是著名的缓存中间件Redis的服务端，就是使用的单Reactor单线程模型，示意图如下。

那为什么以性能著称的Redis会采取单Reactor单线程模型呢，其实就是因为Redis的操作都在内存中，读写都非常快速，所以单Reactor单线程模型也能运行得很流畅，同时还避免了多线程下的各种并发问题。

三. 单Reactor多线程模型

在理解了单Reactor单线程模型后，那么肯定就能想到，假如在Handler中处理READ事件的这个事情能够使用一个线程池来完成，从而就可以实现READ事件的处理不会阻塞主线程。而这样的一个模型，其实就是单Reactor多线程模型，示意图如下所示。

和单Reactor单线程模型唯一的不同，就是在Handler中多了一个线程池。

单Reactor多线程模型的代码实现，除了Handler以外，其余和单Reactor单线程模型一摸一样，所以下面就看一下单Reactor多线程模型中的Handler实现，如下所示。

public class Handler implements Runnable {

    private static final ThreadPoolExecutor threadPool = new ThreadPoolExecutor(16, 32,
            60, TimeUnit.SECONDS, new LinkedBlockingQueue<>(200));

    private final SocketChannel clientSocketChannel;

    public Handler(SocketChannel clientSocketChannel) {
        this.clientSocketChannel = clientSocketChannel;
    }

    @Override
    public void run() {
        threadPool.execute(() -> {
            ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
            try {
                // 读取数据
                int read = clientSocketChannel.read(byteBuffer);
                if (read <= 0) {
                    clientSocketChannel.close();
                } else {
                    System.out.println(new String(byteBuffer.array()));
                }
                // 睡眠10S，演示任务执行耗时长也不会阻塞处理其它客户端请求
                LockSupport.parkNanos(1000 * 1000 * 1000 * 10L);
            } catch (IOException e1) {
                try {
                    clientSocketChannel.close();
                } catch (IOException e2) {
                    e2.printStackTrace();
                }
                e1.printStackTrace();
            }
        });
    }

}
复制代码

其实就是每一个READ事件的处理会作为一个任务被扔到线程池中去处理。

单Reactor多线程模型虽然解决了只有一个线程的问题，但是可以发现，仍旧是只有一个Reactor在同时监听ACCEPT事件和READ事件。

那么现在思考一下，为什么一个Reactor同时监听ACCEPT事件和READ事件是不好的。其实就是因为通常客户端连接的建立是不频繁的，但是连接建立后数据的收发是频繁的，所以如果能够将监听READ事件这个动作拆分出来，让多个子Reactor来监听READ事件，而原来的主Reactor只监听ACCEPT事件，那么整体的效率，会进一步提升，而这，就是主从Reactor多线程模型。

四. 主从Reactor多线程模型

主从Reactor模型中，有一个主Reactor，专门监听ACCEPT事件，然后有多个从Reactor，专门监听READ事件，示意图如下所示。

上述示意图中，一次完整的处理流程可以概括如下。

  1. 主Reactor监听到ACCEPT事件发生，表示此时有客户端建立连接；
  2. 主Reactor将ACCEPT事件分发给Acceptor处理；
  3. Acceptor会在服务端创建与客户端通信的client-socket管道，然后注册到从Reactor的IO多路复用器selector上，并监听READ事件；
  4. 从Reactor监听到READ事件发生，表示此时客户端数据可读；
  5. 从Reactor将ACCEPT事件分发给Handler处理，Handler处理READ事件就会基于client-socket管道完成客户端数据的读取。

下面将基于Java语言，实现一个简单的主从Reactor多线程模型的服务端，整体代码实现完全符合上述示意图，大家可以进行参照阅读。

首先是主Reactor的实现，如下所示。

public class MainReactor implements Runnable {

    private final Selector selector;

    public MainReactor(int port) throws IOException {
        // 开多路复用器
        selector = Selector.open();
        // 服务端创建listen-socket管道
        ServerSocketChannel listenSocketChannel = ServerSocketChannel.open();
        // 设置为非阻塞
        listenSocketChannel.configureBlocking(false);
        // 绑定监听端口
        listenSocketChannel.socket().bind(new InetSocketAddress(port));
        // 将listen-socket管道绑定到主Reactor的多路复用器上
        // 并且主Reactor上只会注册listen-socket管道，用于监听ACCEPT事件
        listenSocketChannel.register(selector, SelectionKey.OP_ACCEPT,
                new Acceptor(listenSocketChannel));
    }

    @Override
    public void run() {
        while (!Thread.interrupted()) {
            try {
                selector.select();
                Set<SelectionKey> selectionKeys = selector.selectedKeys();
                Iterator<SelectionKey> iterable = selectionKeys.iterator();
                while (iterable.hasNext()) {
                    // 对事件进行分发
                    dispatch(iterable.next());
                    iterable.remove();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            LockSupport.parkNanos(1000 * 1000 * 1000);
        }
    }

    private void dispatch(SelectionKey selectionKey) {
        // 获取事件附加器，只会是Acceptor
        Runnable attachment = (Runnable) selectionKey.attachment();
        if (attachment != null) {
            attachment.run();
        }
    }

}
复制代码

主Reactor的实现中，还是先创建服务端监听客户端连接的listen-socket管道，然后注册到主Reactor的IO多路复用器上，并监听ACCEPT事件，同时我们现在知道，主Reactor的IO多路复用器上只会注册listen-socket管道且只会监听ACCEPT事件。同样，也添加了一个Acceptor作为附加器，那么当发生ACCEPT事件时，就能够获取到作为ACCEPT事件附加器的Acceptor来处理ACCEPT事件。

下面是Acceptor的实现，如下所示。

public class Acceptor implements Runnable {

    // 指定从Reactor一共有16个
    private static final int TOTAL_SUBREACTOR_NUM = 16;

    // 服务端的listen-socket管道
    private final ServerSocketChannel listenSocketChannel;

    // 用于运行从Reactor
    private final ThreadPoolExecutor threadPool = new ThreadPoolExecutor(
            TOTAL_SUBREACTOR_NUM, TOTAL_SUBREACTOR_NUM * 2,
            60, TimeUnit.SECONDS, new LinkedBlockingQueue<>(200));

    // 从Reactor集合
    private final List<SubReactor> subReactors = new ArrayList<>(TOTAL_SUBREACTOR_NUM);

    public Acceptor(ServerSocketChannel listenSocketChannel) throws IOException {
        this.listenSocketChannel = listenSocketChannel;
        // 将从Reactor初始化出来并运行
        for (int i = 0; i < TOTAL_SUBREACTOR_NUM; i++) {
            SubReactor subReactor = new SubReactor(Selector.open());
            subReactors.add(subReactor);
            threadPool.execute(subReactor);
        }
    }

    @Override
    public void run() {
        try {
            // 为连接的客户端创建client-socket管道
            SocketChannel clientSocketChannel = listenSocketChannel.accept();
            // 设置为非阻塞
            clientSocketChannel.configureBlocking(false);
            // 任意选择一个从Reactor，让其监听连接的客户端的READ事件
            Optional<SubReactor> anySubReactor = subReactors.stream().findAny();
            if (anySubReactor.isPresent()) {
                SubReactor subReactor = anySubReactor.get();
                // 从Reactor的多路复用器会阻塞在select()方法上
                // 这里需要先唤醒多路复用器，立即从select()方法返回
                subReactor.getSelector().wakeup();
                // 让从Reactor负责处理客户端的READ事件
                clientSocketChannel.register(subReactor.getSelector(), SelectionKey.OP_READ,
                        new Handler(clientSocketChannel));
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}
复制代码

首先在Acceptor的构造函数中，会将所有从Reactor初始化出来，并且每一个从Reactor都会持有一个IO多路复用器。当一个从Reactor创建出来后就会立即运行，此时从Reactor的IO多路复用器就会开始监听，即阻塞在select() 方法上。

然后在Acceptor的主体逻辑中，会为连接的客户端创建client-socket管道，然后从所有从Reactor中基于某种策略（随机）选择一个从Reactor，并将client-socket管道注册在选择的从Reactor的IO多路复用器上，有一点需要注意，此时从Reactor的IO多路复用器可能会阻塞在select() 方法上，所以注册前需要先通过wakeup() 方法进行唤醒。

接下来继续看从Reactor的实现，如下所示。

public class SubReactor implements Runnable {

    private final Selector selector;

    public SubReactor(Selector selector) {
        this.selector = selector;
    }

    @Override
    public void run() {
        while (!Thread.interrupted()) {
            try {
                selector.select();
                Set<SelectionKey> selectionKeys = selector.selectedKeys();
                Iterator<SelectionKey> iterator = selectionKeys.iterator();
                while (iterator.hasNext()) {
                    // 对事件进行分发
                    dispatch(iterator.next());
                    iterator.remove();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            LockSupport.parkNanos(1000 * 1000 * 1000);
        }
    }

    private void dispatch(SelectionKey selectionKey) {
        // 获取事件附加器，只会是Handler
        Runnable runnable = (Runnable) selectionKey.attachment();
        if (runnable != null) {
            runnable.run();
        }
    }

    public Selector getSelector() {
        return selector;
    }

}
复制代码

从Reactor的实现中，会监听服务端为连接的客户端创建的client-socket管道上的READ事件，一旦有READ事件发生，就会使用作为附加器的Handler来处理READ事件。同样，从Reactor的IO多路复用器上只会注册client-socket管道且只会监听READ事件。

然后是Handler，因为是多线程模型，所以其实现和第三节中的Handler完全一样，下面再贴一下代码。

public class Handler implements Runnable {

    private static final ThreadPoolExecutor threadPool = new ThreadPoolExecutor(16, 32,
            60, TimeUnit.SECONDS, new LinkedBlockingQueue<>(200));

    private final SocketChannel clientSocketChannel;

    public Handler(SocketChannel clientSocketChannel) {
        this.clientSocketChannel = clientSocketChannel;
    }

    @Override
    public void run() {
        threadPool.execute(() -> {
            ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
            try {
                // 读取数据
                int read = clientSocketChannel.read(byteBuffer);
                if (read <= 0) {
                    clientSocketChannel.close();
                } else {
                    System.out.println(new String(byteBuffer.array()));
                }
                // 睡眠10S，演示任务执行耗时长也不会阻塞处理其它客户端请求
                LockSupport.parkNanos(1000 * 1000 * 1000 * 10L);
            } catch (IOException e1) {
                try {
                    clientSocketChannel.close();
                } catch (IOException e2) {
                    e2.printStackTrace();
                }
                e1.printStackTrace();
            }
        });
    }

}
复制代码

最后编写一个主程序将主Reactor运行起来，如下所示。

public class MainServer {

    public static void main(String[] args) throws IOException {
        Thread mainReactorThread = new Thread(new MainReactor(8080));
        mainReactorThread.start();
    }

}
复制代码

总结

Reactor模型主要就是监听事件，分发事件和处理事件。其中Reactor角色会负责监听事件 和分发事件，Handler角色和Acceptor角色会负责处理事件。

Reactor模型虽然分为：单Reactor单线程模型，单Reactor多线程模型和主从Reactor多线程模型，但是其本质就是NIO的实现，是不过套了Reactor设计模式的外壳。

在网络通信框架Netty中，三种Reactor模型都有使用到，所以想要学习Netty的精髓，理解Reactor模型是必不可少的。

#我想象的工作vs实际工作##我的求职思考##如果可以选，你最想从事什么工作##你觉得今年春招回暖了吗#
全部评论
谢谢分享，收藏吃灰中😁
1 回复 分享
发布于 2023-03-17 13:09 湖北
所以楼主有女朋友吗？
点赞 回复 分享
发布于 2023-03-17 12:45 辽宁

相关推荐

头像
10-28 10:02
已编辑
重庆大学 Java
天翼云后端一面
1.&nbsp;Java对象和引用2.&nbsp;String&nbsp;a&nbsp;=&nbsp;new&nbsp;String(&amp;quot;abc&amp;quot;)，a是指向的什么3.&nbsp;Python如何判断对象相等4.&nbsp;在Linux还是在Windows上开发5.&nbsp;Linux部署是有流水线工具还是自己手动，自己手动是怎么部署的6.&nbsp;提到了Docker镜像打包，你怎么打包的7.&nbsp;Java类的生命周期8.&nbsp;Python有类似于Jvm的东西，有了解吗9.&nbsp;redis为什么这么快10.&nbsp;提到了select、epoll，有了解poll吗11.&nbsp;Reactor模式和Proactor模式还有哪些地方你了解到有应用12.&nbsp;Linux出现connection&nbsp;reset&nbsp;by&nbsp;peer怎么排查13.&nbsp;网络连接有哪些状态14.&nbsp;出现了非常多TIME_WAIT怎么排查15.&nbsp;分库分表应该用在什么场景--更新--10.28约二面#软件开发笔面经##天翼云#
寺内勇：人家超级优才已经oc了，我今天才一面，不会此优才非彼优才吧
天翼云科技有限公司一面13人在聊 查看15道真题和解析 软件开发笔面经
点赞 评论 收藏
分享
11-15 15:46
兰州大学 C++
小红书日常实习-分布式存储
#我的实习求职记录##远程面试的尴尬瞬间#本来是投递的搜推的后台开发，没想到转到分布式存储了。面试官非常友好，一开始登录的时候录屏和赛码网两个冲突了，面试官就一直听不到声音，退出登录重连两次才能说上话。接着就是自我介绍，正常的自我介绍了一下背景+项目+比赛，当时没想到面试官就是做分布式存储的，就一直揪着这个项目拷打，说实话这个项目我还没吃透差点被问穿，以后求职的兄弟们可千万不敢这么干。1.&nbsp;这个项目的网络部分是怎么实现的？回答了同步阻塞的rpc2.&nbsp;具体怎么设计的呢？3.&nbsp;使用的什么线程模型？4.&nbsp;如何验证数据库的正确性？后面解释说是如果节点出现故障如何保证一致5.&nbsp;raft的状态如何存储？跳表有持久化下来吗？6.&nbsp;文件是如何存储的，落盘和加载如何确定key和value？7.&nbsp;raft本身自己的状态是如何存储的，比如日志和任期？8.&nbsp;如果没有维护raft本身自己的状态会出现哪些问题？9.&nbsp;跳表的实现思路和优缺点？手撕：假设已有random函数，实现一个简易的跳表实际写的时候有点急，面试官很耐心地指正了部分错误，大体思路是对的
查看10道真题和解析 我的实习求职记录 远程面试的尴尬瞬间
点赞 评论 收藏
分享
11-08 17:13
苏州大学 嵌入式工程师
点赞 评论 收藏
分享
10-27 21:00
华南师范大学 C++
特斯拉c++实习一面凉经验
特斯拉c++地图开发实习一面（30min）自我介绍会不会go语言用过qt吗，介绍一下qt客户端编程介绍一下实习介绍一下智能指针讲一下shared_ptr底层实现，shared_ptr是线程安全的嘛讲一下有哪些线程锁讲一下你说到的自旋锁为什么自选锁线程不会睡眠/阻塞，怎么实现的程序崩溃怎么办，除了gdb调试还有别的吗，没有报错信息直接崩溃怎么办讲一下你了解的数据结构讲一下你熟悉的算法最长路径算法的具体应用有哪些讲一下容器讲一下set，unordered_set区别，unordered_set时间还能优化吗，o（1）还能优化吗，怎么优化，还能优化到毫秒级别的，讲一下你的webserve项目是一个客户端分配一个线程吗为什么缓冲区要用vector实现，string不行吗string也有扩容机制怎么解析不同的数据类型的，假如要传输一个很大mp4文件，应该怎么传输讲一下你会的设计模式讲一下git怎么创建分支用过共享项目吗，怎么创建的问了一下linux相关….还有些忘记了（30min）手撕算法，给定步长范围，在一个int数组里面从开始出发，用给定的步长跳到终点，求出经过元素和最大的路径（动态规划）没撕出来g反问：对实习生的培养，看中面试者哪方面能力
查看27道真题和解析
点赞 评论 收藏
分享
头像
10-27 15:03
门头沟学院 C++
点赞 评论 收藏
分享
4 31 评论
分享

招聘动态

查看更多

字节跳动

2025校园招聘

快手Star

2025届招聘

快手

销售类投递专区

全站热榜

正在热议
# 25届秋招总结 #
279702次浏览 2424人参与
# 如果实习可以转正，你会不会放弃秋招 #
206140次浏览 2807人参与
# 北方华创开奖 #
24583次浏览 263人参与
# 地方国企笔面经互助 #
3281次浏览 7人参与
# 学历or实习经历，哪个更重要 #
47529次浏览 368人参与
# 选完offer后，你后悔学本专业吗 #
16770次浏览 120人参与
# 如何一边实习一边秋招 #
989285次浏览 12623人参与
# 软开人，秋招你打算投哪些公司呢 #
41695次浏览 534人参与
# 数据人的面试交流地 #
436424次浏览 7812人参与
# 0offer是寒冬太冷还是我太菜 #
893127次浏览 7966人参与
# 得物求职进展汇总 #
64944次浏览 674人参与
# 求职遇到的搞笑事件 #
69038次浏览 571人参与
# 你觉得专业和学校哪个对薪资影响最大 #
28965次浏览 215人参与
# 查收我的offer竞争力报告 #
21327次浏览 263人参与
# 你最想要的公司福利是？ #
43540次浏览 161人参与
# 没有实习经历，还有机会进大厂吗 #
809139次浏览 13886人参与
# 来聊聊机械薪资天花板是哪家 #
67533次浏览 460人参与
# 当你面对裁员会如何？ #
26536次浏览 156人参与
# 一觉醒来，我觉醒了超级打工人系统 #
3656次浏览 38人参与
# 应届生被毁约被毁意向了怎么办 #
28863次浏览 247人参与
# 面试体验感最好的是哪家？ #
84213次浏览 822人参与
牛客网
牛客企业服务