C++——C++11线程库

news2024/11/23 7:15:07

目录

一，线程库简介

二，线程库简单使用

2.1 传函数指针

​编辑 2.2 传lamdba表达式

2.3 简单综合运用

2.4 线程函数参数

三，线程安全问题

3.1 为什么会有这个问题？

3.2 锁

3.2.1 互斥锁

3.2.2 递归锁

3.3 原子操作

3.3.1 原子操作变量

3.3.2 atomic模板

五，lock_guard和unique_lock

5.1 可能发生的情况

5.2 lock_guard

5.3 unique_lock

六，两个线程交替打印，一个打印奇数，一个打印偶数

一，线程库简介

在Linux中我们可以使用用户层的线程接口来实现线程操作，但是Linux下的接口无法在Windows下使用，因为Linux支持了POSIX线程标准，但是Windows没有支持，它搞了一套属于它自己的线程标准。所以在C++11之前，涉及到多线程问题的代码可移植性比较差

所以C++11中最重要的特性就是对线程进行支持了，使得C++在并行编程时不需要依赖第三方库，而且在原子操作中还引入了原子类得概念。

C++，Linux和Windows下都可以支持多线程程序 -- 条件编译
#ifdef _WIN32
	CreateThread...
#else
    pthread_create...
#endif

下面是C++中常用的线程函数的介绍：

①thread()：构造一个线程对象，没有关联任何线程函数，即没有启动任何线程

②thread(fn, args1, args2...)：构造一个线程对象，并使其关联函数fn，args是fn线程函数的参数

③get_id：获取线程id

④join()：类似malloc或new之后需要手动free或者delete，join被调用后会阻塞主先，当该线程结束后，主线程继续执行

⑤detach()：一般在创建线程对象后马上调用，用于把创建出来的线程与线程对象分离开，分离后的线程变为后台线程，在这之后后台线程就与主线程无关

二，线程库简单使用

线程函数一般情况下可以按照三种方式提供：①函数指针  ②lamdba表达式 ③函数对象

2.1 传函数指针

先来个最简单的线程使用，如下代码：

void Func(int n, int num)
{
	for (int i = 0; i < n; i++)
	{
		cout <<num<<":" << i << endl;
	}
	cout << endl;
}

void main()
{
	thread t1(Func, 10, 1);
	thread t2(Func, 20, 2);
	
	t1.join();
	t2.join();
}

注：由于是多线程同时运行，所以打印结果会比较乱，属于正常情况！

 2.2 传lamdba表达式

我们还可以直接用lamdba表达式传给线程，如下代码：

void main()
{
	int n1, n2;
	cin >> n1 >> n2;
	thread t1([n1](int num)
		{
			for (int i = 0; i < n1; i++)
			{
				cout << num << ":" << i << endl;
			}
			cout << endl;
		}, 1);

	thread t2([n1](int num)
		{
			for (int i = 0; i < n1; i++)
			{
				cout << num << ":" << i << endl;
			}
			cout << endl;
		}, 2);

	t1.join();
	t2.join();
}

2.3 简单综合运用

但是单独用lamdba表达式传过去的话，代码会重复，所以也可以用循环把多个线程放进数组里，如下代码：

void main()
{
	int m;
	cin >> m;
	//要求m个线程分别打印n
	vector<thread> vthds(m);//把线程作为一个对象放到容器里去
	size_t n;
	for (size_t i = 0; i<m; i++)
	{
		size_t n = 10;
		vthds[i] = thread([i, n]() {
			for (int j = 0; j < n; j++)
			{
				cout << this_thread::get_id() << ":" << j << endl; //用this_thread命名空间打印线程id
				this_thread::sleep_for(chrono::seconds(1)); //每打印一次休眠一秒
			}
			cout << endl;
			});
		//cout << vthds[i].get_id() << endl;
	}

	for (auto& t : vthds) //库线程禁掉了拷贝赋值，所以这里用引用
	{
		t.join();
	}
	
}

2.4 线程函数参数

线程函数的参数是以值拷贝的方式拷贝到线程栈空间中的，因此，即使线程参数为引用类型，在线程中修改后也不能修改外部实参，因为其实际引用的是线程栈中的拷贝，而不是外部实参

