进程和线程
进程
进程是一个正在执行的程序实例，拥有独立的地址空间、数据段、代码段、堆栈以及系统资源（如文件描述符、信号处理器等）。
每个进程在内存中都有自己的地址空间，相互之间不能直接访问对方的内存。进程之间的通信通常需要通过进程间通信（IPC）机制，如管道、消息队列、共享内存等。
由于进程拥有独立的地址空间，进程之间的上下文切换需要保存和恢复大量的状态信息，因此开销较大。
线程
线程是进程中的一个执行单元，多个线程可以共享进程的地址空间和资源。一个进程可以包含多个线程，这些线程可以并发执行。
线程之间共享进程的所有资源（包括代码段、数据段、文件描述符等），但每个线程有自己的栈和寄存器。
在Linux系统中，看到的PCB都是轻量级进程(线程的本质是轻量级进程)
进程和线程的关系
- 进程是承担分配系统资源的基本实体
- 线程是CPU调度和分配的基本单位，是进程里面的执行流
在Linux中没有真正意义上的线程，线程是用进程模拟的，数据结构也是用的task_struct
进程的优缺点
进程的优点：
- 提高并发性和效率:
线程允许程序并发执行多个任务，在多核处理器上，多个线程可以同时在不同的 CPU 核心上执行，从而提高程序的性能。
线程之间可以共享数据和资源，减少了进程间通信的开销。 - 资源共享:
同一进程中的线程共享相同的内存地址空间和系统资源（如文件描述符、全局变量等），这使得线程之间的通信比进程间通信更高效、更简单。 - 上下文切换开销低:
线程的上下文切换（在不同线程之间切换执行）比进程的上下文切换更快，因为线程共享相同的地址空间，不需要频繁地切换内存页表和其他资源。 - 响应性强:
在 GUI 应用程序中，线程可以用来执行耗时的任务（如 I/O 操作、复杂计算）而不会阻塞用户界面主线程，从而提高程序的响应性。
进程的缺点：
- 编程复杂性增加:
多线程编程容易引发并发问题，如竞态条件、死锁、资源竞争等。这些问题难以调试和测试，增加了开发的复杂性。 - 资源共享带来的风险:
虽然线程共享进程的资源，但这也带来了潜在的风险，如一个线程的崩溃可能导致整个进程崩溃，或者一个线程的不当操作（如对共享数据的错误修改）可能影响其他线程的正常运行。 - 调试困难:
由于线程之间的并发执行，程序的执行顺序可能不可预测，这使得调试多线程程序变得更加困难。 - 缺乏可扩展性:
在某些情况下，使用线程可能不如使用进程那样具有可扩展性，特别是在需要隔离和安全的环境中，进程提供了更好的隔离性和独立性。
Linux进程VS线程
进程是资源分配的基本单位，线程是调度的基本单位。
线程共享进程的数据，但是也拥有自己的一部分数据：
- 线程ID， 一组寄存器，栈， errno，信号屏蔽字， 调度优先级.
进程和线程的关系如下图:
Linux线程控制
POSIX线程库
POSIX线程库（Pthreads） 是POSIX标准的一部分，提供了一组用于多线程编程的API，使能够在Unix-like系统上创建、管理和同步线程。它包括线程的创建与管理、线程同步（如互斥锁、条件变量）、线程属性设置，以及线程本地存储等功能。Pthreads广泛用于编写可移植的多线程应用程序。
注意：
- 与线程有关的函数构成了一个完整的系列，绝大多数函数的名字都是以“pthread_”打头的
- 要使用这些函数库，要通过引入头文<pthread.h>
- 链接这些线程函数库时要使用编译器命令的“-lpthread”选项
创建线程
pthread_create
int pthread_create(pthread_t *thread, const pthread_attr_t *attr,
void *(*start_routine) (void *), void *arg);
参数说明:
pthread_t *thread: 这是一个指向线程标识符的指针。pthread_create 会将新线程的 ID 保存到这个指针指向的变量中，以便之后可以使用该 ID 对线程进行操作（如 pthread_join 等）。const pthread_attr_t *attr: 指向线程属性对象的指针，用于指定新线程的属性。如果传入 NULL，则使用默认属性。void *(*start_routine)(void *): 这是线程执行的函数的指针，新线程启动后会执行这个函数。函数需要接受一个void*类型的参数，并返回一个void*类型的值。void *arg: 传递给 start_routine 的参数。 可以将需要传递给线程的参数通过这个指针传递。
返回值：
- 成功: 返回 0，表示线程创建成功。
- 失败: 返回错误码（非零），表示创建线程时发生错误。
示例：
#include <iostream>
#include <pthread.h>
#include <unistd.h>
void * routine(void* arg)
{
while(1)
{
std::cout << "I am new thread" << ((char*)arg) << std::endl;
sleep(1);
}
}
int main ()
{
pthread_t tid; //声明变量
pthread_create(&tid,nullptr,routine,(void*)"thread 1"); //创建线程
//主线程
while(1)
{
std::cout << "I am main thread" << std::endl;
sleep(1);
}
return 0;
}
输出错乱现象是由于多个线程在标准输出（std::cout）上竞争所导致的。std::cout
是一个共享资源，当主线程和新创建的线程几乎同时向 std::cout
输出内容时，由于输出操作没有被同步控制，它们的输出可能会相互交错，从而导致输出混乱。
问题一： main和new线程，谁先运行？
答：不确定。
pthread_t 是什么？
pthread_t 是 POSIX 线程库（Pthreads）中用于标识线程的类型。它是一个平台相关的类型，在不同的系统中可能被定义为不同的数据类型，但通常是一个无符号整数或指针类型。 pthread_t 用来唯一标识一个线程，使得线程可以通过这个标识符进行管理和操作。
通过查看进程发现只有一个进程
使用 ps -aL 可以看到两个线程
问题四：全面看待函数传参
答：因为
arg是一个void*的参数，所以我们可以传入各种类型最后进行强转即可。
#include <iostream>
#include <pthread.h>
#include <unistd.h>
void *routine(void *arg)
{
int n = 10;
int m = *(int *)arg;
while (n--)
{
std::cout << m << " thread running ... cnt : " << n << std::endl;
sleep(1);
}
return nullptr;
}
int main()
{
pthread_t tid; // 声明变量
int n = 10;
pthread_create(&tid, nullptr, routine, (void *)&n); // 创建线程
std::cout << "main thread wait begin... " << std::endl;
return 0;
}
对于int型的变量n，强转void* ，在新进程中再次强转int，拿到arg的值。
也可以传入类对象
#include <iostream>
#include <pthread.h>
#include <unistd.h>
class ThreadDate
{
public:
std::string _name;
int _num;
};
void *routine(void *arg)
{
int n = 10;
ThreadDate *td = static_cast<ThreadDate*>(arg); // (ThreadDate*)arg
while (n--)
{
std::cout << td->_name << " running ... cnt : " << n << " _num : " << td->_num << std::endl;
sleep(1);
}
return nullptr;
}
int main()
{
pthread_t tid; // 声明变量
ThreadDate td;
td._name = "thread -1";
td._num = 5;
pthread_create(&tid, nullptr, routine, (void *)&td); // 创建线程
std::cout << "tid -> " << PrintToHex(tid) << std::endl;
std::cout << "main thread wait begin... " << std::endl;
return 0;
}
因为可以传入类对象，所以我们可以通过arg来给线程传入多个参数，甚至方法了。
但是对于上面的类对象的声明不太推荐，因为在main中直接声明相当于在其栈上开辟空间，这回污染别的线程的栈，所以可以通过使用new在堆上开辟，再把地址传给新线程。
问题六：如何创建多个线程：
使用for循环创建
const int num = 10;
void *threadRun(void *args)
{
std::string name = static_cast<const char *>(args);
std::cout << name << " is running... " << std::endl;
sleep(2);
return args;
}
int main()
{
std::vector<pthread_t> tids;
for (int i = 0; i < num; i++)
{
// 1 创建线程id
pthread_t tid;
// 2 线程的名字
char *name = new char[128];
snprintf(name, 128, "thread-%d", i + 1);
pthread_create(&tid, nullptr, threadRun, (void *)name);
// 3 保存所有线程的id信息
tids.emplace_back(tid);
// sleep(1);
}
for (auto tid : tids)
{
const char *name = nullptr;
pthread_join(tid, (void **)&name);
std::cout << name << " quit ... " << std::endl;
}
return 0;
}
线程等待
pthread_join
int pthread_join(pthread_t thread, void **retval);
参数：
pthread_t thread: 这是被等待线程的标识符。void **retval: 这是一个指向指针的指针，用于存储被等待线程的返回值。如果不需要获取返回值，可以传入 NULL。
返回值
- 成功: 返回 0 表示线程成功等待并获取到其退出状态。
- 失败: 返回错误码（非零），表示等待线程时发生错误。
问题五：如何全面看待线程函数返回:
- 线程的返回只考虑正确的返回，不考虑异常，因为异常了，整个进程就崩溃了，包括主线程。
- 我们可以传递任意类型，但都必须穿地址才能实现。
- 出异常就直接终止进程了。
void *routine(void *arg)
{
sleep(3);
int m = 10 / 0;
}
int main()
{
pthread_t tid; // 声明变量
pthread_create(&tid, nullptr, routine, (void*)"thread 1"); // 创建线程
std::cout << "main thread wait begin... " << std::endl;
sleep(5);
return 0;
}
当出现了 / 0 异常的时候，进程直接本奔溃。
- 可以传递任意类型
- 首先肯定是可以返回数字的。
因为我们当前是64位系统，void *占有8个字节，但是int只占有4个字节，所以出现loses precision错误。
这样修改即可
- 其次，可以返回类对象。
class ThreadDate
{
public:
int Execute()
{
return x + y;
}
public:
int x;
int y;
std::string name;
};
class ThreadResult
{
public:
std::string Print()
{
return std::to_string(x) + "+" + std::to_string(y) + "=" + std::to_string(ret);
}
public:
int x;
int y;
int ret;
};
void *Routine(void *arg)
{
ThreadDate *td = static_cast<ThreadDate *>(arg); // (ThreadDate*)arg
ThreadResult *result = new ThreadResult();
result->ret = td->Execute();
result->x = td->x;
result->y = td->y;
std::cout << "running ..." << std::endl;
std::cout << "--------------------------" << std::endl;
delete td;
return (void *)result;
}
std::string PrintToHex(pthread_t &tid)
{
char buffer[128];
snprintf(buffer, sizeof(buffer), "0x%lx", tid);
return buffer;
}
int main()
{
pthread_t tid; // 声明变量
ThreadDate *td = new ThreadDate();
td->name = "Thread-1";
td->x = 10;
td->y = 20;
pthread_create(&tid, nullptr, Routine, (void *)td); // 创建线程
// 主线程
// 问题二：我们希望主线程最后退出，则需要用join来等待新线程，否则主线程退了新线程没退导致类似于僵尸进程的情况。
// 问题三：tid是什么样子的呢？
std::cout << "tid -> " << PrintToHex(tid) << std::endl;
std::cout << "main thread wait begin... " << std::endl;
// sleep(5);
ThreadResult *ret_ = nullptr;
int ret = pthread_join(tid, (void **)&ret_);
if (ret == 0)
{
std::cout << "main thread wait success get result -> " << ret_->Print() << std::endl;
}
return 0;
}
pthread_join 的作用
- 同步线程:
pthread_join的主要作用是同步线程，确保主线程或其他线程等待目标线程执行完毕后再继续执行。 - 回收资源: 当一个线程结束时，它的资源不会立即被系统回收，只有当其他线程调用
pthread_join来等待它结束时，系统才会回收它的资源。因此，pthread_join也起到了一定的资源管理作用。
注意：
- 只能对已经创建的线程调用
pthread_join。 - 如果多次调用
pthread_join对同一个线程进行等待，可能会导致未定义行为。 - 如果某个线程不希望被等待或需要自动释放资源，可以使用
pthread_detach函数将其设置为“分离”状态。
#include <iostream>
#include <pthread.h>
#include <unistd.h>
void * routine(void* arg)
{
int n = 10;
while(n--)
{
std::cout << "new thread running ... cnt : " << n << std::endl;
sleep(1);
}
return nullptr;
}
int main ()
{
pthread_t tid; //声明变量
pthread_create(&tid,nullptr,routine,(void*)"thread 1"); //创建线程
//主线程
//我们希望主线程最后退出，则需要用join来等待新线程，
//否则主线程退了新线程没退导致类似于僵尸进程的情况。
std::cout << "main thread wait begin... " << std::endl;
int ret = pthread_join(tid,nullptr);
if(ret == 0)
{
std::cout << "main thread wait success " << std::endl;
}
return 0;
}
可以看到主线程一直在阻塞式的等待新线程，等待新线程循环完后主线程等待完成，主线程退出。
问题二：如何保证主线程最后退出
答：join来保证。
问题三：tid 是什么样子的呢？
答：实际上就是一个虚拟地址。先通过打印来验证。
线程终止
线程终止一共三种方法：
- 新线程调用return
- 新线程调用pthread_exit终止自己
- 一个线程调用pthread_cancel终止另外一个线程
1.return退出
2.pthread_exit函数
void pthread_exit(void *retval);
参数说明:
- retval：这是一个指向 void 的指针，允许线程在退出时返回一个值给任何通过 pthread_join 等待这个线程结束的线程。这个返回值可以作为 pthread_join 函数的返回值获得。
返回值：
- 该函数函数本身不返回任何值，因为它直接导致线程退出。任何从 pthread_exit 调用的函数或后续代码都不会被执行。
const int num = 10;
void *threadRun(void *args)
{
std::string name = static_cast<const char *>(args);
std::cout << name << " is running... " << std::endl;
sleep(2);
pthread_exit((void *)111);
}
int main()
{
std::vector<pthread_t> tids;
for (int i = 0; i < num; i++)
{
// 1 创建线程id
pthread_t tid;
// 2 线程的名字
char *name = new char[128];
snprintf(name, 128, "thread-%d", i + 1);
pthread_create(&tid, nullptr, threadRun, (void *)name);
// 3 保存所有线程的id信息
tids.emplace_back(tid);
// sleep(1);
}
for (auto tid : tids)
{
void *num = nullptr;
pthread_join(tid, &num);
std::cout << " quit ... " << (uint64_t)num << std::endl;
}
return 0;
}
3. pthread_cancel函数
int pthread_cancel(pthread_t thread);
参数说明:
- thread：这是一个 pthread_t 类型的参数，表示要取消的线程的标识符。线程标识符是在调用 pthread_create 函数创建线程时返回的。
返回值：
pthread_cancel函数的返回值是一个整数，用于指示函数调用的成功或失败状态：- 0：表示成功发送了取消请求给目标线程。但请注意，这并不意味着目标线程已经实际停止执行；它只是表示取消请求已被成功接收。
- 非0值：表示函数调用失败，无法向目标线程发送取消请求。具体的错误码可以用来进一步诊断问题。
示例：
#include <iostream>
#include <pthread.h>
#include <unistd.h>
#include <vector>
const int num = 10;
void *threadRun(void *args)
{
std::string name = static_cast<const char *>(args);
while (1)
{
std::cout << name << " is running... " << std::endl;
sleep(1);
}
sleep(2);
pthread_exit((void *)111);
}
int main()
{
std::vector<pthread_t> tids;
for (int i = 0; i < num; i++)
{
// 1 创建线程id
pthread_t tid;
// 2 线程的名字
char *name = new char[128];
snprintf(name, 128, "thread-%d", i + 1);
pthread_create(&tid, nullptr, threadRun, (void *)name);
// 3 保存所有线程的id信息
tids.emplace_back(tid);
// sleep(1);
}
sleep(3);
for (auto tid : tids)
{
pthread_cancel(tid);
void *result = nullptr;
pthread_join(tid, &result);
std::cout << (long long int)result << " quit ... " << std::endl;
}
return 0;
}
当自己取消自己的时候，返回的是-1.
问题七：新线程如何终止
- 线程函数 return
- pthread_exit
- main thread call pthread_cancel, 新线程退出结果是-1
线程分离
pthread_cancel:
int pthread_cancel(pthread_t thread);
参数说明:
- thread：被分离线程的ID。
返回值：
- 线程分离成功返回0，失败返回错误码。
示例：
使用detach来分离，join异常返回
问题8: 可以不可以不join线程，让他执行完就退出呢？？可以！
- 一个线程被创建，默认是joinable的，必须要被join的
- 如果一个线程被分离，线程的工作状态分离状态，不须要/不能被join的. 依旧属于进程内部，但是不需要被等待了
使用pthread_detach对新创建的线程进行分离，然后当新线程的任务处理完成后，自动完成对其回收，不再需要等待。
#include <iostream>
#include <pthread.h>
#include <unistd.h>
#include <vector>
const int num = 10;
void *threadRun(void *args)
{
int n = 5; //新线程循环5次后直接退出。
std::string name = static_cast<const char *>(args);
while (n--)
{
std::cout << name << " is running... " << std::endl;
sleep(1);
}
sleep(2);
pthread_exit((void *)111);
}
std::string PrintToHex(pthread_t &tid)
{
char buffer[128];
snprintf(buffer, sizeof(buffer), "0x%lx", tid);
return buffer;
}
int main()
{
std::vector<pthread_t> tids;
for (int i = 0; i < num; i++)
{
// 1 创建线程id
pthread_t tid;
// 2 线程的名字
char *name = new char[128];
snprintf(name, 128, "thread-%d", i + 1);
pthread_create(&tid, nullptr, threadRun, (void *)name);
// 3 保存所有线程的id信息
tids.emplace_back(tid);
// sleep(1);
}
sleep(5); //主线程直接对新线程进行分离
for (auto tid : tids)
{
pthread_detach(tid);
std::cout << "detach tid: " << PrintToHex(tid) << std::endl;
}
std::cout << "Detach finish... " << std::endl;
while (1)
{
std::cout << "I am main thread , i am running ... " << std::endl;
sleep(1);
}
//不再进行join等待回收
// for (auto tid : tids)
// {
// pthread_cancel(tid);
// void *result = nullptr;
// int n = pthread_join(tid, &result);
// std::cout << (long long int)result << " quit ... n: " << n << std::endl;
// }
return 0;
}
1181
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
