download sthread - download do código-fonte sthread

sthread

Outras categorias

1.0.0

Baixar

tópico

Introdução

[sthread] é uma biblioteca de rede de alto desempenho baseada em corrotinas. Atualmente, fornece bibliotecas de cliente e servidor sem bloqueio que suportam TCP/UDP e outros protocolos.

característica

Não há necessidade de depender de bibliotecas de terceiros
Baseado no agendamento de corrotinas com suporte a múltiplas plataformas
Suporte epoll, kequeue
Não há necessidade de escrever código de agendamento assíncrono, todos os códigos são sincronizados, mas o processamento interno do framework é assíncrono
Fornece cliente TCP sem bloqueio
Fornece cliente UDP sem bloqueio
Excelentes recursos de plataforma cruzada e alto desempenho (em teoria, desde que a memória do sistema seja grande o suficiente e não haja limite de identificadores, corrotinas ilimitadas podem ser criadas)
Simples de usar, basta introduzir libmthread.a ou libmthread.so

Além disso, várias bibliotecas clientes estão sendo desenvolvidas com base nesta biblioteca: memcache, redis, wrk, etc.

início rápido

compilar

Compile .a ou .so e execute no diretório atual:

 make

Compile o código de teste e execute-o no diretório de testes:

 make

Ou apenas execute um determinado teste de unidade:

 make event

Um cliente DNS

 void func ( void *args)
{
    std::string *str = (std::string*)args;
    time_t ttl = 0 ;

    std::vector< int32_t > vc;
    int ret = Instance<DNS>()-> dns_lookup (str-> c_str (), vc, &ttl);
    if (ret < 0 ) 
    {
        LOG_ERROR ( " %s, make dns query failed " , str-> c_str ());
        return ;
    }
    for (std::vector< int32_t >::iterator iter = vc. begin (); 
        iter != vc. end (); iter++) 
    {
        struct in_addr addr;
        memcpy (&addr, &(*iter), sizeof ( struct in_addr ));
        LOG_DEBUG ( " %s, %d, %s " , str-> c_str (), *iter, inet_ntoa (addr));
    }
    LOG_DEBUG ( " ttl : %ld " , ttl);
}

int main ( int argc, char * argv[])
{
    int ret = mt_init_frame ();
    LOG_DEBUG ( " init ret : %d " , ret);
    mt_set_hook_flag ();
    mt_set_timeout ( 200 );

    Frame *frame = Instance<Frame>();

    // 测试 : 使用协程请求耗时
    LOG_DEBUG ( " --- start time : %ld " , Util::system_ms ());
    for ( int i = 2000 ; i < 2005 ; i++)
    {
        std::stringstream ss;
        ss << " www. " << i << " .com " ;
        std::string *s = new std::string (ss. str ());
        Frame::CreateThread (func, s);
    }
    Frame::Loop ( true );
    LOG_DEBUG ( " --- end time : %ld " , Util::system_ms ());

    return 0 ;
}

Explique que a interface de chamada de modificação interna do DNS

...

    addr.sin_family = AF_INET;
    if (m_dns_svr_ == NULL )
    {
        addr. sin_addr . s_addr = inet_addr (PUBLIC_DNS_DEFAULT_SERVER);  // /服务器ip
    }
    else
    {
        addr. sin_addr . s_addr = inet_addr (m_dns_svr_);  // /服务器ip
    }
    addr.sin_port = htons(( uint16_t )PUBLIC_DNS_DEFAULT_PORT);

    int query_len = make_dns_query_format();
    if (query_len <= 0 ) 
    {
        return - 1 ;
    }

    int recv_len = sizeof (m_recv_buf_);
    ret = udp_sendrecv(&addr, m_send_buf_, query_len, m_recv_buf_, recv_len, m_timeout_);
    LOG_DEBUG ( " ret : %d, recv_buf : %s, recv_len : %d " , ret, m_recv_buf_, recv_len);

...

servidor HTTP

 class TestIMtAction : public IMtAction
{
public:
    virtual int HandleEncode ( void * buf, int & len, IMessage* msg)
    {
        // ================== 直接发送回包信息 ==================
        char send_buf[ 8192 ] = " HTTP/1.1 200 OK rn "
            " Accept-Ranges: bytes rn "
            " Cache-Control: private, no-cache, no-store, proxy-revalidate, no-transform rn "
            " Connection: Keep-Alive rn "
            " Content-Length: 1 rn "
            " Content-Type: text/html rn "
            " Date: Mon, 20 Aug 2018 14:54:06 GMT rn "
            " Etag: 588604eb-94d rn "
            " Last-Modified: Mon, 23 Jan 2017 13:28:11 GMT rn "
            " Pragma: no-cache rnrn 1 " ;

        len = strlen (send_buf);
        memcpy (buf, send_buf, len);
        (( char *)buf)[len] = '  ' ;
        LOG_DEBUG ( " [send] buf : %s " , send_buf);

        return 0 ;
    }
    virtual int HandleInput ( void * buf, int len, IMessage* msg)
    {
        LOG_DEBUG ( " [recv] buf: %s " , ( char *)buf);

        return len;
    }
    virtual int HandleProcess ( void * buf, int len, IMessage* msg)
    {
        return 0 ;
    }
    virtual int HandleError ( int err, IMessage* msg)
    {
        return 0 ;
    }
};

// 回调函数
static IMtAction* construct ()
{
    IMtAction *action = new TestIMtAction ();
    action-> SetConnType (eTCP_SHORT_CONN);
    return action;
}

static void destruct (IMtAction *action)
{
    if (action)
    {
        action-> Reset ( true );
        safe_delete (action);
    }
}

int main ( int argc, char * argv[])
{
    //定义sockaddr_in
    struct sockaddr_in servaddr;
    memset (&servaddr, 0 , sizeof (servaddr));
    servaddr. sin_family = AF_INET;
    servaddr. sin_port = htons ( 4312 );  // /服务器端口
    servaddr. sin_addr . s_addr = inet_addr ( " 127.0.0.1 " );  // /服务器ip

    int ret = mt_init_frame ();
    mt_set_hook_flag ();

    IMtActionServer *server = new IMtActionServer (&servaddr, eTCP_ACCEPT_CONN);
    server-> SetCallBack (construct, destruct);
    ret = server-> Loop ( 1000 );
    if (ret < 0 )
    {
        LOG_ERROR ( " server error " );
    }

    LOG_TRACE ( " end ... " );
}