wipping的技术小栈
wipping的技术小栈

操作系统——协程

一、前言

自从换工作以后，已经少有业务学习技术的时间了，对于大的知识点的积累和更新变得比较困难。而本文的知识点——了解协程 适合作为一个在紧凑的工作生活中学习的技术。协程本身不难，但是要了解其中精髓并写出好用的协程应用是需要花费一定时间的。本文将初步的讲解协程的基础知识，并结合一段开源代码进行讲解，最后会通过修改代码完成一定的功能修改，尽量使读者可以基本了解协程

本文前置知识：

  1. 进程
  2. 线程
  3. 上下文切换

二、正文

2.1 传统调用

在了解 协程 之前，我们需要了解一下传统执行流中是如何完成我们的任务的。
通常来说，函数 或者 称为 子程序、子例程 都是层级调用的，比如 下面的伪代码中：

int A()
{
    a()
}
int func()
{
    A()
    B()
    C()
}

如果上述代码使用 线程 进行调用函数 func()，那么就会是：

  1. 调用 A()，进入 A() 执行 a() ，然后返回
  2. 调用 B() 后返回
  3. 调用 C() 返回

上述函数如果在执行过程中被系统切换出去，回来继续从原来的地方继续执行。其 调用顺序是明确的 。

2.2 协程调用

结合 进程 和 线程 ，其各自的基本概念如下：

  1. 进程：指计算机中已运行的 程序，程序 是 指令和数据及其组织形式的描述。在以前的描述描述中通常会有 进程是操作系统资源调度的基本单位，但在现在的操作系统中，进程不再是执行的基本单位，而是 线程的容器。相较于 线程 和 协程， 进程 拥有最多的资源，比如 文件、内存 等
  2. 线程：是 操作系统资源调度的基本单位。一个线程是一个进程中的一个单一执行流。统一进程中的线程共享该进程的所有资源
  3. 协程：又称为 用户态线程，用于完成 协作式多任务 的 子程序，允许执行被挂起与被恢复。其本质还是 子例程的上下文。

协程可以这样通俗的理解，即 多个函数可以在一个线程中被平等调用，这里的 平等调用 是允许 挂起和恢复，不是传统意义上的函数调用。也就是函数可以在执行到一半的时候，在适当的时机切出去完成其他函数，而这都是在同一个线程中完成。

需要注意的的时：
1. 通常 协程 主动在合适的时机通过主动让出的方式让其他协程得以执行
2. 如果没有主动让出并完成后退出函数。会按照调度算法调度下一个协程执行
3. 具体如何完成协程的退出需要看具体实现

使用代码说明的话，其更像是：

int func()
{
    A()/B()/C()
}

上述这段奇怪的代码表示的是：

  1. 在 func() 中可以即执行 A()，也执行 B() 和 C()，他们的之间没有明确的调用顺序
  2. 在 A() 执行到中途时，可以在适当的时机切换为执行 B() 或 C()
  3. 当 B() 或 C() 执行完成或者再某个适当的时机再切换为执行 A()
  4. B() 或 C() 同理

以上的过程是在同一个线程中完成，不会涉及到线程的切换，减少了系统开销。

熟悉 GO语言 的读者应该对协程会比较熟悉，在 高IO 场景下，协程可以在 低系统切换开销 的情况下有效的执行多个 子程序，从而优化整体性能。

2.3 代码示例

笔者使用一个比较简单的开源协程库进行说明，以便读者理解协程。
前提说明：

  1. 该代码使用 POSIX 的 ucontext函数族 进行实现，读者可以自行查阅该函数族的相关资料。
  2. 在该代码中可以简单理解 ucontext函数族 提供了 上下文切换的条件

下面的协程的实现讲解

/*---------------------coroutine.h---------------------*/
#ifndef C_COROUTINE_H
#define C_COROUTINE_H

#define COROUTINE_DEAD 0
#define COROUTINE_READY 1
#define COROUTINE_RUNNING 2
#define COROUTINE_SUSPEND 3

struct schedule;

typedef void (*coroutine_func)(struct schedule *, void *ud);

struct schedule * coroutine_open(void);
void coroutine_close(struct schedule *);

int coroutine_new(struct schedule *, coroutine_func, void *ud);
void coroutine_resume(struct schedule *, int id);
int coroutine_status(struct schedule *, int id);
int coroutine_running(struct schedule *);
void coroutine_yield(struct schedule *);

#endif


/*---------------------coroutine.c---------------------*/
struct coroutine;

/* 协程调度器 */
struct schedule {
    char stack[STACK_SIZE]; //栈，用于协程运行时使用
    ucontext_t main;//主协程
    int nco;//协程数量
    int cap;//协程调度器允许创建的最多协程数量
    int running;//当前运行的协程id
    struct coroutine **co;//数组指针，用于指向协程实例数组
};

/* 协程 */
struct coroutine {
    coroutine_func func; //协程执行的子程序或函数
    void *ud;//函数变量
    ucontext_t ctx;//上下文
    struct schedule * sch;//该协程所在的调度器
    ptrdiff_t cap; //协程栈的容量
    ptrdiff_t size; //协程栈的大小，一般和cap相等
    int status; //协程的状态
    char *stack;//协程的栈，用于协程保存栈使用，并不是再运行时使用，主要功能是保存协程的栈
};

/* 创建协程实例 */
struct coroutine * 
_co_new(struct schedule *S , coroutine_func func, void *ud) {
    /* 创建协程所需要的实例 */
    struct coroutine * co = malloc(sizeof(*co));
    /* 初始化各项基本成员 */
    co->func = func;
    co->ud = ud;
    co->sch = S;
    co->cap = 0;
    co->size = 0;
    co->status = COROUTINE_READY; 
    co->stack = NULL;
    return co;
}

/* 删除协程实例 */
void
_co_delete(struct coroutine *co) {
    /* 
      协程在调度过程中可能会开辟栈，所以这里需要释放，
      相关内容需要在下面的代码中才能进行讲解 
    */
    free(co->stack);
    /* 释放协程 */
    free(co);
}

/* 打开协程调度器，通过调用该函数的为主协程 */
struct schedule * 
coroutine_open(void) {
    /* 开辟调度器 */
    struct schedule *S = malloc(sizeof(*S));
    /* 初始化调度器成员 */
    S->nco = 0;
    S->cap = DEFAULT_COROUTINE;//DEFAULT_COROUTINE = 16
    S->running = -1;//running = -1指当前为主协程在执行
    S->co = malloc(sizeof(struct coroutine *) * S->cap);//开辟协程数组
    memset(S->co, 0, sizeof(struct coroutine *) * S->cap);//清空协程数组
    return S;
}

/* 关闭协程调度器 */
void 
coroutine_close(struct schedule *S) {
    int i;
    /* 删除所有协程 */
    for (i=0;icap;i++) {
        struct coroutine * co = S->co[i];
        if (co) {
            _co_delete(co);
        }
    }
    /* 删除协程数组 */
    free(S->co);
    S->co = NULL;
    /*  释放调度器 */
    free(S);
}

