线程

一、线程的概念：

                在一个程序里的一个执行路线就叫做线程，线程是一个进程内部的控制序列。

                一切进程至少有一个线程。

二、线程和进程之间的区别：

                1、一个程序至少有一个进程，一个进程至少有一个线程。

                2、线程的划分尺度小于进程，使得多线程的程序并发性高。

                3、进程在执行过程中拥有独立的内存单元，而多个线程内存共享，从而极大地提高了运行效率。（进程的效率高）

                4、线程是最小的执行单位；进程是最小的资源分配单位。

                5、线程也有PCB，创建线程使用的底层函数和进程一样，都是clone,他们都有各自不同的PCB，但是PCB中指向内存资源的三级页表是相同的。

                6、线程可以看作寄存器的栈的集合。

三、线程的共享资源：

                1、文件描述符表

                2、每种信号的处理方式

                3、当前工作目录

                4、用户ID和组ID

                5、内存地址空间

四、线程的非共享空间

                1、线程ID

                2、处理器现场和栈指针

                3、独立的栈空间

                4、errno变量

                5、信号屏蔽器

                6、调度优先级

五、线程优缺点

                优点：    1、提高程序的并发性                2、开销小            3、数据通信、共享数据方便

                缺点：    1、库函数、不稳定                   2、调试、编写困难、gdb不支持            3、对信号支持不好

六、创建线程：

                int pthread_create(pthread_t *thread,           //返回线程ID

                                                    const phtread_attr_t *attr,    //设置线程属性，attr为NULL表示使用默认属性

                                                    void *(*start_routine)(void*),        //是个函数地址，线程启动后要执行的函数

                                                    void (*arg));            //传给线程启动函数的参数

                返回值：    成功返回0，失败返回错误码。

#include<unistd.h>
#include<stdlib.h>
#include<stdio.h>
#include<string.h>
#include<pthread.h>
void *rout(void *arg)
{
        int i;
        for(;;)
        {
                printf("I'am thread 1\n");
                sleep(1);
        }
}
int main()
{
        pthread_t tid;
        int ret;
        if((ret = pthread_create(&tid,NULL,root,NULL)) !=0)
        {
                fprintf(stderr,"pthread_create : %s\n ",strerror(ret));
                exit(EXIT_FAILURE);


  }
        int i;
        for(;;)
        {
                printf("I'am main thread\n");
                sleep(1);
        }
        return 0;
}

七、pthread_exit函数

    功能：    线程终止

    原型：    void pthread_exit(void *value_ptr);

    参数：    value_ptr:value_ptr不要指向局部变量

    返回值：    无返回值，跟进程一样，线程结束的时候无法返回到他的调用者（自己）

八、pthread_cancel函数

    功能：    取消一个执行中的线程

    原型：    int pthread_cancel(pthread_t thraed);

    参数：    thread:    线程 ID

    返回值：    成功返回0；失败返回错误码

九、线程等待

    功能：    等待线程结束

    原型：    int pthread_join(pthread_t thread,           //线程ID

                                            void **value_ptr);         //它指向一个指针，后者指向线程的返回值

    返回值：    成功返回0；失败返回错误码

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<unistd.h>
#include<pthread.h>
void *thread1(void *arg)
{
        printf("thread 1 returning ... \n");
        int *p = (int*)malloc(sizeof(int));
        *p = 1;
        return (void*)p;
}

void *thread2(void *arg)
{
        printf("thread 2 exting ...\n");
        int *p = (int*)malloc(sizeof(int));
        *p = 2;
        pthread_exit((void*)p);
}

void *thread3(void *arg)
{
        while(1)
        {
                printf("thread 3 is running ...\n");
                sleep(1);
        }
        return NULL;
}

int main(void)
{
        pthread_t tid;
        void *ret;

        //thread 1 return
        pthread_create(&tid,NULL,thread1,NULL);
        pthread_join(tid,&ret);
        printf("thread return, thread id %x, return code:%d\n",tid,*(int*)ret);
 free(ret);

        //thread 2 exit
        pthread_create(&tid,NULL,thread2,NULL);
        pthread_join(tid,&ret);
        printf("thread return ,thread id %x,return code:%d\n",tid,*(int*)ret);
        free(ret);

        //thread 3 cancel by other
        pthread_create(&tid,NULL,pthread3,NULL);
        sleep(3);
        pthread_cancel(tid);
        pthread_join(tid,&ret);
        if(ret == PTHREAD_CANCELED)
                printf("thread return,thread id %x,return code:PTHREAD_CANCELED\n",tid);
        else
                printf("thread return,thread id %x,return code:NULL\n",tid);
}

十、分离线程

        int pthread_detach(pthread_t pthread);

        可以是线程组内其他线程对目标线程进行分离，也可以是线程分离自己

        pthread_detach(pthread_self());

        joinable和分离是冲突的，一个线程不能既是joinable又是分离的

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<unistd.h>
#include<pthread.h>

void *pthread_run(void * arg)
{
        pthread_detach(pthread_self());
        printf("%s\n",(char *)arg);
        return NULL;
}

int main()
{
        pthread_t tid;
        if (pthread_create(&tid,NULL,thread_run,"thread1 run..." != 0));
        {
                printf("create thread error\n");
        return 1;
        }
        int ret = 0;
        sleep(1);

        if (pthread_join(tid,NULL) == 0)
        {
                printf("pthread wait success\n");
                ret = 0;
        }
        else
        {
                printf("pthread wait fail\n");
                ret = 1;
        }
        return ret;
}