Linux学习之旅（21）-----线程

最新推荐文章于 2022-09-26 18:58:14 发布

呢喃无音

最新推荐文章于 2022-09-26 18:58:14 发布

阅读量376

点赞数

分类专栏： linux学习之旅

本文链接：https://blog.csdn.net/qq_39038983/article/details/88646452

版权

linux学习之旅专栏收录该内容

35 篇文章 2 订阅

订阅专栏

进程和线程的区别和联系

（1）进程是资源分配的最小单位，线程是最小的执行单位。

（2）线程是进程的一部分，如果没有进行显示的进程分配，可以认为进程是单线程的，如果进程中建立了线程，则可以认为系统是多线程的。

（3）多进程和多线程是两个不同的概念，虽然两者都是并行完成功能。但是，多个线程之间像内存、变量等资源可以通过简单的办法共享，多进程则需要通过进程间通信的方式共享。

（4）进程有进程控制表PCB，系统通过PCB对进程进行调度，线程有线程控制表TCB。但TCB所表示的状态比PCB要少的多。

进程的状态

（1）执行状态：线程已获得处理机，正在运行。

（2）就绪状态：线程已具备除CPU之外的全部资源。

（3）阻塞状态：线程在执行过程中因事件受阻而处于暂停的状态。

线程控制块（TCB）

（1）线程标识符，为每一个线程赋予一个唯一的线程标识符。

（2）一组寄存器，包括程序计数器、状态寄存器和通用寄存器等。

（3）线程运行状态，用于描述线程正处于何种运行状态。

（4）优先级，描述线程执行的优先程度。

（5）线程专有的存储区，用于线程切换时存放现场保护信息，和与该线程有关的统计信息。

（6）信号屏蔽，对那些信号加以屏蔽（最好不要同时使用线程和信号）

（7）堆栈指针。

多线程OS中的进程属性

通常在多进程OS中的进程都包含了多个属性，并为它们提供资源。OS支持一个进程中的多个线程能够并发执行，但此时的进程就不再作为一个执行的实体。多线程OS中的进程有以下的属性。

（1）进程是一个可拥有资源的基本单位。

（2）多个线程可并发执行。通常一个进程中拥有一个或多个线程（至少一个），线程必须属于进程，不存在单独的线程。

（3）进程已不再是可执行的实体。（线程是执行的最小的单位）

*并发：两个或两个以上的事件在同一事件间隔内发生。

*并行：两个或两个以上的事件在同一时刻发生。

线程间的共享资源

（1）文件描述表

（2）每种信号的处理方式

（3）当前的工作目录（工作目录被一个线程修改后，在所有线程中都会改变）

（4）用户ID和组ID

（5）内存地址空间

线程间的非共享资源

（1）线程ID

（2）处理器现场和栈指针

（3）独立的栈空间

（4）errno变量

（5）信号屏蔽字

（6）调度的优先级

线程的优缺点

优点：（1）提高了程序的并发性

（2）开销小，不用重新分配内存

（3）通信和共享数据方便

缺点：（1）线程不稳定

（2）线程调试比较困难（调试是已进程为基础的）

（3）线程无法使用unix经典事件，例如信号。

线程控制原语

（1）线程创建函数

int pthread_create(pthread_t *thread,pthread_attr_t *attr,void* (*start_routine)(void *),void *arg);
函数功能：创建一个线程
参数说明：
thread:线程号，用于标识一个线程 (typedef unsigned long int pthread_t)
attr:这个参数用于设置线程的属性，如果不设置可以写为NULL
strat_routine:当线程的资源分配成功后，线程运行的单元。
arg:线程函数运行时传入的参数。
返回值：
成功：返回0，失败：返回错误代码。

常见的错误代码：EAGAIN（系统中线程数量达到了上限）和EINVAL（线程的属性非法）。

（2）获取线程的ID

pthread_t pthread_self();

程序1：获取进程线程ID

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

