《大胸护士》在线观看无码,少女哔哩哔哩免费观看,精品无人乱码一区二区三区

swoole的整體數據流程圖可以看官方文檔swoole運行流程

在主進程中有兩個關鍵線程主線程和reactor線程，主線程用來處理 accept() 事件，創建新的socket fd，接收到新連接后會把新的socket 連接放到reactor線程的的事件監聽循環中， reactor線程負責接收從client端發過來的數據，按協議解析后，通過pipe管道傳輸給worker進程處理，worker進程處理完后，把結果通過pipe回傳給reactor線程，reactor線程再按協議把結果通過socket發送給client。可以看到reactor線程負責數據的IO和傳輸，在linux環境下，這些IO事件通過epoll機制來處理。

下一步我們看下主線程和 reactor線程數據交換的過程的源碼

第一步要找到 swServer_start(swServer *serv) 函數，這個是swoole啟動server的入口，在這個函數中很容易就能讀到這么一句

int swServer_start(swServer *serv) {
    ......
    ret = swServer_start_proxy(serv);  //啟動主線程和reactor線程，并注冊各種事件處理函數，和協議解析

    ......
}

下面著重講 swServer_start_proxy

//src/network/Server.c

static int swServer_start_proxy(swServer *serv)
{
    int ret;
    swReactor *main_reactor = SwooleG.memory_pool->alloc(SwooleG.memory_pool, sizeof(swReactor));

    ret = swReactor_create(main_reactor, SW_REACTOR_MAXEVENTS); // 創建主線程reactor對象事件處理，只是創建對象，主線程不用pthread_create() 真正去創建線程
    //...... // 省略區

    ret = swReactorThread_start(serv, main_reactor);  //把server監聽端口的listen事件加入到主線程事件監聽，創建reactor線程
    
     //...... // 省略區
 
    main_reactor->setHandle(main_reactor, SW_FD_LISTEN, swServer_master_onAccept); //主線程reactor listen事件處理handle


     //...... // 省略區
    return main_reactor->wait(main_reactor, NULL); //主線程循環
}


int swReactorThread_start(swServer *serv, swReactor *main_reactor_ptr)
{
//..... 省略區
    swListenPort *ls;
    LL_FOREACH(serv->listen_list, ls)
    {
        if (ls->type == SW_SOCK_UDP || ls->type == SW_SOCK_UDP6 || ls->type == SW_SOCK_UNIX_DGRAM)
        {
            continue;
        }
        main_reactor_ptr->add(main_reactor_ptr, ls->sock, SW_FD_LISTEN); //把監聽的端口fd加入到 主線程事件監聽循環中
    }

//..... 省略區
    return SW_OK;
}

int swServer_master_onAccept(swReactor *reactor, swEvent *event)
{

    //..... 省略區
    //SW_ACCEPT_AGAIN
    for (i = 0; i < SW_ACCEPT_MAX_COUNT; i++)
    {
        new_fd = accept(event->fd, (struct sockaddr *) &client_addr, &client_addrlen);  // accept新socket
    //..... 省略區

        if (sub_reactor->add(sub_reactor, new_fd, SW_FD_TCP | SW_EVENT_WRITE) < 0)  //新socket加入到 reactor線程事件監聽中
        {
            bzero(conn, sizeof(swConnection));
            close(new_fd);
            return SW_OK;
        }
    }
    return SW_OK;
}

swReactor_create() ，創建主線程reactor對象，只是創建對象，主線程不用pthread_create() 真正去創建線程，主線程就在主進程中
swReactorThread_start() , 這里面主要分成兩件事，一個是把server監聽端口的listen事件加入到主線程事件監聽中去，這樣一旦有連接達到監聽端口就會調用主線程的 swServer_master_onAccept()來處理新連接。另外一件事就是創建reactor線程并注冊各種事件監聽和協議處理
3.main_reactor->setHandle() , 這個注冊主線程reactor listen事件處理handle ，也就是注冊swServer_master_onAccept()
4.main_reactor->wait(main_reactor, NULL); 這個是主線程循環，主線程一直在這個函數中循環，等待新連接，然后把新連接通過swServer_master_onAccept() ，拿到新的socket，再把新的socket ，通過 sub_reactor->add(sub_reactor, new_fd, SW_FD_TCP | SW_EVENT_WRITE) 加入到reactor線程的事件處理循環中

同過上面的幾部可以清楚的看到主線程是如何監聽listen事件，又是如何accept()新連接，并把新連接加入到reactor線程的監聽中的

下面繼續說reactor線程

reactor線程通過 swReactorThread_start() ，調用創建

//src/network/ReactorThread.c 函數中間有省略，只粘貼了關鍵部分

