Linux —— 《线程控制》

前言：

上一文我们学习了解了线程的相关概念，我们以生动形象的概念阐释了线程这一具体的概念，我们同时也输出了一个重要的结论：“线程是CPU调度的基本单位”。在那一刻，我们同样也输出了重要的知识，在Linux中不存在进程和线程控制块这个区分，而针对于Linux，CPU只认轻量级进程，而不是什么线程控制块。
那同样，进程我们是存在控制的，例如创建、删除、等待和替换，那么针对于线程我们同样也是要对其进行管理控制的，因此本文重点讲解线程控制。

为什么要链接pthread库？

在正式讲解线程控制的具体操作，我想先来打通一个疑惑，就是为什么我们上次在写代码时，要在使用g++编译的时候加上选项-pthread？这个操作的本质是链接pthread库，那为什么我要链接它呢？

让我们先暂时回到上文，还记得我说过，Linux本质没有线程的，就算你非说有，那也只是轻量级进程，而我们目前想认为你Linux生成的就是线程，所以就有两个概念—— “用户级线程”和“内核级线程”。

很明显这是两个不同的概念，而为了将这两个概念打通，就不得不提供接口，让用户按照普通的方式调用函数使用线程即可，也使用户也可以认为自己使用的就是现场，同时又可以兼顾Linux系统使用轻量级进程的方法。因此我们就不得不使用pthread库。

线程控制：

线程创建：

我们使用函数：pthread_create
在上一文我们也介绍和粗略的使用过，但是我们并没有研究其参数的各种含义，下面我们就来介绍和使用。

#include <pthread.h>int pthread_create(pthread_t *thread, 					/* 输出型参数，用以获取创建成功的线程 ID */const pthread_attr_t *attr,	        /* 设置创建线程的属性，使用 nullptr 表示使用默认属性 */void *(*start_routine) (void *), 	/* 函数地址，该线程启动后需要去执行的函数 */void *arg);							/* 线程要去执行的函数的形参，没参数时可填写 nullptr */

线程创建成功时返回 0，创建失败时返回错误码。

start_routine?

这个和我们的当初创建的学习信号中自定义捕捉很像，同样是传递一个函数指针，但是这里传进来的函数的我们并没有介绍介绍

void* start_routine(void* args)

函数呈现的是这样的一种格式，这个函数和自定义捕捉的函数一致，捕捉到了信号我们就在这个函数里做动作，同理创建好线程后，这里就是线程执行的地方。举个最简单的例子：

// 创建单线程
#include <iostream>
#include <pthread.h>
#include <unistd.h>void* start_routine(void* args)
{while(true){sleep(1);std::cout << "new thread running..." << std::endl;}
}int main()
{pthread_t tid;pthread_create(&tid, nullptr, start_routine, nullptr);while(true){std::cout << "main thread running..." << std::endl;sleep(1);}return 0;
}

传递自定义类型

要知道我们这两个参数的类型都是void*的，这就给了我们很多可能，我们不仅仅可以传递普通的类型，我们也可以传递结构体/类，这大大的提高了我们使用线程的灵活性：

#include <iostream>
#include <pthread.h>
#include <unistd.h>
#include <string>class Person
{
public:std::string Print(){return _name + ":" + std::to_string(_age);}std::string _name;int _age;
};void* start_routine(void* args)
{Person *tp = (Person *)args;std::string info = tp->Print();while (true){sleep(1);std::cout << "new thread running..." << info << std::endl;}
}int main()
{Person p;p._age = 20;p._name = "Eric";pthread_t tid;pthread_create(&tid, nullptr, start_routine, &p);while(true){std::cout << "main thread running..." << std::endl;sleep(1);}return 0;
}

同一份栈空间？

