posix线程的优先级测试

2023-05-16

测试的时候，如果创建的线程不够多，有些问题体现不出来，例如pthread_cond_signal和pthread_cond_broadcast。

奇怪的优化是不会有好结果的。

优先级打印：

测试目的：输出三种调度模式下的最大优先级和最小优先级

#include <stdio.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <fcntl.h>
#include <stdlib.h>
#include <unistd.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <string.h>
#include <pthread.h>
#include <sys/select.h>
#include <sys/epoll.h>
#include <errno.h>
#include <sys/wait.h>
#include <netinet/tcp.h>

#define DEBUG_INFO(format, ...) printf("%s:%d -- " format "\n", __func__, __LINE__,##__VA_ARGS__)


int main(){
    int min;
    int max;
    min = sched_get_priority_min(SCHED_OTHER);
    max = sched_get_priority_max(SCHED_OTHER);
    DEBUG_INFO("SCHED_OTHER min = %d,max = %d",min,max);

    min = sched_get_priority_min(SCHED_RR);
    max = sched_get_priority_max(SCHED_RR);
    DEBUG_INFO("SCHED_RR min = %d,max = %d",min,max);

    min = sched_get_priority_min(SCHED_FIFO);
    max = sched_get_priority_max(SCHED_FIFO);
    DEBUG_INFO("SCHED_FIFO min = %d,max = %d",min,max);


    return 0;
}

执行结果：

main:25 -- SCHED_OTHER min = 0,max = 0
main:29 -- SCHED_OTHER min = 1,max = 99
main:33 -- SCHED_OTHER min = 1,max = 99

测试一：先创建10个线程。

使用默认属性。

#include <stdio.h>
#include <iostream>
#include <pthread.h>
#include <unistd.h>
#include <string.h>
#include <semaphore.h>
#include <signal.h>
#include <map>

#define DEBUG_INFO(format, ...) printf("%s:%d -- " format "\n", __func__, __LINE__,##__VA_ARGS__)

std::map<pthread_t ,int> thread_index_map;

struct mystruct{
    int index;
    pthread_t thread;

};

void clean_up_resource(void *arg){
    struct mystruct *pms = (struct mystruct *)arg;
    DEBUG_INFO("delete thread index = %d\n", pms->index);
    free(arg);
}

void *func(void *arg){
    struct mystruct *pms = (struct mystruct *)arg;
    static pthread_t thread_id = pthread_self();
    pthread_cleanup_push(clean_up_resource,arg);
    
    while(1){
        for(int i = 0;i < 10000000;i++){

        }
        break;
    }
    DEBUG_INFO("index = %d",pms->index);
    return 0;
    pthread_cleanup_pop(0);
}

int main(int argc, char**){
    for(int i=0; i < 10; i++){
        pthread_t t;
        struct mystruct *pms = (struct mystruct*)malloc(sizeof(struct mystruct));
        pms->index = i;
        int ret = pthread_create(&t, NULL, func,pms);
        if(ret != 0){
            perror("pthread_create");
        }
    }
    while(1){
        sleep(1);
    }
}

执行结果：

main:44 -- pid = 39495
func:37 -- index = 3
func:37 -- index = 8
func:37 -- index = 0
func:37 -- index = 4
func:37 -- index = 6
func:37 -- index = 9
func:37 -- index = 2
func:37 -- index = 7
func:37 -- index = 5
func:37 -- index = 1

pstree -p命令的执行截图

上面我们看到输出的index的值，不是倒叙也不是正序，而是乱序的，现在，我们需要设置线程的优先级，让他们有序的运行，如何操作呢。

测试二：线程的清理

捕获信号SIGINT，在SIGINT信号处理函数中，结束10个线程。然后

#include <stdio.h>
#include <iostream>
#include <pthread.h>
#include <unistd.h>
#include <string.h>
#include <semaphore.h>
#include <signal.h>
#include <map>
#include <list>

#define DEBUG_INFO(format, ...) printf("%s:%d -- " format "\n", __func__, __LINE__,##__VA_ARGS__)

std::map<pthread_t ,int> thread_index_map;
typedef void (*sighandler)(int signo);
struct mystruct{
    int index;
    pthread_t thread;

};

void clean_up_resource(void *arg){
    struct mystruct *pms = (struct mystruct *)arg;
    DEBUG_INFO("delete thread index = %d\n", pms->index);
    free(arg);
}
std::list<pthread_t> pthread_list;
void *func(void *arg){
    pthread_list.push_back(pthread_self());
    struct mystruct *pms = (struct mystruct *)arg;
    static pthread_t thread_id = pthread_self();
    pthread_cleanup_push(clean_up_resource,arg);
    
    while(1){
        for(int i = 0;i < 10000000;i++){

        }
        break;
    }
    DEBUG_INFO("index = %d",pms->index);
    while(1)sleep(1);
    return 0;
    pthread_cleanup_pop(0);
}