int swReactorThread_start(swServer *serv, swReactor *main_reactor_ptr)
{
    //..... 省略區
    //create reactor thread
    for (i = 0; i < serv->reactor_num; i++)
    {
        thread = &(serv->reactor_threads[i]);
        param = SwooleG.memory_pool->alloc(SwooleG.memory_pool, sizeof(swThreadParam));
        if (param == NULL)
        {
            swError("malloc failed");
            return SW_ERR;
        }

        param->object = serv;
        param->pti = i;

        if (pthread_create(&pidt, NULL, (void * (*)(void *)) swReactorThread_loop, (void *) param) < 0)
        {
            swError("pthread_create[tcp_reactor] failed. Error: %s[%d]", strerror(errno), errno);
        }
        thread->thread_id = pidt;
    }


    return SW_OK;
}

pthread_create 創建reactor線程，線程的循環函數是swReactorThread_loop

//src/network/ReactorThread.c  函數中間有省略，只粘貼了關鍵部分

static int swReactorThread_loop(swThreadParam *param)
{
   
    //創建線程reactor對象
    swReactor *reactor = &thread->reactor;
    ret = swReactor_create(reactor, SW_REACTOR_MAXEVENTS);


    //注冊pipe管道的事件處理handle
    reactor->setHandle(reactor, SW_FD_CLOSE, swReactorThread_onClose);
    reactor->setHandle(reactor, SW_FD_PIPE | SW_EVENT_READ, swReactorThread_onPipeReceive);
    reactor->setHandle(reactor, SW_FD_PIPE | SW_EVENT_WRITE, swReactorThread_onPipeWrite);


    //set protocol function point  添加socket read write事件監聽， 并注冊協議處理函數
    swReactorThread_set_protocol(serv, reactor);


    // reactor線程循環  
    reactor->wait(reactor, NULL);
    //shutdown
    reactor->free(reactor);

    return SW_OK;
}

void swReactorThread_set_protocol(swServer *serv, swReactor *reactor)
{
    //UDP Packet
    reactor->setHandle(reactor, SW_FD_UDP, swReactorThread_onPackage);
    //Write   socket 可寫事件處理handle
    reactor->setHandle(reactor, SW_FD_TCP | SW_EVENT_WRITE, swReactorThread_onWrite);
    //Read  socket 可讀事件處理handle
    reactor->setHandle(reactor, SW_FD_TCP | SW_EVENT_READ, swReactorThread_onRead);

    swListenPort *ls;
    //listen the all tcp port
    LL_FOREACH(serv->listen_list, ls)
    {
        if (swSocket_is_dgram(ls->type))
        {
            continue;
        }
        swPort_set_protocol(ls);  //協議處理解析， 比如http、http2、websocket、mqtt等
    }
}

swPort_set_protocol 協議處理函數

//src/network/Port.c
void swPort_set_protocol(swListenPort *ls)
{
    //Thread mode must copy the data.
    //will free after onFinish
    if (ls->open_eof_check)
    {
        if (ls->protocol.package_eof_len > sizeof(ls->protocol.package_eof))
        {
            ls->protocol.package_eof_len = sizeof(ls->protocol.package_eof);
        }
        ls->protocol.onPackage = swReactorThread_dispatch;
        ls->onRead = swPort_onRead_check_eof;
    }
    else if (ls->open_length_check)
    {
        if (ls->protocol.package_length_type != '\0')
        {
            ls->protocol.get_package_length = swProtocol_get_package_length;
        }
        ls->protocol.onPackage = swReactorThread_dispatch;
        ls->onRead = swPort_onRead_check_length;
    }
    else if (ls->open_http_protocol)
    {
        if (ls->open_websocket_protocol)
        {
            ls->protocol.get_package_length = swWebSocket_get_package_length;
            ls->protocol.onPackage = swWebSocket_dispatch_frame;
            ls->protocol.package_length_size = SW_WEBSOCKET_HEADER_LEN + SW_WEBSOCKET_MASK_LEN + sizeof(uint64_t);
        }
#ifdef SW_USE_HTTP2
        else if (ls->open_http2_protocol)
        {
            ls->protocol.get_package_length = swHttp2_get_frame_length;
            ls->protocol.package_length_size = SW_HTTP2_FRAME_HEADER_SIZE;
            ls->protocol.onPackage = swReactorThread_dispatch;
        }
#endif
        ls->onRead = swPort_onRead_http; //**http協議處理**
    }
    else if (ls->open_mqtt_protocol)
    {
        ls->protocol.get_package_length = swMqtt_get_package_length;
        ls->protocol.onPackage = swReactorThread_dispatch;
        ls->onRead = swPort_onRead_check_length;
    }
    else if (ls->open_redis_protocol)
    {
        ls->protocol.onPackage = swReactorThread_dispatch;
        ls->onRead = swPort_onRead_redis;
    }
    else
    {
        ls->onRead = swPort_onRead_raw;
    }
}

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频

swoole源碼-主線程和reactor線程交互流程

swoole源碼-主線程和reactor線程交互流程

推薦閱讀更多精彩內容

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美 国产 综合 欧美 视频

swoole源碼-主線程和reactor線程交互流程

推薦閱讀更多精彩內容

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频