进程和线程
进程
进程是一个正在执行的程序实例,拥有独立的地址空间、数据段、代码段、堆栈以及系统资源(如文件描述符、信号处理器等)。
每个进程在内存中都有自己的地址空间,相互之间不能直接访问对方的内存。进程之间的通信通常需要通过进程间通信(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;
}