void sig_func(int signo){
    auto it = pthread_list.begin();
    DEBUG_INFO("%lu",pthread_list.size());
    for(;it != pthread_list.end();it++){
        pthread_cancel(*it);
    }
    DEBUG_INFO("good bye");
    sleep(2);
    exit(0);
}

int main(int argc, char**){
    sighandler sig_ret;
    sig_ret = signal(SIGINT, sig_func);
    if(sig_ret == SIG_ERR){
        perror("signal");
        exit(-1);
    }
    DEBUG_INFO("pid = %u",getpid());
    for(int i=0; i < 10; i++){
        pthread_t t;
        struct mystruct *pms = (struct mystruct*)malloc(sizeof(struct mystruct));
        pms->index = i;
        int ret = pthread_create(&t, NULL, func,pms);
        if(ret != 0){
            perror("pthread_create");
        }
    }
    while(1){
        sleep(1);
    }
    return 0;
}

执行结果：

main:65 -- pid = 50827
func:39 -- index = 1
func:39 -- index = 4
func:39 -- index = 2
func:39 -- index = 3
func:39 -- index = 0
func:39 -- index = 5
func:39 -- index = 6
func:39 -- index = 8
func:39 -- index = 7
func:39 -- index = 9
^Csig_func:49 -- 10
sig_func:53 -- good bye
clean_up_resource:23 -- delete thread index = 0

clean_up_resource:23 -- delete thread index = 4

clean_up_resource:23 -- delete thread index = 1

clean_up_resource:23 -- delete thread index = 3

clean_up_resource:23 -- delete thread index = 5

clean_up_resource:23 -- delete thread index = 8

clean_up_resource:23 -- delete thread index = 9

clean_up_resource:23 -- delete thread index = 2

clean_up_resource:23 -- delete thread index = 7

clean_up_resource:23 -- delete thread index = 6

按下CTRL+C后，sig_func被执行，开始遍历删除链表中的线程。最后退出进程。为了让删除动作成功完成，执行exit(0)之前先休眠2秒。

线程的属性

pthread_attr_init函数

NAME
       pthread_attr_init, pthread_attr_destroy - initialize and destroy thread attributes object

SYNOPSIS
       #include <pthread.h>

       int pthread_attr_init(pthread_attr_t *attr);
       int pthread_attr_destroy(pthread_attr_t *attr);

       Compile and link with -pthread.

pthread_getattr_np函数

NAME
       pthread_getattr_np - get attributes of created thread

SYNOPSIS
       #define _GNU_SOURCE             /* See feature_test_macros(7) */
       #include <pthread.h>

       int pthread_getattr_np(pthread_t thread, pthread_attr_t *attr);

       Compile and link with -pthread.

pthread_attr_t结构体

pthread_attr_init函数

NAME
       pthread_attr_init, pthread_attr_destroy - initialize and destroy thread attributes object

SYNOPSIS
       #include <pthread.h>

       int pthread_attr_init(pthread_attr_t *attr);
       int pthread_attr_destroy(pthread_attr_t *attr);

       Compile and link with -pthread.

线程的优先级是经常设置的属性，由两个函数进行控制：pthread_attr_getschedparam()函数获得线程的优先级设置；函数pthread_attr_setschedparam()设置线程的优先级。

pthread_attr_setschedparam函数

NAME
       pthread_attr_setschedparam, pthread_attr_getschedparam - set/get scheduling parameter attributes in thread attributes object

SYNOPSIS
       #include <pthread.h>

       int pthread_attr_setschedparam(pthread_attr_t *attr,
                                      const struct sched_param *param);
       int pthread_attr_getschedparam(const pthread_attr_t *attr,
                                      struct sched_param *param);

       Compile and link with -pthread.

结构体struct sched_param

struct sched_param {
               int sched_priority;     /* Scheduling priority */
           };

pthread_testcancel函数

NAME
       pthread_testcancel - request delivery of any pending cancellation request

SYNOPSIS
       #include <pthread.h>

       void pthread_testcancel(void);

       Compile and link with -pthread.

schedpolicy：这个属性控制线程的调度方式。它的取值可以是SCHED_OTHER、SCHED_RP和SCHED_FIFO。这个属性的默认值为SCHED_OTHER。另外两种调度方式只能用于以超级用户权限运行的进程，因为它们都具备实时调度的功能，但在行为上略有区别。SCHED_RP使用循环（round-robin）调度机制，而SCHED_FIFO使用“先进先出”策略。