void ThreadFunc1(int& x)
{
 x += 10;
}
void ThreadFunc2(int* x)
{
 *x += 10;
}
int main()
{
 int a = 10;
 // 在线程函数中对a修改，不会影响外部实参，因为：线程函数参数虽然是引用方式，但其实际
引用的是线程栈中的拷贝
 thread t1(ThreadFunc1, a);
 t1.join();
 cout << a << endl;

 // 如果想要通过形参改变外部实参时，必须借助std::ref()函数
 thread t2(ThreadFunc1, std::ref(a);
 t2.join();
 cout << a << endl;

 // 地址的拷贝
 thread t3(ThreadFunc2, &a);
 t3.join();
 cout << a << endl;

 return 0;
}

三，线程安全问题

3.1 为什么会有这个问题？

先看下面代码：

unsigned long sum = 0;

void fun(size_t num)
{
 for (size_t i = 0; i < num; ++i)
 sum++;
}
int main()
{
 cout << "Before joining,sum = " << sum << std::endl;
 thread t1(fun, 10000000);
 thread t2(fun, 10000000);
 t1.join();
 t2.join();
 cout << "After joining,sum = " << sum << std::endl;
 return 0;
}

 从上面的运行结果可以看出，两个线程都对一个全局变量进行相加时，结果与我们预期的不同。

多线程最主要的问题就是访问临界资源带来的线程安全问题，如果所有临界资源都是只读的，那就是线程安全的，因为数据不会被修改，但是当一个或多个线程要修改临界资源时，如果没有对临界资源给予相关的保护措施，比如++，那么就是线程不安全的，因为我们说一条汇编语句是原子的，但是++等操作经过编译器编译后会编程三条汇编语句，那么++操作就不是原子的，具体的底层细节我们到linux系统编程部分再讲。

3.2 锁

关于锁的概念我们到Linux系统编程再进行讲解，这里只展示用法：

3.2.1 互斥锁

list<int> lt;
int x = 0;
mutex mtx;
void Func2(int n)
{
	//并行
	for (int i = 0; i < n; i++)
	{
		mtx.lock(); 
		++x;
		lt.push_back(x);
		mtx.unlock();

		cout << i << endl;
		cout << i << endl;
		cout << i << endl;
	}

	//串行 --> 如果我们只是++，没有push_back等其他操作时，可以看出并行并不比串行快，并行会有大量的加锁和解锁，而且由于计算太快了，还有切换线程的切换上下文的消耗
	//但是当我们++后再push_back插到链表后，还是并行快，而且随着多临界资源的访问消耗变大时，并行的优势更大
	/*mtx1.lock(); 
	for (int i = 0; i < n; i++)
	{
		++x;
		lt.push_back(x);
		cout << i << endl;
		cout << i << endl;
		cout << i << endl;
	}
	mtx1.unlock();*/
}

void main()
{
	int n = 2000000;
	size_t begin = clock();
	thread t1(Func2, 10000); //每个线程都有自己独自的栈，这个栈在共享区中，由库提供
	thread t2(Func2, 20000);

	t1.join();
	t2.join();

	size_t end = clock();
	cout << (end - begin) << endl;
	cout << x << endl;
}

 上面的有点复杂，我们直接传lamdba

void main()
{
	int n = 20000;
	int x = 0;
	mutex mtx1;
	size_t begin = clock();
	thread t1([&, n](){
		mtx.lock();
		for (int i = 0; i < n; i++)
		{
			++x;
		}
		mtx1.unlock();
	});
	thread t2([&, n]() {
		mtx1.lock();
		for (int i = 0; i < n; i++)
		{
			++x;
		}
		mtx1.unlock();
		});

	t1.join();
	t2.join();

	size_t end = clock();
	cout << (end - begin) << endl;
	cout << x << endl;
}

3.2.2 递归锁

recursive_mutex mtx2;
void Func3(int n)
{
	if (n == 0)
		return;
	mtx2.lock();
	++x;
	Func3(n - 1);
	mtx2.unlock(); //当普通锁的解锁在这里定义的时候会造成死锁，递归锁解决在递归场景中的死锁问题
}
void main()
{
	thread t1(Func3, 1000); 
	thread t2(Func3, 1000);

	t1.join();
	t2.join();
	cout << x << endl;
}

3.3 原子操作

虽然加锁可以解决线程安全问题，但是加锁有一个缺陷就是：只要一个线程在对sum++，其他线程就必须阻塞等待，一旦线程很多的情况下就会影响总体的效率，而且如果控制不好容易造成死锁问题。

因此C++11引入了原子操作，也叫无锁操作，需要用到头文件#include<atomic>

(该操作也是用到了一个叫做CAS的同步原语，就是当我写一个数的时候，如果这个数已经改变过了，那我就不写了，如果每改变就写)

3.3.1 原子操作变量

#include <thread>
#include <atomic>

atomic_long sum{ 0 }; //这只是其中一个原子操作变量

void fun(size_t num)
{
 for (size_t i = 0; i < num; ++i)
 sum ++;   // 原子操作
}
int main()
{
 cout << "Before joining, sum = " << sum << std::endl;
 thread t1(fun, 1000000);
 thread t2(fun, 1000000);
 t1.join();
 t2.join();
 
 cout << "After joining, sum = " << sum << std::endl;
 return 0;
}

3.3.2 atomic模板

atmoic<T>  t; //声明一个类型为T的原子类型变量t

 注意：原子类型通常属于“资源型”数据，多个线程只能访问单个原子类型的拷贝，因此在C++11中，原子类型只能从其模板参数中进行改造，不允许原子类型进行拷贝构造，移动构造和operator=等，所以为了防止意外，标准库直接将atomic模板类中的拷贝构造，移动构造，赋值运算符重载全部删除了

#include <atomic>
int main()
{
 atomic<int> a1(0);
 //atomic<int> a2(a1);   // 编译失败
 atomic<int> a2(0);
 //a2 = a1;               // 编译失败
 return 0;
}

下面是atomic模板类的演示代码：

void Func5(int n)
{
	cout << x << endl;
}
void main()
{
	int n = 200;
	//atomic<int> x = 0; 三种写法都一样，都是去调用构造函数
	//atomic<int> x = {0};
	atomic<int> x{ 0 };
	thread t1([&, n]() {
		for (int i = 0; i < n; i++)
		{
			++x;
		}
		});
	thread t2([&, n]() {
		for (int i = 0; i < n; i++)
		{
			++x;
		}
		});
	Func5(x.load());

	t1.join();
	t2.join();
	cout << x << endl;
}

五，lock_guard和unique_lock

5.1 可能发生的情况

在多线程中，如果想要保证临界资源的安全性，可以将其设置为原子类型避免死锁，也可以通过加锁保证一段代码的安全性。但是还有一种情况，那就是如果在加锁和解锁中间抛异常了，那么代码会直接跳到捕获的地方导致无法执行unlock来释放锁。因此，C++11采用RAII的方式对锁进行了封装，即lock_guard和unique_lock

5.2 lock_guard

template<class Lock>
class LockGuard
{
public:
	LockGuard(Lock& lk)
		:_lk(lk)
	{
		_lk.lock();
	}
	~LockGuard()
	{
		_lk.unlock();
	}
private:
	Lock& _lk; //三类成员必须在初始化列表初始化：引用，const和没有默认构造的成员变量
};
void Func4(int n)
{
	for (int i = 0; i < n; i++)
	{
		try
		{
			//把锁交给对象，构造函数时加锁，析构函数解锁 --> RAII
			//mtx.lock();
			//LockGuard<mutex> lock(mtx); // --> 我们自己实现的
			lock_guard<mutex> lock(mtx);  // --> 库里的
			++x;
			//...抛异常
			if (rand() % 3 == 0)
			{
				throw exception("抛异常");
			}
			mtx.unlock();
		}
		catch (const exception& e)
		{
			cout << e.what() << endl;
		}
	}
}
void main()
{
	thread t1(Func4, 100);
	thread t2(Func4, 100);

	t1.join();
	t2.join();
}

 通过上述代码可以看到，lock_guard类模板通过RAII的方式，对其管理的互斥量进行了封装，在需要加锁的地方生成一个lock_guard，调用构造函数自动上锁，然后出作用域时通过析构函数自动解锁

5.3 unique_lock

lock_guard的缺陷：太单一，用户没办法对其进行控制，因此C++11还提供了unique_lock.

unique_lock与lock_guard类似，也是采用RAII进行封装，但是unique_lock对象需要传一个mutex对象作为参数，对传入的锁进行上锁和解锁操作。而且它还提供了更多的成员函数：

①上锁/解锁操作：lock，try_lock，try_lock_for，try_lock_until和unlock

②修改操作：移动赋值，交换（swap：与另一个unique_lock对象交换所管理的互斥量），释放（release：返回它所管理的互斥量的指针，释放所有权）

③获取属性：owns_lock（返回当前对象是否上了锁），operator bool(),mutex（返回当前unique_lock所管理互斥量的指针）

六，两个线程交替打印，一个打印奇数，一个打印偶数

//C++也支持条件变量（不是线程安全的，所以要配合锁使用）
//题目：两个线程交替打印，一个线程打印奇数，一个打印偶数
//condition_variable::wait  当前进程会进行阻塞，直到被唤醒，和linux一样，在阻塞之前会进行解锁，防止死锁问题，然后唤醒后重新申请锁
//文档中的 wait_for和wait_until表示等待的时间，notify_one和notify_all表示唤醒一个线程和唤醒所有线程
#include<condition_variable>
void main39()
{
	condition_variable cv;
	int n = 100;
	int x = 1;

	//如何做到t1和t2不管谁抢到锁都保证t1先运行，t2阻塞 --> t1不等待，t2有等待，这样t1获得了锁，t2就等着，t2获得了锁但是wait，释放锁，t1获得锁
	//如何防止一个线程不断申请锁释放锁，不断运行？（ t1打印的时候，释放锁并且通知t2，t2重新获得锁，但是t1没停下来又等待了，t1又获得了锁） --> t1, if(x%2 == 0) cv.wait(lock);  t2,if (x % 2 != 0) cv.wait(lock);
	//为什么要防止一个线程连续打印？ --> 假设t1，先获取到锁，t2后获取到锁，t2就阻塞在锁上面 --> t1打印奇数，++x，x变成偶数 --> t1 notift唤醒，但是没有线程wait（因为t1有锁，t2没有锁所以在阻塞等待） --> t1解锁，t1时间片到了，切出去了 
	// --> t2获取到锁，打印，notify，但是没有线程等待，t2再出作用域，解锁 --> t2的时间片充裕会比t1先获得锁，所以如果没有条件控制，就会导致t2连续打印
	thread t1([&, n]() {
		while(1)
		{
			unique_lock<mutex> lock(mtx);
			if (x >= 100)
				break;
			//if(x%2 == 0) //奇数
			//	cv.wait(lock);
			cv.wait(lock, [&x]() {return x % 2 != 0; });
			cout << this_thread::get_id() << ":" << x << endl;
			x++;
			cv.notify_one();
		}
	});
	thread t2([&, n]() {
		while(1)
		{
			unique_lock<mutex> lock(mtx);
			if (x > 100)
				break;
			//if (x % 2 != 0) //偶数
			//	cv.wait(lock);
     		cv.wait(lock, [&x](){return x % 2 == 0; });


			cout << this_thread::get_id() << ":" << x << endl;
			++x;
			cv.notify_one();
		}
	});
	t1.join();
	t2.join();
}

unsigned long sum = 0;

void fun(size_t num)
{
	for (size_t i = 0; i < num; ++i)
		sum++;
}
int main()
{
	cout << "Before joining,sum = " << sum << std::endl;
	thread t1(fun, 10000000);
	thread t2(fun, 10000000);
	t1.join();
	t2.join();
	cout << "After joining,sum = " << sum << std::endl;
	return 0;
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1553546.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

Java代码混淆技术的进阶应用与优化策略探讨

Java代码混淆技术的进阶应用与优化策略探讨

摘要 本文探讨了代码混淆在保护Java代码安全性和知识产权方面的重要意义。通过混淆技术&#xff0c;可以有效防止代码被反编译、逆向工程或恶意篡改&#xff0c;提高代码的安全性。常见的Java代码混淆工具如IPAGuard、Allatori、DashO、Zelix KlassMaster和yGuard等&#xff0…
阅读更多...
ERROR: No matching distribution found for tb-nightly

ERROR: No matching distribution found for tb-nightly

问题描述 安装tb-lightly失败&#xff1a;ERROR: No matching distribution found for tb-nightly 解决方案 因为我的镜像源默认是清华的&#xff0c;但是pip源中没有对应的“tb-nightly”依赖包。 如果不知道的&#xff0c;也可以查看一下pip的配置&#xff1a; python -m …
阅读更多...
12.Java语言的发展

12.Java语言的发展

JAVA语言的诞生是具有一定戏剧性的&#xff0c;可以说是命运多舛&#xff0c;差点凉凉&#xff0c;差点GG&#xff0c;差点嗝屁。 在1990年的时候Sun&#xff08;Stanford University Network&#xff1a;斯坦福大学网络&#xff09;公司成立了一个由 James Gosling 领导的Gree…
阅读更多...
2024软件设计师备考讲义——（3）

2024软件设计师备考讲义——（3）

程序设计语言 一、程序语言基础 1.基本概念 低级语言&#xff1a;机器语言、汇编语言高级语言&#xff1a; Fortran 科学计算&#xff0c;执行效率高Pascal 为教学开发&#xff0c;表达能力强Prolog 逻辑性程序设计语言C语言 指针操作能力强&#xff0c;可以开发系统级软件&a…
阅读更多...
【计算机网络】第 9 问：四种信道划分介质访问控制？

【计算机网络】第 9 问：四种信道划分介质访问控制？

目录 正文什么是信道划分介质访问控制&#xff1f;什么是多路复用技术&#xff1f;四种信道划分介质访问控制1. 频分多路复用 FDM2. 时分多路复用 TDM3. 波分多路复用 WDM4. 码分多路复用 CDM 正文 什么是信道划分介质访问控制&#xff1f; 信道划分介质访问控制&#xff08;…
阅读更多...
Go语言学习Day6：数组与切片

Go语言学习Day6：数组与切片

名人说&#xff1a;莫愁千里路&#xff0c;自有到来风。 ——钱珝 创作者&#xff1a;Code_流苏(CSDN)&#xff08;一个喜欢古诗词和编程的Coder&#x1f60a;&#xff09; 目录 1. 数组① 什么是数组② 数组的声明③ 初始化数组的几种方式④ 遍历数组元素⑤ 数组为值类型⑥ 数…
阅读更多...
深入理解Vue 3.0中Async/Await 语法

深入理解Vue 3.0中Async/Await 语法

引言 在 JavaScript 中&#xff0c;异步操作一直是一个挑战&#xff0c;因为它们通常涉及回调函数的嵌套和复杂的 Promise 链式调用。为了解决这些问题&#xff0c;ES8 引入了 Async/Await 语法&#xff0c;它提供了一种更简洁、易读的方式来处理异步操作。 Async/Await 主要…
阅读更多...
使用mysql官网软件包安装mysql

使用mysql官网软件包安装mysql

确定你的操作系统&#xff0c;我的是Centos myqsl 所有安装包的地址&#xff1a;https://repo.mysql.com/yum/ 如果你是使用rpm安装你可以到对应的版本里面找到对应的包。 mysql 发行包的地址&#xff1a;http://repo.mysql.com/ 在这里你可以找到对应的发布包安装。 这里使用y…
阅读更多...
【3DsMax+Pt】练习案例

【3DsMax+Pt】练习案例

目录 一、在3DsMax中展UV 二、在Substance 3D Painter中绘制贴图 一、在3DsMax中展UV 1. 首先创建如下模型 2. 选中如下三条边线作为接缝 重置剥 发现如下部分还没有展开 再选一条边作为接缝 再次拨开 拨开后的UV如下 二、在Substance 3D Painter中绘制贴图 1. 新建项目&am…
阅读更多...
MIPI RFFE接口

MIPI RFFE接口

1. 概况 MIPI RFFE是一种专门针对当前及未来无线系统在射频(RF)前端控制界面规范。随着手机射频系统日趋复杂&#xff0c;业界需要一个单一控制界面解决方案。MIPI联盟的RF前端控制界面(RFFE)规范通过提供一个可连接到收发器或无线电的总线界面解决了这一难题&#xff0c;可用于…
阅读更多...
【机器学习】数据探索(Data Exploration)---数据质量和数据特征分析

【机器学习】数据探索(Data Exploration)---数据质量和数据特征分析

一、引言 在机器学习项目中&#xff0c;数据探索是至关重要的一步。它不仅是模型构建的基础&#xff0c;还是确保模型性能稳定、预测准确的关键。数据探索的过程中&#xff0c;数据质量和数据特征分析占据了核心地位。数据质量直接关系到模型能否从数据中提取有效信息&#xff…
阅读更多...
分布式部署LNMP+WordPress

分布式部署LNMP+WordPress

需要四台虚拟机&#xff0c;实际上&#xff0c;我们只需要操作三台 一个数据库&#xff0c;一个nginx&#xff0c;一个php&#xff0c;还需要准备一个软件包wordpress-4.7.3-zh_C 首先配置nginx的服务环境 [rootnginx ~]# vi /usr/local/nginx/conf/nginx.conf 修改文件中的loc…
阅读更多...
1.8 python 模块 time、random、string、hashlib、os、re、json

1.8 python 模块 time、random、string、hashlib、os、re、json

ython之模块 一、模块的介绍 &#xff08;1&#xff09;python模块&#xff0c;是一个python文件&#xff0c;以一个.py文件&#xff0c;包含了python对象定义和pyhton语句 &#xff08;2&#xff09;python对象定义和python语句 &#xff08;3&#xff09;模块让你能够有逻辑地…
阅读更多...
从零开始的软件开发实战：互联网医院APP搭建详解

从零开始的软件开发实战：互联网医院APP搭建详解

今天&#xff0c;笔者将以“从零开始的软件开发实战&#xff1a;互联网医院APP搭建详解”为主题&#xff0c;深入探讨互联网医院APP的开发过程和关键技术。 第一步&#xff1a;需求分析和规划 互联网医院APP的主要功能包括在线挂号、医生预约、医疗咨询、健康档案管理等。我们…
阅读更多...
Elasticsearch 向量搜索

Elasticsearch 向量搜索

目标记录 ["你好&#xff0c;我的爱人","你好&#xff0c;我的爱妻","你好&#xff0c;我的病人","世界真美丽"] 搜索词 爱人 预期返回 ["你好&#xff0c;我的爱人","你好&#xff0c;我的爱妻"] 示例代码…
阅读更多...
企业微信知识库：从了解到搭建的全流程

企业微信知识库：从了解到搭建的全流程

你是否也有这样的疑惑&#xff1a;为什么现在的企业都爱创建企业微信知识库&#xff1f;企业微信知识库到底有什么用&#xff1f;如果想要使用企业微信知识库企业应该如何创建&#xff1f;这就是我今天要探讨的问题&#xff0c;感兴趣的话一起往下看吧&#xff01; | 为什么企业…
阅读更多...
踏入网页抓取的旅程：使用 grequests 构建 Go 视频下载器

踏入网页抓取的旅程：使用 grequests 构建 Go 视频下载器

引言 在当今数字化的世界中&#xff0c;网页抓取技术变得越来越重要。无论是获取数据、分析信息&#xff0c;还是构建自定义应用程序&#xff0c;我们都需要从互联网上抓取数据。本文将介绍如何使用 Go 编程语言和 grequests 库来构建一个简单的 Bilibili 视频下载器&#xff…
阅读更多...
小米汽车正式发布：开启智能电动新篇章

小米汽车正式发布：开启智能电动新篇章

随着科技的不断进步&#xff0c;汽车产业正经历着前所未有的变革。智能电动汽车作为这一变革的重要方向&#xff0c;正吸引着越来越多的目光。在这个充满机遇和挑战的时代&#xff0c;小米汽车凭借其卓越的技术实力和深厚的市场底蕴&#xff0c;终于迈出了坚实的一步。今天&…
阅读更多...
FSV13罗德与施瓦茨FSV13频谱分析仪

FSV13罗德与施瓦茨FSV13频谱分析仪

181/2461/8938产品概述&#xff1a; 罗德与施瓦茨 FSV13 是一款速度极快且多功能的信号和频谱分析仪&#xff0c;适用于从事射频系统开发、生产、安装和维修工作的注重性能、注重成本的用户。 在开发应用中&#xff0c;罗德与施瓦茨 FSV13 凭借其出色的射频特性、同类产品中无…
阅读更多...
论文笔记：分层问题-图像共注意力问答

论文笔记：分层问题-图像共注意力问答

整理了2017 Hierarchical Question-Image Co-Attention for Visual Question Answering&#xff09;论文的阅读笔记 背景模型问题定义模型结构平行共注意力交替共注意力 实验可视化 背景 视觉问答(VQA)的注意力模型在此之前已经有了很多工作&#xff0c;这种模型生成了突出显示…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023