Linux多线程(1)

线程

多线程(1)

线程的基本概念

线程是进程的进一步细化，进程是系统分配资源的基本单位，而线程cpu调度的基本单位。
进程就像是包工头，获取到系统资源，然后再分配给它里面线程。
操作系统用于管理线程有个数据结构tcb，用来描述和管理线程。
而在Linux下称之为轻量级进程。和进程用同一块pcb来表示。
那么一个进程至少有一个线程。
线程共享进程一些数据，也有自己的一些数据。

线程自己拥有：

• 线程ID
• 一组寄存器
• 栈
• errno
• 信号屏蔽字
• 调度优先级

一个进程下多个线程共享：

• 同一地址空间，因此Text Segment 、Data Segment都是共享的，如果定义一个函数，在进程内的各个线程都可以调用，如果定义一个全局变量，在各个线程都可以访问到。
• 文件描述符
• 每种信号的处理方式(SIG_IGN、SIG_DFL或者自定义捕捉函数)
• 当前目录
• 用户ID和组ID

线程的优缺点：

• 线程的优点
  
  • 创建一个新线程的代价要比创建一个新进程小得多
  • 与进程之间的切换相比，线程之间的切换需要操作系统做的工作要少很多
  • 线程占用的资源要比进程少很多
  • 能充分利用多处理器的可并行数量
  • 在等待慢速I/O操作结束的同时，程序可执行其他的计算任务
  • 计算密集型应用，为了能在多处理器系统上运行，将计算分解到多个线程中实现
  • I/O密集型应用，为了提高性能，将I/O操作重叠。线程可以同时等待不同的I/O操作。
• 线程的缺点
  
  • 性能损失
    一个很少被外部事件阻塞的计算密集型线程往往无法与共它线程共享同一个处理器。如果计算密集型线程的数量比可用的处理器多，那么可能会有较大的性能损失，这里的性能损失指的是增加了额外的同步和调度开销，而可用的资源不变。
  • 健壮性降低
    编写多线程需要更全面更深入的考虑，在一个多线程程序里，因时间分配上的细微偏差或者因共享了不该共享的变量而造成不良影响的可能性是很大的，换句话说线程之间是缺乏保护的。
  • 缺乏访问控制
    进程是访问控制的基本粒度，在一个线程中调用某些OS函数会对整个进程造成影响。
  • 编程难度提高编写与调试一个多线程程序比单线程程序困难得多

线程控制

POSIX线程库

与线程有关的函数构成了一个完整的系列，绝大多数函数的名字都是以“pthread_”打头的
要使用这些函数库，要通过引入头文<pthread.h>
链接这些线程函数库时要使用编译器命令的“-lpthread”选项
POSIX在用户空间内

创建线程：
功能：创建一个新的线程
原型

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

参数
thread:返回线程ID
attr:设置线程的属性，attr为NULL表示使用默认属性
start_routine:是个函数地址，线程启动后要执行的函数
arg:传给线程启动函数的参数
返回值：成功返回0；失败返回错误码

错误检查：
传统的一些函数是，成功返回0，失败返回-1，并且对全局变量errno赋值以指示错误。
pthreads函数出错时不会设置全局变量errno（而大部分其他POSIX函数会这样做）。而是将错误代码通过返回值返回。
pthreads同样也提供了线程内的errno变量，以支持其它使用errno的代码。对于pthreads函数的错误，建议通过返回值业判定，因为读取返回值要比读取线程内的errno变量的开销更小。

#include <stdio.h>
#include <pthread.h>
void* Fun(void* arg)
{
    while(1)
    {
       printf("I am pthread! id = %lu\n", pthread_self());//获取用户线程ID
       sleep(1);
    }
}

int main()
{
    pthread_t pid;
    int ret;
   if((ret = pthread_create(&pid, NULL, Fun, NULL)) < 0)
   {
       perror("pthread_create");
       return 1;
   }
   while(1)
   {
       printf("I am main pthread!\n");
       sleep(2);
   }
    return 0;
}

