线程属性相关函数与操作

（1）线程属性相关函数

int pthread_attr_init(pthread_attr_t *attr);

int pthread_attr_destroy(pthread_attr_t *attr);

 

/* 栈空间大小 */

PTHREAD_STACK_MIN // 0x4000

int pthread_attr_setstacksize(pthread_attr_t *attr, size_t stacksize);

int pthread_attr_getstacksize(pthread_attr_t *attr, size_t *stacksize);

 

/* 分离状态 */

PTHREAD_CREATE_JOINABLE

PTHREAD_CREATE_DETACHED

int pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate);

int pthread_attr_getdetachstate(pthread_attr_t *attr, int *detachstate);

 

/* 作用域 */

PTHREAD_SCOPE_SYSTEM

PTHREAD_SCOPE_PROCESS

int pthread_attr_setscope(pthread_attr_t *attr, int scope);

int pthread_attr_getscope(pthread_attr_t *attr, int *scope);

 

/* 调度策略 */

SCHED_FIFO

SCHED_RR

SCHED_OTHER

int pthread_attr_setschedpolicy(pthread_attr_t *attr, int policy);

int pthread_attr_getschedpolicy(pthread_attr_t *attr, int *policy);

/* 调度优先级 */

#include <sched.h>

MAX：int sched_get_priority_max(int policy);  // 99

MIN：int sched_get_priority_min(int policy); // 1

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

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

 

/* 继承属性 */

PTHREAD_INHERIT_SCHED

PTHREAD_EXPLICIT_SCHED

int pthread_attr_setinheritsched(pthread_attr_t *attr,int inheritsched);

int pthread_attr_getinheritsched(pthread_attr_t *attr,int *inheritsched);

 

/* 栈末尾的警戒缓冲区大小 */

int pthread_attr_setguardsize(pthread_attr_t *attr, size_t guardsize);

int pthread_attr_getguardsize(pthread_attr_t *attr, size_t *guardsize);

 

/* 栈空间地址 */

int pthread_attr_setstackaddr(pthread_attr_t *attr, void *stackaddr);

int pthread_attr_getstackaddr(pthread_attr_t *attr, void **stackaddr);

（2）线程操作相关函数

int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine) (void *), void *arg);

void pthread_exit(void *retval);

pthread_t pthread_self(void);

int pthread_equal(pthread_t t1, pthread_t t2);

int pthread_join(pthread_t thread, void **retval);

int pthread_cancel(pthread_t thread);

int pthread_kill(pthread_t thread, int sig);

int pthread_detach(pthread_t thread);

（3）代码举例

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
#include <sched.h>
#include <limits.h>
#include <sys/prctl.h>
#include <errno.h>

/* usr date */
static int usr_date = 0;

static void test_write(void *arg) 
{
    /* set pthread name */
    prctl(PR_SET_NAME, "test_write");
    printf("write pthread id:%lu
", pthread_self());

    while(1) {
        printf("w:usr_date:%d
", usr_date++);
        if (usr_date >= 5) {
            pthread_exit(0);
        }

        sleep(2);
    }    

    return ;
}

static void test_read(void *arg) 
{
    /* set pthread name */
    prctl(PR_SET_NAME, "test_read");
    printf("read pthread id:%lu
", pthread_self());

    while(1) {
        printf("r:usr_date:%d
", usr_date);
        sleep(1);
    }

    return ;
}

int pthread_set_attr(pthread_attr_t *attr, int priority, size_t stacksize)
{
    int rval;
    struct sched_param  params;
    int maxPriority, minPriority;

    rval = pthread_attr_init(attr);
    if (rval != 0)
    {
        return rval;
    }

    /* normally, need not to set */
    rval = pthread_attr_setinheritsched(attr, PTHREAD_EXPLICIT_SCHED);
    if (rval != 0)
    {
        printf("pthread_attr_setinheritsched failed
");
        return rval;
    }

    rval = pthread_attr_setscope(attr, PTHREAD_SCOPE_SYSTEM);
    if (rval != 0)
    {
        if (rval == ENOTSUP)
        {
            printf("The system does not support the %s scope, using %s
",
                    "PTHREAD_SCOPE_SYSTEM", "PTHREAD_SCOPE_PROCESS");

            rval = pthread_attr_setscope(attr, PTHREAD_SCOPE_PROCESS);
        }

        if (rval)
        {
            printf("pthread_attr_setscope failed
");
            return rval;
        }
    }

    /* use the round robin scheduling algorithm */
    rval = pthread_attr_setschedpolicy(attr, SCHED_RR);
    if (rval != 0)
    {
        printf("pthread_attr_setschedpolicy failed
");
        return rval;
    }

    /* set the thread to be detached */
    rval = pthread_attr_setdetachstate(attr, PTHREAD_CREATE_JOINABLE);
    if (rval != 0)
    {
        printf("pthread_attr_setdetachstate failed
");
        return rval;
    }

    /* first get the scheduling parameter, then set the new priority */
    rval = pthread_attr_getschedparam(attr, &params);
    if (rval != 0)
    {
        printf("pthread_attr_getschedparam failed
");
        return rval;
    }

    minPriority = sched_get_priority_min(SCHED_RR);
    maxPriority = sched_get_priority_max(SCHED_RR);
    printf("maxPriority:%d, minPriority:%d
", maxPriority, minPriority);

    if (priority < minPriority)
    {
        priority = minPriority;
    }
    else if (priority > maxPriority)
    {
        priority = maxPriority;
    }
    params.sched_priority = priority;
    rval = pthread_attr_setschedparam(attr, &params);
    if (rval != 0)
    {
        printf("pthread_attr_setschedparam failed
");
        return rval;
    }

    /* when set stack size, we define a minmum value to avoid fail */
    printf("PTHREAD_STACK_MIN:%x
", PTHREAD_STACK_MIN);
    if (stacksize < PTHREAD_STACK_MIN)
    {
        stacksize = PTHREAD_STACK_MIN;
    }
    rval = pthread_attr_setstacksize(attr, stacksize);
    if (rval != 0)
    {
        printf("pthread_attr_setstacksize failed
");
        return rval;
    }

    return 0;
}

void test(void)
{
    pthread_t wtest_taskid;
    pthread_t rtest_taskid;
    pthread_attr_t attr;
    int *retval = NULL;
    size_t stacksize;
    int priority;
    int ret;

    pthread_attr_init(&attr);

    stacksize = 4096;
    priority = 50;
    ret = pthread_set_attr(&attr, priority, stacksize);
    if (ret) {
        pthread_attr_destroy(&attr);
        return ;
    }

    /* create write pthread */
    ret = pthread_create(&wtest_taskid, NULL, (void *)test_write, NULL);
    if (ret) {
        printf("%s failed, errno:%d
", __FUNCTION__, errno);
    }
    
    /* create read pthreadi */
    ret = pthread_create(&rtest_taskid, NULL, (void *)test_read, NULL);
    if (ret) {
        printf("%s failed, errno:%d
", __FUNCTION__, errno);
    }

    pthread_attr_destroy(&attr);

    ret = pthread_join(wtest_taskid, (void **)&retval);
    printf("%d %d
", ret, (int *)retval);
    if (ret == 0 && (int *)retval == 0) {
        if (pthread_kill(rtest_taskid, 0) == 0)
            pthread_cancel(rtest_taskid);
    }

    printf("pthread exit success!
");
}

int main(int argc, char **argv)
{
    test();

    pause();
    return 0;
}