Linux中POSIX 多线程技术-学习笔记(九)

1、概念：线程是一个进程内部的控制序列，是轻量级进程。也有PCB,创建线程使用的底层函数和进程一样，都是克隆。
2、线程与进程关系
(1)进程有自己的PCB空间及自己独立的共享地址空间；线程有自己的PCB空间但无自己独立的共享地址空间
(2)CPU执行时以线程为最小执行单位。进程是最小的分配资源的单位。
(3)可以把进程看成一个只有一个线程的进程。程序可看成一个主线程(进程)
3、线程：用于执行一个功能，最终为执行一个函数
   0~3G中stack：栈空间中的stack空间不共享，是函数运行所需的空间，其他部分可共享。
   线程所需的资源从0~3G中克隆出来的。
线程编译：[root@localhost 813]# gcc pthread_create.c -o pthread_create -lpthread

4、线程间非共享资源
 (1)线程id
 (2)处理器现场和栈指针(内核栈)
 (3)独立的栈空间(用户空间栈)-函数的运行空间
 (4)errno变量
 (5)信号屏蔽字-信号和线程不宜一起用，以免冲突
 (6)调度优先级
5、线程优缺点
(1)优点：
1)提高程序的并发性；
2)空间开销小，不用重新分配内存；
3)通信和共享数据方便
(2)缺点：
1)线程不稳定（用库函数实现）；
2)线程调试比较困难（gdb支持不好）；
3)线程无法使用unix经典事件，例如信号
6、函数
(1)int pthread_create(pthread_t *thread, const pthread_attr_t *attr, 
void *(*start_routine) (void *),void *arg); //创建线程
参数1：pthread_t *thread:线程ID
参数2：const pthread_attr_t *attr:线程属性，默认属性为NULL 
参数3：void *(*start_routine) (void *):函数指针，线程应执行的函数
参数4：void *arg:线程要执行的函数的参数 
(2)pthread_t pthread_self(void); //获取调用线程tid
(3)void pthread_exit(void *retval);//线程退出函数
参数1：void *retval:线程退出时传递出的参数，可以是退出值或地址，若是地址时，则不能为线程内部申请的局部地址。 
(4)int pthread_join(pthread_t thread, void **retval); //回收线程的tid=waitpid();
参数1：pthread_t thread:要回收的线程的tid 
参数2：void **retval:接收退出线程传递出的返回值
调用该函数的线程将挂起等待，直到id为thread的线程终止。
(5)int pthread_cancel(pthread_t thread);//进程内某个线程取消另一个线程。相当于kill
参数1：pthread_t thread:要取消的线程的tid 
(6)int pthread_detach(pthread_t tid); //自分离，执行完任务自己回收，无需用pthread_join，也无需关系线程返回值
参数1：pthread_t thread:要自分离的线程的tid 
一般，线程终止后，其终止状态一直保留到其它线程调用pthread_join获取该线程的状态为止。但一个线程也可被置为detach状态，这个线程一旦终止就立刻回收其占用的所有资源，不再保留终止状态。

注：线程中止的3种方法
一个线程可以不同的方法终止，通过int pthread_join(pthread_t thread, void **retval)得到的终止状态不相同的：
(1)通过return返回，retval所指向的单元里存放的是thread线程函数的返回值。
(2)调用pthread_cancel终止同一进程中的另一个线程，retval所指向的单元里存放的是常数PTHREAD_CANCELED。
同一进程的线程间，pthread_cancel向另一线程发终止信号。系统并不会马上关闭被取消线程，只有在被取消线程下次系统调用时，才会真正结束线程。或调用pthread_testcancel，让内核去检测是否需要取消当前线程.
(3)调用pthread_exit终止自己，retval所指向的单元存放的是传给pthread_exit的参数。
若对thread线程的终止状态不感兴趣，可以传NULL给retval参数。
7、程序

//程序1 创建一个线程
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>

