线程

线程

• 进程可以蜕变成线程

• 线程可以看做寄存器和栈的集合

• 进程是分配资源最小的单位，而线程是调度的最小单位，线程共用进程资源

• 线程有时候被称为轻量级进程（light weight process LWP）

• gcc编译时加-pthread

• 线程共享资源
  1.文件描述符表
  2.每种信号的处理方式
  3.当前工作目录
  4.用户ID和组ID
  5.内存地址空间（.text/.data/.bss/heap/共享库）

• 线程非共享资源
  1.线程id
  2.处理器现场和栈指针（内核栈）
  3.独立的栈空间（用户空间栈）
  4.errno变量
  5.信号屏蔽字
  6.调度优先级

线程创建pthread_create（对应进程中的fork）

创建主控线程
#include<pthread.h>
int pthread_create(pthread_t *thread, const pthread_attr_t *attr,void *(*start_routine) (void *), void *arg);

thread：返回新线程的id，传出参数
attr：线程属性，NULL表示默认属性
start_routine：要调用的线程函数
arg：传给线程函数的参数

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

获取线程pthread_self（对应进程中的getpid）

#include<pthread.h>
pthread_t pthread_self();

只会成功，返回线程的id

• 例子：

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

int variety = 1;
void *func()
{
        variety = 2;
        printf("this is thread,thread id :%ld,pid:%d\n",pthread_self(),getpid());

}

int main()
{
        pthread_t *thread;
        thread = (pthread_t *)malloc(sizeof(pthread_t));
        int i;
        printf("variety = %d\n",variety);
        for(i = 0;i<10;i++)
        {
                int tid = pthread_create(thread,NULL,func,NULL);
                if(tid != 0)
                {
                        perror("pthread error:");
                        exit(1);
                }
        sleep(1);

        }
        printf("variety = %d\n",variety);
        free(thread);
        printf("variety = %d\n",variety);
        return 0;
}

线程退出pthread_exit

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

功能：退出单个线程
retval：线程结束时的返回值，由pthread_join接受

线程等待pthread_join（阻塞等待对应waitpid）

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

thread：等待线程的id
retval：由pthread_exit传出的参数
成功：返回0，失败：返回错误代码

• 例子1：

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

struct phones
{
        int price;
        int brand;
};

void *func(void *argc)
{
        struct phones *vivo;
        vivo = (struct phones *)malloc(sizeof(struct phones));
        vivo->price = 4999;
        vivo->brand = 20;
        pthread_exit(vivo);

        free(vivo);
        }

int main()
{
        pthread_t *pthread;
        struct phones *vivo;
        pthread = (pthread_t *)malloc(sizeof(pthread_t));
        int tid = pthread_create(pthread,NULL,func,NULL);

        pthread_join(*pthread,&vivo);
        //pthread_join(*pthread,(void **)&vivo);两个任选一个

        printf("price = %d,brand = %d\n",vivo->price,vivo->brand);
        free(pthread);
        return 0;
}

• 例子2：

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

int var = 0;
int i;

void *func()
{
        //int i;
        //i = (int)argc;

        if(i == 1)
        {
                var = 1;
                printf("i am [%d]thread,tid = %ld,var = %d\n",i,pthread_self(),var);
                pthread_exit(&var);
        }
        else if(i == 3)
        {
                var = 3;
                printf("i am [%d]thread,tid = %ld,var = %d\n",i,pthread_self(),var);
                pthread_exit(&var);
        }
        else
        {
                var = 4;
                printf("i am [%d]thread,tid = %ld,var = %d\n",i,pthread_self(),var);
                pthread_exit(&var);
        }
}
int main()
{
        void *var;
        for(i = 0;i<5;i++)
        {
                pthread_t *thread[i];
                thread[i] = (pthread_t *)malloc(sizeof(pthread_t));

                int tid = pthread_create(thread[i],NULL,func,NULL);
                sleep(1);

                int tid_join = pthread_join(*thread[i],&var);
                //上述注释语句添加时，一个线程用完之后会被退出

                free(thread[i]);
        }
        return 0;
}

线程分离pthread_detach

int pthread_detach(pthread_t thread)；
int pthread_attr_setdetachstate(pthread_attr_t *attr,int detachstate);
成功：0；失败：错误号

• 线程分离状态：指定该状态，线程主动与主控线程断开关系。
  线程结束后，其退出状态不由其他线程获取，而直接自己自动释放。
  网络、多线程服务器常用。
  进程若有该机制，将不会产生僵尸进程。僵尸进程的产生主要由于进程死后，大部分资源被释放，一点残留资源仍存于系统中，导致内核认为该进程仍存在。
  也可使用pthread_create 函数参2（线程属性）来设置线程分离。