进程ID和线程ID
在Linux中，目前的线程实现是Native POSIX Thread Libaray,简称NPTL。在这种实现下，线程又被称为轻量级进程(Light Weighted Process),每一个用户态的线程，在内核中都对应一个调度实体，也拥有自己的进程描述符(task_struct结构体)。
没有线程之前，一个进程对应内核里的一个进程描述符，对应一个进程ID。但是引入线程概念之后，情况发生了变化，一个用户进程下管辖N个用户态线程，每个线程作为一个独立的调度实体在内核态都有自己的进程描述符，进程和内核的描述符一下子就变成了1：N关系，POSIX标准又要求进程内的所有线程调用getpid函数时返回相同的进程ID。
Linux内核引入了线程组的概念。

struct task_struct {
...
pid_t pid;
pid_t tgid;
...
struct task_struct *group_leader;
...
struct list_head thread_group;
...
｝；

多线程的进程，又被称为线程组，线程组内的每一个线程在内核之中都存在一个进程描述符（task_struct）与之对应。进程描述符结构体中的pid，表面上看对应的是进程ID，其实不然，它对应的是线程ID;进程描述符中的tgid，含义是Thread Group ID,该值对应的是用户层面的进ID。

ps命令中的-L选项，会显示如下信息：

• LWP:线程ID，既gettid()系统调用的返回值。
• NLWP:线程组内线程的个数

上面的a.out是多线程的，进程ID ： 2540 一个进程拥有两个线程，ID分别为2540 2541

Linux提供了gettid系统调用来返回其线程ID，可是glibc并没有将该系统调用封装起来，在开放接口来共程序员使用。如果确实需要获得线程ID，可以采用如下方法：

#include <sys/syscall.h>
pid_t tid;
tid = syscall(SYS_gettid);

a.out进程的ID为2540，下面有一个线程的ID也是2540，这不是巧合。线程组内的第一个线程，在用户态被称为主线程(mainthread),在内核中被称为group leader，内核在创建第一个线程时，会将线程组的ID的值设置成第一个线程的线程ID，group_leader指针则指向自身，既主线程的进程描述符。所以线程组内存在一个线程ID等于进程ID，而该线程即为线程组的主线程。

/* 线程组ID等于线程ID，group_leader指向自身 */
p->tgid = p->pid;
p->group_leader = p;
INIT_LIST_HEAD(&p->thread_group);

至于线程组其他线程的ID则有内核负责分配，其线程组ID总是和主线程的线程组ID一致，无论是主线程直接创建线程，还是创建出来的线程再次创建线程，都是这样。

if ( clone_flags & CLONE_THREAD )
p->tgid = current->tgid;
if ( clone_flags & CLONE_THREAD ) {
P->group_lead = current->group_leader;
list_add_tail_rcu(&p->thread_group, &p->group_leader->thread_group);
}

强调一点，线程和进程不一样，进程有父进程的概念，但在线程组里面，所有的线程都是对等关系。

线程ID及进程地址空间布局

pthread_ create函数会产生一个线程ID，存放在第一个参数指向的地址中。该线程ID和前面说的线程ID不是一回事。
前面讲的线程ID属于进程调度的范畴。因为线程是轻量级进程，是操作系统调度器的最小单位，所以需要一个数值来唯一表示该线程。