/* 
    创建协程 
    S ：协程调度器
    func：协程需要执行的函数
    ud：函数参数
*/
int 
coroutine_new(struct schedule *S, coroutine_func func, void *ud) {
    /* 创建协程实例 */
    struct coroutine *co = _co_new(S, func , ud);
    /* 
      查看当前协程的数量是否达到上限 
      如果到达上限，则扩大容量为原来的2倍，并将新创建的协程放在其中
      最后返回协程的id
    */
    if (S->nco >= S->cap) {
        int id = S->cap;
        S->co = realloc(S->co, S->cap * 2 * sizeof(struct coroutine *));
        memset(S->co + S->cap , 0 , sizeof(struct coroutine *) * S->cap);
        S->co[S->cap] = co;
        S->cap *= 2;
        ++S->nco;
        return id;
    } else {
    /*
      如果协程数量没有超过上限，则将协程添加到调度器中，并返回协程的id
    */
        int i;
        for (i=0;icap;i++) {
            int id = (i+S->nco) % S->cap;
            if (S->co[id] == NULL) {
                S->co[id] = co;
                ++S->nco;
                return id;
            }
        }
    }
    assert(0);
    return -1;
}

/*
    协程的主要执行函数，协程并不是执行执行其函数的，一般都在mainfunc中执行
    在协程执行前后需要做一些处理
    low32：调度器地址的低32bit
    high：调度器地址的高32bit
*/
static void
mainfunc(uint32_t low32, uint32_t hi32) {
    /* 获取调度器 */
    uintptr_t ptr = (uintptr_t)low32 | ((uintptr_t)hi32 << 32);
    struct schedule *S = (struct schedule *)ptr;
    /* 获取当前调度需要执行的协程id，并通过id获取协程的实例 */  
    int id = S->running;
    struct coroutine *C = S->co[id];
    /* 执行协程的函数 */
    C->func(S,C->ud);
    /* 由于协程没有主动让出并退出了函数，这里需要对协程进行回收 */
    _co_delete(C);//删除协程实例
    S->co[id] = NULL;//将协程在调度器中去掉
    --S->nco;//减少调度器的协程数量
    /*
      1. 使用ucontext函数族实现时上文下切换，当前上下文退出后会切换到指定的上下文
      2. 该调度器的实现是需要从主线程切换到其他协程，所以当协程退出后会返回主协程
      3. 将当前执行的协程id修改为-1，表示当前是主协程执行
    */
    S->running = -1;
}

/* 
    恢复协程，该函数通常在主协程中使用
    S：协程调度器
    id：需要恢复执行的协程id
*/
void 
coroutine_resume(struct schedule * S, int id) {
    assert(S->running == -1);
    assert(id >=0 && id < S->cap);
    /* 获取需要恢复执行的协程的id并判断其有效性 */
    struct coroutine *C = S->co[id];
    if (C == NULL)
        return;
    /* 获取协程的状态，并根据状态使用不同的操作 */
    int status = C->status;
    switch(status) {
    /* 
      协程完成创建时状态为COROUTINE_READY 
      此时协程的上下文并没有完成初始化，所以需要特殊处理
    */
    case COROUTINE_READY:
        /* 初始化协程上下文 */
        getcontext(&C->ctx);
        C->ctx.uc_stack.ss_sp = S->stack;//指定协程的栈为使用调度的栈成员
        C->ctx.uc_stack.ss_size = STACK_SIZE;//指定协程栈的大小
        C->ctx.uc_link = &S->main;//指定协程退出后返回到主协程，与mainfunc中的操作相呼应
        S->running = id;//声明当前执行的协程id
        C->status = COROUTINE_RUNNING;//将协程的状态设置为RUNNING
        /* 
          使用makecontext创建协程上下文 
          1. 协程的执行函数为mainfunc
          2. 指定mainfunc的参数的数量为2，分别为调度器的指针的高低32bit
        */
        uintptr_t ptr = (uintptr_t)S;//
        makecontext(&C->ctx, (void (*)(void)) mainfunc, 2, (uint32_t)ptr, (uint32_t)(ptr>>32));
          /* 
            使用swapcontext完成上下文的切换
            1. 该函数会将当前的上下文保存在S->main中，该函数通常在主线程中执行，所以S->main也就保存了当前的上下文
            2. 将当前的上下文切换到C->ctx，即刚刚构造的上下文中
            3. 下一步会跳到刚刚指定的mainfunc中执行协程的func成员
          */
        swapcontext(&S->main, &C->ctx);
        break;
    /*
      协程在挂起时状态为COROUTINE_SUSPEND，此时协程已经有了上下文，但是被挂起，现在需要恢复执行
    */
    case COROUTINE_SUSPEND:
        /* 将协程的保存的栈设置到调度器S的栈成员中，因为在协程上下文初始化时指定的栈是调度器S的stack成员 */
        memcpy(S->stack + STACK_SIZE - C->size, C->stack, C->size);
        S->running = id;//声明当前执行的协程id为恢复执行协程的id
        C->status = COROUTINE_RUNNING;//将协程的状态设置为RUNNING
        swapcontext(&S->main, &C->ctx);//切换协程
        break;
    default:
        assert(0);
    }
}

/* 
    保存协程的栈，通常在协程的让出函数中调用，用于保存协程当前执行的栈
    C：协程
    top：协程的栈底指正，使用top表示的是地址的top，因为栈是向上增长的，所以方向反了
*/
static void
_save_stack(struct coroutine *C, char *top) {
    /* dummp为当前协程的栈顶变量，通过dummu可以获取当前的栈顶指针 */
    char dummy = 0;
    assert(top - &dummy <= STACK_SIZE);
    /* 如果当前的栈顶是否已经超出当前栈的容量 */
    if (C->cap < top - &dummy) {
        free(C->stack);//释放当前协程的保存栈
        C->cap = top-&dummy;//获取当前栈使用的大小
        C->stack = malloc(C->cap);//根据大小重新分配保存栈
    }
    C->size = top - &dummy;//设置保存栈大小，也就是当前栈使用的情况
    memcpy(C->stack, &dummy, C->size);//将栈保存到协程的stack成员中，在这里完成了栈的保存
}

/*
  协程让出函数，通常协程自己调用，用于当前协程让出给其他协程使用，在该实现中是让出到主协程
  S：协程调度器
*/
void
coroutine_yield(struct schedule * S) {
    /* 获取当前运行的协程id */
    int id = S->running;
    assert(id >= 0);
    /* 获取当前协程实例 */
    struct coroutine * C = S->co[id];
    assert((char *)&C > S->stack);
    /* 将当前的运行栈保存到协程中 */
    _save_stack(C,S->stack + STACK_SIZE);
    /* 将协程状态置为挂起 */
    C->status = COROUTINE_SUSPEND;
    /* 声明运行协程id */
    S->running = -1;
    /* 切换上下文到主协程 */
    swapcontext(&C->ctx , &S->main);
}