这里见识到了线程的灵活之处，不仅仅可以传递内置类型的数据，就连我们的自定义类型的数据我们都能进行传递，但是这种做法显然不是很好的。
因为在进行对象实例化的时候，对象是在main函数的栈区创建的，然后再传递给新线程。换句话说，就是主线程与新线程共用了同一个栈空间里的资源，这很明显是不对的，因为一但我对主线程的对象进行修改，新线程同样也会看到，并同样也会对其修改造成最终的数据与我们期待的不一致。这个问题通常会发生在创建多线程时，当我需要修改原来的对象然后传递给新线程2的时候，因此我们在这里不得不停下来好好思考思考。

在这里先对代码进行了修改：

#include <iostream>
#include <pthread.h>
#include <unistd.h>
#include <string>class Person
{
public:std::string Print(){return _name + ":" + std::to_string(_age);}std::string _name;int _age;
};void* start_routine(void* args)
{while(true){sleep(1);Person *tp = (Person *)args;std::string info = tp->Print();std::cout << "new thread running..." << info << std::endl;}
}int main()
{Person p;p._age = 20;p._name = "Eric";pthread_t tid;pthread_create(&tid, nullptr, start_routine, &p);std::cout << "ready to change data" << std::endl;sleep(3);// 修改数据p._name = "Alan";p._age = 18;std::cout << "data changed" << std::endl;sleep(30); // 这里我简化了，其实应该是释放新线程再退出主线程好一点。return 0;
}

这个错误不是没有解决办法的，我们要解决的就是主线程用自己的空间，新线程也用自己的空间，那很好办，直接在各自的堆上new一个就好了。这样就算你创建了两个新线程，这两个线程的数据也是在堆空间上独立的！

线程等待：

当然和之前进程一样，主线程也是要等待新线程的结束然后回收资源，这当然也是避免一种类似“僵尸进程”的情况，但是线程提供的接口我们又能做很多工作，下面我们就来看看看线程等待的具体操作。
首先认识接口函数：pthread_join

#include <pthread.h>int pthread_join(pthread_t thread,	/* 被等待的线程的线程 ID */ void **retval);		/* 获取被等待的线程在退出时的返回值 */

与进程不同的是，这里的线程等待默认就是阻塞等待，直到所等待的的新线程终止为止。
同样的是，等待成功会返回0，否则返回对应的错误码，而这个错误码并不与进程等待失败的那个位图一致。

测试一下：

#include <iostream>
#include <pthread.h>
#include <unistd.h>void *start_routine(void* args)
{int cnt = 5;while(cnt){std::cout << "new thread running... cnt: " << cnt << std::endl;--cnt;sleep(1);}return nullptr;
}int main()
{std::cout << "main thread running..." << std::endl;pthread_t tid;pthread_create(&tid, nullptr, start_routine, nullptr);int n = pthread_join(tid, nullptr);if(n == 0){std::cout << "wait suceess!" << std::endl;}else{std::cout << "wait failed...." << std::endl;}return 0;
}

返回值与参数？

我们在刚刚的初次使用上，并没有研究第二个参数retval，而这里要注意它的类型是void**，而它的作用，是用来接收被等待的线程结束时的返回值，那么我们就可以浅浅的试一试使用它：

#include <iostream>
#include <pthread.h>
#include <unistd.h>
#include <string>void *start_routine(void* args)
{int cnt = 5;while(cnt){std::cout << "new thread running... cnt: " << cnt << std::endl;--cnt;sleep(1);}return (void*)"thread done"; // 返回一个stirng类型
}int main()
{std::cout << "main thread running..." << std::endl;// 线程创建pthread_t tid;pthread_create(&tid, nullptr, start_routine, nullptr);// 线程等待void *ret = nullptr; // 用来接收线程结束时的返回值int n = pthread_join(tid, &ret);std::string r = (const char *)ret; // 强制类型转换，获得返回值的合适类型if (n == 0){std::cout << "wait suceess!" << std::endl;std::cout << "new thread return: “" << r << "”"<< std::endl;}else{std::cout << "wait failed...." << std::endl;}return 0;
}