测试三：优先级测试

#ifndef _GNU_SOURCE
#define _GNU_SOURCE     /* To get pthread_getattr_np() declaration */
#endif
#define _REENTRANT
#include <stdio.h>
#include <iostream>
#include <pthread.h>
#include <unistd.h>
#include <string.h>
#include <semaphore.h>
#include <signal.h>
#include <map>
#include <list>
#include <sched.h>
#include <atomic>
using namespace std;

#define DEBUG_INFO(format, ...) printf("%s:%d -- " format "\n", __func__, __LINE__,##__VA_ARGS__)

std::map<pthread_t ,int> thread_index_map;
typedef void (*sighandler)(int signo);
struct mystruct{
    int index;
    pthread_t thread;
    pthread_attr_t attr;
    struct sched_param sched;


};

void clean_up_resource(void *arg){
    struct mystruct *pms = (struct mystruct *)arg;
    DEBUG_INFO("delete thread index = %d\n", pms->index);
    pthread_attr_destroy(&pms->attr);
    free(arg);
}
std::list<pthread_t> pthread_list;
// std::atomic_bool start = false;
atomic<long> start(0);
pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
void *func(void *arg){
    pthread_list.push_back(pthread_self());
    struct mystruct *pms = (struct mystruct *)arg;
    static pthread_t thread_id = pthread_self();
    pthread_cleanup_push(clean_up_resource,arg);

    // pthread_mutex_lock(&mtx);
    // while(start == 0){
    //     pthread_cond_wait(&cond,&mtx);
    // }
    // pthread_mutex_unlock(&mtx);
    int ret = pthread_setschedparam(pthread_self(), SCHED_FIFO, &pms->sched);
    if (ret != 0) {
        perror("pthread_setschedparam");
        exit(-1);
    }
    while(start == 0){}
    DEBUG_INFO("start thread = %d",pms->index);
    
    while(1){
        for(int i = 0;i < 100;i++){
            pthread_testcancel();
            for(int j = 0;j < 100;j++){usleep(1);}
        }
        break;
    }
    DEBUG_INFO("index = %d",pms->index);
    while(1)sleep(1);
    return 0;
    pthread_cleanup_pop(0);
}

void sig_func(int signo){
    auto it = pthread_list.begin();
    DEBUG_INFO("%lu",pthread_list.size());
    for(;it != pthread_list.end();it++){
        
        pthread_cancel(*it);
    }
    DEBUG_INFO("good bye");
    sleep(2);
    exit(0);
}

int main(int argc, char**){
    sighandler sig_ret;
    sig_ret = signal(SIGINT, sig_func);
    if(sig_ret == SIG_ERR){
        perror("signal");
        exit(-1);
    }
    DEBUG_INFO("pid = %u",getpid());
    for(int i=0; i < 10; i++){
        pthread_t t;
        struct mystruct *pms = (struct mystruct*)malloc(sizeof(struct mystruct));
        if(!pms){
            perror("malloc");
            raise(SIGINT);
            while(1)sleep(1);
        }
        pms->index = i;       

        pthread_attr_init(&pms->attr);
        pthread_attr_getschedparam(&pms->attr,&pms->sched);
        DEBUG_INFO("pms->sched.sched_priority = %d",pms->sched.sched_priority);
        pthread_attr_setschedpolicy(&pms->attr,SCHED_FIFO);//SCHED_OTHER);//SCHED_RP);//SCHED_FIFO);
        pms->sched.sched_priority = (i + 1)*5;
        pthread_attr_setschedparam(&pms->attr,&pms->sched);

        pthread_attr_getschedparam(&pms->attr,&pms->sched);
        DEBUG_INFO("pms->sched.sched_priority = %d",pms->sched.sched_priority);

        
        int ret = pthread_create(&t, NULL, func,pms);
        if(ret != 0){
            perror("malloc");
            raise(SIGINT);
            free(pms);            
            
        }
    }
    start = 1;
    //pthread_cond_signal(&cond);
    pthread_cond_broadcast(&cond);
    while(1){
        sleep(1);
    }
    return 0;
}

