Linux下的多线程操作一：线程的创建于访问控制

Linux的线程是采用用户级的线程库实现的，一般采用pthread线程库实现线程的访问和控制。它用第 3 方 posix 标准的 pthread，具有良好的可移植性。 编译的时候要在后面加上 –lpthread，即链接一个第三方库。
线程的创建

#include <pthread.h>
int pthread_create(pthread_t *thread, const pthread_attr_t *attr,void *(*start_routine) (void *), void *arg);

第一个参数是线程id,第二个参数是线程的属性，第三个参数是函数指针，真正要线程去处理的函数，第四个参数是给第三个参数所指的函数传递的参数。成功返回0，失败返回错误码。
接下来我们写一个简单的创建一个线程

#include <func.h>

void* threadFunc(void* p)
{
    printf("i am child pthread\n");

    pthread_exit(NULL);
}
int main()
{
    pthread_t thid;
    int ret=0;
    ret=pthread_create(&thid,NULL,threadFunc,NULL);
    THREAD_ERROR_CHECK(ret,"pthread_create");

    printf("i am main thread\n");
    usleep(0);
    return 0;
}

THREAD_ERROR_CHECK是我们自己封装的一个宏，工作中我们常使用strerror，strerror不仅会把错误打印到屏幕，还会打印到日志。

#define THREAD_ERROR_CHECK(ret,funcName)\
    do{\
        if(ret != 0){\
            printf("%s : %s\n",funcName, strerror(ret));\
        }\
    }while(0)

执行上面的代码，会发现一个有趣的事情

竟然打印了三次，这是因为，printf的打印换行和刷新缓冲区不是一气呵成的原子操作。main线程只睡眠了1us,可能子线程刚刚打印完换行，还没来的及刷新缓冲区，就切换到了main线程，此时执行return 0语句，再次刷新缓冲区。打印缓冲区里面的语句。
创建线程之后可以给子线程传递值，我们先试试给子线程传递一个栈空间的值，pthread_create的第四个参数是void*,表示的是可以传递任意类型的指针，这个值就是threadFunc的参数。

#include <func.h>
void* threadFunc(void *p)
{
    //接收主线程传递过来的值
    int retVal=*(int *)p;
    printf("i am child thread val=%d\n",retVal);
    pthread_exit(NULL);
}
int main()
{
    pthread_t thid;
    int ret=0;
    int val=2;
    //给子线程传递一个整型值
    ret=pthread_create(&thid,NULL,threadFunc,&val);
    THREAD_ERROR_CHECK(ret,"pthread_create");
    
    sleep(1);
    return 0;
}

我们也可以传递一个堆空间的值，这样可以在主线程和子线程里面操作同一片空间

#include <func.h>

void* threadFunc(void* p)
{
    //子线程去修改堆空间的内容
    printf("i am child thread %s\n",(char *)p);
    strcpy((char *)p,"hellomain");

    pthread_exit(NULL);
}
int main()
{
    pthread_t thid;
    int ret=0;
    //申请一片堆空间
    char *p=(char *)malloc(20);
    strcpy(p,"hellochild");

    //给子线程传递堆空间
    ret=pthread_create(&thid,NULL,threadFunc,p);
    THREAD_ERROR_CHECK(ret,"pthread_create");

    printf("i am main thread\n");
   sleep(1); 
   //主线程打印的是子线程对堆空间修改的内容
   printf("p=%s\n",p);
    return 0;
}

给两个线程传递参数，又会出现有意思的事情
对比一下如果只是传递一个指针和传值，如果只是简单的传递一个指针，就是线程进栈和出栈，后面一个在栈顶，先执行

#include <func.h>

void* threadFunc(void *p)
{
    printf("i am child thread=%d,id=%d\n",*(int *)p,(int)pthread_self());
    pthread_exit(NULL);
}

int main()
{
    pthread_t thid1,thid2;
    int ret=0;
    int num=2;

    ret=pthread_create(&thid1,NULL,threadFunc,&num);
    THREAD_ERROR_CHECK(ret,"pthread_create");
    printf("thid1=%d\n",(int)thid1);

    num+=2;
    ret=pthread_create(&thid2,NULL,threadFunc,&num);
    THREAD_ERROR_CHECK(ret,"pthread_create");
    printf("thid2=%d\n",(int)thid2);

    printf("i am main thread\n");
    sleep(1);

    return 0;
}

传递的是一个long类型的值，顺序执行

#include <func.h>

void* threadFunc(void *p)
{
    printf("i am child thread=%ld,id=%d\n",(long)p,(int)pthread_self());

    pthread_exit(NULL);
}
int main()
{
    pthread_t thid1,thid2;
    int ret=0;
    long num=2;

     //传递long类型，是因为指针就是8个字节，所以我们可以传递
    
    ret=pthread_create(&thid1,NULL,threadFunc,(void *)num);
    THREAD_ERROR_CHECK(ret,"pthread_create");
    printf("thid1=%d\n",(int)thid1);

    num+=2;
    ret=pthread_create(&thid2,NULL,threadFunc,(void *)num);
    THREAD_ERROR_CHECK(ret,"pthread_create");
    printf("thid2=%d\n",(int)thid2);

    printf("i am main thread\n");
    sleep(1);
    return 0;
}

对比

线程的等待退出，pthread_exit传的是一个指针，那么pthread_jioin就要二级指针来接这个参数，当传递的是long类型有意思的事情来了

#include <pthread.h>
void pthread_exit(void *retval);

 #include <pthread.h>
 int pthread_join(pthread_t thread, void **retval);

传递的是堆空间的数据，子线程申请一片堆空间，传递给主线程，但是这样很容易造成内存泄露

#include <func.h>
void* threadFunc(void* p)
{
    //申请一块堆空间传递出
    char* p1=(char *)malloc(20);
    strcpy(p1,"hello");

    pthread_exit(p1);
}
int main()
{
    pthread_t thid;
    int ret=0;
    ret=pthread_create(&thid,NULL,threadFunc,NULL);
    THREAD_ERROR_CHECK(ret,"pthread_create");

    char* retVal=NULL;
    //捕获子线程的退出码
    ret=pthread_join(thid,(void **)&retVal);
    printf("retVal=%s\n",retVal);
    free(retVal);
    retVal=NULL;
    return 0;
}

当传递的是long类型的时候，事情就发生变化了

#include <func.h>
void* threadFunc(void *p)
{
    printf("i am child thread\n");

    long ret=3;

    pthread_exit((void *)ret);
}
int main()
{
    pthread_t thid;
    int ret=0;
    ret=pthread_create(&thid,NULL,threadFunc,NULL);
    THREAD_ERROR_CHECK(ret,"pthread_create");

    printf("i am main thread\n");

    //使用long类型接收子线程的退出码
    long retVal=0;
    ret=pthread_join(thid,(void **)&retVal);

    printf("retVal=%ld\n",retVal);
    return 0;
}

long本身就是八个字节，强制转换即给转化成一个void *类型的指针,在主线程接收的时候，也只需要把一个long类型取地址强转成二级指针即可