同样的我们也可以对自定义类型进行传参，比如这里我还是创建Person类，但是我这里只是new一个而不对其进行初始化，相当于直接传递了一个“空类”，然后我们在新创建的线程中，对这个“空类”进行初始化，然后我们返回这个类，看看我们是否能读取出来？

#include <iostream>
#include <pthread.h>
#include <unistd.h>
#include <string>class Person
{
public:std::string _name;int age;
};void *start_routine(void* args)
{int cnt = 5;while(cnt){std::cout << "new thread running... cnt: " << cnt << std::endl;--cnt;sleep(1);}// 设置对象的数据，并返回Person* pt = (Person*)args;pt->_name = "Carl";pt->age = 19;return (void *)pt;
}int main()
{std::cout << "main thread running..." << std::endl;// new实例化对象Person *p = new Person;// 创建线程pthread_t tid;pthread_create(&tid, nullptr, start_routine, p);void *ret = nullptr; // 用来接收线程结束时的返回值int n = pthread_join(tid, &ret);Person *r = (Person *)ret; // 强制类型转换，获得返回值的合适类型if (n == 0){std::cout << "wait suceess!" << std::endl;std::cout << "new thread return: “" << r->_name << ":" << r->age << "”" << std::endl;}else{std::cout << "wait failed...." << std::endl;}return 0;
}

创建多线程

结合已有的知识，我们已经完全具备创建多线程，然后在主线程结束之前回收这些多线程，比如现在我想创建10个线程，然后各个线程去打印一段话就好了，最后再一次返回，主线程依次等待回收。

#include <iostream>
#include <pthread.h>
#include <unistd.h>
#include <string>
#include <vector>const pthread_t num = 10;
void *start_routine(void *args)
{std::string tt = (const char *)args;std::cout << tt << " is running..."<< std::endl;sleep(1);return args;
}int main()
{// 创建线程std::vector<pthread_t> tids;for (int i = 1; i <= num; ++i){char *name = new char[128];snprintf(name, 128, "thread_%d", i);pthread_t tid;pthread_create(&tid, nullptr, start_routine, name);tids.push_back(tid);}// 回收线程for (int i = 0; i < tids.size(); ++i){void *ret = nullptr;pthread_join(tids[i], &ret);char *r = (char *)ret;std::cout << r << "quit..." << std::endl;}return 0;
}

线程终止

如果只是想终止某个线程而不是整个进程，可以有如下 3 种方法。

1. 使用 return 终止线程：非主线程可以在执行的函数中使用 return 终止当前线程。
2. 使用 pthread_exit 终止线程：线程自己可以调用该函数终止自己。
3. 使用 pthread_cancel 终止线程：该函数能通线程 ID 终止任意线程。

切记你最好不要用exit(1)这样的方式终止线程，因为这不仅仅会终止线程，还会直接终止掉你的进程，这个必须要额外注意！

线程分离

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

#include <pthread.h>int pthread_detach(pthread_t thread);	// thread 是要分离出去的线程的 ID

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

注意：这里的pthread_self()是获取自己线程的ID，哪个线程调用这个函数就返回哪个线程的ID

pthread_self 函数获得的线程 ID 不等于内核的 LWP 值，pthread_self 函数获得的是用户级原生线程库的线程 ID，而 LWP 是内核的轻量级进程ID，它们之间是一对一的关系。
后续我们会逐一展开

**一个线程要是被分离了，那么该线程就是处于分离状态，是不能被join的！但是依旧属于进程内部，只是不再需要被等待了！**joinable和分离是冲突的，一个线程不能既是joinable又是分离的。

• 虽然分离出去的线程已经不归主线程管了，但一般还是建议让主线程最后再退出。
• 分离出去的线程可以被 pthread_cancel 函数终止，但不能被 pthread_join 函数等待。
• 一个线程可以将其他线程分离出去，也可以将自己分离出去。