void* ChilePthread(void* arg)
{
    int *p=(int*)arg;
    printf("chilePthread Process ID:%d\n",getpid());
    printf("chilePthread ID:%x\n",(unsigned int)pthread_self());
    printf("childPthread arg:%d\n",*p);
    sleep(1);
}

int main()
{
    pthread_t tid;
    int n=10;
    //tid不一定等于childpthread中的线程号
    /*
    （1）创建线程
    创建出线程后，可能CPU会将线程调度
    （2）将线程ID写入tid中
    （3）将tid返回
    */
    pthread_create(&tid,NULL,ChilePthread,(void *)&n);
    printf("main process ID:%d\n",getpid());
    printf("main pthread ID:%x\n",(unsigned int)pthread_self());
    printf("main ChilePthread ID:%d\n",(unsigned int)tid);
    //保证主线程最后完成
    sleep(2);
    return 0;
}

（*pthred是pthread库中的函数，在编译时需要加-lpthread参数）

在这个列子中我们就可以证明：调用pthread_create()函数返回的线程ID和执行和函数额线程的ID并不相同。

（3）线程的退出

void pthread_exit(void* retval);
参数说明：
void *retval:线程退出时的传出参数，可以时退出值或者地址，如果时地址，不能是线程内部申请的局部地址(因为当其他线程得到这个返回指针时线程函数已经退出了，这样内部变量就会被释放)。
*这个值可以被pthread_join()函数捕获

在线程中，任何一个线程执行exit()函数或_exit()函数都会导致全部的线程退出，其他线程没有结束工作时，主控线程退出不同执行return(在主函数中的效果和exit的一样)和exit。

（4）等待线程结束

int pthread_join(pthread_t thread,void **retval);
函数功能：
用来等待一个线程运行结束，如果线程没有结束一直等待（阻塞）和wait()函数的效果差不多
参数说明：
thraed:线程标识符（线程号），即pthread_create()创建成功的返回值
retval:线程返回值，它是一个指针，可以用来存储被等待线程的返回值。
返回值：
成功返回0，失败返回错误号

线程以不同的方法终止，通过pthread_join()得到的终止状态的返回值是不同的：

*如果线程通过return返回，retval所指向的单元里存放的是线程函数的返回值。

*如果线程是被别的进程调用pthread_cancle异常终止掉，retval中存放的PTHREAD_CANCELED

*如果新城是使用pthread_exit函数终止的，retval中存放的是pthread_exit的参数

*如果对线程的终止状态不关心，可以使用NULL作为参数。

（5）取消线程

int pthread_cancel(pthread_t thread);
函数功能：
取消线程（在同一个进程的一个线程可以取消另一个线程）

被取消的线程的退出值，定义在Linux的pthread库中常数PTHREAD_CANCELED的值为-1。

需要注意的时，使用pthread_cancel向另一个线程发送终止信号时，系统并不会马上关闭取消线程，只有再被取消的线程再次系统调用时，才会被真正的结束线程，或者使用pthread_testcancel，让内核检测是否需要取消当前线程。

#define PTHREAD_CANCELED((void *)-1)

程序2

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

static int run=1;
static int retval=0;

void* do_pthread(void *arg)
{
    int *running=(int*)arg;
    printf("子线程初始化完毕,传入参数为%d\n",*running);
    while(*running)
    {
        printf("子进程正在运行...\n");
        sleep(1);
    }
    printf("子线程退出！\n");
    retval=10;
    //return ((void*)&retval);
    pthread_exit((void*)&retval);
}

int main()
{
    pthread_t tid;
    int ret=pthread_create(&tid,NULL,do_pthread,(void*)(&run));
    if(ret!=0)
    {
        printf("子线程创建失败...\n");
        exit(1);
    }
    int i=0;
    for(i=3;i>0;--i)
    {
        printf("主控进程打印....\n");
        sleep(1);
    }
    run=0;
    int* retjoin;
    pthread_join(tid,(void**)(&retjoin));
    printf("do_pthread return: %d\n",*retjoin);
    return 0;
}

程序3

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

void* pthreadOne(void *arg)
{
    printf("%x:线程1....\n",(unsigned int)pthread_self());
    return (void*)1;
}

void* pthreadTwo(void *arg)
{
    printf("%x:线程2....\n",(unsigned int)pthread_self());
    pthread_exit((void*)2);
}

void* pthreadThree(void *arg)
{
    
    while(1)
    {
        printf("%x:线程3....\n",(unsigned int)pthread_self());
        sleep(1);
    }
}
int main()
{
    pthread_t tid1,tid2,tid3;
    void *retval1,*retval2,*retval3;

    pthread_create(&tid1,NULL,pthreadOne,(void*)1);
    //pthread_join(tid1,&retval1);
    //printf("main pthread1 retval:%d,%x\n",(int)retval1,tid1);

    pthread_create(&tid2,NULL,pthreadTwo,(void*)2);
    //pthread_join(tid2,&retval2);
    //printf("main pthread2 retval:%d,%x\n",(int)retval2,tid2);

    pthread_create(&tid3,NULL,pthreadThree,(void*)3);
    sleep(3);
    pthread_cancel(tid3);

    pthread_join(tid3,&retval3);
    pthread_join(tid1,&retval1);
    pthread_join(tid2,&retval2);
    printf("main pthread1 retval:%d,%x\n",(int)retval1,tid1);
    printf("main pthread2 retval:%d,%x\n",(int)retval2,tid2);    
    printf("main pthread3 retval:%d,%x\n",(int)retval3,tid3);
    
    return 0;
}

（6）分离线程

int pthread_detach(pthrad_t tid);

函数功能：

将线程设置为分离态（线程任务执行完成后直接退出，不需要pthread_join回收）

返回值：

成功返回0，失败返回错误号。

pthread_join和pthread_join函数为互斥的，即使用了pthread_detach就不能使用pthread_join函数了。

程序4：pthread_datech

#include <unistd.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <stdlib.h>
#include <pthread.h>
void* do_pthread(void* arg)
{
    int n=3;
    while(n)
    {
        printf("child pthread :%d\n",n);
        sleep(1);
        n--;
    }
    return (void*)1;
}
int main()
{
    pthread_t tid;
    void* retval;
    int err;
    pthread_create(&tid,NULL,do_pthread,(void*)1);
    pthread_detach(tid);
    while(1)
    {
        err=pthread_join(tid,&retval);
        if(err!=0)
        {
            printf("child pthread %s\n",strerror(err));
        }
        else
        {
            printf("child pthread return :%d\n",(int)retval);
        }
        sleep(1);
    }
    return 0;
}

注释了pthread_datech(tid)的结果：

没有注释pthread_datech的结果：

（6）判断线程相等

int pthread_equal(pthread_t t1,pthread_t t2);

线程细节：

1、主线程退出其他线程不退出，主线程应使用pthread_exit函数。

2、避免僵尸线程：pthread_join函数、pthread_detach函数、在创建时将线程设置为分离态

3、mmap和mmap申请的内存可以被其他线程释放。

4、如果线程终止时没有释放加锁的互斥量，则该互斥量不能再次被使用。

5、避免在多线程模型中使用fork()函数。

6、避免在多线程中使用信号机制。

呢喃无音

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Linux学习之旅（21）-----线程

进程和线程的区别和联系（1）进程是资源分配的最小单位，线程是最小的执行单位。（2）线程是进程的一部分，如果没有进行显示的进程分配，可以认为进程是单线程的，如果进程中建立了线程，则可以认为系统是多线程的。（3）多进程和多线程是两个不同的概念，虽然两者都是并行完成功能。但是，多个线程之间像内存、变量等资源可以通过简单的办法共享，多进程则需要通过进程间通信的方式共享。（4）进程有进程控制...
复制链接

扫一扫