/* 获取指定id协程的状态 */
int 
coroutine_status(struct schedule * S, int id) {
    assert(id>=0 && id < S->cap);
    if (S->co[id] == NULL) {
        return COROUTINE_DEAD;
    }
    return S->co[id]->status;
}

/* 获取当前运行的协程id*/
int 
coroutine_running(struct schedule * S) {
    return S->running;
}

上面主要讲解了协程的实现，但关看实现可能还无法完全了解协程是如何运行的，此时还无法将协程的整个声明周期组织起来
下面讲解一下该协程库的demo，方便读者理解

#include "coroutine.h"
#include 

struct args {
    int n;
};

/* 协程的执行函数 */
static void
foo(struct schedule * S, void *ud) {
    struct args * arg = ud;
    int start = arg->n;
    int i;
    for (i=0;i<5;i++) {
      /* 打印当前协程的id和变量 */
        printf("coroutine %d : %d\n",coroutine_running(S) , start + i);
        /* 让出协程 */
        coroutine_yield(S);
    }
}

/* 测试函数 */
static void
test(struct schedule *S) {
    struct args arg1 = { 0 };
    struct args arg2 = { 100 };
    /* 
      1. 创建2个协程，并传入相同的执行函数 
      2. 传入不同的变量，用于区分协程
    */
    int co1 = coroutine_new(S, foo, &arg1);
    int co2 = coroutine_new(S, foo, &arg2);
    printf("main start\n");
    /* 
      1. 判断2个协程的状态，如果为COROUTINE_DEAD(0)则说明协程已经退出 
      2. 至于协程退出可以看上一章节中的mainfunc函数讲解
    */
    while (coroutine_status(S,co1) && coroutine_status(S,co2)) {
        /* 如果没有退出则恢复当前协程执行 */
        printf("step 1\n");
        coroutine_resume(S,co1);
        printf("step 2\n");
        coroutine_resume(S,co2);
        printf("step 3\n");
    } 
    printf("main end\n");
}

int 
main() {
    struct schedule * S = coroutine_open();
    test(S);
    coroutine_close(S);
    
    return 0;
}

执行结果为：


修改

从demo可以看出几点：
1. 每次执行完协程后都需要返回主协程，并由主协程继续恢复下一个协程的运行
2. 从而可以看出该库的协程的顺序是明确的

2.4 代码修改

在 2.3章节 中我们可以了解到协程的的运行，但该实现会造成2个问题：
1.每次协程让出都需要回到主协程才能继续下一个协程，造成不必要的切换，因为主协程本身没有做任何事情
2. 协程的执行顺序由主协程指定，无法根据调度算法进行切换

基于上面2个原因，笔者修改代码以实现下面2点：
1. 协程让出或者退出后不回到主协程，由调度器查找下一个运行的协程并执行
2. 运行的协程有调度算法决定

下面的代码修改和讲解

/*---------------------coroutine_v2.h---------------------*/
#ifndef C_COROUTINE_H
#define C_COROUTINE_H

#define COROUTINE_DEAD 0
#define COROUTINE_READY 1
#define COROUTINE_RUNNING 2
#define COROUTINE_SUSPEND 3

struct schedule;

typedef void (*coroutine_func)(struct schedule *, void *ud);

struct schedule * coroutine_open(void);
void coroutine_close(struct schedule *);

/* 相比于上面版本，少了resum恢复函数，只有yield让出函数 */
int coroutine_new(struct schedule *, coroutine_func, void *ud);
int coroutine_status(struct schedule *, int id);
int coroutine_running(struct schedule *);
void coroutine_yield(struct schedule *);

#endif

/*---------------------coroutine_v2.c---------------------*/
#include "coroutine.h"
#include 
#include 
#include 
#include 
#include 
#include 

#if __APPLE__ && __MACH__
    #include 
#else
    #include 
#endif

#define STACK_SIZE (1024*1024)
#define DEFAULT_COROUTINE 16

/* 协程 */
struct coroutine
{
    coroutine_func func;//协程执行函数
    void *ud;//函数变量
    ucontext_t ctx;//协程上下文
    struct schedule * sch;//协程所在的调度器
    ptrdiff_t cap;//协程栈的容量
    ptrdiff_t size;//协程栈的大小，一般于cap相等
    int status;//协程状态
    char* stack;//协程的栈，该栈是运行时使用。并不是之前是保存时使用
};

/*
    协程调度器
    可以看出和之前相比少了许多成员
*/
struct schedule
{
    int nco;//协程数量
    int cap;//调度器的协程最大数量
    int running;//当前运行的协程id
    ucontext_t main;//主协程上下文
    struct coroutine **co;//数组指针，指向协程数组
};

/* 删除协程 */
void co_delete(struct coroutine *co)
{
    /*
        1. 与之前的实现不同，这里删除协程修改为将协程的状态置为COROUTINE_DEAD
        2. 使用该状态以让协程在调度时不会被选择
    */
    co->status = COROUTINE_DEAD;
}

/* 查找下一个可以执行的协程 */
static int find_next_co(struct schedule *S, int id)
{
    /*
        1. 找到下一个存在切状态为挂起或者ready的协程
        2. 状态为COROUTINE_DEAD的协程不会被查找到
    */
    for (int i = id; i < S->nco; i++)
    {
        if (NULL == S->co[i])
        {
            continue;
        }

        if (COROUTINE_SUSPEND == S->co[i]->status || COROUTINE_READY == S->co[i]->status)
        {
            return i;
        }
    }

    /* 如果没有满足的协程的返回-1，回到主协程 */
    return -1;
}

/*
  协程的主要执行函数，在该函数中执行协程中的func成员
*/
static void mainfunc(uint32_t low32, uint32_t hi32)
{
    uintptr_t ptr = (uintptr_t)low32 | ((uintptr_t)hi32 << 32);
    struct schedule *S = (struct schedule *)ptr;
    int id = S->running;
    struct coroutine *C = S->co[id];
    struct coroutine *next_C = NULL;
    C->func(S,C->ud);
    /*
      与之前的实现不同，这里对于协程退出的处理做了修改
      1. co_delete没有直接删除协程，只是修改了状态
      2. 因为这里还在协程的上下文中，此时删除协程会出错
      3. 查找下一个执行的协程
      4. 如果协程调度器没有需要执行的协程了，则直接返回主协程
    */
    co_delete(C);
    id = find_next_co(S, id);
    if (-1 == id)
    {
        /* 如果协程调度器没有需要执行的协程了，则直接返回主协程 */
        S->running = -1;
        setcontext(&S->main);
    }
    else
    {
        /* 执行下一个协程 */
        S->running = id;
        next_C = S->co[id];
        setcontext(&next_C->ctx);
    }
}

