个人主页：Lei宝啊
愿所有美好如期而遇
目录
线程概念
线程是进程内部的一个执行分支，是CPU调度的基本单位。
线程理解
首先我们以Linux系统为例，不同的操作系统对线程的设计是有差别的，概念上也有差距。
我们知道进程有进程控制块，那么线程应不应该有他的控制块？应该有，但是对于线程的调度，和进程是很相似的，都是执行流，于是Linux就没有设计线程的控制块，没有为线程再单独设计数据结构，而是复用的进程的，所以我们上面的图中，可以看到线程我们也是使用的task_struct，一个进程内部的代码由几个线程分别去执行。
再这里，我们重新理解一下进程，之前我们理解的进程是：进程控制块+进程的代码和数据，现在，我们对进程的理解：分配资源的基本实体，因为地址空间和虚拟地址实际上也是资源。
所以，上面的一个整体，包括PCB，虚拟地址空间，页表，在内核角度：我们理解为进程。
关于线程的调度，你可能会问，那么CPU如何区分线程和进程？我们给出的答案是不区分，因为他们都是task_struct，并且线程执行的是进程的一部分代码，CPU该怎么执行就怎么执行，完全不会影响，在Linux中，所有调度执行流都叫做轻量级进程，所以，在linux中，实际上没有线程，有的是轻量级进程。
在一般操作系统中：进程内部只有一个执行流的叫做进程，进程内部有多个执行流的，这些执行流叫做线程。在Windows操作系统中，为线程单独设计了线程的数据结构，系统调用等。
页表和虚拟地址空间
我们以32位机器为例，虚拟地址被划分为3部分来看，第一部分和第二部分10位，第三部分12位，第一部分的值在页目录中索引页表，在页表中由第二部分的值索引物理地址中的数据块，此时找到的不是数据的实际地址，只是他所在的数据块的地址，接下来由这个地址加上第三部分的值找到数据的实际地址。
操作系统对于内存的管理是这样的，既然有了页框，那么页框的属性是什么？就要描述起来，内存中由多少页框？既然要管理，就将他们组织起来：
而是否被使用，我们在分配内存时这个标志位只需要与上这样的宏就可以判断，是用户使用还是内核使用？我们对应的属性与上对应的宏即可。
线程控制
多个执行流是如何进行代码划分的？我们上代码来理解：
线程创建
我们要注意到，线程的创建我们使用的是库函数，不是系统调用。
参数解释：
- 第一个参数，线程标识符的地址，调用者应提供一个非空的指针。
- 第二个参数，一个指向线程属性的指针，通过他可以调整线程属性以满足我们的需求，一般情况下，我们传nullptr足以满足需求。
- 第三个参数，一个函数指针，指向线程要执行的任务，任务类型为void* ()(void*)，线程创建成功后会自动调用这个函数。
- 第四个参数，一个void*类型的参数，用来将需要的数据传递给第三个参数。
#include <iostream>
#include <pthread.h>
#include <unistd.h>
using namespace std;
void *task(void *p)
{
while (true)
{
cout << "线程" << endl;
sleep(1);
}
}
int main()
{
pthread_t id;
pthread_create(&id, nullptr, task, nullptr);
while (true)
{
cout << "主线程" << endl;
sleep(1);
}
return 0;
}testpthread: testpthread.cc
g++ -o $@ $^ -std=c++11 -lpthread
.PHONY:clean
clean:
rm -f testpthread 
这里我们补充一个细节：就是我们编译文件时，后面加了-lpthread，同时，我们前面提到，创建线程用的是库函数，不是系统调用，同时，pthread是Linux的原生线程库，他不是C语言的，也不是C++的，所以编译时需要指定这个库。
所以，在使用多线程的库函数时，要告诉编译器链接哪个库，所以需要-l选项，pthread就是库的名字。，我们可以看一下创建轻量级进程的系统调用：
所以，我们在用户层面上会谈线程，在Linux系统层面上，我们说轻量级进程。比如：用户层面上，我们说，进程中至少包含一个线程，线程是进程的一个执行分支；从系统层面上来讲，没有线程，只有轻量级进程，而进程中至少包含一个轻量级进程，轻量级进程是进程的一个执行分支。
我们能够看见，在用户层面和系统层面，他们能够如此相似，是因为原生线程库的封装，这也就是这个库的意义。
现在，我们提及轻量级进程是如何划分进程的代码的：我们知道所有轻量级进程共享一个地址空间的大部分数据，并且他们是由进程创建出来来执行进程的部分代码，在进程代码编译后，我们可以查看他的汇编代码，全部都是一块块以函数为单位的代码，而这些函数都有一个入口地址，我们创建的线程会去执行我们分配的函数，这样也就将代码做了划分。
线程等待
- 第一个参数：线程tid(库级别)，用来唯一标识一个线程。
- 第二个参数：用来获取线程执行函数的返回值。
如同父进程需要等待子进程回收资源一样，线程也需要进行等待。
#include <iostream>
#include <pthread.h>
#include <unistd.h>
using namespace std;
void *task(void *p)
{
cout << "线程" << endl;
sleep(1);
return reinterpret_cast<void*>(123);
}
int main()
{
pthread_t id;
pthread_create(&id, nullptr, task, nullptr);
sleep(2);
void* ret;
int val = pthread_join(id, &ret);
cout << "main pthread quit, pthread_jion return val = " << val << endl;
cout << "main get ret : " << reinterpret_cast<long long>(ret) << endl;
return 0;
}
ret需要用long long强制类型转换是因为云服务器是是64位机器。
前面我们提到tid，那么我们可以看看tid是多少，线程的tid如何获得。
#include <iostream>
#include <pthread.h>
#include <unistd.h>
using namespace std;
void *task(void *p)
{
cout << "线程 tid: " << pthread_self() << endl;
sleep(1);
return reinterpret_cast<void*>(123);
}
int main()
{
pthread_t id;
pthread_create(&id, nullptr, task, nullptr);
cout << "create get tid: " << id << endl;
cout << "main pthread tid: " << pthread_self() << endl;
sleep(2);
void* ret;
int val = pthread_join(id, &ret);
cout << "main pthread quit, pthread_jion return val = " << val << endl;
cout << "main get ret : " << reinterpret_cast<long long>(ret) << endl;
return 0;
}
线程退出
首先看一个例子：
void *task(void *p)
{
while(true)
{
cout << "恋爱循环" << endl;
sleep(1);
}
return nullptr;
}
int main()
{
pthread_t id;
pthread_create(&id, nullptr, task, nullptr);
sleep(3);
cout << "main pthread exit" << endl;
return 0;
}
我们这里给出一个结论：主线程退出 == 进程退出，而进程是分配资源的基本实体，线程只是进程的一个执行分支，进程退出，那么所有线程也就退出了。
- 主线程往往需要最后退出。
- 线程需要被wait，否则会产生内存泄漏的问题。
那么再看一个例子：
void *task(void *p)
{
sleep(3);
int *pp = nullptr;
*pp = 100;
return nullptr;
}
int main()
{
pthread_t id;
pthread_create(&id, nullptr, task, nullptr);
while(true)
{
sleep(1);
cout << "main pthread 在跑" << endl;
}
return 0;
}
我们给出结论：任何一个线程异常退出，则进程退出，所有线程也就退出了，因为所有线程共享信号的三个表：pending，block，handler。
总结：线程非正常退出：主线程直接先退出；线程出现异常。
接下来介绍线程正常退出的方式：
- return
- pthread_exit
- pthread_cancel
第一种我们不做解释，线程执行到函数末尾就会return。
第二种：
void *task(void *p)
{
sleep(3);
cout << "线程要退出了" << endl;
pthread_exit(reinterpret_cast<void*>(123));
cout << "我没退出啊？" << endl;
return nullptr;
}
int main()
{
pthread_t id;
pthread_create(&id, nullptr, task, nullptr);
void* ret = nullptr;
pthread_join(id, &ret);
cout << reinterpret_cast<long long>(ret) << endl;
return 0;
}
也许你有疑惑：为什么不使用exit？exit是进程退出，也就是说，所有线程都干掉了。
第三种：
调用这个函数，有一个前提，要取消的线程必须已经存在。
void *task(void *p)
{
while(true)
{
cout << "不想跑50米啊啊啊啊啊" << endl;
sleep(1);
}
return nullptr;
}
int main()
{
pthread_t id;
pthread_create(&id, nullptr, task, nullptr);
sleep(3);
pthread_cancel(id);
void* ret = nullptr;
pthread_join(id, &ret);
cout << reinterpret_cast<long long>(ret) << endl;
return 0;
}
线程分离
#include <iostream>
#include <pthread.h>
#include <unistd.h>
using namespace std;
void* func(void* args)
{
int cnt = 5;
while(cnt--)
{
cout << "??" << endl;
sleep(1);
}
return nullptr;
}
int main()
{
pthread_t tid;
pthread_create(&tid, nullptr, func, nullptr);
pthread_detach(tid);
while(true)
{
cout << "?" << endl;
sleep(1);
}
return 0;
}
理解线程
由于Linux中只有轻量级进程，所以操作系统不会维护线程，而pthread原生线程库就承担了这个责任，由他来维护线程。
我们在线程跑起来的时候，可以用ps -aL看到线程的lwp，并且可以发现他的值和tid的值是不一样的，这是因为lwp是操作系统维护的轻量级线程的唯一标识符，而tid是库级别的。
我们从上图给出结论：tid就是线程在库中的起始地址，线程栈是通过库的维护实现了独立。
什么是线程局部存储？通过对全局的共享资源使用__thread修饰，使每个__thread修饰的变量在使用它的线程中各自创建一份(线程局部存储只能存储内置类型变量)
也就是说，同一进程的多个线程，其实可以通过一个全局变量访问到其他线程的各种数据，只要有他的tid就可以访问到。
多线程创建
#include <pthread.h>
#include <iostream>
#include <vector>
#include <string>
#include <unistd.h>
using namespace std;
class Task
{
public:
void func()
{
cout << "任务完成" << endl;
}
private:
};
class information
{
public:
information(pthread_t pt, string& pthreadname)
:_pt(pt)
,_pthreadname(pthreadname)
{}
pthread_t Gettid()
{
return _pt;
}
string getname()
{
return _pthreadname;
}
private:
pthread_t _pt;
string _pthreadname;
};
class Result
{
public:
Result(bool ret = true)
:_ret(ret)
{}
bool getret()
{
return _ret;
}
private:
bool _ret;
};
class pthread
{
public:
static void* Pthread_Run(void* args)
{
pthread* pr = reinterpret_cast<pthread*>(args);
pr->task.func();
Result* rs = new Result;
pr->rets.push_back(rs);
return rs;
}
void Create_Run(int pthreadnum)
{
for(int i=0; i<pthreadnum; i++)
{
string pthreadname("pthread--" + to_string(i));
pthread_t tid;
pthread_create(&tid, nullptr, Pthread_Run, this);
vpt.emplace_back(tid,pthreadname);
sleep(1);
}
}
void GetInformation()
{
void *ret = nullptr;
for(auto &e : vpt)
{
pthread_join(e.Gettid(), &ret);
cout << e.getname() << "-" <<
reinterpret_cast<Result*>(ret)->getret() << endl;;
}
}
~pthread()
{
GetInformation();
for(auto &e : rets)
{
delete e;
}
}
private:
vector<information> vpt;
vector<Result*> rets;
Task task;
};
int main(int argc, char* argv[])
{
if(argc != 2)
{
cout << "Usage: " << argv[0] << " " << "number" << endl;
exit(1);
}
int pthreadnum = stoi(argv[1]);
pthread pr;
pr.Create_Run(pthreadnum);
return 0;
}
7755
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
