线程的学习及经验总结

一、什么是线程

典型的UNIX/Linux进程可以看成只有一个控制线程：一个进程在同一时刻只做一件事情。有了多个控制线程后，在程序设计时可以把进程设计成在同一时刻做不止一件事，每个线程各自处理独立的任务。

人话：一个线程对应一件事，一个进程里可以包含多个线程

进程是程序执行时的一个实例，是担当分配系统资源（CPU时间、内存等）的基本单位。在面向线程设计的系统中，进程本身不是基本运行单位，而是线程的容器。程序本身只是指令、数据及其组织形式的描述，进程才是程序（那些指令和数据）的真正运行实例。

人话：程序就是程序，就是代码没跑起来，跑起来叫做进程

线程是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。线程包含了表示进程内执行环境必须的信息，其中包括进程中表示线程的线程ID、一组寄存器值、栈、调度优先级和策略、信号屏蔽字、errno常量以及线程私有数据。进程的所有信息对该进程的所有线程都是共享的，包括可执行的程序文本、程序的全局内存和堆内存、栈以及文件描述符。在Unix和类Unix操作系统中线程也被称为轻量级进程（lightweight processes），但轻量级进程更多指的是内核线程（kernel thread），而把用户线程（user thread）称为线程。

"进程——资源分配的最小单位，线程——程序执行的最小单位”

进程有独立的地址空间，一个进程崩溃后，在保护模式下不会对其它进程产生影响，而线程只是一个进程中的不同执行路径。线程有自己的堆栈和局部变量，但线程没有单独的地址空间，一个线程死掉就等于整个进程死掉，所以多进程的程序要比多线程的程序健壮，但在进程切换时，耗费资源较大，效率要差一些。但对于一些要求同时进行并且又要共享某些变量的并发操作，只能用线程，不能用进程。

二、线程的函数

这里我只学习了三个线程的API

1、pthread_create

注意：编译需要+ -lpthread！

一开始我一直编译报错，后来在这篇博文中找到了原因：

ubuntu 编译c程序报错：对‘pthread_create’未定义的引用_ubuntu c工程引用pthread-CSDN博客

 程序如下：

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


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

void *func1(void *arg)
{
        printf("%ld thread is create\n",(unsigned long)pthread_self());//打印线程的pidi
        printf("param is %d\n",*((int *)arg));//理论上输出应该是param，100
}

int main()
{
        int ret_create;
        int param = 100;
        pthread_t t1;

        //第一个参数是指针，参数2是线程的属性，参数3是启动线程需要调用的函数，参数4是3函数的参数
        ret_create = pthread_create(&t1,NULL,func1,(void *)&param);
        if(ret_create == 0)
        {
                printf("create t1 success\n");
        }else
        {
                printf("create t1 failed\n");
                exit(-1);
        }



        while(1);//死循环防止进程直接结束，线程还没跑完

        return 0;
}

运行结果如下： 

 

我在最后加了一个死循环，之前没加的时候并不会打印t1的内容

为什么不加while（1）的时候t1没有打印呢？

有两个可能：

1.我们只创建了t1线程，却没有使用（但我们要思考那创建t1时的参数都去哪了）

2.t1还没来得及打印，main函数已经结束了，或者说进程已经结束了（前面讲了进程与线程的关系）

因此我们可以试着修改代码，比如让main函数等一会，看看多久会让t1打印

修改后的代码如下：

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


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

void *func1(void *arg)
{
        printf("t1:%ld thread is create\n",(unsigned long)pthread_self());//打印线程的pidi
        printf("t1:param is %d\n",*((int *)arg));//理论上输出应该是param，100
}

int main()
{
        int ret_create;
        int param = 100;
        int i = 0;
        pthread_t t1;

        //第一个参数是指针，参数2是线程的属性，参数3是启动线程需要调用的函数，参数4是3函数的参数
        ret_create = pthread_create(&t1,NULL,func1,(void *)&param);
        if(ret_create == 0)
        {
                printf("main:create t1 success\n");
        }else
        {
                printf("main:create t1 failed\n");
                exit(-1);
        }
        printf("main:%ld thread is create\n",(unsigned long)pthread_self());//打印进程的pidi
        while(i != 50)
        {
                printf("i = %d\n",i);
                i++;
        }
   
        return 0;
}