main:93 -- pid = 87681
main:106 -- pms->sched.sched_priority = 0
main:112 -- pms->sched.sched_priority = 5
main:106 -- pms->sched.sched_priority = 0
main:112 -- pms->sched.sched_priority = 10
main:106 -- pms->sched.sched_priority = 0
main:112 -- pms->sched.sched_priority = 15
main:106 -- pms->sched.sched_priority = 0
main:112 -- pms->sched.sched_priority = 20
main:106 -- pms->sched.sched_priority = 0
main:112 -- pms->sched.sched_priority = 25
main:106 -- pms->sched.sched_priority = 0
main:112 -- pms->sched.sched_priority = 30
main:106 -- pms->sched.sched_priority = 0
main:112 -- pms->sched.sched_priority = 35
main:106 -- pms->sched.sched_priority = 0
main:112 -- pms->sched.sched_priority = 40
main:106 -- pms->sched.sched_priority = 0
main:112 -- pms->sched.sched_priority = 45
main:106 -- pms->sched.sched_priority = 0
main:112 -- pms->sched.sched_priority = 50
func:59 -- start thread = 4
func:59 -- start thread = 0
func:59 -- start thread = 1
func:59 -- start thread = 3
func:59 -- start thread = 6
func:59 -- start thread = 5
func:59 -- start thread = 7
func:59 -- start thread = 9
func:59 -- start thread = 2
func:59 -- start thread = 8
func:68 -- index = 9
func:68 -- index = 6
func:68 -- index = 7
func:68 -- index = 8
func:68 -- index = 4
func:68 -- index = 2
func:68 -- index = 3
func:68 -- index = 5
func:68 -- index = 0
func:68 -- index = 1

线程9优先级最高，所以先执行完成，线程0优先级最低，倒数第二完成。只能说整体上能看出来是优先级的趋势是对的了。因为是多核的关系吗。所以不是纯正的降序。

在单核的ARM板上运行，如下所示，没有达到我心中的降序的效果啊。4都最先完成了。但是每次执行完成的数序确实固定的，这...

func:68 -- index = 4
func:68 -- index = 5
func:68 -- index = 6
func:68 -- index = 7
func:68 -- index = 3
func:68 -- index = 2
func:68 -- index = 8
func:68 -- index = 9
func:68 -- index = 1
func:68 -- index = 0

测试五：优化后的代码

#ifndef _GNU_SOURCE
#define _GNU_SOURCE     /* To get pthread_getattr_np() declaration */
#endif
#ifndef _REENTRANT
#define _REENTRANT
#endif
#include <stdio.h>
#include <iostream>
#include <pthread.h>
#include <unistd.h>
#include <string.h>
#include <semaphore.h>
#include <signal.h>
#include <map>
#include <list>
#include <sched.h>
#include <atomic>
using namespace std;

#define DEBUG_INFO(format, ...) printf("%s:%d -- " format "\n", __func__, __LINE__,##__VA_ARGS__)

std::map<pthread_t ,int> thread_index_map;
typedef void (*sighandler)(int signo);
struct mystruct{
    int index;
    pthread_t thread;
    pthread_attr_t attr;
    struct sched_param sched;


};

void clean_up_resource(void *arg){
    struct mystruct *pms = (struct mystruct *)arg;
    DEBUG_INFO("delete thread index = %d\n", pms->index);
    pthread_attr_destroy(&pms->attr);
    free(arg);
}
std::list<pthread_t> pthread_list;
// std::atomic_bool start = false;
atomic<long> start(0);
atomic<long> counter(0);
pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
void *func(void *arg){
    pthread_list.push_back(pthread_self());
    struct mystruct *pms = (struct mystruct *)arg;
    static pthread_t thread_id = pthread_self();
    pthread_cleanup_push(clean_up_resource,arg);

    
    // int ret = pthread_setschedparam(pthread_self(), SCHED_FIFO, &pms->sched);
    // if (ret != 0) {
    //     perror("pthread_setschedparam");
    //     exit(-1);
    // }
    sched_setscheduler(pthread_self(), SCHED_FIFO,&pms->sched);//SCHED_FIFO//SCHED_RR(round-robin)
    pthread_mutex_lock(&mtx);
    while(start == 0){
        pthread_cond_wait(&cond,&mtx);
    }
    pthread_mutex_unlock(&mtx);
    DEBUG_INFO("start thread = %d",pms->index);
    pthread_attr_getschedparam(&pms->attr,&pms->sched);
    DEBUG_INFO("pms->sched.sched_priority = %d",pms->sched.sched_priority);
    
    while(1){
        for(int i = 0;i < 10000;i++){
            //pthread_testcancel();
            for(int j = 0;j < 10000;j++){counter++;}
        }
        break;
    }
    DEBUG_INFO("index = %d",pms->index);
    while(1)sleep(1);
    return 0;
    pthread_cleanup_pop(0);
}

