整理目录

docs/dev/backend/_category_.json

@@ -0,0 +1,4 @@
+{
+  "label": "后端开发",
+  "position": 3
+}

docs/dev/backend/c-协程.md

@@ -0,0 +1,277 @@
+---
+title: c 协程
+---
+
+## 前言
+
+协程可以说是用同步的代码写出异步的效果，前几天还看了异步，这些都算是在高性能系统中的一部分，都是压榨我们的 cpu，将 io 堵塞的时间去做其他事情。
+
+异步的解决方式是执行立刻返回，我们的代码继续往下走，当完成之后通知我们。
+
+协程的方式是代码执行立刻返回，之后我们将该条协程挂起，然后这段时间去执行其他的协程，等待 io 完成后恢复这条协程继续往下执行。相比于异步，至少在代码上就不会出现那种回调地狱了。
+
+和线程相比，协程更加轻量，占用资源更少，通过协作的方式利用资源（因为是在单条线程内，不会同时执行）而不是抢占（多条线程可能同时执行读取某一数据），线程是由系统进行调度，协程是用户自己进行调度。
+
+## 实现
+
+在 c 中有好几种协程的实现方式，这里我使用 ucontext 实现
+
+- 利用 switch-case 奇淫巧技实现
+- asm 汇编实现
+- 利用 c 的 setjmp 和 longjmp 函数实现
+- ucontext 保存上下文实现
+- boost.context
+
+### ucontext 函数
+
+先了解一下[ucontext](http://pubs.opengroup.org/onlinepubs/7908799/xsh/ucontext.h.html)的函数
+
+```c
+int  getcontext(ucontext_t *);
+int  setcontext(const ucontext_t *);
+void makecontext(ucontext_t *, (void *)(), int, ...);
+int  swapcontext(ucontext_t *, const ucontext_t *);
+```
+
+### get/setcontext
+
+[http://pubs.opengroup.org/onlinepubs/7908799/xsh/getcontext.html](http://pubs.opengroup.org/onlinepubs/7908799/xsh/getcontext.html)
+用于获取当前和设置上下文
+
+#### 例子
+
+这个例子会一直输出 hello，和 goto 有点相似，不同的是，它可以在不同的函数之中进行跳转
+
+getcontext 把当前的上下文保存到 ucp 中，后面使用 setcontext 恢复
+
+```c
+ucontext_t ucp;
+void print() {
+    printf("hello\n");
+    setcontext(&ucp);
+}
+int main() {
+    getcontext(&ucp);
+    sleep(1);
+    print();
+    return 0;
+}
+```
+
+### make/swapcontext
+
+修改 getcontext 初始化的 ucp 上下文，调用 swapcontext 或 setcontext 恢复的时候程序将调用 func，可以自己分配堆栈，**uc_link**可以指定执行完后的上下文
+
+swapcontext 将当前上下文保存在 ocup 上，并将上下文设置为 ucp
+
+#### 例子
+
+```c
+void print() {
+    printf("hello\n");
+}
+
+int main() {
+    ucontext_t ucp, print_ucp;
+    getcontext(&ucp);
+    print_ucp = ucp;
+    char stack[10 * 1204];
+    print_ucp.uc_stack.ss_sp = stack;
+    print_ucp.uc_stack.ss_size = sizeof(stack);
+    print_ucp.uc_stack.ss_flags = 0;
+    print_ucp.uc_link = &ucp;
+    makecontext(&print_ucp, print, 0);
+
+    swapcontext(&ucp, &print_ucp);
+    printf("end\n");
+    return 0;
+}
+```
+
+### 协程
+
+协程的一个关键就是上下文切换，在我们需要的时候切换至其他的协程
+
+这里我只是写了一个非常简单的协程，只有创建，挂起，恢复功能
+
+### 定义
+
+定义了协程的状态，大小，协程函数指针，我的协程的结构体
+
+**重点是我们的结构体里面，两个 ucontext_t，我们需要利用他们进行上下文的切换**
+
+```c
+#define STACK_SIZE 1024*128
+#define CO_RUN 1
+#define CO_HANG 2
+#define CO_OVER 3
+
+typedef void (*co_func)(struct coroutine *co);
+
+struct coroutine {
+    char stack[STACK_SIZE];//栈
+    ucontext_t ctx;//协程上下文
+    ucontext_t ucp;//主线程上下文
+    char status;//协程状态
+};
+```
+
+#### 创建协程
+
+这里我没有直接的指向**func**因为还有一个完成状态要标记，所以我们定义了一个我们的协程主函数进行一些处理
+
+我的创建协程主要是做的事情是，初始化上下文，调起函数
+
+```c
+void co_main(struct coroutine *co, co_func func) {
+    func(co);
+    co->status = CO_OVER;
+}
+void co_create(struct coroutine *co, co_func func) {
+    getcontext(&co->ucp);
+    co->ctx = co->ucp;
+    co->ctx.uc_stack.ss_sp = co->stack;
+    co->ctx.uc_stack.ss_size = STACK_SIZE;
+    co->ctx.uc_stack.ss_flags = 0;
+    co->ctx.uc_link = &co->ucp;
+    co->status = CO_RUN;
+    makecontext(&co->ctx, co_main, 2, co, func);//指向的co_main
+    swapcontext(&co->ucp, &co->ctx);
+}
+```
+
+### 挂起/恢复协程
+
+挂起和恢复的时候我们都用 status 判断了一下是否执行结束
+
+挂起和恢复就是上下文的交换，调用的**swapcontext**，挂起时将我们协程的上下文记录，切换到线程的上下文，交给线程去进行调度，恢复则相反
+
+```c
+void co_yield(struct coroutine *co) {
+    if (co->status == CO_OVER) {
+        return;
+    }
+    co->status = CO_HANG;
+    swapcontext(&co->ctx, &co->ucp);
+}
+
+void co_resume(struct coroutine *co) {
+    if (co->status == CO_OVER) {
+        return;
+    }
+    co->status = CO_RUN;
+    swapcontext(&co->ucp, &co->ctx);
+}
+```
+
+### 完整源码
+
+```c
+#include <stdio.h>
+#include <ucontext.h>
+#include <mhash.h>
+
+#define STACK_SIZE 1024*128
+#define CO_RUN 1
+#define CO_HANG 2
+#define CO_OVER 3
+
+typedef void (*co_func)(struct coroutine *co);
+
+struct coroutine {
+    char stack[STACK_SIZE];//栈
+    ucontext_t ctx;//ucp
+    ucontext_t ucp;
+    char status;//协程状态
+};
+
+void co_main(struct coroutine *co, co_func func) {
+    func(co);
+    co->status = CO_OVER;
+}
+
+void co_create(struct coroutine *co, co_func func) {
+    getcontext(&co->ucp);
+    co->ctx = co->ucp;
+    co->ctx.uc_stack.ss_sp = co->stack;
+    co->ctx.uc_stack.ss_size = STACK_SIZE;
+    co->ctx.uc_stack.ss_flags = 0;
+    co->ctx.uc_link = &co->ucp;
+    co->status = CO_RUN;
+    makecontext(&co->ctx, co_main, 2, co, func);
+    swapcontext(&co->ucp, &co->ctx);
+}
+
+void co_yield(struct coroutine *co) {
+    if (co->status == CO_OVER) {
+        return;
+    }
+    co->status = CO_HANG;
+    swapcontext(&co->ctx, &co->ucp);
+}
+
+void co_resume(struct coroutine *co) {
+    if (co->status == CO_OVER) {
+        return;
+    }
+    co->status = CO_RUN;
+    swapcontext(&co->ucp, &co->ctx);
+}
+
+int co_status(struct coroutine *co) {
+    return co->status;
+}
+
+void print1(struct coroutine *co) {
+    for (int i = 0; i < 50; i++) {
+        printf("1号协程:%d\n", i);
+        co_yield(co);
+    }
+}
+
+void print2(struct coroutine *co) {
+    for (int i = 100; i < 200; i++) {
+        printf("2号协程:%d\n", i);
+        co_yield(co);
+    }
+}
+
+int main() {
+    struct coroutine co1, co2;
+    co_create(&co1, print1);
+    co_create(&co2, print2);
+    while (co_status(&co1) != CO_OVER || co_status(&co2) != CO_OVER) {
+        co_resume(&co1);
+        co_resume(&co2);
+    }
+    return 0;
+}
+```
+
+### 栈
+
+贴一个例子，将上面的第二个 swapcontext 那里的例子，print 换成下面这个，帮助大家理解一下栈，看输出，暂时就不写说明了
+
+```c
+void test() {
+    int a = 1, len = ((int64_t) (&stack[10 * 1024 - 1]) - (int64_t) (&a)), b = 23;
+    for (int i = 10 * 1024 - len - 8; i < 10 * 1024; i++) {
+        if (i % 20 == 0) {
+            printf("\n");
+        }
+        printf("%d\t", stack[i]);
+    }
+}
+
+void print() {
+    int a = 1, len = ((int64_t) (&stack[10 * 1024 - 1]) - (int64_t) (&a)), b = 23;
+    printf("hello,%ld,%ld,%d\n", &a, &stack[10 * 1024 - 1], (int64_t) (&stack[10 * 1024 - 1]) - (int64_t) (&a));
+    test();
+//    for (int i = 10 * 1024 - len - 8; i < 10 * 1024; i++) {
+//        if (i % 20 == 0) {
+//            printf("\n");
+//        }
+//        printf("%d\t", stack[i]);
+//    }
+}
+```

docs/dev/frontend/README.md

@@ -0,0 +1 @@
+前端开发

docs/dev/frontend/_category_.json

@@ -0,0 +1,4 @@
+{
+  "label": "前端开发",
+  "position": 3
+}

docs/dev/language/README.md

@@ -0,0 +1,6 @@
+---
+title: 编程语言
+sidebar_position: 1
+---
+
+编程语言

docs/dev/language/_category_.json

@@ -0,0 +1,4 @@
+{
+  "label": "编程语言",
+  "position": 2
+}

docs/dev/language/golang/go-slice.md

@@ -1,5 +1,5 @@
 ---
-title: GO Slice(切片)
+title: Go Slice(切片)
 ---
 
 > 感觉切片只要知道底层是引用的一个数组对象,就挺好理解了.这里写下一些笔记,方便记忆和以后再来查找.

docs/dev/tools/_category_.json

@@ -0,0 +1,4 @@
+{
+  "label": "开发工具",
+  "position": 5
+}