前言：

在前一篇文章中，我们已经探讨了线程的基本概念，了解到可以通过ps -aL命令查看线程。由于线程的特殊性，我们需要在用户层和操作系统层之间添加一个线程库，并在编译程序时将程序链接到这个线程库。

我们也初步学习了如何创建线程，使用pthread_create函数。然而，仅通过创建和概念来学习线程是远远不够的。因此，本文将详细介绍线程的各种操作。

我们将从多个角度探讨问题，然后尝试模拟实现一个线程。

---

我们将从多个子问题出发来全面了解线程操作。

子问题一：主线程和新线程之间谁先运行？让我们看一段代码：

void* threadRun(void* args){
    std::string name = static_cast<const char*>(args);
    std::cout << name << " is running" << std::endl;
    return nullptr;
}
<p>int main(){
pthread_t tid;
pthread_create(&tid, nullptr, threadRun, (void<em>)"thread -1");
std::cout << "main thread is running" << std::endl;
return 0;
}

我们期望看到屏幕上打印两条语句，以便讨论谁先运行的问题。然而，实际运行多次后，却没有看到子线程的结果。

这是因为我们没有调用join函数。主线程在创建子线程后，不会等待子线程完成任务就直接退出。如果运气好，子线程比主线程先完成任务，我们就能看到子线程的输出。

通过这个问题，我们可以清楚地看到，主线程和子线程的运行顺序是随机的，这与进程的父子进程调度顺序类似。

子问题二：我们期望谁是最后退出的呢？为什么？

int main(){
pthread_t tid;
void</em> result;
pthread_create(&tid, nullptr, threadRun, (void<em>)"thread -1");
std::cout << "main thread is running" << std::endl;
pthread_join(tid, &result);
return 0;
}

对于这个问题，基于进程的基础知识，我们可以推测期望主线程最后退出。就像父进程需要收集子进程的退出信息一样，子线程退出时，其信息也需要传递给主线程。我们如何查看子线程的信息呢？

在前一篇文章中，我们提到pthread_create的第一个参数是输出参数，第二个参数是线程属性，我们暂时将其设为nullptr。第三个参数是函数指针，返回值和参数都是void。我们可以直接使用这个参数，因为它来自pthread_create的第四个参数。

当我们以16进制打印tid时，会发现它是一个地址。如果主线程不等待子线程，可能会出现类似于僵尸进程的问题。因此，我们期望主线程是最后退出的线程。

子问题三：tid是什么？

std::string ToHex(pthread_t& tid){
char buffer[128];
snprintf(buffer, sizeof(buffer), "0x%lx", tid);
return buffer;
}

通过查看pthread_t的源码，我们发现它实际上是一个无符号的长整型。我们通过该函数将其以16进制形式打印出来：

Linux Omniscient

>全知全能技能Linux版。

下载

它是一个地址，理解到这里就足够了，关于它的更深层次内容，我们将在后续讨论。

子问题四：全面看待线程函数的传参，我们到底能传些什么？

class ThreadData{
public:
std::string _name;
int _id;
};</p><p>void<em> threadRunClass(void</em> args){
ThreadData t = <em>(ThreadData</em>)args;
std::cout << t._name << " " << t._id << " is running" << std::endl;
return nullptr;
}</p><p>int main(){
pthread_t tid1;
ThreadData t1;
t1._name = "thread -1";
t1._id = 1;
pthread_create(&tid1, nullptr, threadRunClass, (void<em>)&t1);
pthread_join(tid1, nullptr);
return 0;
}

对于最后一个参数，我们可以传递字符串，那么我们能传递自定义的类成员吗？

当然可以。如果你问为什么，我只能说：当然可以啊。

所以我们可以实现这样的效果：

然而，如果我们在主线程的栈区修改t1，可能会导致问题。因为线程有自己的栈，如果我们传递的是局部变量的地址，所有线程都可以看到这个地址，如果其中一个线程修改了它，就会引起问题。

因此，最安全的方式是在堆上分配空间，然后传递指针。

int main(){
pthread_t tid1;
ThreadData t1;
t1._name = "thread -1";
t1._id = 1;
ThreadData </em>td = new ThreadData();
td->_name = "thread-2";
pthread_create(&tid1, nullptr, threadRunClass, (void*)&t1);
pthread_create(&tid1, nullptr, threadRunClass, td);
pthread_join(tid1, nullptr);
return 0;
}

对于这个问题，我们不能局限于传递内置类型，我们可以传递任何类型。

子问题五：全面看待线程的返回值。对于线程返回值的问题，类似于线程函数的传参，我们可以返回不仅仅是nullptr，而是任意类型，只需进行强制类型转换即可。

同学，到现在，你理解C语言或C++的泛型指针了吗？

class ThreadResult{
public:
bool _result;
};</p><p>class ThreadData{
public:
std::string _name;
};</p><p>void<em> threadRun(void</em> args){
ThreadData<em> t = static_cast<ThreadData</em>>(args);
std::cout << t->_name << " is running" << std::endl;
ThreadResult<em> s = new ThreadResult();
s->_result = true;
return (void</em>)s;
}</p><p>int main(){
pthread_t tid;
ThreadResult<em> result = nullptr;
ThreadData</em> t = new ThreadData();
t->_name = "thread -1";
pthread_create(&tid, nullptr, threadRun, (void*)t);
pthread_join(tid, (void**)&result);
std::cout << "Thread result: " << result->_result << std::endl;
delete t;
delete result;
return 0;
}

这段代码是否还需要进一步解释呢？