void sig_func(int signo){
    auto it = pthread_list.begin();
    DEBUG_INFO("%lu",pthread_list.size());
    for(;it != pthread_list.end();it++){
        
        pthread_cancel(*it);
    }
    DEBUG_INFO("good bye");
    sleep(2);
    std::cout << "counter = " << counter << std::endl;
    exit(0);
}

int main(int argc, char**){
    sighandler sig_ret;
    sig_ret = signal(SIGINT, sig_func);
    if(sig_ret == SIG_ERR){
        perror("signal");
        exit(-1);
    }
    DEBUG_INFO("pid = %u",getpid());
    for(int i=0; i < 10; i++){
        pthread_t t;
        struct mystruct *pms = (struct mystruct*)malloc(sizeof(struct mystruct));
        if(!pms){
            perror("malloc");
            raise(SIGINT);
            while(1)sleep(1);
        }
        pms->index = i;       

        pthread_attr_init(&pms->attr);
        pthread_attr_getschedparam(&pms->attr,&pms->sched);
        DEBUG_INFO("pms->sched.sched_priority = %d",pms->sched.sched_priority);
        pthread_attr_setschedpolicy(&pms->attr,SCHED_FIFO);//SCHED_OTHER);//SCHED_RP);//SCHED_FIFO);
        pms->sched.sched_priority = 100 - (i + 1)*5;
        pthread_attr_setschedparam(&pms->attr,&pms->sched);

        pthread_attr_getschedparam(&pms->attr,&pms->sched);
        DEBUG_INFO("pms->sched.sched_priority = %d",pms->sched.sched_priority);

        
        int ret = pthread_create(&t, NULL, func,pms);
        if(ret != 0){
            perror("malloc");
            raise(SIGINT);
            free(pms);            
            
        }
    }
    start = 1;
    //pthread_cond_signal(&cond);
    pthread_cond_broadcast(&cond);
    while(1){
        sleep(1);
    }
    return 0;
}

测试结果略

奇怪的优化代表着腐朽

#ifndef _GNU_SOURCE
#define _GNU_SOURCE     /* To get pthread_getattr_np() declaration */
#endif
#ifndef _REENTRANT
#define _REENTRANT
#endif
#include <stdio.h>
#include <iostream>
#include <pthread.h>
#include <unistd.h>
#include <string.h>
#include <semaphore.h>
#include <signal.h>
#include <map>
#include <list>
#include <sched.h>
#include <atomic>

using namespace std;

#define DEBUG_INFO(format, ...) printf("%s:%d -- " format "\n", __func__, __LINE__,##__VA_ARGS__)

std::map<pthread_t ,int> thread_index_map;
typedef void (*sighandler)(int signo);
struct mystruct{
    int index;
    pthread_t thread;
    pthread_attr_t attr;
    struct sched_param sched;


};

void clean_up_resource(void *arg){
    struct mystruct *pms = (struct mystruct *)arg;
    DEBUG_INFO("delete thread index = %d", pms->index);
    pthread_attr_destroy(&pms->attr);
    free(arg);
}
std::list<pthread_t> pthread_list;
// std::atomic_bool start = false;
atomic<long> start(0);
atomic<long> start_sync(0);
atomic<long> counter(0);
pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

sem_t gsem;
void *func(void *arg){
    pthread_list.push_back(pthread_self());
    struct mystruct *pms = (struct mystruct *)arg;
    static pthread_t thread_id = pthread_self();
    pthread_cleanup_push(clean_up_resource,arg);

    
    // int ret = pthread_setschedparam(pthread_self(), SCHED_FIFO, &pms->sched);
    // if (ret != 0) {
    //     perror("pthread_setschedparam");
    //     exit(-1);
    // }
    sched_setscheduler(pthread_self(), SCHED_FIFO,&pms->sched);//SCHED_FIFO//SCHED_RR(round-robin)
    pthread_mutex_lock(&mtx);
    while(start == 0){
        pthread_cond_wait(&cond,&mtx);
    }
    pthread_mutex_unlock(&mtx);
    sleep(1);//等待1秒，是为了最大限度的让每个线程同步
    while(start_sync == 0){}
    //到这里，理想情况下，能够最先得到信号量的线程就是优先级最高的线程
    sem_wait(&gsem);
    int sem_value = 0;
    sem_getvalue(&gsem,&sem_value);
    pthread_attr_getschedparam(&pms->attr,&pms->sched);
    //DEBUG_INFO("start thread = %d,pms->sched.sched_priority = %d,sem_value = %d",pms->index,pms->sched.sched_priority,sem_value);
    
    while(1){
        for(int i = 0;i < 10000;i++){
            //pthread_testcancel();
            for(int j = 0;j < 10000;j++){
                // counter++;
            }
            //usleep(1);
        }
        break;
    }
    pthread_attr_getschedparam(&pms->attr,&pms->sched);
    printf("%d,",pms->index);
    //DEBUG_INFO("index = %d,pms->sched.sched_priority = %d",pms->index,pms->sched.sched_priority);
    while(1)sleep(1);
    return 0;
    pthread_cleanup_pop(0);
}

