自学教程：C++ tb_spinlock_enter函数代码示例

static tb_void_t tb_aiop_rtor_poll_exit(tb_aiop_rtor_impl_t* rtor){    tb_aiop_rtor_poll_impl_t* impl = (tb_aiop_rtor_poll_impl_t*)rtor;    if (impl)    {        // exit pfds        tb_spinlock_enter(&impl->lock.pfds);        if (impl->pfds) tb_vector_exit(impl->pfds);        impl->pfds = tb_null;        tb_spinlock_leave(&impl->lock.pfds);        // exit cfds        if (impl->cfds) tb_vector_exit(impl->cfds);        impl->cfds = tb_null;        // exit hash        tb_spinlock_enter(&impl->lock.hash);        if (impl->hash) tb_hash_exit(impl->hash);        impl->hash = tb_null;        tb_spinlock_leave(&impl->lock.hash);        // exit lock        tb_spinlock_exit(&impl->lock.pfds);        tb_spinlock_exit(&impl->lock.hash);        // free it        tb_free(impl);    }}

static tb_bool_t tb_aiop_rtor_poll_delo(tb_aiop_rtor_impl_t* rtor, tb_aioo_impl_t const* aioo){    // check    tb_aiop_rtor_poll_impl_t* impl = (tb_aiop_rtor_poll_impl_t*)rtor;    tb_assert_and_check_return_val(impl && impl->pfds && impl->cfds && aioo && aioo->sock, tb_false);    // the aiop    tb_aiop_impl_t* aiop = rtor->aiop;    tb_assert_and_check_return_val(aiop, tb_false);    // delo it, TODO: delo by binary search    tb_spinlock_enter(&impl->lock.pfds);    tb_remove_first_if(impl->pfds, tb_poll_walk_delo, (tb_pointer_t)(((tb_long_t)aioo->sock) - 1));    tb_spinlock_leave(&impl->lock.pfds);    // del sock => aioo    tb_spinlock_enter(&impl->lock.hash);    if (impl->hash) tb_hash_del(impl->hash, aioo->sock);    tb_spinlock_leave(&impl->lock.hash);    // spak it    if (aiop->spak[0]) tb_socket_send(aiop->spak[0], (tb_byte_t const*)"p", 1);    // ok    return tb_true;}

static tb_void_t tb_aiop_rtor_select_cler(tb_aiop_rtor_impl_t* rtor){    tb_aiop_rtor_select_impl_t* impl = (tb_aiop_rtor_select_impl_t*)rtor;    if (impl)    {        // free fds        tb_spinlock_enter(&impl->lock.pfds);        impl->sfdm = 0;        FD_ZERO(&impl->rfdi);        FD_ZERO(&impl->wfdi);        FD_ZERO(&impl->efdi);        FD_ZERO(&impl->rfdo);        FD_ZERO(&impl->wfdo);        FD_ZERO(&impl->efdo);        tb_spinlock_leave(&impl->lock.pfds);        // clear hash        tb_spinlock_enter(&impl->lock.hash);        if (impl->hash) tb_hash_clear(impl->hash);        tb_spinlock_leave(&impl->lock.hash);        // spak it        if (rtor->aiop && rtor->aiop->spak[0]) tb_socket_send(rtor->aiop->spak[0], (tb_byte_t const*)"p", 1);    }}

/* ////////////////////////////////////////////////////////////////////////////////////// * implementation */static tb_bool_t tb_aiop_rtor_select_addo(tb_aiop_rtor_impl_t* rtor, tb_aioo_impl_t const* aioo){    // check    tb_aiop_rtor_select_impl_t* impl = (tb_aiop_rtor_select_impl_t*)rtor;    tb_assert_and_check_return_val(impl && rtor->aiop && aioo && aioo->sock, tb_false);    // the aiop    tb_aiop_impl_t* aiop = rtor->aiop;    tb_assert_and_check_return_val(aiop, tb_false);    // check size    tb_spinlock_enter(&impl->lock.hash);    tb_size_t size = tb_hash_size(impl->hash);    tb_spinlock_leave(&impl->lock.hash);    tb_assert_and_check_return_val(size < FD_SETSIZE, tb_false);    // add sock => aioo    tb_bool_t ok = tb_false;    tb_spinlock_enter(&impl->lock.hash);    if (impl->hash)     {        tb_hash_set(impl->hash, aioo->sock, aioo);        ok = tb_true;    }    tb_spinlock_leave(&impl->lock.hash);    tb_assert_and_check_return_val(ok, tb_false);    // the fd    tb_long_t fd = ((tb_long_t)aioo->sock) - 1;    // the code    tb_size_t code = aioo->code;    // enter    tb_spinlock_enter(&impl->lock.pfds);    // update fd max    if (fd > (tb_long_t)impl->sfdm) impl->sfdm = (tb_size_t)fd;        // init fds    if (code & (TB_AIOE_CODE_RECV | TB_AIOE_CODE_ACPT)) FD_SET(fd, &impl->rfdi);    if (code & (TB_AIOE_CODE_SEND | TB_AIOE_CODE_CONN)) FD_SET(fd, &impl->wfdi);    FD_SET(fd, &impl->efdi);    // leave    tb_spinlock_leave(&impl->lock.pfds);    // spak it    if (aiop->spak[0] && code) tb_socket_send(aiop->spak[0], (tb_byte_t const*)"p", 1);    // ok?    return ok;}

tb_bool_t tb_aicp_exit(tb_aicp_ref_t aicp){    // check    tb_aicp_impl_t* impl = (tb_aicp_impl_t*)aicp;    tb_assert_and_check_return_val(impl, tb_false);    // kill all first    tb_aicp_kill_all((tb_aicp_ref_t)impl);    // wait all exiting    if (tb_aicp_wait_all((tb_aicp_ref_t)impl, 5000) <= 0)     {        // wait failed, trace left aicos        tb_spinlock_enter(&impl->lock);        if (impl->pool) tb_fixed_pool_walk(impl->pool, tb_aicp_walk_wait, tb_null);        tb_spinlock_leave(&impl->lock);        return tb_false;    }       // kill loop    tb_aicp_kill((tb_aicp_ref_t)impl);    // wait workers exiting     tb_hong_t time = tb_mclock();    while (tb_atomic_get(&impl->work) && (tb_mclock() < time + 5000)) tb_msleep(500);    // exit proactor    if (impl->ptor)    {        tb_assert(impl->ptor && impl->ptor->exit);        impl->ptor->exit(impl->ptor);        impl->ptor = tb_null;    }    // exit aico pool    tb_spinlock_enter(&impl->lock);    if (impl->pool) tb_fixed_pool_exit(impl->pool);    impl->pool = tb_null;    tb_spinlock_leave(&impl->lock);    // exit lock    tb_spinlock_exit(&impl->lock);    // free impl    tb_free(impl);    // ok    return tb_true;}

tb_size_t tb_timer_delay(tb_timer_ref_t timer){    // check    tb_timer_impl_t* impl = (tb_timer_impl_t*)timer;    tb_assert_and_check_return_val(impl && impl->heap, -1);    // stoped?    tb_assert_and_check_return_val(!tb_atomic_get(&impl->stop), -1);    // enter    tb_spinlock_enter(&impl->lock);    // done    tb_size_t delay = -1;     if (tb_heap_size(impl->heap))    {        // the task        tb_timer_task_impl_t const* task_impl = (tb_timer_task_impl_t const*)tb_heap_top(impl->heap);        if (task_impl)        {            // the now            tb_hong_t now = tb_timer_now(impl);            // the delay            delay = task_impl->when > now? (tb_size_t)(task_impl->when - now) : 0;        }    }    // leave    tb_spinlock_leave(&impl->lock);    // ok?    return delay;}

tb_hize_t tb_timer_top(tb_timer_ref_t timer){    // check    tb_timer_impl_t* impl = (tb_timer_impl_t*)timer;    tb_assert_and_check_return_val(impl && impl->heap, -1);    // stoped?    tb_assert_and_check_return_val(!tb_atomic_get(&impl->stop), -1);    // enter    tb_spinlock_enter(&impl->lock);    // done    tb_hize_t when = -1;     if (tb_heap_size(impl->heap))    {        // the task        tb_timer_task_impl_t const* task_impl = (tb_timer_task_impl_t const*)tb_heap_top(impl->heap);        if (task_impl) when = task_impl->when;    }    // leave    tb_spinlock_leave(&impl->lock);    // ok?    return when;}

tb_size_t tb_thread_pool_task_post_list(tb_thread_pool_ref_t pool, tb_thread_pool_task_t const* list, tb_size_t size){    // check    tb_thread_pool_impl_t* impl = (tb_thread_pool_impl_t*)pool;    tb_assert_and_check_return_val(impl && list, 0);    // init the post size    tb_size_t post_size = 0;    // enter    tb_spinlock_enter(&impl->lock);    // done    tb_size_t ok = 0;    if (!impl->bstoped)    {        for (ok = 0; ok < size; ok++)        {            // post task            tb_thread_pool_job_t* job = tb_thread_pool_jobs_post_task(impl, &list[ok], &post_size);            tb_assert_and_check_break(job);        }    }    // leave    tb_spinlock_leave(&impl->lock);    // post the workers    if (ok && post_size) tb_thread_pool_worker_post(impl, post_size);    // ok?    return ok;}

tb_void_t tb_pool_dump(tb_pool_ref_t pool){    // check    tb_pool_impl_t* impl = (tb_pool_impl_t*)pool;    tb_assert_and_check_return(impl);    // uses allocator?    if (impl->allocator)    {        // dump it        tb_allocator_dump(impl->allocator);        return ;    }    // check    tb_assert_and_check_return(impl->large_pool && impl->small_pool);    // enter    tb_spinlock_enter(&impl->lock);    // dump pool    tb_small_pool_dump(impl->small_pool);    // leave    tb_spinlock_leave(&impl->lock);}

tb_void_t tb_pool_exit(tb_pool_ref_t pool){    // check    tb_pool_impl_t* impl = (tb_pool_impl_t*)pool;    tb_assert_and_check_return(impl);    // uses allocator?    if (impl->allocator)    {        // exit it        tb_allocator_free(impl->allocator, impl);        return ;    }    // enter    tb_spinlock_enter(&impl->lock);    // exit small pool    if (impl->small_pool) tb_small_pool_exit(impl->small_pool);    impl->small_pool = tb_null;    // leave    tb_spinlock_leave(&impl->lock);    // exit lock    tb_spinlock_exit(&impl->lock);    // exit pool    if (impl->large_pool) tb_large_pool_free(impl->large_pool, impl);}

/* ////////////////////////////////////////////////////////////////////////////////////// * implementation */tb_aico_ref_t tb_aico_init(tb_aicp_ref_t aicp){    // check    tb_aicp_impl_t* aicp_impl = (tb_aicp_impl_t*)aicp;    tb_assert_and_check_return_val(aicp_impl && aicp_impl->pool, tb_null);    // enter     tb_spinlock_enter(&aicp_impl->lock);    // make aico    tb_aico_impl_t* aico = (tb_aico_impl_t*)tb_fixed_pool_malloc0(aicp_impl->pool);    // init aico    if (aico)    {        aico->aicp      = aicp;        aico->type      = TB_AICO_TYPE_NONE;        aico->handle    = tb_null;        aico->state     = TB_STATE_CLOSED;        // init timeout         tb_size_t i = 0;        tb_size_t n = tb_arrayn(aico->timeout);        for (i = 0; i < n; i++) aico->timeout[i] = -1;    }    // leave     tb_spinlock_leave(&aicp_impl->lock);        // ok?    return (tb_aico_ref_t)aico;}

tb_void_t tb_aico_exit(tb_aico_ref_t aico){    // check    tb_aico_impl_t* impl = (tb_aico_impl_t*)aico;    tb_aicp_impl_t* aicp_impl = (tb_aicp_impl_t*)impl->aicp;    tb_assert_and_check_return(impl && aicp_impl && aicp_impl->pool);    // wait closing?    tb_size_t tryn = 15;    while (tb_atomic_get(&impl->state) != TB_STATE_CLOSED && tryn--)    {        // trace        tb_trace_d("exit[%p]: type: %lu, handle: %p, state: %s: wait: ..", aico, tb_aico_type(aico), impl->handle, tb_state_cstr(tb_atomic_get(&impl->state)));            // wait some time        tb_msleep(200);    }    // check    tb_assert_abort(tb_atomic_get(&impl->state) == TB_STATE_CLOSED);    tb_check_return(tb_atomic_get(&impl->state) == TB_STATE_CLOSED);    // enter     tb_spinlock_enter(&aicp_impl->lock);    // trace    tb_trace_d("exit[%p]: type: %lu, handle: %p, state: %s: ok", aico, tb_aico_type(aico), impl->handle, tb_state_cstr(tb_atomic_get(&impl->state)));        // free it    tb_fixed_pool_free(aicp_impl->pool, aico);    // leave     tb_spinlock_leave(&aicp_impl->lock);}

static tb_bool_t tb_aiop_rtor_poll_post(tb_aiop_rtor_impl_t* rtor, tb_aioe_t const* aioe){    // check    tb_aiop_rtor_poll_impl_t* impl = (tb_aiop_rtor_poll_impl_t*)rtor;    tb_assert_and_check_return_val(impl && impl->pfds && impl->cfds && aioe, tb_false);    // the aiop    tb_aiop_impl_t* aiop = rtor->aiop;    tb_assert_and_check_return_val(aiop, tb_false);    // the aioo    tb_aioo_impl_t* aioo = (tb_aioo_impl_t*)aioe->aioo;    tb_assert_and_check_return_val(aioo, tb_false);    // save aioo    aioo->code = aioe->code;    aioo->priv = aioe->priv;    // sete it, TODO: sete by binary search    tb_spinlock_enter(&impl->lock.pfds);    tb_walk_all(impl->pfds, tb_poll_walk_sete, (tb_pointer_t)aioe);    tb_spinlock_leave(&impl->lock.pfds);    // spak it    if (aiop->spak[0]) tb_socket_send(aiop->spak[0], (tb_byte_t const*)"p", 1);    // ok    return tb_true;}

tb_void_t tb_timer_task_exit(tb_timer_ref_t timer, tb_timer_task_ref_t task){    // check    tb_timer_impl_t*         impl = (tb_timer_impl_t*)timer;    tb_timer_task_impl_t*    task_impl = (tb_timer_task_impl_t*)task;    tb_assert_and_check_return(impl && impl->pool && task_impl);    // trace    tb_trace_d("exit: when: %lld, period: %u, refn: %u", task_impl->when, task_impl->period, task_impl->refn);    // enter    tb_spinlock_enter(&impl->lock);    // remove it?    if (task_impl->refn > 1)    {        // refn--        task_impl->refn--;        // cancel task         task_impl->func      = tb_null;        task_impl->priv      = tb_null;        task_impl->repeat    = 0;    }    // remove it from pool directly if the task_impl have been expired     else tb_fixed_pool_free(impl->pool, task_impl);    // leave    tb_spinlock_leave(&impl->lock);}

/* ////////////////////////////////////////////////////////////////////////////////////// * implementation */tb_bool_t tb_dns_cache_init(){    // enter    tb_spinlock_enter(&g_lock);    // done    tb_bool_t ok = tb_false;    do    {        // init hash        if (!g_cache.hash) g_cache.hash = tb_hash_init(tb_align8(tb_isqrti(TB_DNS_CACHE_MAXN) + 1), tb_item_func_str(tb_false), tb_item_func_mem(sizeof(tb_dns_cache_addr_t), tb_null, tb_null));        tb_assert_and_check_break(g_cache.hash);        // ok        ok = tb_true;    } while (0);    // leave    tb_spinlock_leave(&g_lock);    // failed? exit it    if (!ok) tb_dns_cache_exit();    // ok?    return ok;}

/* ////////////////////////////////////////////////////////////////////////////////////// * aioo */static tb_aioo_ref_t tb_aiop_aioo_init(tb_aiop_impl_t* impl, tb_socket_ref_t sock, tb_size_t code, tb_cpointer_t priv){    // check    tb_assert_and_check_return_val(impl && impl->pool, tb_null);    // enter     tb_spinlock_enter(&impl->lock);    // make aioo    tb_aioo_impl_t* aioo = (tb_aioo_impl_t*)tb_fixed_pool_malloc0(impl->pool);    // init aioo    if (aioo)    {        aioo->code = code;        aioo->priv = priv;        aioo->sock = sock;    }    // leave     tb_spinlock_leave(&impl->lock);        // ok?    return (tb_aioo_ref_t)aioo;}

tb_pointer_t tb_allocator_malloc_(tb_allocator_ref_t allocator, tb_size_t size __tb_debug_decl__){    // check    tb_assert_and_check_return_val(allocator, tb_null);    // enter    tb_spinlock_enter(&allocator->lock);    // malloc it    tb_pointer_t data = tb_null;    if (allocator->malloc) data = allocator->malloc(allocator, size __tb_debug_args__);    else if (allocator->large_malloc) data = allocator->large_malloc(allocator, size, tb_null __tb_debug_args__);    // trace    tb_trace_d("malloc(%lu): %p at %s(): %d, %s", size, data __tb_debug_args__);    // check    tb_assertf(data, "malloc(%lu) failed!", size);    tb_assertf(!(((tb_size_t)data) & (TB_POOL_DATA_ALIGN - 1)), "malloc(%lu): unaligned data: %p", size, data);    // leave    tb_spinlock_leave(&allocator->lock);    // ok?    return data;}

tb_void_t tb_aiop_exit(tb_aiop_ref_t aiop){    // check    tb_aiop_impl_t* impl = (tb_aiop_impl_t*)aiop;    tb_assert_and_check_return(impl);    // exit reactor    if (impl->rtor && impl->rtor->exit)        impl->rtor->exit(impl->rtor);    // exit spak    if (impl->spak[0]) tb_socket_exit(impl->spak[0]);    if (impl->spak[1]) tb_socket_exit(impl->spak[1]);    impl->spak[0] = tb_null;    impl->spak[1] = tb_null;    // exit pool    tb_spinlock_enter(&impl->lock);    if (impl->pool) tb_fixed_pool_exit(impl->pool);    impl->pool = tb_null;    tb_spinlock_leave(&impl->lock);    // exit lock    tb_spinlock_exit(&impl->lock);    // free impl    tb_free(impl);}

static tb_void_t tb_aiop_ptor_exit(tb_aicp_ptor_impl_t* ptor){    // check    tb_aiop_ptor_impl_t* impl = (tb_aiop_ptor_impl_t*)ptor;    tb_assert_and_check_return(impl);    // trace    tb_trace_d("exit");    // exit file    tb_aicp_file_exit(impl);    // exit loop    if (impl->loop)    {        tb_long_t wait = 0;        if ((wait = tb_thread_wait(impl->loop, 5000)) <= 0)        {            // trace            tb_trace_e("loop[%p]: wait failed: %ld!", impl->loop, wait);        }        tb_thread_exit(impl->loop);        impl->loop = tb_null;    }    // exit spak    tb_spinlock_enter(&impl->lock);    if (impl->spak[0]) tb_queue_exit(impl->spak[0]);    if (impl->spak[1]) tb_queue_exit(impl->spak[1]);    impl->spak[0] = tb_null;    impl->spak[1] = tb_null;    tb_spinlock_leave(&impl->lock);    // exit aiop    if (impl->aiop) tb_aiop_exit(impl->aiop);    impl->aiop = tb_null;    // exit list    if (impl->list) tb_free(impl->list);    impl->list = tb_null;    // exit wait    if (impl->wait) tb_semaphore_exit(impl->wait);    impl->wait = tb_null;    // exit timer    if (impl->timer) tb_timer_exit(impl->timer);    impl->timer = tb_null;    // exit ltimer    if (impl->ltimer) tb_ltimer_exit(impl->ltimer);    impl->ltimer = tb_null;    // exit lock    tb_spinlock_exit(&impl->lock);    // exit it    tb_free(impl);}

tb_void_t tb_timer_exit(tb_timer_ref_t timer){    // check    tb_timer_impl_t* impl = (tb_timer_impl_t*)timer;    tb_assert_and_check_return(impl);    // stop it    tb_atomic_set(&impl->stop, 1);    // wait loop exit    tb_size_t tryn = 10;    while (tb_atomic_get(&impl->work) && tryn--) tb_msleep(500);    // warning    if (!tryn && tb_atomic_get(&impl->work)) tb_trace_w("[timer]: the loop has been not exited now!");    // post event    tb_spinlock_enter(&impl->lock);    tb_event_ref_t event = impl->event;    tb_spinlock_leave(&impl->lock);    if (event) tb_event_post(event);    // enter    tb_spinlock_enter(&impl->lock);    // exit heap    if (impl->heap) tb_heap_exit(impl->heap);    impl->heap = tb_null;    // exit pool    if (impl->pool) tb_fixed_pool_exit(impl->pool);    impl->pool = tb_null;    // exit event    if (impl->event) tb_event_exit(impl->event);    impl->event = tb_null;    // leave    tb_spinlock_leave(&impl->lock);    // exit lock    tb_spinlock_exit(&impl->lock);    // exit it    tb_free(impl);}

static tb_void_t tb_aiop_spak_wait_timeout(tb_bool_t killed, tb_cpointer_t priv){    // the aico    tb_aiop_aico_t* aico = (tb_aiop_aico_t*)priv;    tb_assert_and_check_return(aico && aico->waiting);    // the impl    tb_aiop_ptor_impl_t* impl = aico->impl;    tb_assert_and_check_return(impl && impl->aiop);    // for sock    if (aico->base.type == TB_AICO_TYPE_SOCK)    {        // check        tb_assert_and_check_return(aico->aioo);        // delo aioo        tb_aiop_delo(impl->aiop, aico->aioo);        aico->aioo = tb_null;    }    // have been waited ok for the spak loop? need not spak it repeatly    tb_bool_t ok = tb_false;    if (!aico->wait_ok)    {        // the priority        tb_size_t priority = tb_aice_impl_priority(&aico->aice);        tb_assert_and_check_return(priority < tb_arrayn(impl->spak) && impl->spak[priority]);        // trace        tb_trace_d("wait: timeout: code: %lu, priority: %lu, time: %lld", aico->aice.code, priority, tb_cache_time_mclock());        // enter        tb_spinlock_enter(&impl->lock);        // spak aice        if (!tb_queue_full(impl->spak[priority]))        {            // save state            aico->aice.state = killed? TB_STATE_KILLED : TB_STATE_TIMEOUT;            // put it            tb_queue_put(impl->spak[priority], &aico->aice);            // ok            ok = tb_true;            aico->wait_ok = 1;        }        else tb_assert(0);        // leave        tb_spinlock_leave(&impl->lock);    }    // work it    if (ok) tb_aiop_spak_work(impl);}

tb_void_t tb_thread_store_setp(tb_thread_store_data_t const* data){    // enter lock    tb_spinlock_enter(&g_lock);    // get data    if (g_store) tb_hash_map_insert(g_store, (tb_pointer_t)tb_thread_self(), data);    // leave lock    tb_spinlock_leave(&g_lock);}

static tb_void_t tb_aiop_rtor_poll_cler(tb_aiop_rtor_impl_t* rtor){    tb_aiop_rtor_poll_impl_t* impl = (tb_aiop_rtor_poll_impl_t*)rtor;    if (impl)    {        // clear pfds        tb_spinlock_enter(&impl->lock.pfds);        if (impl->pfds) tb_vector_clear(impl->pfds);        tb_spinlock_leave(&impl->lock.pfds);        // clear hash        tb_spinlock_enter(&impl->lock.hash);        if (impl->hash) tb_hash_clear(impl->hash);        tb_spinlock_leave(&impl->lock.hash);        // spak it        if (rtor->aiop && rtor->aiop->spak[0])            tb_socket_send(rtor->aiop->spak[0], (tb_byte_t const*)"p", 1);    }}

tb_bool_t tb_mutex_enter(tb_mutex_ref_t mutex){    // check    tb_assert_and_check_return_val(mutex, tb_false);    // enter    tb_spinlock_enter((tb_spinlock_ref_t)mutex);    // ok    return tb_true;}

tb_void_t tb_timer_loop(tb_timer_ref_t timer){    // check    tb_timer_impl_t* impl = (tb_timer_impl_t*)timer;    tb_assert_and_check_return(impl);    // work++    tb_atomic_fetch_and_inc(&impl->work);    // init event     tb_spinlock_enter(&impl->lock);    if (!impl->event) impl->event = tb_event_init();    tb_spinlock_leave(&impl->lock);    // loop    while (!tb_atomic_get(&impl->stop))    {        // the delay        tb_size_t delay = tb_timer_delay(timer);        if (delay)        {            // the event            tb_spinlock_enter(&impl->lock);            tb_event_ref_t event = impl->event;            tb_spinlock_leave(&impl->lock);            tb_check_break(event);            // wait some time            if (tb_event_wait(event, delay) < 0) break;        }        // spak ctime        if (impl->ctime) tb_cache_time_spak();        // spak it        if (!tb_timer_spak(timer)) break;    }    // work--    tb_atomic_fetch_and_dec(&impl->work);}

static tb_bool_t tb_aiop_rtor_poll_addo(tb_aiop_rtor_impl_t* rtor, tb_aioo_impl_t const* aioo){    // check    tb_aiop_rtor_poll_impl_t* impl = (tb_aiop_rtor_poll_impl_t*)rtor;    tb_assert_and_check_return_val(impl && impl->pfds && impl->cfds && aioo && aioo->sock, tb_false);    // the aiop    tb_aiop_impl_t* aiop = rtor->aiop;    tb_assert_and_check_return_val(aiop, tb_false);    // add sock => aioo    tb_bool_t ok = tb_false;    tb_spinlock_enter(&impl->lock.hash);    if (impl->hash)     {        tb_hash_set(impl->hash, aioo->sock, aioo);        ok = tb_true;    }    tb_spinlock_leave(&impl->lock.hash);    tb_assert_and_check_return_val(ok, tb_false);    // the code    tb_size_t code = aioo->code;    // init pfd    struct pollfd pfd = {0};    pfd.fd = ((tb_long_t)aioo->sock) - 1;    if (code & TB_AIOE_CODE_RECV || code & TB_AIOE_CODE_ACPT) pfd.events |= POLLIN;    if (code & TB_AIOE_CODE_SEND || code & TB_AIOE_CODE_CONN) pfd.events |= POLLOUT;    // add pfd, TODO: addo by binary search    tb_spinlock_enter(&impl->lock.pfds);    tb_vector_insert_tail(impl->pfds, &pfd);    tb_spinlock_leave(&impl->lock.pfds);    // spak it    if (aiop->spak[0] && code) tb_socket_send(aiop->spak[0], (tb_byte_t const*)"p", 1);    // ok?    return ok;}

tb_void_t tb_thread_store_exit(){       // enter lock    tb_spinlock_enter(&g_lock);    // exit store    if (g_store) tb_hash_map_exit(g_store);    g_store = tb_null;    // leave lock    tb_spinlock_leave(&g_lock);}