![](https://wandergeneral.cn/static/img/f9d79291fbaddf8d82ec53b738f6fd9e.clion-wsl-start.webp)

我们使用C++进行开发时，大多数情况下是在Linux环境下进行，但是当我们使用虚拟机软件搭建Linux环境并使用时总是觉得不如意，因此需要使用一种新的方式来提升开发的体验。在这里我推荐使用WSL进行开发。



WSL是`Windows下的Linux子系统`，它可以使我们可以在Windows下直接使用Linux系统而不需要用虚拟机软件进行搭建。

## 1. 开启WSL，安装Linux

在Windows上要使用WSL需要开启WSL选项，具体的安装教程网上有很多，这里就不多叙述了。

## 2. 使用WSL-Linux

当成功安装完之后，我们可以在资源管理器中看到以下这种情况：

![](https://wandergeneral.cn/static/img/44c5bd9038a84175a4a3bcc8a8cff8f2.wsl-linux.webp)

点击进入发行版，可以看到一个标准的Linux文件根目录：

![](https://wandergeneral.cn/static/img/fec7d018e4ac85f6db7487caf2a2bfef.Linux_dir_file.webp)

我们可以直接查看操作Linux下的文件和目录。

### 2.1 通过过终端查看和使用WSL

进入WIndows终端，输入以下命令，便可以看到WSL相关的所有信息：
```shell
wsl --help
```

以下便是WSL中常用的操作：
![](https://wandergeneral.cn/static/img/40fe6a144ed45ed233027af31573bbbf.WSL_USE.webp)

:::tip{title="多个版本"}
值得注意的是为了方便不同的项目有着不同的环境，我们会使用docker来配置环境，但是在这里我们不需要使用docker，直接使用WSL安装不同的版本。
:::

我们可以看到，当我们在已存在的发行版中配置好基础设施，但是要保留副本时，使用以下命令：
```shell
wsl --export Ubuntu_20.04 Ubuntu-ver01.tar 
```
其目的便是将Ubuntu_20.04这个发行版保存到Ubuntu-ver01.tar。

而当我们要创建新的时，只需要使用这个tar包即可，使用以下代码：
```shell
wsl --import new-Ubuntu E:\ubuntu .\Ubuntu-ver01.tar 
```

这样我们就可以得到同一个环境的不同版本了。

### 2.2 WSL-Linux中配置开发环境

在Linux下安装开发需要的编译器，工具等。

例如：安装C/C++开发所需要的环境
```bash
sudo apt update
sudo apt install gcc
sudo apt install g++
sudo apt install gdb
sudo apt install cmake
```

### 2.3 Windows中配置CLion

#### 2.3.1 下载CLion

CLion作为现代化的IDE，其在Windows下的开发体验可以说是相当不错的，其在Linux下也有相关的版本。但我们使用的是WSL，我们可以轻松的在Windows中打开Linux下的文件。

当我们要编辑Linux下的文件时大多数情况下是使用vim来进行编辑，那多麻烦啊！

我们可以在Windows下使用vscode或其他IDE直接打开Linux下的文件，也可以直接拖动文件进入到Linux。

这种方式既享受了Windows的便捷，又使用了Linux的环境，同时占了两个系统的便宜，就像那句话说的，**小孩子才做选择,大人我全都要**。

具体的下载方式网上有大量的教程，以下是下载地址：

- CLion: [Jetbrains-CLion](https://www.jetbrains.com/clion/)

#### 2.3.2 配置CLion环境

要想在Windows上使用CLion进行Linux开发，前提是需要在Linux下载配置好`CMake以及相关的编译工具`，因为CLion是使用CMake进行项目构建的。

1. 进入【设置】 -> 选择【构建执行部署】 -> 选择【工具链】 -> 点击【+】 -> 选择【WSL】
![](https://wandergeneral.cn/static/img/092745e7b0a77fe48c814e31a72d0ce6.clion_01.webp)

2. 点击选项，软件会自动搜索相应WSL的工具
![](https://wandergeneral.cn/static/img/ed5af69c1afdde05fd409a8a497ed91a.clion_02.webp)

3. 【构建执行部署】下 -> 选择【CMake】 -> 点击【+】 -> 修改【名称】 -> 点击【工具链】 -> 选择【WSL】 -> 其他选项按照个人爱好和习惯选择：例如构建目录我会修改为build。
![](https://wandergeneral.cn/static/img/230527bed3dac4abc26a8ce18e315e6b.clion_03.webp)

4. 此时就已经完成软件和环境的设置。

5. 打开项目，自动完成构建，运行：
![](https://wandergeneral.cn/static/img/5a8ed8888e508c2ba523c2ee59189f47.clion_run.webp)

这样我们就可以在Windows环境下，使用CLion进行Linux下的项目开发了。

## 3. 多个开发环境

当我们需要不同的开发环境时，就需要使用下面的方法：
![](https://wandergeneral.cn/static/img/40fe6a144ed45ed233027af31573bbbf.WSL_USE.webp)

使用方法上面已经进行了示例。

#

本次所有的WSL的使用方法都是观看了以下视频学习：

[东北大学张引-使用Windows构建高效的Linux开发环境](https://www.bilibili.com/video/BV1Du4y1q7YJ/?spm_id_from=333.1387.favlist.content.click&vd_source=c947e414941f765ef242305633b6e7b1)

感谢张引老师的视频教学。

使用CLion进行WSL开发

![imgui_start](https://wandergeneral.cn/static/img/8fd9c036d40c424301d04f5e132747fb.imgui_start.webp)

使用C++构建桌面应用程序，寻找一个合适的Gui框架是棘手的，尽管有很多其他的方法，例如：QT，Wx_Widgets等，但相比于它们，我更喜欢使用ImGui来进行构建应用程序。



在开始前，我们要知道ImGui是什么。

ImGui是一个轻量级、跨平台的图形界面库，不同于Qt、WPF等“保留模式”GUI，ImGui更适合动态、实时场景，值得注意的是ImGui中所有控件都是自绘的，不调用系统UI（如Windows按钮）。

那我们应该如何使用它来构建应用程序呢？

## 1.准备工作

### 1.1项目目录

首先我们先准备项目目录。

例如：项目名为ImGuiGLFW，其中创建三个子文件夹**build/**(其中放项目构建时产生的中间文件)，**libs/**（其中放和imgui，glfw等相关的源文件），**src/**（自己编写的源文件）；由于使用CMake进行项目构建，因此还有新建一个**CMakeLists**文件。如下图所示：

![imgui_project_dir](https://wandergeneral.cn/static/img/45d0822950e4b5e8bf983e2869144cb8.imgui_dir.webp)

### 1.2下载相关源码

要使用ImGui，需要一些必备的东西，以下是需要下载的源码及其网址：

|                  | 网址                   | 位置           |
| --- | --- | --- |
| Dear ImGui 源码| https://github.com/ocornut/imgui/archive/refs/heads/master.zip | 根目录中的cpp和h文件以及backends/文件夹放入 **libs/imgui/** 中 |
| GLFW Windows 预编译 | https://www.glfw.org/download.html → 64-bit binaries | 解压压缩包，将include/ 和 lib-vc2022/ 放入 **libs/glfw/** 中 |
| glad OpenGL 加载器 | https://glad.dav1d.de/ 选 gl3.3Core + Generate&download | 解压文件，将 include/ 与 src/ 放入 **libs/glad/** 中 |

工作做完之后 **libs/** 类似于以下这种结构：
```
libs/
 ├─ imgui/
 │   ├─ *.cpp *.h
 │   └─ backends/
 │       ├─ imgui_impl_glfw.cpp
 │       ├─ imgui_impl_glfw.h
 │       ├─ imgui_impl_opengl3.cpp
 │       └─ imgui_impl_opengl3.h
 ├─ glfw/
 │   ├─ include/
 │   └─ lib-vc2022/glfw3.lib
 └─ glad/
     ├─ include/
     └─ src/glad.c
```


## 2.编写项目文件

### 2.1编写最小main文件

为了测试方便，编写一个最小的可用的main函数放在 **/src/main.cpp** 中。

```C++
// 1) 必须放在最前面
#include <glad/glad.h>

// 2) 然后是 GLFW
#include <GLFW/glfw3.h>

// 3) 其余标准库 / ImGui
#include "imgui.h"
#include "imgui_impl_glfw.h"
#include "imgui_impl_opengl3.h"

#include <cstdio>
#include <cstdlib>

static void glfw_error_callback(int error, const char* description)
{
    fprintf(stderr, "GLFW Error %d: %s\n", error, description);
}

int main(int, char**)
{
    glfwSetErrorCallback(glfw_error_callback);
    if (!glfwInit()) return 1;

    const char* glsl_version = "#version 130";
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 0);

    GLFWwindow* window = glfwCreateWindow(1280, 720, "Dear ImGui GLFW+OpenGL3", nullptr, nullptr);
    if (!window) return 1;
    glfwMakeContextCurrent(window);
    glfwSwapInterval(1); // 开启垂直同步

    // 初始化 GLAD（或 gladLoadGLLoader）
    if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
        return -1;

    IMGUI_CHECKVERSION();
    ImGui::CreateContext();
    ImGuiIO& io = ImGui::GetIO(); (void)io;
    ImGui::StyleColorsDark();
    ImGui_ImplGlfw_InitForOpenGL(window, true);
    ImGui_ImplOpenGL3_Init(glsl_version);

    ImVec4 clear_color(0.45f, 0.55f, 0.60f, 1.00f);

    while (!glfwWindowShouldClose(window) {
        glfwPollEvents();

        ImGui_ImplOpenGL3_NewFrame();
        ImGui_ImplGlfw_NewFrame();
        ImGui::NewFrame();

        ImGui::Begin("Hello, world");
        ImGui::Text("This is a minimal ImGui+GLFW+OpenGL3 program.");
        if (ImGui::Button("Press me"))
            puts("Button pressed!");
        ImGui::End();

        ImGui::Render();
        int display_w, display_h;
        glfwGetFramebufferSize(window, &display_w, &display_h);
        glViewport(0, 0, display_w, display_h);
        glClearColor(clear_color.x, clear_color.y, clear_color.z, clear_color.w);
        glClear(GL_COLOR_BUFFER_BIT);
        ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());

        glfwSwapBuffers(window);
    }

    ImGui_ImplOpenGL3_Shutdown();
    ImGui_ImplGlfw_Shutdown();
    ImGui::DestroyContext();
    glfwDestroyWindow(window);
    glfwTerminate();
    return 0;
}
```

这个函数会展示一个名为`Hello, world`的窗口，其中有一个按钮，按下后打印`Press me`。


### 2.2编写CMakeLists文件

在根目录下新建CMakeLists.txt文件，添加以下内容：

```CMakeLists.txt
cmake_minimum_required(VERSION 3.15)
project(ImGuiGLFW)

set(CMAKE_CXX_STANDARD 17)
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)

# 包含路径
include_directories(
    libs/imgui
    libs/imgui/backends
    libs/glfw/include
    libs/glad/include
)

# ImGui 源码
set(IMGUI_DIR libs/imgui)
add_library(imgui STATIC
    ${IMGUI_DIR}/imgui.cpp
    ${IMGUI_DIR}/imgui_demo.cpp
    ${IMGUI_DIR}/imgui_draw.cpp
    ${IMGUI_DIR}/imgui_tables.cpp
    ${IMGUI_DIR}/imgui_widgets.cpp
    ${IMGUI_DIR}/backends/imgui_impl_glfw.cpp
    ${IMGUI_DIR}/backends/imgui_impl_opengl3.cpp
)

# glad
add_library(glad STATIC libs/glad/src/glad.c)

# 可执行文件
add_executable(${PROJECT_NAME} src/main.cpp)
target_link_libraries(${PROJECT_NAME}
    imgui
    glad
    opengl32
    ${CMAKE_CURRENT_SOURCE_DIR}/libs/glfw/lib-vc2022/glfw3.lib
)
```

//

## 3.编译构建项目&运行

### 3.1编译构建

当所有的文件都准备好以后，就可以进行项目的编译了。

打开终端，进入项目目录，依次输入以下内容：

```bash
cmake -B build -G "Visual Studio 17 2022"
cmake --build build --config Release
```

当如下所示时，代表完成：

![](https://wandergeneral.cn/static/img/8ffed4a65cab56579dbff6dcb89d4ab9.imgui_complate.webp)

这是我们可以在 **/build/bin/Release/** 中找到可执行文件 **ImGuiGLFW.exe** 。

### 3.2运行

找到 ImGuiGLFW.exe ，双击运行便可以看到界面窗口。

至此，我们便使用ImGui构建了一个简单的GUI应用程序。

使用ImGui构建C++应用程序

![](https://wandergeneral.cn/static/img/a429402d45a29afff7302f6232ee312f.orangepistart.webp)
OrangePi香橙派作为一个Linux开发板，从零开始使用也是有一定的难度的，因此需要进行记录。本篇文章是本人使用Linux开发板的一个引领，是开发路上的指向标。

那么就开始吧！


我自己使用的是OrangePi Zero3 1GB版本，其具体的实体如下所示，上面的接口足够我们入门以及基础使用。
![](https://wandergeneral.cn/static/img/001db8c02a75404aeb6b3c90bc0fbb9a.orangepi_picture.webp)

要想使用它，要求我们会使用Linux系统，因此，第一件事便是为其安装Linux系统。
# #安装&配置篇

# 一.下载和烧录Linux系统

## 1.1准备和下载相关的镜像和工具

要想使用OrangePi，首先要烧录Linux系统。

这之前要准备一些东西，如下表所示：

| 物品 | 获取方式 | 备注 |
| --- | --- | --- |
| balenaEtcher | 网上有大量的教程安装，也可以在[香橙派官网](http://www.orangepi.cn/html/serviceAndSupport/)下载官方提供的工具 | 推荐使用这个软件烧录镜像，操作方便，界面简洁。 |
| TF卡和读卡器 | 网上可以买，很便宜 | 推荐使用闪迪品牌的，大小最少8G，我自己用的是16G的。 |


在[香橙派官网](http://www.orangepi.cn/html/serviceAndSupport/)下载Linux镜像，我个人选择的是Ubuntu。
![](https://wandergeneral.cn/static/img/6e78d2db6f660a2f046d520b6cdc3497.gfjx.webp)

:::tip{title="提示"}
获取镜像时会有Linux5.4和Linux6.1内核可选，如果要稳定可以选择5.4版本。
同时还会遇到jammy和focal两种，Focal代表Ubuntu 20.04 LTS，Jammy代表Ubuntu 22.04 LTS。如何选择看自己的习惯。
:::

等下载完成后，就开始准备烧录镜像。

## 1.2基于WindowsPC烧录Linux镜像

将TF卡插入读卡器，并将其插入PC，打开balenaEtcher烧录软件：1.选择镜像（以img结尾）。2.选择盘符（读卡器所在）。3.开始烧录。具体如下所示：
![](https://wandergeneral.cn/static/img/ebe3ab1e30fed7795487a9528e50df9c.shaolu.webp)

烧录时进度条会呈现紫色，等其呈现为绿色时代表正在验证，一直等待其完成烧录。这样我们的系统就准备好了。

# 二.第一次启动（无屏幕）

现在系统已经准备好了，如果你有合适的小的显示器，可以使用HDMI工作，那么这一节便无关紧要，但是，如果你没有合适的显示器，那么这节就刚刚好。

首先要想无屏幕启动并连接，最起码要使用某种方式进行`有线连接`，而我们使用串口进行连接。

## 2.1准备串口连接物品

正所谓：工欲善其事必先利其器，因此在正式的连接前需要我们准备一些东西，如下所示：
| 清单 | 物品 | 备注 |
| --- | --- | --- |
| 1 | USB-TTL | 会使用串口通信测试 |
| 2 | USB-TypeC数据线 | 开发板的供电 |
| 3 | 杜邦线（母-母） | 四根，最少三根。 |
| 4 | MobaXtrem | 连接软件，官方工具中可以找到 |

这些准备好之后就可以进行正式连接了。

首先，**俯视开发板**，将**以太网接口朝下**，我们可以发现**最上方**有**3个**单独的**引脚**，这3个便是串口引脚。如下图引脚图所示：
![OrangePi-Zero3-Pin](https://wandergeneral.cn/static/img/8f909a2be9402dc8fd5e0a5870459507.orangepi_pin_picture.webp)

然后，拿出USB-TTL模块，按照以下方式进行连接，并将其插入PC，具体的顺序可能不同，但接线方法是相同的。
![image.png](https://wandergeneral.cn/static/img/77cd0648b1edf6d66677f2390e7440da.image.webp)

## 2.2使用串口进行连接
插入TF卡，接入电源。

打开 **MobaXtrem** ，打开串口连接，选择相应的串口和波特率（115200），确认连接，等待一段时间，屏幕上会出现启动信息。
![image.png](https://wandergeneral.cn/static/img/8fd9dc55326f39c31b0ede801aed54da.image.webp)

输入密码orange，Linux输入密码是不回显的，因此完整输完后便回车。

:::note{title="账号&密码"}
OrangePi官方默认的账户为orangepi，密码为orangepi。
root用户的密码为orangepi。
:::

等启动完成后，我们便成功的使用串口连接到了orangepi的系统中了。

# 三.配置网络和SSH连接

如果一直使用串口连接显得不是很妥，作为现代化的设备，不支持无线是不可能的，OrangePi Zero3便支持无线WiFi，但是OrangePi要使用WiFi需要进行配置。

## 3.1OrangePiZero连接WiFi

连接WiFi较为繁琐，请参考这篇文章[ OrangePiZero开发板进行WiFi连接 ](https://blog.csdn.net/lsfeitianzhuzhuxia/article/details/134114635)

//

## 3.2使用SSH进行远程连接

//

# 四.配置基础开发环境（C/C++）



## 4.1安装C/C++/make/CMake

//

## 4.2安装git/sql等其他开发工具

//


# #开发&使用篇

OrangePiZero3开发指南

构建分布式RPC调用框架

![](https://wandergeneral.cn/static/img/3a67a54ffb9804052c1ce52fa56ccd60.Reactor_epoll_start.webp)



我们可以将 `Reactor 模型 + epoll` 抽象成一个“事件驱动”的 `I/O 框架`。
 
当我们使用简单的`阻塞IO`时，当有多个客户端进行连接请求时，并不能同一时间都连接上，因此，需要使用循环和多线程的方式将这些连接分布在不同的线程中来各自处理。
 
但是，这样就引发了一些问题。当已连接的fd没有数据可读时，就会在线程中阻塞。当有大量的连接请求时，就会产生同样多的线程，这样就很浪费系统资源。因此需要我们来进行改进使用的方法，将这些问题尽量解决掉。

### 解决1

每个连接都会因为数据的读写而阻塞，能否使用一种方式将阻塞大大减少，这样就不会使所有的连接阻塞，只需要在一个或少量的阻塞对象上等待即可。

这里的解决方法便是使用 `IO多路复用` ；

### 解决2

当有大量的连接请求时，就会有大量线程被创建，连接断开，线程也会随之销毁，连接阻塞时，线程也会一直存在。当数量庞大时就会很浪费系统资源。

这里的解决方法便是使用 `线程池` ；


这两种方式组合在一起便是 `Reactor模型`。

## 1. Reactor

在Reactor中，核心是`epoll`，
```
|1.启动|
|main → socket → bind → listen 
      → epoll_create → epoll_ctl(ADD, listen_fd, EPOLLIN) → epoll_wait |
|2.连接|
|epoll_wait(返回) → accept → conn_fd 
      → epoll_ctl(ADD, conn_fd, EPOLLIN|EPOLLET) → epoll_wait |
|3.可读|
|epoll_wait 返回 → on_read → read (循环直到 EAGAIN) → 解析 → 生成响应 → 写应用缓冲区 
      → epoll_ctl(MOD, conn_fd, EPOLLIN|EPOLLOUT) → epoll_wait |
|4.关闭|
|epoll_wait 返回 → read=0 → close(conn_fd) 
      → epoll_ctl(DEL, conn_fd) |
|5.退出|
|收到 SIGINT → close(listen_fd) → close(epoll_fd) → exit |
```

其中主要的部分`启动`，`连接`，`（可读）回调`的过程如下所示：

![epoll_total](https://wandergeneral.cn/static/img/ba568ef438a7da86473989e3c0b7132f.epoll_total.webp)

## 2. 使用Reactor构建服务端

使用 `epoll + Reactor` 构建服务端程序示例：

```C++
#include <stdlib.h>
#include <stdio.h> 
#include <stdio.h>
#include <sys/socket.h>
#include <sys/epoll.h>
#include <arpa/inet.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <time.h>

#define MAX_EVENTS  1024
#define BUFLEN 128
#define SERV_PORT   8080
/*
 * status:1表示在监听事件中，0表示不在 
 * last_active:记录最后一次响应时间,做超时处理
 */
struct myevent_s {
    int fd;                 //cfd listenfd
    int events;             //EPOLLIN  EPLLOUT
    void *arg;              //指向自己结构体指针
    void (*call_back)(int fd, int events, void *arg);
    int status;
    char buf[BUFLEN];
    int len;
    long last_active;
};

int g_efd;          /* epoll_create返回的句柄 */
struct myevent_s g_events[MAX_EVENTS+1];   /* +1 最后一个用于 listen fd */

void eventset(struct myevent_s *ev, int fd, void (*call_back)(int, int, void *), void *arg) {
    ev->fd = fd;
    ev->call_back = call_back;
    ev->events = 0;
    ev->arg = arg;
    ev->status = 0;
    //memset(ev->buf, 0, sizeof(ev->buf));
    //ev->len = 0;
    ev->last_active = time(NULL);
    return;
}

void recvdata(int fd, int events, void *arg);
void senddata(int fd, int events, void *arg);

void eventadd(int efd, int events, struct myevent_s *ev) {
    struct epoll_event epv = {0, {0}};
    int op;
    epv.data.ptr = ev;
    epv.events = ev->events = events;
    if (ev->status == 1) {
        op = EPOLL_CTL_MOD;
    } 
    else {
        op = EPOLL_CTL_ADD;
        ev->status = 1;
    }
    if (epoll_ctl(efd, op, ev->fd, &epv) < 0) {
        printf("event add failed [fd=%d], events[%d]\n", ev->fd, events);
    }
    else {
        printf("event add OK [fd=%d], op=%d, events[%0X]\n", ev->fd, op, events);
    }
    return;
}

void eventdel(int efd, struct myevent_s *ev) {
    struct epoll_event epv = {0, {0}};
    if (ev->status != 1) {
        return;
    }
    epv.data.ptr = ev;
    ev->status = 0;
    epoll_ctl(efd, EPOLL_CTL_DEL, ev->fd, &epv);
    return;
}

/*接受连接回调*/
void acceptconn(int lfd, int events, void *arg) {
    struct sockaddr_in cin;
    socklen_t len = sizeof(cin);
    int cfd, i;
    if ((cfd = accept(lfd, (struct sockaddr *)&cin, &len)) == -1) {
        if (errno != EAGAIN && errno != EINTR) {
            /* 暂时不做出错处理 */
        }
        printf("%s: accept, %s\n", __func__, strerror(errno));
        return;
    }
    do {
        for (i = 0; i < MAX_EVENTS; i++) {
            if (g_events[i].status == 0)
                break;
        }
        if (i == MAX_EVENTS) {
            printf("%s: max connect limit[%d]\n", __func__, MAX_EVENTS);
            break;
        }
        int flag = 0;
        if ((flag = fcntl(cfd, F_SETFL, O_NONBLOCK)) < 0) {
            printf("%s: fcntl nonblocking failed, %s\n", __func__, strerror(errno));
            break;
        }
        eventset(&g_events[i], cfd, recvdata, &g_events[i]);
        eventadd(g_efd, EPOLLIN, &g_events[i]);
    } while(0);
    printf("new connect [%s:%d][time:%ld], pos[%d]\n", inet_ntoa(cin.sin_addr), ntohs(cin.sin_port), g_events[i].last_active, i);
    return;
}

/*读取数据回调*/
void recvdata(int fd, int events, void *arg) {
    struct myevent_s *ev = (struct myevent_s *)arg;
    int len;
    len = recv(fd, ev->buf, sizeof(ev->buf), 0);
    eventdel(g_efd, ev);
    if (len > 0) {
        ev->len = len;
        ev->buf[len] = '\0';
        printf("C[%d]:%s\n", fd, ev->buf);
        /* 转换为发送事件 */
        eventset(ev, fd, senddata, ev);
        eventadd(g_efd, EPOLLOUT, ev);
    }
    else if (len == 0) {
        close(ev->fd);
        /* ev-g_events 地址相减得到偏移元素位置 */
        printf("[fd=%d] pos[%d], closed\n", fd, (int)(ev - g_events));
    }
    else {
        close(ev->fd);
        printf("recv[fd=%d] error[%d]:%s\n", fd, errno, strerror(errno));
    }
    return;
}

/*发送数据回调*/
void senddata(int fd, int events, void *arg) {
    struct myevent_s *ev = (struct myevent_s *)arg;
    int len;
    len = send(fd, ev->buf, ev->len, 0);
    //printf("fd=%d\tev->buf=%s\ttev->len=%d\n", fd, ev->buf, ev->len);
    //printf("send len = %d\n", len);
    eventdel(g_efd, ev);
    if (len > 0) {
        printf("send[fd=%d], [%d]%s\n", fd, len, ev->buf);
        eventset(ev, fd, recvdata, ev);
        eventadd(g_efd, EPOLLIN, ev);
    }
    else {
        close(ev->fd);
        printf("send[fd=%d] error %s\n", fd, strerror(errno));
    }
    return;
}

/*初始化监听套接字*/
void initlistensocket(int efd, short port) {
    int lfd = socket(AF_INET, SOCK_STREAM, 0);
    fcntl(lfd, F_SETFL, O_NONBLOCK);
    eventset(&g_events[MAX_EVENTS], lfd, acceptconn, &g_events[MAX_EVENTS]);
    
    eventadd(efd, EPOLLIN, &g_events[MAX_EVENTS]);
    
    struct sockaddr_in sin;
    memset(&sin, 0, sizeof(sin));
    sin.sin_family = AF_INET;
    sin.sin_addr.s_addr = INADDR_ANY;
    sin.sin_port = htons(port);
    
    bind(lfd, (struct sockaddr *)&sin, sizeof(sin));
    listen(lfd, 20);
    return;
}

int main(int argc, char *argv[]) {
    unsigned short port = SERV_PORT;
    if (argc == 2)
        port = atoi(argv[1]);
    
    g_efd = epoll_create(MAX_EVENTS+1);
    if (g_efd <= 0)
        printf("create efd in %s err %s\n", __func__, strerror(errno));
    initlistensocket(g_efd, port);
    /* 事件循环 */
    struct epoll_event events[MAX_EVENTS+1];
    printf("server running:port[%d]\n", port);
    int checkpos = 0, i;
    while (1) {
        /* 超时验证，每次测试100个链接，不测试listenfd 当客户端60秒内没有和服务器通信，则关闭此客户端链接 */
        long now = time(NULL);
        for (i = 0; i < 100; i++, checkpos++) {
            if (checkpos == MAX_EVENTS)
                checkpos = 0;
            if (g_events[checkpos].status != 1)
                continue;
            long duration = now - g_events[checkpos].last_active;
            if (duration >= 60) {
                close(g_events[checkpos].fd);
                printf("[fd=%d] timeout\n", g_events[checkpos].fd);
                eventdel(g_efd, &g_events[checkpos]);
            }
        }
        /* 等待事件发生 */
        int nfd = epoll_wait(g_efd, events, MAX_EVENTS+1, 1000);
        if (nfd < 0) {
            printf("epoll_wait error, exit\n");
            break;
        }
        for (i = 0; i < nfd; i++) {
            struct myevent_s *ev = (struct myevent_s *)events[i].data.ptr;
            if ((events[i].events & EPOLLIN) && (ev->events & EPOLLIN)) {
                ev->call_back(ev->fd, events[i].events, ev->arg);
            }
            if ((events[i].events & EPOLLOUT) && (ev->events & EPOLLOUT)) {
                ev->call_back(ev->fd, events[i].events, ev->arg);
            }
        }
        //
    }
    /* 退出前释放所有资源 */
    return 0;
}
```
理论

Reactor 与 epoll——构建高并发的TCP服务框架

韩康慨的个人主页，记录计算机/互联网行业的一名普通人在学习和开发过程中的点滴，为自己留下一个憧憬。

MP-RPC项目