void sig_func(int signo){
    auto it = pthread_list.begin();
    DEBUG_INFO("%lu",pthread_list.size());
    for(;it != pthread_list.end();it++){
        
        pthread_cancel(*it);
    }
    DEBUG_INFO("%s","good bye");
    sleep(2);
    std::cout << "counter = " << counter << std::endl;
    exit(0);
}

int main(int argc, char**){
    sighandler sig_ret;
    sig_ret = signal(SIGINT, sig_func);
    if(sig_ret == SIG_ERR){
        perror("signal");
        exit(-1);
    }
    sem_init(&gsem,0,0);
    DEBUG_INFO("pid = %u",getpid());
    for(int i=0; i < 10; i++){
        pthread_t t;
        struct mystruct *pms = (struct mystruct*)malloc(sizeof(struct mystruct));
        if(!pms){
            perror("malloc");
            raise(SIGINT);
            while(1)sleep(1);
        }
        pms->index = i;       

        pthread_attr_init(&pms->attr);
        pthread_attr_setinheritsched(&pms->attr,PTHREAD_EXPLICIT_SCHED);
        pthread_attr_getschedparam(&pms->attr,&pms->sched);
        //DEBUG_INFO("pms->sched.sched_priority = %d",pms->sched.sched_priority);
        pthread_attr_setschedpolicy(&pms->attr,SCHED_FIFO);//SCHED_OTHER);//SCHED_RP);//SCHED_FIFO);
        pms->sched.sched_priority = (i + 1);//*5;//100 - (i + 1)*5;
        pthread_attr_setschedparam(&pms->attr,&pms->sched);

        pthread_attr_getschedparam(&pms->attr,&pms->sched);
        //DEBUG_INFO("pms->sched.sched_priority = %d",pms->sched.sched_priority);

        
        int ret = pthread_create(&t, NULL, func,pms);
        if(ret != 0){
            perror("malloc");
            raise(SIGINT);
            free(pms);            
            
        }
    }
    start = 1;
    //pthread_cond_signal(&cond);
    pthread_cond_broadcast(&cond);
    for(int i = 0;i < 10;i++){ 
        sem_post(&gsem);
    }
    sleep(1);
    start_sync = 1;
    sleep(5);
    printf("\n");
    
    while(1){
        sleep(1);
    }
    return 0;
}

执行结果：

main:115 -- pid = 60349
0,2,5,4,6,1,8,3,9,7,

小结

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

posix线程的优先级测试的相关文章

curl: (7) Failed to connect to raw.githubusercontent.com port 443: Operation timed out

ERROR usr bin ruby e curl fsSL https raw githubusercontent com Homebrew install master install curl 7 Failed to connect
银河麒麟高级服务器v10 sp1 搭建局域网yum源（同步阿里yum源centos7.9）

系统环境 xff1a root 64 localhost nkvers Kylin Linux Version Release Kylin Linux Advanced Server release V10 Tercel Kernel 4
初识QT（向主部件添加对象、Qt中使用类继承）

第一个QT程序 include lt QApplication gt include lt QWidget gt include lt QPushButton gt int main int argc char argv QApplicat
死锁

死锁 xff1a 指多个进程因竞争共享资源而造成的一种僵局 xff0c 若无外力作用 xff0c 这些进程都将永远不能再向前推进安全状态与不安全状态 xff1a 安全状态指系统能按某种进程顺序来为每个进程分配其所需资源 xff0c 直
C语言使用scanf()函数时，%c前面和后面分别加上空格后的结果

在使用scanf 读取输入的字符时 xff0c 当转换说明为 c时 xff0c 34 c 34 34 c 34 34 c 34 这三种不同的写法 xff0c 对数据读取的结果有什么影响吗 xff0c 答案是肯定的 xff0c c 加不加空格
npm安装依赖包报错，npm ERR! code ENOTFOUND（2020-07-03）

vue项目安装依赖包 xff0c 报错如下 xff1a npm install npm WARN registry Using stale data from https registry npmjs org because the hos
pb9在64位系统下提示：error opening DLL library pbws32.dll for external function

pb9在64位系统下提示 xff1a error opening DLL library pbws32 dll for external function 解决方法 xff1a 打开PB9的目录 xff0c 在pb90 exe的属性中选择兼
集成学习