struct coroutine *co_new(struct schedule *S , coroutine_func func, void *ud)
{
    struct coroutine* co = malloc(sizeof(*co));
    co->func = func;
    co->ud = ud;
    co->sch = S;
    co->cap = STACK_SIZE;
    co->size = STACK_SIZE;
    co->status = COROUTINE_READY;
    co->stack = malloc(STACK_SIZE);//分配协程的栈，这里主要是用于协程执行时使用

    /*
      初始化协程上下文
      与之前相比：
      1. 协程上下文的初始化在创建协程时完成，不在resum函数中执行
      2. 协程上下文中运行的栈改为协程的stack成员，而不是之前调度器中stack成员
      这样做的好处是不需要在调度时保存栈，直接切换上下文即可
    */
    getcontext(&co->ctx);
    co->ctx.uc_stack.ss_sp = co->stack;
    co->ctx.uc_stack.ss_size = STACK_SIZE;
    co->ctx.uc_link = &S->main;
    /* 创建协程上下文 */
    uintptr_t ptr = (uintptr_t)S;
    makecontext(&co->ctx, (void (*)(void)) mainfunc, 2, (uint32_t)ptr, (uint32_t)(ptr>>32));

    return co;
}

/* 打开协程调度器，与之前的实现一样 */
struct schedule* coroutine_open(void)
{
    struct schedule *S = malloc(sizeof(*S));
    S->nco = 0;
    S->cap = DEFAULT_COROUTINE;
    S->running = -1;
    S->co = malloc(sizeof(struct coroutine *) * S->cap);
    memset(S->co, 0, sizeof(struct coroutine *) * S->cap);
    return S;
}

/* 关闭协程调度器 */
void coroutine_close(struct schedule *S)
{
    int i;
    for (i = 0; i < S->cap; i++)
    {
        struct coroutine* co = S->co[i];
        if (co)
        {
            /* 删除协程及其栈 */
            free(co->stack);
            free(co);
        }
    }
    free(S->co);
    S->co = NULL;
    free(S);
}

/* 创建协程，与之前的实现一样 */
int coroutine_new(struct schedule *S, coroutine_func func, void *ud)
{
    struct coroutine *co = co_new(S, func , ud);
    if (S->nco >= S->cap)
    {
        int id = S->cap;
        S->co = realloc(S->co, S->cap * 2 * sizeof(struct coroutine *));
        memset(S->co + S->cap , 0 , sizeof(struct coroutine *) * S->cap);
        S->co[S->cap] = co;
        S->cap *= 2;
        ++S->nco;
        return id;
    }
    else
    {
        int i;
        for (i=0;icap;i++)
        {
            int id = (i+S->nco) % S->cap;
            if (S->co[id] == NULL)
            {
                S->co[id] = co;
                ++S->nco;
                return id;
            }
        }
    }
    return -1;
}

/*
    协程让出函数
    1. 与之前的实现不同，这里的yield函数会指定下一个执行的协程
    2. 完成协程的直接切换，不需要回到主协程
*/
void coroutine_yield(struct schedule * S)
{
    int id = S->running;//获取当前执行协程的id
    struct coroutine *C = NULL;
    struct coroutine* next_C = NULL;
    if (0 >= S->nco)
    {
        printf("no routine create\n");
        return;
    }

    /* 如果当前为主协程 */
    if (-1 >= id)
    {
        id = 0;//指定默认协程
        id = find_next_co(S, id);//查找下一个可用
        if (-1 == id)
        {
            /*
                如果找不到则返回，因为当前是主协程，所以不需要切换
            */
            printf("yidld error\n");
            return;
        }
        C = S->co[id];//获取协程的实例
        S->running = id;
        C->status = COROUTINE_RUNNING;
        swapcontext(&S->main, &C->ctx);//切换到第一个协程
    }
    else //如果当前为其他协程
    {
        C = S->co[id];//获取当前协程
        C->status = COROUTINE_SUSPEND;//将当前协程的状态修改为挂起

        id = find_next_co(S, id);//查找下一个可用
        if (-1 == id)
        {
            /*
                如果找不到可执行协程，则返回主协程
            */
            setcontext(&S->main);
        }
        next_C = S->co[id];//获取下一个协程实例
        next_C->status = COROUTINE_RUNNING;//将下一个协程状态置为运行

        S->running = id;//设置运行协程的id
        swapcontext(&C->ctx , &next_C->ctx);//切换到下一个协程
    }
}

/* 获取指定协程状态 */
int coroutine_status(struct schedule * S, int id)
{
    if (S->co[id] == NULL)
    {
        return COROUTINE_DEAD;
    }
    return S->co[id]->status;
}

/* 获取当前运行的协程 */
int coroutine_running(struct schedule * S)
{
    return S->running;
}

上面讲解修改后的代码，下面我们看看具体的使用用例方便读者理解

#include "coroutine_v2.h"
#include 

struct args {
    int n;
};

static void
foo(struct schedule * S, void *ud) {
    struct args * arg = ud;
    int start = arg->n;
    int i;
    for (i=0;i<5;i++) {
        printf("coroutine %d : %d\n",coroutine_running(S) , start + i);
        coroutine_yield(S);
    }
}

static void
test(struct schedule *S) {
    struct args arg1 = { 0 };
    struct args arg2 = { 100 };
    /* 创建2个协程 */
    int co1 = coroutine_new(S, foo, &arg1);
    int co2 = coroutine_new(S, foo, &arg2);
    printf("main start\n");
    /* 判断协程状态是否正常 */
    while (0 != coroutine_status(S,co1) || 0 != coroutine_status(S,co2)) {
        /* 让出协程 */
        printf("before yield\n");
        coroutine_yield(S);
        printf("after yield\n");
    }
    printf("main end\n");
}

int
main() {
    struct schedule * S = coroutine_open();
    test(S);
    coroutine_close(S);

    return 0;
}

执行结果如下，可以看到每次调度都没有进入主协程


修改后

PS：以上代码作为demo进行，可能存在bug，欢迎各位读者朋友讨论

2.5 总结

总结一下，协程有以下优点及适用场景如下：
优点：

  1. 在某些场景如生产消费场景，可以简化编程模型
  2. 降低切换开销，因为不需要系统中断和系统进行调度，仅有上下文开销

适用于 高IO场景，典型的有：

  1. 高并发网络编程
  2. 高IO，比如 异构计算、磁盘IO、设备IO

三、参考链接

  1. 参考代码
  2. 维基百科
  3. 协程 以及进程和线程
  4. 协程（coroutine）简介
  5. 上下文切换