//线程执行的函数
void *func(void *arg)
{
    //打印进程id和线程id，getpid()--pthread_self()
    printf("int fun pthread id=%lu,pid=%u\n",pthread_self(),getpid());
    return NULL;
}
int main(void)
{
    //定义线程tid
    pthread_t tid;
    int ret;//返回值:成功返回0,失败返回错误号
    //打印进程id和线程id，getpid()--pthread_self()
    printf("int main1 pthread id=%lu,pid=%u\n",pthread_self(),getpid());
    //创建线程 参数(线程ID,线程属性,线程执行的函数,线程执行的函数所需的参数)
    ret=pthread_create(&tid,NULL,func,NULL);
    if(ret !=0)
    {
        printf("pthread_create error\n");
        exit(1);
    }
    //打印进程id和线程id，getpid()--pthread_self()
    printf("int main2 pthread id=%lu,pid=%u\n",pthread_self(),getpid());
    sleep(1);//延时1s
    return 0;
}

程序执行效果：

//程序2 循环创建多个线程
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>

//线程执行的函数
void *func(void *arg)
{
    //类型转换
    int i=(int)arg;
    //打印进程id和线程id
    printf("%d int func pthread id=%lu,pid=%u\n",i+1,pthread_self(),getpid());
    return NULL;
}
int main(void)
{
    //定义线程tid
    pthread_t tid,i;
    int ret;//返回值:成功返回0,失败返回错误号
    //打印进程id和线程id
    printf("int main1 pthread id=%lu,pid=%u\n",pthread_self(),getpid());
    for(i=0;i<5;i++)//创建5个进程
    {
        //创建线程 参数(线程ID,线程属性,线程执行的函数,线程执行的函数所需的参数)
        ret=pthread_create(&tid,NULL,func,(void *)i);
        if(ret !=0)
        {
            printf("pthread_create error\n");
            exit(1);
        }
    }
    //打印进程id和线程id
    printf("int main2 pthread id=%lu,pid=%u\n",pthread_self(),getpid());
    sleep(1);//延时1s
    return 0;
}

程序执行效果：

//程序3 共享全局资源
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>

int var=100;//定义全局变量

//线程执行的函数
void *func(void *arg)
{
    int i=(int)arg;//赋值并作类型转换
    var=200;//全局变量重新赋值
    printf("func pthread\n");
    return NULL;
}
int main(void)
{
    pthread_t tid,i; //定义线程tid和int类型变量i
    int ret;//返回值:成功返回0,失败返回错误号
    printf("first var=%d\n",var);//输出全局变量值
    //创建线程 参数(线程ID,线程属性,线程执行的函数,线程执行的函数所需的参数)
    ret=pthread_create(&tid,NULL,func,(void *)i);
    if(ret !=0)
    {
        printf("pthread_create error\n");
        exit(1);
    }
    sleep(1);//延时1s
    printf("second var=%d\n",var);//输出全局变量值
    return 0;
}

程序执行效果：

//程序4 回收线程，显示退出码
#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
#include <stdlib.h>

typedef struct  //定义结构体
{
    int a;
    int b;
}exit_t;

//线程执行的函数
void *func(void *arg)
{
    exit_t *ret;//定义结构体类型指针,线程退出时传递出的参数
    ret=malloc(sizeof(exit_t));//为ret开辟空间
    ret->a=11;//赋值
    ret->b=12;
    pthread_exit((void *)ret);//线程退出
    //ret为退出值或地址，若是地址，则不能为线程内部申请的局部地址。
}

int main(void)
{
    //定义线程tid
    pthread_t tid;
    exit_t *retval;//定义结构体类型指针,线程退出时传递出的参数
    //创建线程 参数(线程ID,线程属性,线程执行的函数,线程执行的函数所需的参数)
    pthread_create(&tid,NULL,func,NULL);
    //回收线程tid 参数(要回收的线程的tid ,接收退出线程传递出的返回值)
    pthread_join(tid,(void **)&retval);
    //输出结构体成员值
    printf("a=%d,b=%d\n",retval->a,retval->b);
    return 0;
}

程序执行效果：

//程序5  线程结束的3种方法
#include <stdio.h>
#include <unistd.h>
#include <pthread.h>
#include <stdlib.h>

//线程执行的函数
void *fun1(void *arg)//法一 通过return返回
{
    printf("pthread 1 return\n");
    return (void *)1111; //退出值为1111
}