李宏毅机器学习周志华机器学习第8章使用sklearn进行集成学习 stacking心得 xgboost实战 bagging xff1a 当原模型已经很复杂的时候 xff0c bias已经很小但variance很大时候比较容易overf
【C++中级篇】gtest的使用方法及cmake配置

个人箴言 xff1a 不积跬步 xff0c 无以至千里 xff1b 不积小流 xff0c 无以成江海夯实基础 xff0c 成就高楼大厦前言 xff1a 在一项c 43 43 工程中 xff0c 会存在很多类 xff0c 很多功能方法 x
CMake如何控制两个文件生成的依赖关系

使用target link libraries函数 xff1a 这个函数可以让你指定一个目标 xff08 target xff09 依赖于哪些其他目标或库 CMake会自动根据这些依赖关系来确定编译的顺序 xff0c 先编译被依赖的目标 x
关于windows连不上服务器的问题

报错 xff1a kex exchange identification read Connection reset 也有可能报错 xff1a remote side unexpectedly closed network connecti
Jackson多态反序列化的使用

缘起最近看Apache Druid的源代码 0 5很老的版本 xff0c 印象最深的就是对Jackson的多态反序列化和注入的使用了 xff0c 这里也属于自己的知识盲点 xff0c 看着复杂的json直接反序列化为可用对象 xff0c
Apache Druid源码导读--Google guice DI框架

文章目录缘起Google Guice介绍与Spring的对比Example覆盖已有绑定关系默认绑定 Apache Druid中Guice模块guice lifecycleguice jsonconfigguice jersey jetty
向Python女神推荐这些年我追过的经典书籍

最近 34 瑞丽模特学Python 34 的热点牵动了大江南北程序员的心 xff0c 有人说这是炒作 xff0c 也有人说这是推广Python的爆点我嘿嘿一笑 xff0c 美女就是美女 xff0c 眼光那是杠杠的 xff0c 不仅人美 x
[gevent源码分析] 深度分析gevent运行流程

一直对gevent运行流程比较模糊 xff0c 最近看源码略有所得 xff0c 不敢独享 xff0c 故分享之 gevent是一个高性能网络库 xff0c 底层是libevent xff0c 1 0版本之后是libev xff0c 核心是g
TCP服务器端和客户端程序设计

一实验目的学习和掌握Linux下的TCP服务器基本原理和基本编程方法体会TCP与UDP编程的不同 xff0c UDP编程 xff1a http blog csdn net yueguanghaidao article details
UDP服务器端和客户端程序设计

实验三 UDP服务器端程序设计一实验目的学习和掌握Linux下的UDP服务器基本原理和基本编程方法 xff0c 体会与TCP的区别 xff0c TCP编程 xff1a http blog csdn net yueguanghaidao
python实现的文本编辑器

wxpython实现的文本编辑器效果如下 xff1a 主要功能 xff1a 1 编辑保存文本 xff0c 打开修改文本 2 常用快捷键 xff0c 复制 xff0c 粘贴 xff0c 全选等 3 支持撤销功能 4 支持弹出式菜单代码如下
C语言开发Linux下web服务器(支持GET/POST,SSL,目录显示等)

这个主要是在CSAPP基础上做的 xff0c 添加了POST xff0c SSL xff0c 目录显示等功能一实现功能 xff1a 1 支持GET POST方法 2 支持SSL安全连接即HTTPS 3 支持CGI 4 基于IP地址和掩码
sklearn2pmml xgboost缺失值(missing)处理的坑

sklearn2pmml xgboost缺失值 missing 处理的坑今天同事在部署xgboost pmml模型时遇到了大坑 xff0c 线上spark预测和本地python预测结果怎么都不对应 xff0c 记录一下处理过程看了下同事

随机推荐

adb导出手机应用到电脑

简单说一下相关步骤 xff0c 以备不时之需 1 手机开启usb调试 2 Windows系统 Win 43 R打开命令行窗口 xff0c 输入adb devices xff0c 如果连接成功会出现机子的序列号 3 adb shell pm
Js作用域与作用域链详解

一直对Js的作用域有点迷糊 xff0c 今天偶然读到Javascript权威指南 xff0c 立马被吸引住了 xff0c 写的真不错我看的是第六版本 xff0c 相当的厚 xff0c 大概1000多页 xff0c Js博大精深 xff0c
windows10环境下tensorflow安装教程

楼主最近一直忙着找工作最近几个月一直all in java 好久没学机器学习深度学习前几天突然通知要提交论文中期了于是赶紧打开电脑结果发现之前安装的tensorflow居然登陆不上了折腾了半天搜过各种csdn博客一直安装失败
'gbk' codec can't encode character '\xa0'