你可能感兴趣的:(操作系统——协程)

  • Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类qt开发语言sdl2linux
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
  • PHP环境搭建详细教程 好看资源平台 前端php
    PHP是一个流行的服务器端脚本语言，广泛用于Web开发。为了使PHP能够在本地或服务器上运行，我们需要搭建一个合适的PHP环境。本教程将结合最新资料，介绍在不同操作系统上搭建PHP开发环境的多种方法，包括Windows、macOS和Linux系统的安装步骤，以及本地和Docker环境的配置。1.PHP环境搭建概述PHP环境的搭建主要分为以下几类：集成开发环境：例如XAMPP、WAMP、MAMP，这
  • python os 环境变量 CV矿工 python开发语言numpy
    环境变量：环境变量是程序和操作系统之间的通信方式。有些字符不宜明文写进代码里，比如数据库密码，个人账户密码，如果写进自己本机的环境变量里，程序用的时候通过os.environ.get（）取出来就行了。os.environ是一个环境变量的字典。环境变量的相关操作importos"""设置/修改环境变量：os.environ[‘环境变量名称’]=‘环境变量值’#其中key和value均为string类
  • 【从浅识到熟知Linux】Linux发展史 Jammingpro 从浅学到熟知Linuxlinux运维服务器
    归属专栏：从浅学到熟知Linux个人主页：Jammingpro每日努力一点点，技术变化看得见文章前言：本篇文章记录Linux发展的历史，因在介绍Linux过程中涉及的其他操作系统及人物，本文对相关内容也有所介绍。文章目录Unix发展史Linux发展史开源Linux官网企业应用情况发行版本在学习Linux前，我们可能都会问Linux从哪里来？它是如何发展的。但在介绍Linux之前，需要先介绍一下Un
  • linux 发展史 种树的猴子 内核java操作系统linux大数据
    linux发展史说明此前对linux认识模糊一知半解，近期通过学习将自己对于linux的发展总结一下方便大家日后的学习。那Linux是目前一款非常火热的开源操作系统，可是linux是什么时候出现的，又是因为什么样的原因被开发出来的呢。以下将对linux的发展历程进行详细的讲解。目录一、Linux发展背景二、UINIX的诞生三、UNIX的重要分支-BSD的诞生四、Minix的诞生五、GNU与Free
  • 2023最详细的Python安装教程（Windows版本） 程序员林哥 Pythonpythonwindows开发语言
    python安装是学习pyhon第一步，很多刚入门小白不清楚如何安装python，今天我来带大家完成python安装与配置，跟着我一步步来，很简单，你肯定能完成。第一部分：python安装（一）准备工作1、下载和安装python(认准官方网站)当然你不想去下载的话也可以分享给你，还有入门学习教程，点击下方卡片跳转进群领取（二）开始安装对于Windows操作系统，可以下载“executableins
  • 深入浅出 -- 系统架构之负载均衡Nginx的性能优化 xiaoli8748_软件开发 系统架构系统架构负载均衡nginx
    一、Nginx性能优化到这里文章的篇幅较长了，最后再来聊一下关于Nginx的性能优化，主要就简单说说收益最高的几个优化项，在这块就不再展开叙述了，毕竟影响性能都有多方面原因导致的，比如网络、服务器硬件、操作系统、后端服务、程序自身、数据库服务等，对于性能调优比较感兴趣的可以参考之前《JVM性能调优》中的调优思想。优化一：打开长连接配置通常Nginx作为代理服务，负责分发客户端的请求，那么建议开启H
  • 经纬恒润二面&三七互娱一面&元象二面 Redstone Monstrosity 面试前端
    1.请尽可能详细地说明，进程和线程的区别，分别有哪些应用场景？进程间如何通信？线程间如何通信？你的回答中不要写出示例代码。进程和线程是操作系统中的两个基本概念，它们在计算机系统中扮演着不同的角色，并且在不同的应用场景中发挥作用。进程和线程的区别定义：进程：进程是操作系统进行资源分配和调度的基本单位。每个进程都有独立的内存空间和系统资源。线程：线程是进程内的一个执行单元，是操作系统进行调度的最小单位
  • C++常见知识掌握 nfgo c++开发语言
    1.Linux软件开发、调试与维护内核与系统结构Linux内核是操作系统的核心，负责管理硬件资源，提供系统服务，它是系统软件与硬件之间的桥梁。主要组成部分包括：进程管理：内核通过调度器分配CPU时间给各个进程，实现进程的创建、调度、终止等操作。使用进程描述符（task_struct）来存储进程信息，包括状态（就绪、运行、阻塞等）、优先级、内存映射等。内存管理：包括物理内存和虚拟内存管理。通过页表映
  • AUTO TECH 2025 广州国际汽车软件与安全技术展览会 ws201907 汽车安全
    AUTOTECH2025广州国际汽车软件与安全技术展览会ChinaGuangzhouSoftware-DefinedVehicleExpo2025亚洲领先的汽车软件与安全技术专业展会——是与来自世界各地的汽车工程师们交流的最佳平台！广州国际汽车软件与安全技术展览会是AUTOTECH2025华南展专题展之一，汇集了各种汽车嵌入式软件开发与应用、车载操作系统、智驾功能安全与SOTIF、基础软件平台、车
  • python中文版软件下载-Python中文版 编程大乐趣
    python中文版是一种面向对象的解释型计算机程序设计语言。python中文版官网面向对象编程，拥有高效的高级数据结构和简单而有效的方法，其优雅的语法、动态类型、以及天然的解释能力，让它成为理想的语言。软件功能强大，简单易学，可以帮助用户快速编写代码，而且代码运行速度非常快，几乎可以支持所有的操作系统，实用性真的超高的。python中文版软件介绍：python中文版的解释器及其扩展标准库的源码和编
  • 关闭Windows自动更新的6种方法 Gemini1995 windows
    在Windows操作系统中，可以使用多种方法来关闭自动更新。以下是其中一些常用的方法：使用设置应用：打开“设置”应用（Win+I），选择“更新和安全”。在左侧菜单中选择“Windows更新”。点击“更改活动时间”或“高级选项”。在“更新选项”下拉菜单中选择“通知我但不自动下载或安装”或“从不检查更新”。通过服务管理器：打开“服务”管理器，可以通过在运行对话框中输入services.msc来打开。找
  • Day9：别沦为自动化的奴隶——为自己建一座“喷泉广场” 钱塘风华
    电子设备解决了小麻烦，却制造了大麻烦。【书名】：混乱——如何成为失控时代的掌控者【作者】：蒂姆哈福德【本书总页码】：288【已读页码】：220（第七章：自动化end）2009年5月31日晚，法航447号航班在电传操作系统失效的情况下，飞行员因习惯了对电传操作系统的依赖，无法对当时的情况作出正确判断，因而也无法作出对应操作——当时的情况：飞机因为急速上升后，过于稀薄的空气密度导致飞机失速，机头抬升，
  • OpenCV图像处理技术（Python）——入门 森屿_ opencv
    ©FuXianjun.AllRightsReserved.OpenCV入门图像作为人类感知世界的视觉基础，是人类获取信息、表达信息的重要手段，OpenCV作为一个开源的计算机视觉库，它包括几百个易用的图像成像和视觉函数，既可以用于学术研究，也可用于工业邻域，它于1999年由因特尔的GaryBradski启动，OpenCV库主要由C和C++语言编写，它可以在多个操作系统上运行。1.1图像处理基本操作
  • 如何重启Linux服务器？ 老男孩IT教育 gitlinux运维
    在Linux操作系统中，提供了多种方法用于重启服务器，那么Linux服务器如何重启?以下列举了常用的几种方法，希望对大家有所帮助，快来看看吧。重启Linux服务器有以下几种方法：1、使用命令行使用reboot命令reboot使用shutdown命令shutdown-rnow2、使用systemctl使用以下命令：systemctlreboot3、使用web界面大多数现代Linux发行版本都提供一个
  • 操作系统基础 怡晗★ Linuxlinux
    目录操作系统基础冯诺依曼体系结构介绍操作系统基本认知本篇文章是后面学习操作系统知识的基础操作系统基础冯诺依曼体系结构介绍冯诺依曼体系结构如下：在上图中「输入设备」和「输出设备」一般被称为计算机的外设，而「存储器」在冯诺依曼体系结构中表示「内存」输入设备一般包括：网卡、磁盘、键盘、触摸屏等输出设备一般包括：网卡、磁盘、鼠标、触摸屏、显示器（非触摸屏）等内存的作用「内存」是中央处理器与计算机其他设备的
  • Golang channel 死锁 羊城程序猿 golanggolang
    死锁是指两个或两个以上的协程的执行过程中，由于竞争资源或由于彼此通信而造成的一种阻塞的现象，若无外力作用，他们将无法推进下去,以下是总结出来的几种死锁情况。1.死锁1：一个通道在一个主go程里同时进行读和写2.死锁2：go程开启之前使用通道3.死锁3：通道1中调用了通道2，通道2中调用通道14.死锁4：直接读取空channel的死锁5.死锁5：超过channel缓存继续写入数据导致死锁6.向已关闭
  • golang学习笔记--MPG模型 xxzed golang#学习笔记学习笔记golang
    MPG模式：M（Machine）：操作系统的主线程P（Processor）：协程执行需要的资源（上下文context），可以看作一个局部的调度器，使go代码在一个线程上跑，他是实现从N：1到N：M映射的关键G（Goroutine）：协程，有自己的栈。包含指令指针（instructionpointer）和其它信息（正在等待的channel等等），用于调度。一个P下面可以有多个G1、当前程序有三个M,
  • Linux使用mjpg-streamer进行图像传输 —你的鼬先生 Linux驱动linux树莓派图像传输
    图像传输是一项在Linux操作系统中比较常见的一个操作，在视频图传时，一般是采用MJPG-streamer来进行图像传输，本文就以树莓派为例子，来示范一个图像传输。1.树莓派的摄像头激活首先更新树莓派sudoapt-getupdatesudoapt-getupgrade随后打开树莓派的配置界面，选择InterfaceOptionsudoraspi-config在InterfaceOption选择C
  • [Golang] goroutine 沉着冷静2024 Golanggolang后端
    [Golang]goroutine文章目录[Golang]goroutine并发进程和线程协程goroutine概述如何使用goroutine并发进程和线程谈到并发，大多都离不开进程和线程，什么是进程、什么是线程？进程可以这样理解：进程就是运行着的程序，它是程序在操作系统的一次执行过程，是一个程序的动态概念，进程是操作系统分配资源的基本单位。线程可以这样理解：线程是一个进程的执行实体，它是比进程粒
  • 磁盘性能评价指标—IOPS和吞吐量 ???? ??? Frank
    一、磁盘I/O的概念I/O的概念，从字义来理解就是输入输出。操作系统从上层到底层，各个层次之间均存在I/O。比如，CPU有I/O，内存有I/O,VMM有I/O,底层磁盘上也有I/O，这是广义上的I/O。通常来讲，一个上层的I/O可能会产生针对磁盘的多个I/O，也就是说，上层的I/O是稀疏的，下层的I/O是密集的。磁盘的I/O，顾名思义就是磁盘的输入输出。输入指的是对磁盘写入数据，输出指的是从磁盘读
  • 两种方法判断Python的位数是32位还是64位 sanqima Python编程电脑python开发语言
      Python从1991年发布以来，凭借其简洁、清晰、易读的语法、丰富的标准库和第三方工具，在Web开发、自动化测试、人工智能、图形识别、机器学习等领域发展迅猛。  Python是一种胶水语言，通过Cython库与C/C++语言进行链接，通过Jython库与Java语言进行链接。  Python是跨平台的，可运行在多种操作系统上，包括但不限于Windows、Linux和macOS。这意味着用Py
  • Linux下read函数详解 威桑 Linuxlinux服务器运维
    在Linux中，read函数是最常用的系统调用之一，用于从文件或其他输入设备读取数据。它是低级别的I/O操作的核心，直接与操作系统的内核交互，提供了高效的数据读取方式。一、read函数简介read函数的声明如下：#includessize_tread(intfd,void*buf,size_tcount);其中：fd是文件描述符，代表了需要读取的文件或设备。文件描述符可以通过调用open或其他文件
  • python logging模块默认日志级别_一看就懂，Python 日志 logging 模块详解及应用 路易·罗莎 pythonlogging模块默认日志级别
    日志概述百度百科的日志概述：Windows网络操作系统都设计有各种各样的日志文件，如应用程序日志，安全日志、系统日志、Scheduler服务日志、FTP日志、WWW日志、DNS服务器日志等等，这些根据你的系统开启的服务的不同而有所不同。我们在系统上进行一些操作时，这些日志文件通常会记录下我们操作的一些相关内容，这些内容对系统安全工作人员相当有用。比如说有人对系统进行了IPC探测，系统就会在安全日志
  • 《黑神话：悟空》游戏AkExpander.dll文件缺失，使用工具修复更快捷 李秋秋啊 游戏
    在Windows操作系统中，当遇到“黑神话：悟空”游戏中的AkExpander.dll文件丢失问题时，用户可能会经历游戏启动失败或运行中断的情况。这个DLL文件是游戏正常运行所必需的，缺失或损坏会导致关键功能无法执行，影响游戏体验。针对《黑神话：悟空》游戏中AkExpander.dll文件缺失的问题，您可以尝试以下几种解决方法：一、重新安装游戏首先，考虑卸载当前安装的游戏版本，并从官方渠道重新下载
  • linux 操作系统下的compress命令介绍和使用案例 lisanmengmeng linux命令工具linux运维服务器
    linux操作系统下的compress命令介绍和使用案例compress命令是Linux系统中用于文件压缩的一个工具，主要使用Lempel-Ziv-Welch(LZW)算法进行数据压缩。压缩后，文件的扩展名将变为“.Z”。虽然compress命令在历史上有其重要性，但在现代Linux系统中，它已经被更高效的压缩工具如gzip和bzip2所取代使用方法基本语法bashcompress[选项][文件名
  • OpenCV结构分析与形状描述符（24）检测两个旋转矩形之间是否相交的一个函数rotatedRectangleIntersection()的使用 jndingxin OpenCVopencv人工智能计算机视觉
    操作系统：ubuntu22.04OpenCV版本：OpenCV4.9IDE:VisualStudioCode编程语言：C++11算法描述测两个旋转矩形之间是否存在交集。如果存在交集，则还返回交集区域的顶点。下面是一些交集配置的例子。斜线图案表示交集区域，红色顶点是由函数返回的。rotatedRectangleIntersection()这个函数看起来像是用于检测两个旋转矩形之间是否相交的一个方法。
  • 如何在麒麟操作系统中限制SSH远程登录而不影响FTP Seal^_^ 国产化#麒麟OSssh运维国产化操作系统SSH
    如何在麒麟操作系统中限制SSH远程登录而不影响FTP1、禁止SSH远程登录1.1禁止Root用户1.2禁止特定用户1.3禁止特定用户组2、重启SSHD服务3、注意事项TheBegin点点关注，收藏不迷路在服务器管理中，出于安全考虑，我们经常需要限制特定用户或用户组通过SSH远程登录服务器，但同时保持FTP等服务的正常使用不受影响。本文将详细介绍在麒麟操作系统（假设基于Linux，类似于Ubuntu
  • 麒麟桌面操作系统：查看最近安装与卸载的软件包 Seal^_^ 国产化#麒麟OS运维国产化操作系统麒麟桌面操作系统kylin
    麒麟桌面操作系统：查看最近安装与卸载的软件包1、查看最近安装的deb包2、查看最近卸载的deb包TheBegin点点关注，收藏不迷路在麒麟桌面操作系统中，快速查看最近安装与卸载的软件包非常简单。这里有两个快速命令，帮助你轻松完成这一任务。1、查看最近安装的deb包打开终端，输入以下命令：grep"install"/var/log/dpkg.log这个命令会列出所有最近安装的deb软件包信息。2、查
  • 《android进阶之光》——多线程编程（上） TAING要一直努力 读书笔记
    今天了解了下多线程编程，知识点如下：进程与线程：进程是什么？线程是什么？进程可以看作是程序的实体，是线程的容器，是受操作系统管理的基本运行单元，例如exe文件就是一个进程。线程是进程运行的一些子任务，是操作系统调度的最小单元，各线程拥有自己的计数器，堆栈，局部变量等，也可以访问线程间共享的内存。线程的状态有哪些？新创建，可运行，等待，超时等待，阻塞，终止怎么创建一个线程？-三种方法第一种，MyTr
  • ASM系列四 利用Method 组件动态注入方法逻辑 lijingyao8206 字节码技术jvmAOP动态代理ASM
            这篇继续结合例子来深入了解下Method组件动态变更方法字节码的实现。通过前面一篇，知道ClassVisitor 的visitMethod()方法可以返回一个MethodVisitor的实例。那么我们也基本可以知道，同ClassVisitor改变类成员一样，MethodVIsistor如果需要改变方法成员，注入逻辑，也可以
  • java编程思想 --内部类 百合不是茶 java内部类匿名内部类
    内部类;了解外部类 并能与之通信 内部类写出来的代码更加整洁与优雅   1,内部类的创建  内部类是创建在类中的 package com.wj.InsideClass; /* * 内部类的创建 */ public class CreateInsideClass { public CreateInsideClass(
  • web.xml报错 crabdave web.xml
    web.xml报错   The content of element type "web-app" must match "(icon?,display-  name?,description?,distributable?,context-param*,filter*,filter-mapping*,listener*,servlet*,s
  • 泛型类的自定义 麦田的设计者 javaandroid泛型
       为什么要定义泛型类，当类中要操作的引用数据类型不确定的时候。 采用泛型类，完成扩展。   例如有一个学生类     Student{ Student(){ System.out.println("I'm a student....."); } }  有一个老师类  
  • CSS清除浮动的4中方法 IT独行者 JavaScriptUIcss
    清除浮动这个问题，做前端的应该再熟悉不过了，咱是个新人，所以还是记个笔记，做个积累，努力学习向大神靠近。CSS清除浮动的方法网上一搜，大概有N多种，用过几种，说下个人感受。 1、结尾处加空div标签 clear:both 1 2 3 4 .div 1 { background : #000080 ; border : 1px   s
  • Cygwin使用windows的jdk 配置方法 _wy_ jdkwindowscygwin
    1.[vim /etc/profile]    JAVA_HOME="/cgydrive/d/Java/jdk1.6.0_43"  (windows下jdk路径为D:\Java\jdk1.6.0_43)    PATH="$JAVA_HOME/bin:${PATH}"    CLAS
  • linux下安装maven 无量 mavenlinux安装
    Linux下安装maven(转) 1.首先到Maven官网 下载安装文件，目前最新版本为3.0.3，下载文件为 apache-maven-3.0.3-bin.tar.gz，下载可以使用wget命令； 2.进入下载文件夹，找到下载的文件，运行如下命令解压 tar -xvf  apache-maven-2.2.1-bin.tar.gz 解压后的文件夹
  • tomcat的https 配置,syslog-ng配置 aichenglong tomcathttp跳转到httpssyslong-ng配置syslog配置
    1) tomcat配置https,以及http自动跳转到https的配置     1)TOMCAT_HOME目录下生成密钥(keytool是jdk中的命令)      keytool -genkey -alias tomcat -keyalg RSA -keypass changeit -storepass changeit
  • 关于领号活动总结 alafqq 活动
    关于某彩票活动的总结 具体需求，每个用户进活动页面，领取一个号码，1000中的一个； 活动要求 1，随机性，一定要有随机性； 2，最少中奖概率，如果注数为3200注，则最多中4注 3，效率问题，（不能每个人来都产生一个随机数，这样效率不高）； 4，支持断电（仍然从下一个开始），重启服务；（存数据库有点大材小用，因此不能存放在数据库） 解决方案 1，事先产生随机数1000个，并打
  • java数据结构 冒泡排序的遍历与排序 百合不是茶 java
    java的冒泡排序是一种简单的排序规则   冒泡排序的原理：           比较两个相邻的数，首先将最大的排在第一个，第二次比较第二个 ，此后一样；         针对所有的元素重复以上的步骤，除了最后一个     例题；将int array[]
  • JS检查输入框输入的是否是数字的一种校验方法 bijian1013 js
    如下是JS检查输入框输入的是否是数字的一种校验方法： <form method=post target="_blank"> 数字：<input type="text" name=num onkeypress="checkNum(this.form)"><br> </form>
  • Test注解的两个属性：expected和timeout bijian1013 javaJUnitexpectedtimeout
    JUnit4：Test文档中的解释： 　　The Test annotation supports two optional parameters. 　　The first, expected, declares that a test method should throw an exception. 　　If it doesn't throw an exception or if it
  • [Gson二]继承关系的POJO的反序列化 bit1129 POJO
    父类     package inheritance.test2; import java.util.Map; public class Model { private String field1; private String field2; private Map<String, String> infoMap
  • 【Spark八十四】Spark零碎知识点记录 bit1129 spark
    1. ShuffleMapTask的shuffle数据在什么地方记录到MapOutputTracker中的 ShuffleMapTask的runTask方法负责写数据到shuffle map文件中。当任务执行完成成功，DAGScheduler会收到通知，在DAGScheduler的handleTaskCompletion方法中完成记录到MapOutputTracker中  
  • WAS各种脚本作用大全 ronin47 WAS 脚本
    　　　http://www.ibm.com/developerworks/cn/websphere/library/samples/SampleScripts.html 　　　无意中，在WAS官网上发现的各种脚本作用，感觉很有作用，先与各位分享一下 　　　 获取下载 这些示例 jacl 和 Jython 脚本可用于在 WebSphere Application Server 的不同版本中自
  • java-12.求 1+2+3+..n不能使用乘除法、 for 、 while 、 if 、 else 、 switch 、 case 等关键字以及条件判断语句 bylijinnan switch
    借鉴网上的思路，用java实现： public class NoIfWhile { /** * @param args * * find x=1+2+3+....n */ public static void main(String[] args) { int n=10; int re=find(n); System.o
  • Netty源码学习-ObjectEncoder和ObjectDecoder bylijinnan javanetty
    Netty中传递对象的思路很直观： Netty中数据的传递是基于ChannelBuffer（也就是byte[]）； 那把对象序列化为字节流，就可以在Netty中传递对象了 相应的从ChannelBuffer恢复对象，就是反序列化的过程 Netty已经封装好ObjectEncoder和ObjectDecoder 先看ObjectEncoder ObjectEncoder是往外发送
  • spring 定时任务中cronExpression表达式含义 chicony cronExpression
    一个cron表达式有6个必选的元素和一个可选的元素，各个元素之间是以空格分隔的，从左至右，这些元素的含义如下表所示： 代表含义            是否必须 允许的取值范围         &nb
  • Nutz配置Jndi ctrain JNDI
    1、使用JNDI获取指定资源： var ioc = { dao : { type :"org.nutz.dao.impl.NutDao", args : [ {jndi :"jdbc/dataSource"} ] } } 以上方法,仅需要在容器中配置好数据源,注入到NutDao即可.
  • 解决 /bin/sh^M: bad interpreter: No such file or directory daizj shell
    在Linux中执行.sh脚本，异常/bin/sh^M: bad interpreter: No such file or directory。   分析：这是不同系统编码格式引起的：在windows系统中编辑的.sh文件可能有不可见字符，所以在Linux系统下执行会报以上异常信息。 解决： 1）在windows下转换： 利用一些编辑器如UltraEdit或EditPlus等工具
  • [转]for 循环为何可恨？ dcj3sjt126com 程序员读书
      Java的闭包(Closure)特征最近成为了一个热门话题。 一些精英正在起草一份议案，要在Java将来的版本中加入闭包特征。 然而，提议中的闭包语法以及语言上的这种扩充受到了众多Java程序员的猛烈抨击。 不久前，出版过数十本编程书籍的大作家Elliotte Rusty Harold发表了对Java中闭包的价值的质疑。 尤其是他问道“for 循环为何可恨？”[http://ju
  • Android实用小技巧 dcj3sjt126com android
    1、去掉所有Activity界面的标题栏 　　修改AndroidManifest.xml 　　在application 标签中添加android:theme="@android:style/Theme.NoTitleBar"   2、去掉所有Activity界面的TitleBar 和StatusBar  　　修改AndroidManifes
  • Oracle 复习笔记之序列 eksliang Oracle 序列sequenceOracle sequence
    转载请出自出处：http://eksliang.iteye.com/blog/2098859 1.序列的作用 序列是用于生成唯一、连续序号的对象 一般用序列来充当数据库表的主键值 2.创建序列语法如下：   create sequence s_emp start with 1 --开始值 increment by 1 --増长值 maxval
  • 有“品”的程序员 gongmeitao 工作
    完美程序员的10种品质　　   完美程序员的每种品质都有一个范围，这个范围取决于具体的问题和背景。没有能解决所有问题的   完美程序员（至少在我们这个星球上），并且对于特定问题，完美程序员应该具有以下品质： 　　1. 才智非凡- 能够理解问题、能够用清晰可读的代码翻译并表达想法、善于分析并且逻辑思维能力强   （范围：用简单方式解决复杂问题）　　
  • 使用KeleyiSQLHelper类进行分页查询 hvt sql.netC#asp.nethovertree
    本文适用于sql server单主键表或者视图进行分页查询，支持多字段排序。KeleyiSQLHelper类的最新代码请到http://hovertree.codeplex.com/SourceControl/latest下载整个解决方案源代码查看。或者直接在线查看类的代码：http://hovertree.codeplex.com/SourceControl/latest#HoverTree.D
  • SVG 教程 （三）圆形，椭圆，直线 天梯梦 svg
    SVG <circle> SVG 圆形 - <circle> <circle> 标签可用来创建一个圆： 下面是SVG代码： <svg xmlns="http://www.w3.org/2000/svg" version="1.1"> <circle cx="100" c
  • 链表栈 luyulong java数据结构
    public class Node { private Object object; private Node next; public Node() { this.next = null; this.object = null; } public Object getObject() { return object; } public
  • 基础数据结构和算法十：2-3 search tree sunwinner Algorithm2-3 search tree
      Binary search tree works well for a wide variety of applications, but they have poor worst-case performance. Now we introduce a type of binary search tree where costs are guaranteed to be loga
  • spring配置定时任务 stunizhengjia springtimer
    最近因工作的需要，用到了spring的定时任务的功能,觉得spring还是很智能化的,只需要配置一下配置文件就可以了,在此记录一下，以便以后用到：     //------------------------定时任务调用的方法------------------------------ /** * 存储过程定时器 */ publi
  • ITeye 8月技术图书有奖试读获奖名单公布 ITeye管理员 活动
    ITeye携手博文视点举办的8月技术图书有奖试读活动已圆满结束，非常感谢广大用户对本次活动的关注与参与。 8月试读活动回顾： http://webmaster.iteye.com/blog/2102830 本次技术图书试读活动的优秀奖获奖名单及相应作品如下（优秀文章有很多，但名额有限，没获奖并不代表不优秀）： 《跨终端Web》 gleams：http
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他