铁猴子传奇之边城困兽:Linux多线程编程的基本的函数

#include 
int pthread_create(pthread_t *restrict tidp,const pthread_attr_t *restrict attr, void *(*start_rtn)(void),void *restrict arg);

    返回值：若是成功建立线程返回0,否则返回错误的编号
   形式参数：
                pthread_t *restrict tidp 要创建的线程的线程id指针
               const pthread_attr_t *restrict attr 创建线程时的线程属性
               void* (start_rtn)(void) 返回值是void类型的指针函数
                vodi*restrict arg   start_rtn的行参
   例题1：
       功能：测试建立一个新的线程
       程序名称： pthread_test.c      

#include 
#include 
void *create(void *arg)
...{
    printf("new thread created ..... ");
    
}
int main(int argc,char *argv[])
...{
    pthread_t tidp;
    int error;

    error=pthread_create(&tidp,NULL,create,NULL);
    if(error!=0)
    ......{
        printf("pthread_create is not created ... ");
        return -1;
    }
    printf("prthread_create is created... ");
    return 0;
}

     编译方法：

#gcc -Wall -lpthread pthread_test.c

    因为pthread的库不是linux系统的库，所以在进行编译的时候要加上-lpthread，否则编译不过，会出现下面错误

thread_test.c: 在函数 ‘create’ 中：
thread_test.c:7: 警告： 在有返回值的函数中，程序流程到达函数尾
/tmp/ccOBJmuD.o: In function `main':thread_test.c:(.text+0x4f)：对‘pthread_create’未定义的引用
collect2: ld 返回 1

#include 
#include 
#include 
void *create(void *arg)
...{
    int *num;
    num=(int *)arg;
    printf("create parameter is %d  ",*num);
    return (void *)0;
}
int main(int argc ,char *argv[])
...{
    pthread_t tidp;
    int error;
    
    int test=4;
    int *attr=&test;
    
    error=pthread_create(&tidp,NULL,create,(void *)attr);

    if(error!=0)
    ...{
        printf("pthread_create is created is not created ... ");
        return -1;
    }
    sleep(1);
    printf("pthread_create is created is  created ... ");
    return 0;
}

    编译方法：

gcc -lpthread thread_int.c -Wall

    执行结果：

create parameter is 4
pthread_create is created is  created ...

    例题总结：
   可以看出来，我们在main函数中传递的整行指针，传递到我们新建的线程函数中。
   在上面的例子可以看出来我们向新的线程传入了另一个线程的int数据，线程之间还可以传递字符串或是更复杂的数据结构。

    例题3：
   程序功能：向新建的线程传递字符串
    程序名称：thread_char.c   

#include 
#include 
#include 
void *create(void *arg)
...{
    char *name;
    name=(char *)arg;
    printf("arg is %s ",name);
    return (void *)0;
}
int main(int argc,char *argv[])
...{
    char *a="wang";
    int error;
    pthread_t tidp;

    error=pthread_create(&tidp,NULL,create,(void *)a);

    if(error!=0)
    ...{
        printf("pthread is not created ");
        return -1;
    }
    sleep(1);
    printf("pthread is created...");
    return 0;
}    

    编译方法：

gcc -Wall thread_char.c -lpthread

    执行结果：

arg is wang
pthread is created...

    例题总结：
   可以看出来main函数中的字符串传入了新建里的线程中。

    例题4
   程序名称：thread_struct.c   

#include 
#include 
#include 
#include  /**//*malloc()*/
struct test
...{
    int a;
    char *s;
};

void *create(void *arg)
...{
    struct test *temp;
    temp=(struct test *)arg;
    printf("test->a ==%d ",temp->a);
    printf("test->s ==%s ",temp->s);
    return (void *)0;
}
int main(int argc,char *argv[])
...{
    pthread_t tidp;
    int error;
    struct test *b;
    b=(struct test *)malloc(sizeof(struct test));
    b->a=4;
    b->s="wang";

    error=pthread_create(&tidp,NULL,create,(void *)b);

    if(error!=0)
    ...{
        printf("phread is not created...");
        return -1;
    }
    sleep(1);
    printf("pthread is created...");
    return 0;
}

    编译方法：

gcc -Wall -lpthread thread_struct.c

    执行结果：

test->a ==4
test->s ==wang
pthread is created...

#include 
#include 
#include 
static int a=4;
void *create(void *arg)
...{
    printf("new pthread ...");
    printf("a==%d  ",a);
    return (void *)0;
}
int main(int argc,char *argv[])
...{
    pthread_t tidp;
    int error;
    a=5;

    error=pthread_create(&tidp,NULL,create,NULL);

    if(error!=0)
    ...{
        printf("new thread is not create ...");
        return -1;
    }
    sleep(1);
    printf("new thread is created ...");
    return 0;
}

    编译方法：

gcc -Wall -lpthread thread_share.c

    执行结果：

new pthread ...
a==5
new thread is created ...

#include 
void pthread_exit(void *rval_ptr);
/*rval_ptr 线程退出返回的指针*/

int pthread_join(pthread_t thread,void **rval_ptr);
  /*成功结束进程为0,否则为错误编码*/

    例题6
    程序目的：线程正常退出，接受线程退出的返回码
   程序名称：exit_return.c   

   #include 
#include 
#include 
void *create(void *arg)
...{
    printf("new thread is created ...");
    return (void *)2;
}
int main(int argc,char *argv[])
...{
    pthread_t tid;
    int error;
    void *temp;

    error=pthread_create(&tid,NULL,create,NULL);

    if(error!=0)
    ...{
        printf("thread is not created ...");
        return -1;
    }
    error=pthread_join(tid,&temp);

    if(error!=0)
    ...{
        printf("thread is not exit ...");
        return -2;
    }
    printf("thread is exit code %d ",(int )temp);
    sleep(1);
    printf("thread is created...");
    return 0;
}

    编译方法：

gcc -Wall exit_return.c -lpthread

    执行结果：

new thread is created ...
thread is exit code 2
thread is created...

   线程退出不仅仅可以返回线程的int数值，还可以返回一个复杂的数据结构
    例题7
   程序目的：线程结束返回一个复杂的数据结构
    程序名称：exit_thread.c   

   #include 
#include 
#include 
struct test
...{
    int a;
    char *b;
};

struct test temp=
...{
    .a    =4,
    .b    ="wang"
};

void *create(void *arg)
...{
    printf("new thread ...");
    return (void *)&temp;
}

int main(int argc,char *argv[])
...{
    int error;
    pthread_t tid;
    struct test *c;

    error=pthread_create(&tid,NULL,create,NULL);
    
    if(error!=0)
    ...{
        printf("new thread is not created ...");
        return -1;
    }
    printf("main ...");

    error=pthread_join(tid,(void *)&c);

    if(error!=0)
    ...{
        printf("new thread is not exit ...");
        return -2;
    }
    printf("c->a ==%d ",c->a);
    printf("c->b ==%s ",c->b);
    sleep(1);
    return 0;
}

    编译方法：
 

gcc -Wall -lpthread exit_struct.c

   
    执行结果：

main ...
new thread ...
c->a ==4
c->b ==wang

   例题总结：一定要记得返回的数据结构要是在这个数据要返回的结构没有释放的时候应用，如果数据结构已经发生变化，那返回的就不会是我们所需要的，而是藏数据阿。

pthread_t pthread_self(void);
   例题8
    程序目的：实现在新建立的线程中打印该线程的id和进程id
    程序名称：thread_self.c
   #include 
#include 
#include  /**//*getpid()*/
void *create(void *arg)
...{
    printf("new thread .... ");
    printf("thread_tid==%u  ",(unsigned int)pthread_self());
    printf("thread pid is %d  ",getpid());
    return (void *)0;
}
int main(int argc,char *argv[])
...{
    pthread_t tid;
    int error;

    printf("Main thread is starting ... ");

    error=pthread_create(&tid,NULL,create,NULL);

    if(error!=0)
    ...{
        printf("thread is not created ... ");
        return -1;
    }
    printf("main pid is %d  ",getpid());
    sleep(1);
    return 0;
}


    编译方法：

   gcc -Wall -lpthread thread_self.c
   执行结果：

Main thread is starting ...
main pid is 6860
new thread ....
thread_tid==3084954544
thread pid is 6860

   4、 线程的处理程序

    函数原型：   

#include 
void pthread_cleanup_push(void (*rtn)(void *),void *arg);
    函数rtn是清理函数，arg是调用参数

void pthread_cleanup_pop(int execute);

   在前面讲过线程的终止方式，是正常终止还是非正常终止，都会存在一个资源释放的问题，在posix中提供了一组，就是我们上面看的函数进行线程退出的处理函数，有些像在进程中的atexit函数。释放的方式是指pthread_cleanup_push的调用点到pthread_cleanup_pop之间程序段进行终止。

pthread_cleanup_push()/pthread_cleanup_pop采用先入后出的方式的栈的管理方式，void*rtn(void*),在执行pthread_cleanup_push()时压入函数栈，多次执行pthread_cleanup_push()形成一个函数链，在执行这个函数链的时候会以反方向弹出，即先入后出。execute参数表识，是否执行弹出清理函数，当execute=0时不进行弹出清理函数，非零的时候弹出处理函数。

    例题9

    程序目的：实现在正常结束线程的时候，进行函数处理

    程序名称：thread_clean.c

    编译方法：

    执行结果： 

thread 1 start
thread 1 push complete
thread 1 exit code 1
thread 2 start
thread 2 push complete
cleanup :thread 2 second handler
cleanup :thread 2 first handler
thread 2 exit code 2

 gcc -Wall -lpthread thread_clean.c#include 
#include 
#include 
void *clean(void *arg)
...{
    printf("cleanup :%s  ",(char *)arg);
    return (void *)0;
}
void *thr_fn1(void *arg)
...{
    printf("thread 1 start  ");
    pthread_cleanup_push(clean,"thread 1 first handler");
    pthread_cleanup_push(clean,"thread 1 second hadler");
    printf("thread 1 push complete  ");
    if(arg)
    ...{
        return((void *)1);
    }
    pthread_cleanup_pop(0);
    pthread_cleanup_pop(0);
    return (void *)1;
}
void *thr_fn2(void *arg)
...{
    printf("thread 2 start  ");
    pthread_cleanup_push(clean,"thread 2 first handler");
    pthread_cleanup_push(clean,"thread 2 second handler");
    printf("thread 2 push complete  ");
    if(arg)
    ...{
        pthread_exit((void *)2);
    }
    pthread_cleanup_pop(0);
    pthread_cleanup_pop(0);
    pthread_exit((void *)2);
}
int main(void)
...{
    int err;
    pthread_t tid1,tid2;
    void *tret;

    err=pthread_create(&tid1,NULL,thr_fn1,(void *)1);
    if(err!=0)
    ...{
        printf("error .... ");
        return -1;
    }
    err=pthread_create(&tid2,NULL,thr_fn2,(void *)1);

    if(err!=0)
    ...{
        printf("error .... ");
        return -1;
    }
    err=pthread_join(tid1,&tret);
    if(err!=0)
    ...{
        printf("error .... ");
        return -1;
    }
    printf("thread 1 exit code %d  ",(int)tret);

    err=pthread_join(tid2,&tret);
    if(err!=0)
    ...{
        printf("error .... ");
        return -1;
    } gcc -Wall -lpthread thread_clean.c
    printf("thread 2 exit code %d  ",(int)tret);
    exit(0);
}