从网上抓了一些字节流 xff0c 想打印出来结果发生了一下错误 xff1a UnicodeEncodeError 39 gbk 39 codec can 39 t encode character 39 xbb 39 in position
【Git记录学习】github创建项目以及本地使用(vscode)

一 github创建空仓库从github中创建空仓库在执行完上一步操作后会返回这样的界面 xff0c 包括了一些基本的git操作以及HttpS SSH地址生成一个readme md文档 xff08 步骤2 Set up下面有蓝色的超链
关于DFT变换含义、公式和具体形式

原文地址 xff1a http blog sina com cn s blog 7853c3910102v9wd html 这篇文章从实际工程应用的角度 xff0c 记录一下如何计算 xff0c 关于公式变形和应用维基百科上的 DFT公
1602显示数字不稳定一直跳动（AD转换）

程序如下所示首先说明下 xff0c 此程序为AD转换芯片PCF8591采集电压数据 xff0c 然后送到1602显示现象 xff1a 1602显示的数字一直频繁的跳动 xff0c 乱花眼此现象不是一直出现的 xff0c 有时候会出现
C++11中的线程类

前面介绍的线程是利用了POSIX线程库 xff0c 这是传统C C 43 43 程序员使用线程的方式 xff0c 而C 43 43 11提供了语言层面使用线程的方式 C 43 43 11新标准中引入了5个头文件来支持多线程编程 xff0c
4.4.1内核编译

内核源码下载地址 xff1a https mirrors edge kernel org pub linux kernel v4 x linux 4 4 1 tar gz 安装依赖包 xff1a 报错就装 cp boot config xx
fatal error: hugetlbfs.h: No such file or directory

fatal error hugetlbfs h No such file or directory 解决办法 xff1a sudo apt get update sudo apt get install libhugetlbfs dev
WSL下配置NFS-失败

配置一个IP地址 xff1a sudo ip addr add 192 168 250 2 24 broadcast 192 168 250 255 dev eth2 sudo apt get install nfs kernel serv
OMT 对象模型、动态模型和功能模型

对象模型描述系统中对象的静态结构对象之间的关系对象的属性对象的操作对象模型表示静态的结构上的系统的数据 34 特征对象模型为动态模型和功能模型提供了基本的框架 xff0c 对象模型用包含对象和类的对象图来表示 OMT的对象模
关于epoll的调试的几个问题

将今天调试的几个小问题点总结下 xff0c 后续遇到再添加一将总结的问题点放在最前面 1 epoll wait的maxevents参数 epoll wait的maxevents参数 xff0c 经过测试 xff0c maxevents的
poll函数测试

一基础知识 include lt poll h gt int poll struct pollfd fds nfds t nfds int timeout 其中参数fds指向一个结构体数组的第0个元素的指针 xff0c 每个数组元素都是一
IPC:匿名管道和命名管道

一管道初级测试写两个小程序 xff0c 一个负责向管道发数据 xff0c 一个从管道接收数据 xff1b pipe cpp include lt iostream gt using namespace std int main cout
IPC:system V消息队列

ftok函数 ftok convert a pathname and a project identifier to a System V IPC key SYNOPSIS include lt sys types h gt include
IPC:system V 信号量和共享内存

信号量相关知识结构体 union semun int val Value for SETVAL struct semid ds buf Buffer for IPC STAT IPC SET unsigned short array Ar
信号signal编程测试

信号会打断系统调用 xff0c 慎用 xff0c 就是用的时候测一测下面是信号的基础测试信号信号 xff08 signal xff09 机制是UNIX系统中最为古老的进程之间的通信机制它用于在一个或多个进程之间传递异步信号信号可以
线程间通讯的信号量semaphore.h

sem init SEM INIT 3 Linux Programmer 39 s Manual SEM INIT 3 NAME sem init initialize an unnamed semaphore SYNOPSIS inclu
posix线程的优先级测试

测试的时候 xff0c 如果创建的线程不够多 xff0c 有些问题体现不出来 xff0c 例如pthread cond signal和pthread cond broadcast 奇怪的优化是不会有好结果的优先级打印 xff1a 测试目的

posix线程的优先级测试

优先级打印：

测试一：先创建10个线程。

执行结果：

测试二：线程的清理

线程的属性

测试三：优先级测试

测试五：优化后的代码

奇怪的优化代表着腐朽

小结

posix线程的优先级测试 的相关文章

随机推荐

热门标签

posix线程的优先级测试的相关文章