其实只增加了这一点（我没用sleep是因为试了之后发现睡一秒都太长了） 

下面是运行结果： 

可以看到，在main线程计数的时候，t1打印出来了，这说明就是第二个原因，因此我们可以设置一个while（1）等待t1打印

但是还有另一个方法，这里就引入了pthread_join：线程等待函数

2、join的小小使用

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


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

void *func1(void *arg)
{
        printf("t1:%ld thread is create\n",(unsigned long)pthread_self());//打印线程的pidi
        printf("t1:param is %d\n",*((int *)arg));//理论上输出应该是param，100
}

int main()
{
        int ret_create;
        int param = 100;
        pthread_t t1;

        //第一个参数是指针，参数2是线程的属性，参数3是启动线程需要调用的函数，参数4是3函数的参数
        ret_create = pthread_create(&t1,NULL,func1,(void *)&param);
        if(ret_create == 0)
        {
                printf("main:create t1 success\n");
        }else
        {
                printf("main:create t1 failed\n");
                exit(-1);
        }
        printf("main:%ld thread is create\n",(unsigned long)pthread_self());//打印进程的pidi


       //int pthread_join(pthread_t thread, void **retval);

        pthread_join(t1,NULL);
        return 0;
}

注意：这里只是简单使用一下join函数，运行结果如下：

不需要退出死循环，main线程会等待t1线程结束再继续运行

整个过程如下：

main线程先创建线程t1，然后根据返回值判断创建成功并打印“main:create t1 success”，接着打印main线程的pid

直到遇到语句 pthread_join(t1,NULL) main线程才开始等待t1线程的结束（通过上面的例子已经知道其实t1线程在创建的时候就开始运行了）

待t1结束以后，main结束

2、join的大大使用 

这一段是学习join的参数，我自己也挺头疼这些二级指针，空类型指针什么的，尽量把我的理解讲的更详细一点 

有一点需要注意但是本文没有提及，如果返回值是int型，那么定义这个int型的时候需要加static，不然返回值和定义的不一样，具体原因我不太清楚，希望评论区大佬可以点拨一下

下面是返回字符串的程序

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


//int pthread_create(pthread_t *thread, const pthread_attr_t *attr,void *(*start_routine) (void *), void *arg);
void *func1(void *arg)
{
        char *p = "t1 exit";

        printf("t1:%ld thread is create\n",(unsigned long)pthread_self());//打印线程的pidi
        printf("t1:param is %d\n",*((int *)arg));//理论上输出应该是param，100

        pthread_exit((void *)p);

}

int main()
{
        int ret_create;
        int param = 100;
        char *ret_p;
        pthread_t t1;

        //第一个参数是指针，参数2是线程的属性，参数3是启动线程需要调用的函数，参数4是3函数的参数
        ret_create = pthread_create(&t1,NULL,func1,(void *)&param);
        if(ret_create == 0)
        {
                printf("main:create t1 success\n");
        }else
        {
                printf("main:create t1 failed\n");
                exit(-1);
        }


       //int pthread_join(pthread_t thread, void **retval);

        pthread_join(t1,(void **)&ret_p);
        printf("ret_p:%s\n",(char *)ret_p);

        return 0;
}

int pthread_join(pthread_t thread, void **retval);

 join函数有两个参数，我们已经知道了这个函数的功能是让调用join函数的线程去等待一个目标线程，所以第一个参数是要被等待的对象，第二个参数是被等待的对象在结束时会有一个返回值，这个返回值可以是int型也可以是字符串，在我这个例子中就是返回字符串“t1 exit”。

怎么返回字符串呢？

使用函数pthread_exit(void *);

注意参数是空类型指针，因此我们要定义一个指针char *p = "t1 exit";然后传参的时候需要强制类型转换

那么在pthread_join函数中就需要通过retval去读取返回值，注意retval是个二级指针，这里就比较绕了

下面是传参和打印返回的字符串内容的写法：

我定义的是char * ret_p 用于接收返回的字符串

传参：(void **)&ret_p；

打印：ret_p；

当然也可以定义二级指针char **ret_p

传参：(void **)ret_p；

打印：*ret_p

我个人感觉整个比较难理解的就是这一点了，其实如果指针学的还可以的话，这一段也不会有什么问题，就是二级指针的运用以及强制类型转换。