[Linux#41][线程] 线程的特性 | 分离线程 | 并发的问题

lvy- 2024-08-23 13:07:03 阅读 80

1.线程的特性

进程和线程的关系如下图:

关于进程线程的问题

• 如何看待之前学习的单进程?具有一个线程执行流的进程

线程 ID 及进程地址空间布局

pthread_ create 函数会产生一个线程 ID,存放在第一个参数指向的地址中。 该线程 ID 和前面说的线程 ID 不是一回事。 前面讲的线程 ID 属于进程调度的范畴。因为线程是轻量级进程,是操作系统 调度器的最小单位,所以需要一个数值来唯一表示该线程。 pthread_ create 函数第一个参数指向一个虚拟内存单元,该内存单元的地址即 为新创建线程的线程 ID,属于 NPTL 线程库的范畴。线程库的后续操作,就是根据 该线程 ID 来操作线程的。 线程库 NPTL 提供了 pthread_ self 函数,可以获得线程自身的 ID:<code>pthread_t pthread_self(void);

pthread_t 到底是什么类型呢?取决于实现。对于 Linux 目前实现的 NPTL 实现而 言,pthread_t 类型的线程 ID,本质就是一个进程地址空间上的一个地址。

在线程栈中

创建线程,如何实现批量传参数据--vector+循环 创建

<code>void *threadRoutine(void *args)//接收类指针

{

threadData *td=static_cast<threadData *>(args);

int i=0;

while(i<10)

{

cout<<"pid: "<<getpid()<<" , ";

}

return nullptr;

}

int main()

{

vector<pthread_t> tids;

for(int i=0;i<NUM;i++)

{

pthread_t tid;

threadData *td=new threadData;

pthread_create(&tid,nullptr,threadRoutine,td);

tids.push_back(tid);

}

}

注意:对于 threadData *td=new threadData;传入函数后要对 void * 强转

threadData *td=static_cast<threadData *>(args);

防止两个栈空间混乱

所以 要 传指针,指向的是堆空间,一线程一个

下面函数的初始化是如何实现的呢, InitThreadData 的设计

struct threadData

{

string threadname;

};

// __thread threadData td;

string toHex(pthread_t tid)

{

char buffer[128];

snprintf(buffer, sizeof(buffer), "0x%x", tid);

return buffer;

}

void InitThreadData(threadData *td, int number)

{

td->threadname = "thread-" + to_string(number); // thread-0

}

snprintf 函数被用来将线程 ID (tid) 转换成一个十六进制字符串,并存储在 buffer 字符数组中

监测的打印:

while :; do ps ajx | head -1 && ps ajx | grep myprocess |grep -x grep;sleep 1;done

//将ps ajx替换为ps -aL

所有的线程,执行的都是这个函数?是的

1. 但每个线程都有自己独立栈结构,打印测试

会每个线程的 test_i 有自己的地址空间,是独立的

多执行流--可重入函数,线程和线程几乎没有秘密,虽然有独立栈结构,要是想访问也是可以的

2. 线程的栈上数据,也是可以被其他线程看到并访问的

线程可以拿到某一线程数据,例如对主线程进行测试,发现访问到了

3. 全局变量可以被所有线程同时看到的,++测试:

<code> cout << "pid: " << getpid() << ", tid : "

// << toHex(number) << ", threadname: " << td->threadname

// << ", g_val: " << g_val << " ,&g_val: " << &g_val <<endl;

g_val 数据称为共享资源

如果我线程想要一个私有的全局变量呢??

<code>__thread(编译选项创建) int g_val 线程的局部存储,每个线程都对共享资源存储了一份

定义出线程级别的全局变量,并且互不干扰,进行线程的局部存储!只能定义内置类型,可以用于线程函数


2. 分离线程

• 默认情况下,新创建的线程是 joinable 的,线程退出后,需要对其进行 pthread_join 操作,否则无法释放资源,从而造成系统泄漏。

• 如果不关心线程的返回值,join 是一种负担,这个时候,我们可以告诉系统,当线程退出时,自动释放线程资源。 <code> int pthread_detach(pthread_t thread);

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

joinable 和分离是冲突的,一个线程不能既是pthread_join又是 pthread_detach的。

//测试发现矛盾

// void *threadRoutine(void *args)

// {

// pthread_detach(pthread_self());//自己分家

int main(){

vector<pthread_t> tids;

// for(auto i : tids)

// {

// pthread_detach(i);//被父亲驱逐分家

// }

// cout << "main thread get a thread local value, val: " << *p << ", &val: " << p << endl;

for (int i = 0; i < tids.size(); i++)

{

int n = pthread_join(tids[i], nullptr);

printf("n = %d, who = 0x%x, why: %s\n", n, tids[i], strerror(n));

}

如何创建多个进程

vector<pthread_t> tids;//循环创建

for (int i = 0; i < NUM; i++)

{

pthread_t tid;

threadData *td = new threadData;

InitThreadData(td, i);

pthread_create(&tid, nullptr, threadRoutine, td);

tids.push_back(tid);

//sleep(1);

}


3.并发的问题

进程线程间的互斥相关背景概念

临界资源:多线程执行流共享的资源就叫做临界资源

临界区:每个线程内部,访问临界资源的代码,就叫做临界区

互斥:任何时刻,互斥保证有且只有一个执行流进入临界区,访问临界资源, 通常对临界资源起保护作用

原子性(后面讨论如何实现):不会被任何调度机制打断的操作,该操作只有 两态,要么完成,要么未完成

互斥量 mutex

• 大部分情况,线程使用的数据都是局部变量,变量的地址空间在线程栈空间 内,这种情况,变量归属单个线程,其他线程无法获得这种变量。

• 但有时候,很多变量都需要在线程间共享,这样的变量称为共享变量,可以通 过数据的共享,完成线程之间的交互。

• 多个线程并发的操作共享变量,会带来一些问题。

模拟实现抢电影票

#include <iostream>

#include <cstdio>

#include <cstring>

#include <vector>

#include <unistd.h>

#include <pthread.h>

using namespace std;

#define NUM 4

class threadData

{

public:

threadData(int number)

{

threadname = "thread-" + to_string(number);

}

public:

string threadname;

};

int tickets = 1000; // 用多线程,模拟一轮抢票

void *getTicket(void *args)

{

threadData *td = static_cast<threadData *>(args);

const char *name = td->threadname.c_str();

while (true)

{

if(tickets > 0)

{

usleep(1000);

printf("who=%s, get a ticket: %d\n", name, tickets); // ?

tickets--;

}//有票的时候才进行抢票

else

break;

}

printf("%s ... quit\n", name);

return nullptr;

}

int main()

{

vector<pthread_t> tids//存储多线程的id信息

vector<threadData *> thread_datas;//传入的参数 类 数组

for (int i = 1; i <= NUM; i++)

{

pthread_t tid;

threadData *td = new threadData(i);//创建对象传入

thread_datas.push_back(td);

pthread_create(&tid, nullptr, getTicket, thread_datas[i - 1]);

tids.push_back(tid);

}

//四个线程同时运行抢票

注意:

对象数组的创建和传入,传入类 类型,因为类具有可扩展性

vector<threadData *> thread_datas;

threadData *td = new threadData(i);//创建对象传入

thread_datas.push_back(td);//对象存储到数组空间中

pthread_create(&tid, nullptr, getTicket, thread_datas[i - 1]);//传入

2. 对于两个vector 回收处理

for (auto thread : tids)

{

pthread_join(thread, nullptr);

}

for (auto td : thread_datas)

{

delete td;

}

return 0;

}

运行发现,存在抢票抢超了,共享数据-->数据不一致问题! 肯定和多线程并发访问是有关系的

首先需要来理解一下 tickets--   为什么不是一个原子操作?

--操作并不是原子的,而是对应三条汇编指令,其中在执行任何一条指令时都有可能被切走

load:将共享变量tickets从内存加载到寄存器中update:更新寄存器里面的值,执行-1操作store:将新值,从寄存器写回共享变量ticket的内存地址

每一步都会对应一条汇编操作

tickets--=>1.mov[XXX]eax 2.-- 3.mov eax[XXX]

图解:

寄存器不等于寄存器的内容,线程在执行的时候,将共享数据,加载到 CPU 寄存器的本质:把数据的内容,变成了自己的上下文,同时自己拷贝了一份数据

拿走数据,拿走上下文,每次通过上下文轮番刷新

对一个全局变量进行多线程并发--/++是否是安全的?(并发情况下,对变量的操作)

不安全

出现负数原因分析 sum

<code> while (true)

{

if(tickets > 0)

{

usleep(1000);

printf("who=%s, get a ticket: %d\n", name, tickets); // ?

tickets--;

}//有票的时候才进行抢票

if语句判断条件为真以后(判断也需要CPU参与),代码可以并发的切换到其他线程,"同一时刻"有多个线程判断tickets时tickets的值是相同的usleep用于模拟漫长业务的过程,在这个漫长的业务过程中,可能有很多个线程会进入该代码段tickets-- 操作本身就不是一个原子操作

每个进程都认为自己是 1,操作完第一步之后就被切走了,我在修改的时候你也修改了,例如:

假设我们有两个线程,它们都在尝试递减全局变量 tickets 的值。如果没有适当的同步机制,可能会发生以下情形:

线程 A线程 B 都检查 tickets 的值是否大于 0线程 A线程 B 都发现 tickets 的值大于 0,因此都会尝试递减 tickets 的值。线程 A 先递减 tickets 的值,例如从 1000 减到 999线程 B 也递减 tickets 的值,但是由于它读取的是原始值 1000,所以也会将 tickets 的值从 1000 减到 999最终结果:尽管两个线程都执行了递减操作,但 tickets 的值只减少了 1 而不是期望的 2

这就是并发造成的

怎么解决??

对共享数据的任何访问,保证任何时候只有一个执行流访问!---互斥,加锁,下篇文章中我们将详细讲解~



声明

本文内容仅代表作者观点,或转载于其他网站,本站不以此文作为商业用途
如有涉及侵权,请联系本站进行删除
转载本站原创文章,请注明来源及作者。