Question

主要功能基于libevent，但函数中有一个长期运行的任务。所以开始N踏步来完成任务。这个想法好吗？以及如何在C中一起使用libevent和pthread？

Answer 1

提出一个老问题，可能已经解决了。但是发布答案以防其他人需要它。

是的，在这种情况下可以进行线程化。我最近在pthreads中使用了libevent，它似乎工作正常。这是代码：

#include <stdint.h>
#include <pthread.h>
#include <event.h>

void * thread_func (void *);

int main(void)
{
    int32_t tid = 0, ret = -1;
    struct event_base *evbase;
    struct event *timer;
    int32_t *t_ret = &ret;
    struct timeval tv;

    // 1. initialize libevent for pthreads
    evthread_use_pthreads();

    ret = pthread_create(&tid, NULL, thread_func, NULL);
    // check ret for error

    // 2. allocate event base
    evbase = event_base_new();
    // 3. allocate event object
    timer = event_new(evbase, -1, EV_PERSIST, callback_func, NULL);
    // 4. add event
    tv.tv_sec = 0;
    tv.tv_usec = 1000;
    evtimer_add(timer, &tv);
    // 5. start the event loop
    event_base_dispatch(evbase);   // event loop

    // join pthread...

    // 6. free resources
    event_free(timer);
    event_base_free(evbase);
    return 0;
}

void * thread_func(void *arg)
{
    struct event *ev;
    struct event_base *base;

    base = event_base_new();
    ev = event_new(base, -1, EV_PERSIST, thread_callback, NULL);
    event_add(ev, NULL);  // wait forever
    event_base_dispatch(base);  // start event loop

    event_free(ev);
    event_base_free(base);
    pthread_exit(0);
}

正如您所看到的，在我的例子中，主线程的事件是计时器。遵循的基本逻辑如下：

调用 evthread_use_pthreads（）来初始化Linux上的pthreads的libevent（我的情况）。对于windows evthread_use_window_threads（）。查看 event.h 本身提供的文档。
按照文档中的说明在全局堆上分配 event_base 结构。确保检查错误的返回值。
与上述相同，但分配事件结构本身。在我的例子中，我没有等待任何文件描述符，所以-1作为参数传递。此外，我希望我的活动能够持续，因此 EV_PERSIST 。回调函数的代码被省略。
安排执行事件
启动事件循环
完成后释放资源。

在我的案例中使用的Libevent版本是 libevent2 5.1.9 ，您还需要 libevent_pthreads.so 库进行链接。

欢呼声。

Answer 2

那会有用。

在I / O回调函数中，将耗时的作业委托给线程池的另一个线程。确切的机制取决于工作线程或线程池的接口。

要将结果从工作线程传回I / O线程，请使用管道。工作线程将结果对象的指针写入管道和I / O线程醒来并从管道中读取指针。

Answer 3

这篇博文中有一个多线程的libevent示例： http://www.roncemer.com/multi-threaded-libevent-server-example

他的解决方案是，引用：

解决方案是为每个活动连接创建一个libevent事件队列（AKA event_base），每个队列都有自己的事件泵线程。这个项目正是如此，为您提供编写高性能，多线程，基于libevent的套接字服务器所需的一切。

Answer 4

注意这是针对libev而不是libevent，但这个想法可能适用。

这里我举一个社区的例子。请评论，如果有任何明显的错误，请告诉我。这个例子可能包括一个信号处理程序，用于将来的线程终止和正常退出。

//This program is demo for using pthreads with libev. 
//Try using Timeout values as large as 1.0 and as small as 0.000001
//and notice the difference in the output

//(c) 2009 debuguo
//(c) 2013 enthusiasticgeek for stack overflow
//Free to distribute and improve the code. Leave credits intact
//compile using:           gcc -g test.c -o test -lpthread -lev

#include <ev.h>
#include <stdio.h> // for puts
#include <stdlib.h>
#include <pthread.h>

pthread_mutex_t lock;
double timeout = 0.00001;
ev_timer timeout_watcher;
int timeout_count = 0;

ev_async async_watcher;
int async_count = 0;

struct ev_loop* loop2;

void* loop2thread(void* args)
{ 
    // now wait for events to arrive on the inner loop
    ev_loop(loop2, 0);
    return NULL;
}

static void async_cb (EV_P_ ev_async *w, int revents)
{
    //puts ("async ready");
    pthread_mutex_lock(&lock);     //Don't forget locking
    ++async_count;
    printf("async = %d, timeout = %d \n", async_count, timeout_count);
    pthread_mutex_unlock(&lock);   //Don't forget unlocking
}

static void timeout_cb (EV_P_ ev_timer *w, int revents) // Timer callback function
{
    //puts ("timeout");
    if(ev_async_pending(&async_watcher)==false){ //the event has not yet been processed (or even noted) by the event loop? (i.e. Is it serviced? If yes then proceed to)
        ev_async_send(loop2, &async_watcher); //Sends/signals/activates the given ev_async watcher, that is, feeds an EV_ASYNC event on the watcher into the event loop. 
    }

    pthread_mutex_lock(&lock);     //Don't forget locking
    ++timeout_count;
    pthread_mutex_unlock(&lock);   //Don't forget unlocking
    w->repeat = timeout;
    ev_timer_again(loop, &timeout_watcher); //Start the timer again.
}

int main (int argc, char** argv)
{
    if (argc < 2) {
        puts("Timeout value missing.\n./demo <timeout>");
        return -1;
    }
    timeout = atof(argv[1]);

    struct ev_loop *loop = EV_DEFAULT;  //or ev_default_loop (0);

    //Initialize pthread
    pthread_mutex_init(&lock, NULL);
    pthread_t thread;

    // This loop sits in the pthread
    loop2 = ev_loop_new(0);

    //This block is specifically used pre-empting thread (i.e. temporary interruption and suspension of a task, without asking for its cooperation, with the intention to resume that task later.)  
    //This takes into account thread safety
    ev_async_init(&async_watcher, async_cb);
    ev_async_start(loop2, &async_watcher);
    pthread_create(&thread, NULL, loop2thread, NULL);

    ev_timer_init (&timeout_watcher, timeout_cb, timeout, 0.); // Non repeating timer. The timer starts repeating in the timeout callback function
    ev_timer_start (loop, &timeout_watcher);

    // now wait for events to arrive on the main loop
    ev_loop(loop, 0);
    //Wait on threads for execution
    pthread_join(thread, NULL);

    pthread_mutex_destroy(&lock);
    return 0;
}

如何在C中一起使用libevent和pthread

4 个答案: