【Linux】线程基本知识概述-蒲公英云

本文内容概述：

1.线程的基本概念（包括线程的定义，线程之间的共享资源和私有资源）；

2.基本函数（包括线程的创建，终止，等待，可分离和可切换，当然其中还会涉及互斥锁方面的内容等等）。

1.线程的基本概念：

在前边的学习中，我们知道，进程是在各自独立的地址空间中运行，如果需要共享资源，则要进行进程间的通信，比如管道，消息队列，信号量，共享内存这些，所以完成通信是比较困难的。而线程是进程内的一个执行分支，顾名思义，线程是在进程内部执行，占用着进程的地址空间，所以，线程之间的通信是比较容易的—-定义一个公共的buf，然后就能直接进行通信。

在Linux系统下，是没有线程这个概念的，都是用进程去模拟线程。

我们看到的进程有可能是线程，所以，我们将线程称为轻量级进程。

由于线程是进程内部的执行流，所以线程就会共享一些进程的信息，当然也会有自己私有的信息：

线程共享进程的以下资源：

1）文件描述符信息；

2）每种信号的处理方式（由于线程是进程内部的执行流，所以每种信号的处理方式也是共享的）；

3）当前工作目录；

4）各种id信息，比如用户id和组id信息。

线程也会有自己私有的信息：

1）线程id；

2）线程的上下文信息（每个线程都必须有自己的上下文信息，存储在自己的PCB中，当然有些操作系统中会有一种存储线程信息的TCB结构体）

3）栈空间

4）调度优先级

5）errno变量

在Linux下的C api函数发生异常时，一般会将errno变量（在errno.h文件中）赋予一个整形值，不同的值代表不同的含义，可以通过输出的值来查看出错的信息。

比如：printf(“%d”,errno);就可以输出异常时的错误码

6）信号屏蔽字信息，这里的信号屏蔽字就有点类似于文件的权限信息中的umask。

2.基本函数：

（1）线程的创建

Center

（2）线程的终止：

线程的终止方法是有3种：

a.直接在线程函数中return，但是在main函数中return，是表示整个进程的终止；

b.采用pthread_cancel函数让同一进程中的其他的线程去终止；

Center 1

程序举例：

#include<stdio.h>
#include<pthread.h>
#include<unistd.h>
void* pthreadRun(void* arg)
{
    int count = 3;
    while(count--)
    {
        printf("new pthread,tid:%lu,pid:%d\n",pthread_self(),getpid());
    }
}
int main()
{
    pthread_t tid = 0;
    int ret = pthread_create(&tid,NULL,pthreadRun,NULL);
    if(ret != 0)
    {
        perror("pthread_create");
        return -1;
    }
    if(ret != 0)
    {
        perror("pthread_detach");
        return -1;
    }
    sleep(1);
   if(pthread_cancel(tid)!= 0)
    {
        printf("cancel failed\n");
        return 1;
    }
    int exitCode;
    pthread_join(tid,(void**)&exitCode);
    printf("new pthread exit code:%d\n",exitCode);
    return 0;
}

这段程序的运行结果是：

Center 2

解释：由于在主线程中已经sleep了1秒之后，才终止新线程的，由于在1秒之内，新线程早已运行完成，所以，就会终止失败。

如果将终止新线程之前的sleep去掉，程序的运行结果究竟是什么呢？

Center 3

解释：新线程没有执行完成，就被主线程终止了，此时是终止成功的，所以退出码就是-1.

c.使用pthread_exit（）自己终止自己。

Center 4

（3）线程的等待：

Center 5

（4）线程的可分离性：

一个线程是可结合的或者是可分离的。一个可结合的线程可以被与之在同一个进程中的其他线程所终止；而一个可分离的线程不需要主线程的等待，它的存储器等资源会在它运行结束时被操作系统回收。我们都知道，线程是进程内部的一个执行分支，为什么这么说？因为进程内的线程共享一个地址空间，所以在被分离的线程没有执行完成时，主线程不要退出，否则新的线程无法继续执行。主线程不可以等待被分离的线程。

Center 6

程序举例：

#include<stdio.h>
#include<pthread.h>
#include<unistd.h>
void* pthreadRun(void* arg)
{
    int count = 3;
    while(count--)
    {
        printf("new pthread,tid:%lu,pid:%d\n",pthread_self(),getpid());
        sleep(1);
    }
}
int main()
{
    pthread_t tid = 0;
    int ret = pthread_create(&tid,NULL,pthreadRun,NULL);
    if(ret != 0)
    {
        perror("pthread_create");
        return -1;
    }
    usleep(1000);
    ret = pthread_detach(tid);
    if(ret != 0)
    {
        perror("pthread_detach");
        return -1;
    }
     if(pthread_cancel(tid)!= 0)
    {
        printf("cancel failed\n");
        return 1;
    }
    int exitCode;
    if(0 == pthread_join(tid,(void*)&exitCode))
    {
        printf("wait success.\n");
        printf("new pthread exit code:%d\n",exitCode);
    }
    else
    {
        printf("wait failed\n");
    }
    return 0;
}

程序运行结果：

Center 7

解释：从运行结果我们可以看出，我们不可以等待已经被分离的线程，但是可以终止已经分离的线程。

（5）线程的切换：

线程切换的条件：

a.一个时间片的完成；

b.操作系统模式的切换（内核态向用户态的切换）。

时间片的结束，会进行线程的切换，这个是比较容易理解的。

为什么操作系统模式的切换就会进行线程的切换？因为线程（在linux系统下，线程也被认为是进程，也有自己的PCB）的PCB是在内核中，只有内核态（也就是系统）才可以进行查看线程的信息，即就是访问PCB。我们知道，系统调用都是在内核态进行完成的，printf函数的底层调用的就是系统调用，所以我们采用printf函数进行显示数据的时候，就可能完成线程的切换。

所以，写一个程序，制造线程的切换。

#include<stdio.h>
#include<pthread.h>
#include<unistd.h>
static int count = 0;
void* pthreadRun(void* arg)
{
    int val = 0;
    int i = 0;
    while(i < 5000)
    {
        val = count;
        printf("new pthread,tid:%lu,pid:%d,count:%d\n",pthread_self(),getpid(),count);
        count = val + 1;
        i++;
    }
    return NULL;
}
int main()
{
    pthread_t tid1 = 0;
    pthread_t tid2 = 0;
    int ret = pthread_create(&tid1,NULL,pthreadRun,NULL);
    if(ret != 0)
    {
        perror("pthread_create");
    return -1;
    }
    ret = pthread_create(&tid2,NULL,pthreadRun,NULL);
    if(ret != 0)
    {
        perror("pthread_create");
        return -1;
    }
    pthread_join(tid1,NULL);
    pthread_join(tid2,NULL);
    printf("count:%d\n",count);
    return 0;
}

运行结果介于5000到10000之间不等。

如果我们给临界资源加锁，运行完代码之后解锁。代码如下：

#include<stdio.h>
#include<pthread.h>
#include<unistd.h>
static int count = 0;
pthread_mutex_t myLock = PTHREAD_MUTEX_INITIALIZER;
void* pthreadRun(void* arg)
{
    int val = 0;
    int i = 0;
    while(i < 3000)
    {
       pthread_mutex_lock(&myLock);
        val = count;
        printf("new pthread,tid:%lu,pid:%d,count:%d\n",pthread_self(),getpid(),count);
        count = val + 1;
        i++;
        pthread_mutex_unlock(&myLock);
    }
    return NULL;
}
int main()
{
    pthread_t tid1 = 0;
    pthread_t tid2 = 0;
    int ret = pthread_create(&tid1,NULL,pthreadRun,NULL);
    if(ret != 0)
    {
        perror("pthread_create");
    return -1;
    }
    ret = pthread_create(&tid2,NULL,pthreadRun,NULL);
    if(ret != 0)
    {
        perror("pthread_create");
        return -1;
    }
    pthread_join(tid1,NULL);
    pthread_join(tid2,NULL);
    pthread_mutex_destroy(&myLock);
    printf("count:%d\n",count);
    return 0;
}