thread---基本使用和常见错误

多线程基础

一、C++多线程基础

线程概念：线程是操作系统能够调度的最小执行单元，同一进程内的多个线程共享内存空间
头文件：#include <thread>
线程生命周期：创建->执行->销毁（需显式管理）
注意事项：
- 线程函数参数建议使用值传递
- 注意数据竞争问题（需配合互斥锁使用）
- 主线程退出前必须处理所有子线程

二、核心函数详解

1. std::thread()

// 创建线程的三种方式
void func1();
void func2(int num);

// 方式1：普通函数
std::thread t1(func1);

// 方式2：带参数的函数
std::thread t2(func2, 42);

// 方式3：Lambda表达式
std::thread t3([](){
    std::cout << "Lambda thread" << std::endl;
});

特性：

构造函数立即启动线程
参数自动转发给线程函数
必须处理线程对象（join或detach）

2. join()

std::thread t(func);
t.join(); // 阻塞当前线程，直到t执行完成

特点：

同步线程执行顺序
每个线程对象只能调用一次
调用后线程对象不再关联实际线程

3. joinable()

if(t.joinable()) {
    t.join(); // 或t.detach()
}

判断条件：

线程已被创建（关联实际系统线程），正在进行的线程返回true
尚未被join或detach

4. detach()

std::thread t(func);
t.detach(); // 分离线程

特点：

线程在后台独立运行（守护线程）
失去对线程的直接控制
必须确保线程函数内的资源有效性

三、使用示例

#include <iostream>
#include <thread>

void print_num(int num) {
    std::cout << "Number: " << num << std::endl;
}

int main() {
    std::thread worker(print_num, 42);
    
    if(worker.joinable()) {
        worker.join(); // 或detach()
    }
    
    return 0;
}

线程函数中的数据未定义的错误

1.临时变量导致的传参错误

传递临时变量，临时变量在thread函数结束后销毁，没有传递到func里，导致未定义错误

#include<iostream>
#include<thread>
void func(int& x) {
	x += 1;
}
int main() {
	std::thread t(func, 1); //传递临时变量，临时变量在thread函数结束后销毁，没有传递到func里，导致未定义错误
	t.join();
	return 0;
}

解决方法：创建一个持久变量

#include<iostream>
#include<thread>
void func(int& x) {
	x += 1;
	std::cout << x << " ";
}
int main() {
	int x = 1; //将变量复制到一个持久的对象
	std::thread t(func, std::ref(x));//将变量的引用传递给线程
	t.join();
	return 0;
}

2.传递指针或引用指向局部变量的问题

test函数执行结束，a立刻释放，无法继续传进线程中的func函数中

#include <iostream>
#include<thread>

std::thread t;
void func(int& x) {
	x += 1;
}
void test() {
	int a = 1;
	t = std::thread(func, std::ref(a));
}
int main()
{
	test();
	t.join();
	return 0;
}

解决办法，把a 放到外面，a 变成一直可以被取到的全局变量

#include <iostream>
#include<thread>

std::thread t;
int a = 1;

void func(int& x) {
	x += 1;
}

void test() {
	
	t = std::thread(func, std::ref(a));
}
int main()
{
	test();
	t.join();
	return 0;
}

3. 传递指针或引用指向已释放的内存的问题

指针在传进去之前delete，导致传进去的是空指针（不指向1）

#include<iostream>
#include<thread>

std::thread t;
void func(int* x) {
	std::cout << *x << std::endl;
}

int main() {
	int* ptr = new int(1);
	std::thread t(func, ptr);
	delete ptr;

	t.join();
	return 0;
}

解决办法
取消提前释放即可或使用智能指针

4. 类成员函数作为入口函数，类对象被提前释放

#include<iostream>
#include<thread>
#include<Windows.h>

class A {
public:
	void func() {
		Sleep(1000);
		std::cout << "6" << std::endl;
	}

};

int main() {
	A *a;
	std::thread t(&A::func, a);
	delete a;
	
	t.join();
}

解决办法：使用智能指针

#include<iostream>
#include<thread>
#include<Windows.h>

class A {
public:
	void func() {
		Sleep(1000);
		std::cout << "6" << std::endl;
	}
};

int main() {
	std::shared_ptr<A> a = std::make_shared<A>();//使用智能指针地址一直有效，不会出现提前释放的问题
	std::thread t(&A::func, a);
	
	t.join();
}

5.入口函数为类的私有成员函数

#include<iostream>
#include<thread>
#include<Windows.h>

class A {
private:
	
	void func() {
		Sleep(1000);
		std::cout << "6" << std::endl;
	}
};

void thread_func() {
	std::shared_ptr<A> a = std::make_shared<A>();
	std::thread t(&A::func, a);
	t.join();
}

int main() {
	
	thread_func();
}

解决办法：使用友元函数

#include<iostream>
#include<thread>
#include<Windows.h>

class A {
private:
	friend void thread_func();
	void func() {
		Sleep(1000);
		std::cout << "6" << std::endl;
	}
};

void thread_func() {
	std::shared_ptr<A> a = std::make_shared<A>();
	std::thread t(&A::func, a);
	t.join();
}

int main() {
	
	thread_func();
}