• 一般情况下，线程终止后，其终止状态一直保留到其它线程调用pthread_join获取它的状态为止。但是线程也可以被置为detach状态，这样的线程一旦终止就立刻回收它占用的所有资源，而不保留终止状态。不能对一个已经处于detach状态的线程调用pthread_join，这样的调用将返回EINVAL错误。也就是说，如果已经对一个线程调用了pthread_detach 就不能再调用pthread_join了。

杀死线程pthread_cancel（对应进程的kill）

int pthread_cancel(pthread_t thread)；
成功：0；失败：错误号

• 【注意】：线程的取消并不是实时的，而有一定的延时。需要等待线程到达某个取消点（检查点）。
• 取消点：是线程检查是否被取消，并按请求进行动作的一个位置。通常是一些系统调用creat，open，pause，close，read，write.….执行命令man 7 pthreads可以查看具备这些取消点的系统调用列表。也可参阅APUE.12.7取消选项小节。
  可粗略认为一个系统调用（进入内核）即为一个取消点。如线程中没有取消点，可以通过调用pthread_testcancel函数自行设置一个取消点。
• 被取消的线程，退出值定义在Linux的pthread库中。常数PTHREAD_CANCELED的值是-1。可在头文件pthread.h中找到它的定义：#definePTHREAD_CANCELED((void *)-1)。因此当我们对一个已经被取消的线程使用pthread_join回收时，得到的返回值为-1。
• 接收到取消请求的目标线程可以决定是否允许被取消以及如何取消，这分别由如下两个函数完成:
  #i

nclude <pthread. h>
int pthread_setcancelstate( int state, int *oldstate );
int pthread_setcanceltype( int type, int *oldtype );

• 这两个函数的第一个参数分别用于设置线程的取消状态(是否允许取消)和取消类型(如何取消)，第二个参数则分别记录线程原来的取消状态和取消类型。state 参数有两个可选值:
• PTHREAD_ CANCEL_ENABLE，允许线程被取消。
• PTHREAD_CANCEL_DISABLE，禁止线程被取消。
• type参数也有两个可选值:
• PTHREAD_CANCEL_ASYNCHRONOUS, 线程随时都可以被取消。
• PTHREAD_CANCEL_DEFERRED, 允许目标线程推迟行动，直到它调用了下面几个所谓的取消点函数中的一个: pthread_ join、 pthread_testcancel、 pthread_cond_wait、pthread_cond_timedwait、 sem_wait 和sigwait。
• 例子：

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

void *func1()
{
        printf("---------1\n");
        return (void *)1;
}

void *func3()
{
        printf("---------3\n");
        return (void *)3;
}

void *func2()
{
        printf("---------2\n");
        pthread_exit((void *)2);
}
int main()
{
        pthread_t thread;
        void *temp = NULL;
        int tid = pthread_create(&thread,NULL,func1,NULL);
        pthread_join(thread,&temp);
        printf("temp1 = %d\n",(int)temp);

        pthread_create(&thread,NULL,func2,NULL);
        pthread_cancel(thread);
        pthread_join(thread,&temp);
        printf("temp2 = %d\n",(int)temp);

        pthread_create(&thread,NULL,func3,NULL);
        pthread_detach(thread);
        printf("temp3 = %d\n",(int)temp);

        return 0;
}

线程属性初始化

注意：应先初始化线程属性，再pthread_create创建线程初始化线程属性

设置属性
int pthread_attr_init(pthread_attr_t *attr)；
成功：0；失败：错误号

销毁线程属性所占用的资源
int pthread_attr_destroy(pthread_attr_t*attr)；
成功：0；失败：错误号

