即使使用睡眠也不放弃CPU时间的线程

Question

我正在运行此程序，我有多个线程。三个线程正在为同一父进程生成信号。有四个处理线程用于处理由信号生成线程生成的信号。我有一个监视线程，它也接收信号和进程。但是，我有一个情况。我可以看到信号并不是平等分配的。我的意思是信号指向同一个过程。我有四个处理程序线程和一个监视线程等待信号。所以他们中的任何人都可以收到信号。我期待它被统一分发。但是，我可以看到，处理器线程接收到一整串信号。下一次整个信号突发由监视器线程处理。为什么它不统一。处理程序/监视器线程完成处理一个信号后，我添加了一个睡眠调用。所以只要处理器/监视器完成一个信号，它就应该有另一个机会来处理下一个信号。但是，输出不显示的情况下

#include <pthread.h> 
#include <signal.h> 
#include <stdlib.h> 
#include <iostream> 
#include <unistd.h> 
#include <sys/types.h> 
#include <sys/time.h> 
#include <signal.h> 
#include <cstdio> 
#include <stdlib.h> 

#define NUM_SENDER_PROCESSES 3 
#define NUM_HANDLER_PROCESSES 4 
#define NUM_SIGNAL_REPORT 10 
#define MAX_SIGNAL_COUNT 100000 


using namespace std; 

volatile int usrsig1_handler_count = 0; 
int usrsig2_handler_count = 0; 
int usrsig1_sender_count = 0; 
int usrsig2_sender_count = 0; 
int monitor_count = 0; 
int usrsig1_monitor_count = 0; 
int usrsig2_monitor_count = 0; 
double time_1[10]; 
double time_2[10]; 
int lock_1 = 0; 
int lock_2 = 0; 
int lock_3 = 0; 
int lock_4 = 0; 
int lock_5 = 0; 


double timestamp() { 
    struct timeval tp; 
    gettimeofday(&tp, NULL); 
    return (double)tp.tv_sec + tp.tv_usec/1000000.; 
} 

void sleepMs(double seconds) { 
    usleep((unsigned int)(seconds*1000000)); 
} 

void *senderfunc(void *parm) { 
    srand(time(0)); 
    while(true) { 
    int signal_id = rand()%2 + 1; 
    if(signal_id == 1) { 
     while(__sync_lock_test_and_set(&lock_3,1) != 0) { 
     } 
     usrsig1_sender_count++; 
     lock_3 = 0; 
     kill(getpid(), SIGUSR1); 
    } else { 
     while(__sync_lock_test_and_set(&lock_4,1) != 0) { 
     } 
     usrsig2_sender_count++; 
     lock_4 = 0; 
     kill(getpid(), SIGUSR2); 
    } 


    int r = rand()%10 + 1; 
    double s = (double)r/100; 
    sleepMs(s); 
    } 
} 

void *handlerfunc(void *parm) 
{ 
    int *index = (int *)parm; 
    sigset_t set; 
    sigemptyset(&set); 
    //cout << (*index) << endl; 
    if((*index) % 2 == 0) { 
    sigaddset(&set, SIGUSR1); 
    } else { 
    sigaddset(&set, SIGUSR2); 
    } 


    int sig; 

    while(true) { 
    sigwait(&set, &sig); 
    //cout << "Handler" << endl; 
    if (sig == SIGUSR1) { 
     while(__sync_lock_test_and_set(&lock_1,1) != 0) { 
     } 
     usrsig1_handler_count++;   
     lock_1 = 0; 
    } else if(sig == SIGUSR2) { 
     while(__sync_lock_test_and_set(&lock_2,1) != 0) { 
     } 
     usrsig2_handler_count++; 
     lock_2 = 0; 
    } 

    sleepMs(0.0001); 
    } 

} 

void *monitorfunc(void *parm) { 

    sigset_t set; 
    sigemptyset(&set); 

    sigaddset(&set, SIGUSR1); 
    sigaddset(&set, SIGUSR2); 

    int sig; 

    while(true) { 
    sigwait(&set, &sig); 
    //cout << "Monitor" << endl; 
    if(sig == SIGUSR1) { 
     time_1[usrsig1_monitor_count] = timestamp(); 
     usrsig1_monitor_count++; 
    } else if(sig == SIGUSR2) { 
     time_2[usrsig2_monitor_count] = timestamp(); 
     usrsig2_monitor_count++; 
    } 
    monitor_count++; 
    //cout << monitor_count << endl; 

    if(monitor_count == NUM_SIGNAL_REPORT) { 
     double difference_1 = 0; 
     double difference_2 = 0; 
     if(usrsig1_monitor_count > 1) { 
     for(int i=0; i<usrsig1_monitor_count-1; i++) { 
      difference_1 = difference_1 + time_1[i+1] - time_1[i]; 
     } 
     cout << "Interval SIGUSR1 = " << difference_1/(usrsig1_monitor_count-1)<< endl; 
     } 

     if(usrsig2_monitor_count > 1) { 
     for(int i=0; i<usrsig2_monitor_count-1; i++) { 
      difference_2 = difference_2 + time_2[i+1] - time_2[i]; 
     } 
     cout << "Interval SIGUSR2 = " << difference_2/(usrsig2_monitor_count-1) << endl; 
     } 
     cout << "Count SIGUSR1 = " << usrsig1_sender_count << endl; 
     cout << "Count SIGUSR2 = " << usrsig2_sender_count << endl; 
     monitor_count = 0; 
     usrsig1_monitor_count = 0; 
     usrsig2_monitor_count = 0; 
    } 

    sleepMs(0.001); 

    } 
} 

