多任务处理如何使调用无限循环功能

Question

承担创建通过在pthread_create 3个工作线程，

在这些工作线程例行

后工作线程增益控制，每次调用哪个没有回做计数一个简单的无限循环功能

如何在调用无限循环函数之后使工作线程增益控制并保存用于在工作线程中再次调用的无限循环函数的上下文？

Answer 1

让我换句话来看看我是否理解了这个问题。

您有一个主线程，它产生3个工作线程，每个工作线程执行长时间运行（无限）工作。

在您希望中断处理的某个点上，保存所有线程的状态以恢复以后停止的位置。

我认为这样做的最好方法是组织您的线程在事务绑定块中工作。重新启动时，检查上次完成的事务，然后从那里开始。

但是由于我怀疑这是低级别线程管道中的家庭作业分配，我可能会建议一个共享布尔值，在您每次通过循环退出并存储状态之后选中该值。另一种方法是“杀死”线程并捕获异常并存储状态。最后一个选项是混乱的。

Answer 2

想做一个线程池的作用，呼吁无限循环功能后，每个工作线程可以改变其他任务（其他无限循环功能）运行

例如3个工作线程可以运行4个任务（无限循环功能）

#ifndef JOB_CPP 
#define JOB_CPP 

#include "job.h" 

#define NUM_OF_TASKS 4 
#define NUM_OF_WORKERS 3 
    void (* job_queue[NUM_OF_TASKS])(void*); 
    void (* fp[NUM_OF_WORKERS])(void*); // original running job 
    int running_task[NUM_OF_WORKERS]; 
    int idle[NUM_OF_TASKS]; 
    int last_running_task[NUM_OF_WORKERS]; 
    int no_of_tasks_running[NUM_OF_WORKERS]; 
    my_struct_t data = {PTHREAD_MUTEX_INITIALIZER, PTHREAD_COND_INITIALIZER, 0}; 

void func1(void *arg) 
{ 
    int count = 0; 
    int status; 
    while(true) 
    { 
     //if((count % 100) == 0) 
     //printf("func1 run %d\n", count); 
     count = count + 1; 
     //status = pthread_cond_signal(&data.cv); 
    } 
} 
void func2(void *arg) 
{ 
    int count = 0; 
    int status; 
    while(true) 
    { 
     //printf("func2 run %d\n", count); 
     count = count + 1; 
     //status = pthread_cond_signal(&data.cv); 
    } 
} 
void func3(void *arg) 
{ int count = 0; 
    int status; 
    while(true) 
    { 
     //printf("func3 run %d\n", count); 
     count = count + 1; 
     //status = pthread_cond_signal(&data.cv); 
    } 
} 
void func4(void *arg) 
{ int count = 0; 
    int status; 
    while(true) 
    { 
     //printf("func4 run %d\n", count); 
     count = count + 1; 
     //status = pthread_cond_signal(&data.done); 
    } 
} 

void jobinit() 
{ 
    for(int i=0; i<NUM_OF_TASKS; i++) 
    { 
     job_queue[i] = NULL; 
     idle[i] = 0; 
    } 
    for(int i=0; i<NUM_OF_WORKERS; i++) 
    { 
     fp[i] = NULL; 
     running_task[i] = 0; 
     last_running_task[i] = 0; 
     no_of_tasks_running[i] = 0; 
    } 
    jobadd(func1); 
    jobadd(func2); 
    jobadd(func3); 
    jobadd(func4); 
    jobrun(); 
} 
void jobadd(void (*job)(void*)) 
{ 
    for(int i=0; i<4; i++) 
    { 
     if(job_queue[i] == NULL) 
     { 
      job_queue[i] = job; 
      return; 
     } 
    } 
} 
void* workserver(void *arg); 
void* workserver(void *arg) 
{ 
    int status, timedout; 

    struct timespec timeout; 

    status = pthread_mutex_lock(&data.mutex); 
    while(true) 
    { 
     timedout = 0; 
     clock_gettime(CLOCK_REALTIME, &timeout); 
     timeout.tv_sec += 2; 

     sleep(1); 
     //void (* clean)(void*); 

     status = pthread_cond_timedwait(&data.cv, &data.mutex, &timeout); 
     if(status == ETIMEDOUT){ 
      printf("worker wait timed out %d\n", (int)arg); 
      timedout = 1; 
     }else if(status != 0){ 
      printf("worker wait failed %d\n", (int)arg); 
      status = pthread_mutex_unlock(&data.mutex); 
      return NULL; 
     } 
     printf("workserver number: %d\n", (int)arg); 

     status = pthread_mutex_unlock(&data.mutex);  

     printf("function run %d\n", (int)arg); 
     (* job_queue[(int)arg])(NULL); 

     printf("cond wait start %d\n", (int)arg); 
     status = pthread_cond_wait(&data.done, &data.mutex); 
     printf("cond wait end\n"); 

     status = pthread_mutex_lock(&data.mutex); 
    } 
} 
void jobrun() 
{ 
    for(int i=0; i<3; i++) {idle[i] = 0;} 
    pthread_t r1_threadid[3]; 

    for(int i=0; i<3; i++) 
    { 
     pthread_create(&r1_threadid[i], NULL, workserver, (void*)i); 
    } 

    int status; 
    struct timespec timeout; 

    timeout.tv_sec = time (NULL) + 2; 
    timeout.tv_nsec = 0; 

    while(true) 
    { 
    status = pthread_mutex_lock(&data.mutex); 
    while(data.value == 0) 
    { 
     status = pthread_cond_timedwait(&data.cond, &data.mutex, &timeout); 
    } 
    if(data.value != 0) 
    { 
     //printf("condition was signaled\n"); 
     data.value = 0; 
    } 
    status = pthread_mutex_unlock(&data.mutex); 
    if(status != 0) 
     printf("unlock mutex error"); 
    } 
} 
#endif 

Answer 3

我想你应该澄清你的问题。

如果每个工作者线程调用一个无限循环，那么我想你的主线程将不得不在每个线程上调用pthread_cancel()。从我收集的信息可能需要调用其他pthread_*()函数来设置目标线程的“可取消性”。

当然这个建议引发了问题。最好的办法是防止那些无限循环。编写代码以使其具有退出条件......以便工作受到某种输入的限制或具有某种事件处理。