参数：attr:已初始化的线程属性
detachstate:PTHREAD_CREATE_DETACHED(分离线程）
PTHREAD_CREATE_JOINABLE(非分离线程）

• 这里要注意的一点是，如果设置一个线程为分离线程，而这个线程运行又非常快，它很可能在pthread_create函数返回之前就终止了，它终止以后就可能将线程号和系统资源移交给其他的线程使用，这样调用pthread_create的线程就得到了错误的线程号。要避免这种情况可以采取一定的同步措施，最简单的方法之一是可以在被创建的线程里调用pthread_cond_timedwait 函数，让这个线程等待一会儿，留出足够的时间让函数pthread_create返回。设置一段等待时间，是在多线程编程里常用的方法。但是注意不要使用诸如wait）之类的函数，它们是使整个进程睡眠，并不能解决线程同步的问题。

线程的栈大小

当系统中有很多线程时，可能需要减小每个线程栈的默认大小，防止进程的地址空间不够用，当线程调用的函数会分配很大的局部变量或者函数调用层次很深时，可能需要增大线程栈的默认大小。
函数pthread_attr_getstacksize 和pthread_attr_setstacksize提供设置。

int pthread_attr_setstacksize(pthread_attr_t*att, size_t stacksize)；
成功：0；失败：错误号，设置大小
int pthread_attr_getstacksize(pthread_attr_t*attr,size _t*stacksize)；
成功：0；失败：错误号,查看当前线程栈大小

参数：attr:指向一个线程属性的指针
stacksize:返回线程的堆栈大小

线程的栈地址

• POSlX.1定义了两个常量_POSIX_THREAD_ATTR_STACKADDR 和_POSIXTHREAD_ATTR_STACKSIZE检测系统是否支持栈属性。也可以给sysconf 函数传递_SC_THREAD_ATTR_STACKADDR 或_SC_THREAD_ATTR_STACKSIZE来进行检测。
• 当进程栈地址空间不够用时，指定新建线程使用由malloc分配的空间作为自己的栈空间。通过pthread_attr_setstack和pthread_atr_getstack两个函数分别设置和获取线程的栈地址。

int pthread_attr_setstack(pthread_attr_t*attr, void *stackaddr,size_t stacksize);
成功：0；失败：错误号
int pthread_attr_getstack(pthread_attr_t*attr,void **stackaddr,size_t*stacksize);
成功：0；失败：错误号

参数：attr：指向一个线程属性的指针
stackaddr:返回获取的栈地址
stacksize:返回获取的栈大小

线程的分离状态

线程的分离状态决定一个线程以什么样的方式来终止自己。

• 非分离状态：线程的默认属性是非分离状态，这种情况下，原有的线程等待创建的线程结束。只有当pthread join()函数返回时，创建的线程才算终止，才能释放自己占用的系统资源。
• 分离状态：分离线程没有被其他的线程所等待，自己运行结束了，线程也就终止了，马上释放系统资源。应该根据自己的需要，选择适当的分离状态。

线程分离状态的函数：

设置线程属性，分离or非分离
int pthread_attr_setdetachstate(pthread_attr_t*attr,int detachstate)；
获取程属性，分离or非分离

int pthread_attr_getdetachstate(pthread_attr_t"attr, int*detachstate)；
参数：attr:已初始化的线程属性

detachstate：PTHREAD_CREATE_DETACHED(分离线程）
PTHREAD_CREATE_JOINABLE(非分离线程）

• 这里要注意的一点是，如果设置一个线程为分离线程，而这个线程运行又非常快，它很可能在pthread_create函数返回之前就终止了，它终止以后就可能将线程号和系统资源移交给其他的线程使用，这样调用pthread_create的线程就得到了错误的线程号。要避免这种情况可以采取一定的同步措施，最简单的方法之一是可以在被创建的线程里调用pthread_cond_timedwait 函数，让这个线程等待一会儿，留出足够的时间让函数pthread_create返回。设置一段等待时间，是在多线程编程里常用的方法。但是注意不要使用诸如wait）之类的函数，它们是使整个进程睡
• 例子：

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

#define SIZE 0x1000000

void *func()
{
        while(1)
        {
                printf("++++++++\n");
                sleep(1);
        }
}

int main()
{
        pthread_attr_t *attr;
        attr = (pthread_attr_t *)malloc(sizeof(pthread_attr_t));

        int *detachstate;
        int i = 0;
        void *stackaddr;

        size_t *stacksize;
        stacksize = (size_t *)malloc(sizeof(size_t));

        pthread_t *thread;
        thread = (pthread_t *)malloc(sizeof(pthread_t));

        pthread_attr_init(attr);
        pthread_attr_getstack(attr,&stackaddr,stacksize);

        pthread_attr_getdetachstate(attr, detachstate);
        if(detachstate == PTHREAD_CREATE_DETACHED)
        {
                printf("the thread is detached\n");
        }
        else if(detachstate == PTHREAD_CREATE_JOINABLE)
        {
                printf("the thread is joinable\n");
        }
        else
        {
                printf("unknow\n");
        }


        pthread_attr_setdetachstate(attr,PTHREAD_CREATE_DETACHED);

        while(1)
        {
                stackaddr = malloc(SIZE);
                if(stackaddr == NULL)
                {
                        perror("malloc error:");
                        exit(1);
                }
                }
                //stacksize = SIZE;
                pthread_attr_setstack(attr,stackaddr,16);

                int tid = pthread_create(thread,attr,func,NULL);
                if(tid != 0)
                {
                        perror("create error:");
                        exit(1);
                }
                sleep(1);
                printf("num:%d\n",i++);
        }
        free(attr);
        free(thread);
        free(stacksize);
        return 0;
}