int main(int argc, char **argv) 
{ 
    if(argc != 2) { 
    cout << "Required parameters missing. " << endl; 
    cout << "Option 1 = 1 which means run for 30 seconds" << endl; 
    cout << "Option 2 = 2 which means run until 100000 signals" << endl; 
    exit(0); 
    } 

    int option = atoi(argv[1]); 
    int i; 

    pthread_t handlers[NUM_HANDLER_PROCESSES]; 
    pthread_t generators[NUM_SENDER_PROCESSES]; 
    pthread_t monitor; 

    sigset_t set; 
    sigset_t oldset; 
    sigemptyset(&oldset); 
    sigemptyset(&set); 
    sigaddset(&set, SIGUSR1); 
    sigaddset(&set, SIGUSR2); 

    pthread_sigmask(SIG_BLOCK, &set, &oldset); 


    int handler_mask[4] = {0,1,2,3}; 
    //Initializing the handler threads 
    for(i=0; i<NUM_HANDLER_PROCESSES; i++) { 
    pthread_create(&handlers[i], NULL, handlerfunc, (void *)&handler_mask[i]); 
    } 

    pthread_create(&monitor, NULL, monitorfunc, NULL); 

    sleep(5); 

    for(i=0; i<NUM_SENDER_PROCESSES; i++) { 
    pthread_create(&generators[i], NULL, senderfunc, NULL); 
    } 

    if(option == 1) { 
    cout << "Option 1 " << endl; 
    //sleep(30); 
    while(true){ 

    } 
    exit(0); 
    } else { 
    while(true) { 
     if((usrsig1_handler_count + usrsig2_handler_count) >= MAX_SIGNAL_COUNT) { 
     cout << "Count SIGUSR1 = " << usrsig1_handler_count << endl; 
     cout << "Count SIGUSR2 = " << usrsig2_handler_count << endl; 
     exit(0); 
     } else { 
     pthread_yield(); 
     } 
    } 
    } 
} 

这里是我的输出

HandlerHandler 

Handler 
Handler 
Monitor 
Monitor 
Monitor 
Monitor 
Monitor 
Monitor 
Monitor 
Monitor 
Monitor 
Monitor 
Monitor 
Monitor 
Monitor 
Monitor 
Handler 
Handler 
Handler 
Handler 
Handler 
Handler 
Handler 
Handler 
Handler 
Handler 

你可以看到显示器的突发，随后处理的爆裂。但是，在代码中，一旦处理程序/监视器处理了一个信号并进入sigwait，我就添加了一个睡眠调用，以便将该转换传递给下一个可用线程。但是，这没有帮助。我猜这应该是统一的。但是，监视器仍然会爆炸并打印。即使在监视器中，当它已完成其信号作业后，它已经进入睡眠状态

Answer 1

代码有两个不同的问题，可以让您看到结果。

第一个也是最重要的是每个线程都分配了一个时间片来运行。这个时间片可以被信号或IO中断，而不是一个线程将运行直到它完成时间片。所以，即使你进行了睡眠 - 如果睡眠时间小于该线程的时间片，它也不会将执行转移到其他线程。如果我记得在Windows上这个时间片至少是5ms，但通常是40ms（尽管我可能有错误的号码）。在Linux上，这个时间片可能会更短，但对于通用Linux盒子，我认为它是一样的。我曾经使用Sleep（0）来放弃Windows上的时间片。 usleep（0）可能会做同样的事情。所以你使用睡眠的方式不会做你想做的。但是，由于您使用的并行线程只是叫pthread_yield放弃这应该是更好的做法，但谁知道CPU或SCHED_YIELD（） ...

你可以跟你的测试输出面临的第二个问题是您实际上没有直接的方法来控制在多线程环境中输出到流的字符顺序。如果你真的想要输出为了你需要实现一个单独的线程做输出，并使用队列和一些锁定机制（临界区，互斥锁）或自由锁定机制将消息发送给i。

希望这个得到你的正确方向