void *fun2(void *arg)//法二 调用pthread_exit终止自己
{
    printf("pthread 2 exit\n");
    //结束调用这个函数的线程
    pthread_exit((void *)2222);  //退出值为2222
}

void *fun3(void *arg)//法三 调用pthread_cancel终止同一进程中的本线程
{
    while(1)
    {
        printf("pthread 3:I am going to die in 3 seconds...\n");
        sleep(1);
    }
    return (void *)6666; //退出值为6666
}

int main(void)
{
    pthread_t tid;//定义线程tid
    void *ret=NULL;//接收线程返回值
    //创建线程 参数(线程ID,线程属性,线程执行的函数,线程执行的函数所需的参数)
    pthread_create(&tid,NULL,fun1,NULL);
    //回收线程tid 参数(要回收的线程的tid ,接收退出线程传递出的返回值)
    pthread_join(tid,&ret);
    printf("pthread 1 exit code=%d\n",(int)ret);//输出退出线程的返回值
    //创建线程
    pthread_create(&tid,NULL,fun2,NULL);
    pthread_join(tid,&ret);//回收线程
    printf("pthread 2 exit code=%d\n",(int)ret);
    //创建线程
    pthread_create(&tid,NULL,fun3,NULL);
    sleep(3);//延时3s
    pthread_cancel(tid);//进程内某个线程取消另一个线程。相当于kill
    pthread_join(tid,&ret);//线程挂起等待
    return 0;
}

程序执行效果：

//线程封装函数设计 程序6、7、8一起使用
//程序6 BaseThread.h

#ifndef BASETHREAD_H_
#define BASETHREAD_H_

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

class CBaseThread  //定义线程类
{
public:
    CBaseThread();  //此时还没有创建线程，只有类对象
    ~CBaseThread(); //析构函数
    void start(); //创建线程并启动线程
    virtual int run() = 0;  //用户自定义处理函数，在派生类中必须实现
protected:
    pthread_t m_tid;  //线程ID
    bool m_bRun;  // 运行标记
    bool m_bJoin;   //是否是可分离的
private:
    static void * rountine(void *arg);   //线程类处理函数框架
};

#endif

//程序7 BaseThread.cpp

#include "BaseThread.h"

CBaseThread::CBaseThread():m_bRun(false), m_bJoin(false)//构造函数定义
{
    
}

CBaseThread::~CBaseThread()//析构函数定义
{
    
}
//创建线程并启动线程函数定义
void CBaseThread::start()
{
    if (m_bRun == false) //m_bRun判断线程是否已经在运行了
    {
        //创建线程 参数(线程ID,线程属性,线程执行的函数,线程执行的函数所需的参数)
        if( pthread_create(&m_tid,NULL,rountine,(void *)this) != 0)
        {
            perror("create thread error : ");
        }
    }
}

//线程类处理函数框架函数定义
void * CBaseThread::rountine(void *arg)
{
    CBaseThread *thr = (CBaseThread *)arg;//定义类指针
    if(thr->m_bJoin)
    {
        pthread_detach(pthread_self());  //自分离线程，不用调用join函数等待
    }
    thr->m_bRun = true;
    thr->run();     //用户自定义的处理函数
    thr->m_bRun = false;
    //结束调用这个函数的线程
    pthread_exit(NULL);
}

//程序8 man.cpp

#include <iostream>
#include "BaseThread.h"

using namespace std;//命名空间
//继承线程基类
class CmyThread: public CBaseThread
{
public:
    CmyThread(int value);//构造函数
    ~CmyThread();//析构函数
    int run(); //重写
private:
    int m_iValue;
};

CmyThread::CmyThread(int value)//构造函数定义
{
    m_iValue =  value;
}

CmyThread::~CmyThread()//析构函数定义
{
    
}

int CmyThread::run()//实现虚构函数定义
{
    printf("this is thread, value = %d\n", m_iValue);
    return 0;
}

//主函数
int main(int argc, char* argv[])
{
    CmyThread myThread(2);//定义线程子类对象
    myThread.start();//线程子类对象调用基类成员函数
    sleep(1);//延时1s
    return 0;
}

程序运行结果：