    pthread_ create函数产生并标记在第一个参数指向的地址中的线程ID中，属于NPTL线程库
    的范畴。线程库的后续操作，就是根据该线程ID来操作线程的。线程库NPTL提供了
    pthread_ self函数，可以获得线程自身的ID：
    pthread_t pthread_self(void);

pthread_t到底是什么类型呢？取决于实现。对于Linux目前实现的NPTL实现而言，pthread_t类型的线程ID，本质就是一个进程地址空间上的一个地址。

线程终止

如果需要只终止某个线程而不终止整个进程,可以有三种方法:
1. 从线程函数return。这种方法对主线程不适用,从main函数return相当于调用exit。
2. 线程可以调用pthread_ exit终止自己。
3. 一个线程可以调用pthread_ cancel终止同一进程中的另一个线程。
pthread_exit函数

功能：线程终止
原型
void pthread_exit(void *value_ptr);
参数
value_ptr:value_ptr不要指向一个局部变量。
返回值：无返回值，跟进程一样，线程结束的时候无法返回到它的调用者（自身）

需要注意,pthread_exit或者return返回的指针所指向的内存单元必须是全局的或者是用malloc分配的,不能在线程函数的栈上分配,因为当其它线程得到这个返回指针时线程函数已经退出了。
pthread_cancel函数

功能：取消一个执行中的线程
原型
int pthread_cancel(pthread_t thread);
参数
thread:线程ID
返回值：成功返回0；失败返回错误码

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

void* prun(void* arg)
{
    int  i = 3;
    while(i--)
    {
       printf("I am pthread\n");
       sleep(1);
    }
    *(int*)arg = 1;
    //pthread_exit(NULL);
    //return  arg;
      pthread_cancel(pthread_self());
}
int  main()
{
    pthread_t t;
    int ret = 0;
    if(pthread_create(&t, NULL, prun,(void*)&ret) < 0)
    {
        perror("pthread");
        return 1;
    }
    while(1)
    {
        printf("I am main thread!   ret = %d\n", ret);
        sleep(1);
    }
    return 0;
}

线程等待与分离

线程等待
为什么需要线程等待？
已经退出的线程，其空间没有被释放，仍然在进程的地址空间内。
创建新的线程不会复用刚才退出线程的地址空间。

功能：等待线程结束
原型
int pthread_join(pthread_t thread, void **value_ptr);
参数
thread:线程ID
value_ptr:它指向一个指针，后者指向线程的返回值
返回值：成功返回0；失败返回错误码

#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>
void* run1(void* arg)
{
    int *p =(int*)malloc(sizeof(int));
    printf("I am run1,  return 1!\n");
    *p = 1;
    return (void*)p;
}
void* run2(void* arg)
{
    int *p =(int*)malloc(sizeof(int));
    printf("I am run2, pthread_exit(2)!\n");
    *p = 2;
    pthread_exit((void *)p);
}
void* run3(void* arg)
{
    while(1)
    printf("I am run3, pthread_cancel()!\n");
    //pthread_cancel(pthread_self());   
}

int main()
{
    pthread_t tid;
    void * ret;
   if(!pthread_create(&tid, NULL, run1, NULL))
   {
        pthread_join(tid, &ret);
        printf("I am main pthread ret = %d\n",  *(int*)ret);
        free(ret);
   }
    if(!pthread_create(&tid, NULL, run2, NULL))
    {
        pthread_join(tid, &ret);
        printf("run2 return %d\n", *(int*)ret);
        free(ret);
    }
    if(!pthread_create(&tid, NULL, run3, NULL))
     {
        pthread_cancel(tid);
        pthread_join(tid, &ret);
       if((ret == PTHREAD_CANCELED) )
            printf("run3 return cancel\n");
       else
            printf("errno\n");
    //   if(ret == (void*)0)
    //  {
    //  printf("(void*)0\n");

    //   }

    }
    return 0;
}

调用该函数的线程将挂起等待,直到id为thread的线程终止。thread线程以不同的方法终止,通过pthread_join得到的终止状态是不同的，总结如下:

• 如果thread线程通过return返回,value_ ptr所指向的单元里存放的是thread线程函数的返回值。
• 如果thread线程被别的线程调用pthread_ cancel异常终掉,value_ ptr所指向的单元里存放的是常数PTHREAD_ CANCELED。
• 如果thread线程是自己调用pthreadexit终止的,valueptr所指向的单元存放的是传给pthread_exit的参数。
• 如果对thread线程的终止状态不感兴趣,可以传NULL给value_ ptr参数。

分离线程

默认情况下，新创建的线程是joinable的，线程退出后，需要对其进行pthread_join操作，否则无法释放资源，从而造成系统泄漏。
如果不关心线程的返回值，join是一种负担，这个时候，我们可以告诉系统，当线程退出时，自动释放线程资源。

int pthread_detach(pthread_t thread);

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

pthread_detach(pthread_self());

但是如果分离出来的线程触发异常，整个进程会挂掉。

#include <stdio.h>
#include <pthread.h>
void* Run(void* arg)
{
    while(1)
    ｛
        printf("I am detach pthread!\n");
         usleep(1000);
     ｝
}

int main()
{
    pthread_t tid;
    if(pthread_create(&tid, NULL, Run, NULL) < 0)
    {
        perror("pthread_create");
        return 1;
    }
    if(pthread_detach(tid) < 0)
    {
        perror("pthread_detach()");
        return 2;
    }
    sleep(1);
    if(pthread_join(tid, NULL) == 0)
    {
        printf("join success!\n");
    }
    else
    {
        printf("join failed!\n");
    }
    return 0;
}