C++第四十六弹---解锁多线程编程的奥秘：＜thread＞库深入探索

news2024/9/25 13:25:45

 ✨个人主页： 熬夜学编程的小林

💗系列专栏： 【C语言详解】 【数据结构详解】【C++详解】

目录

1 线程库

1.1 thread类的简单介绍

1.2 线程函数参数

1.3 原子性操作库(atomic)

1.4 lock_guard与unique_lock

1.4.1 mutex的种类

1.4.2 lock_guard

1.4.3 unique_lock

1.5 支持两个线程交替打印，一个打印奇数，一个打印偶数

1 线程库


1.1 thread类的简单介绍


在C++11之前，涉及到多线程问题，都是和平台相关的，比如windows和linux下各有自己的接口，这使得代码的可移植性比较差。C++11中最重要的特性就是对线程进行支持了，使得C++在并行编程时不需要依赖第三方库，而且在原子操作中还引入了原子类的概念。要使用标准库中的线程，必须包含< thread >头文件。

C++11 线程类icon-default.png?t=O83Ahttps://cplusplus.com/reference/thread/thread/

函数名功能
thread()构造一个线程对象，没有关联任何线程函数，即没有启动任何线程
thread(fn,
args1, args2,
...)		构造一个线程对象，并关联线程函数fn，args1，args2，...为线程函数的
参数
get_id()获取线程id
joinable()线程是否还在执行，joinable代表的是一个正在执行中的线程。
join()该函数调用后会阻塞住线程，当该线程结束后，主线程继续执行
detach()在创建线程对象后马上调用，用于把被创建线程与线程对象分离开，分离
的线程变为后台线程，创建的线程的"死活"就与主线程无关

注意：
1. 线程是操作系统中的一个概念，线程对象可以关联一个线程，用来控制线程以及获取线程的
状态。
2. 当创建一个线程对象后，没有提供线程函数，该对象实际没有对应任何线程。

代码演示

#include<iostream>
#include<thread>
using namespace std;

int main()
{
	std::thread t1;
	cout << t1.get_id() << endl;
	return 0;
}

运行结果 

get_id()的返回值类型为id类型，id类型实际为std::thread命名空间下封装的一个类，该类中包含了一个结构体：

// vs下查看
typedef struct
{
    /* thread identifier for Win32 */
    void *_Hnd; /* Win32 HANDLE */
    unsigned int _Id;
} _Thrd_imp_t;

3. 当创建一个线程对象后，并且给线程关联线程函数，该线程就被启动，与主线程一起运行。
线程函数一般情况下可按照以下三种方式提供：

  • 函数指针
  • lambda表达式
  • 函数对象

代码演示

#include<iostream>
#include<thread>
using namespace std;

void ThreadFunc(int a)
{
	cout << "Thread1->" << a << endl;
}
class TF
{
public:
	void operator()()
	{
		cout << "Thread3" << endl;
	}
};
int main()
{
	// 线程函数为函数指针
	thread t1(ThreadFunc, 10);

	// 线程函数为lambda表达式
	thread t2([] {cout << "Thread2" << endl; });

	// 线程函数为函数对象
	TF tf;
	thread t3(tf);

	t1.join();// 阻塞线程
	t2.join();
	t3.join();
	cout << "Main thread!" << endl;
	return 0;
}

运行结果 

4. thread类是防拷贝的，不允许拷贝构造以及赋值，但是可以移动构造和移动赋值，即将一个线程对象关联线程的状态转移给其他线程对象，转移期间不意向线程的执行。
5. 可以通过joinable()函数判断线程是否是有效的，如果是以下任意情况，则线程无效 

  • 采用无参构造函数构造的线程对象
  • 线程对象的状态已经转移给其他线程对象
  • 线程已经调用join或者detach结束

1.2 线程函数参数


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

代码演示 

#include<iostream>
#include<thread>
using namespace std;
void ThreadFunc1(int& x)
{
	x += 10;
}
void ThreadFunc2(int* x)
{
	*x += 10;
}
int main()
{
	int a = 10;
	// 在线程函数中对a修改，不会影响外部实参
	// 因为：线程函数参数虽然是引用方式，但其实际引用的是线程栈中的拷贝
	// vs 2022中必须显示传引用std::ref才行
	//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;
}

运行结果 

注意：如果是类成员函数作为线程参数时，必须将this作为线程函数参数。

1.3 原子性操作库(atomic)


多线程最主要的问题是共享数据带来的问题(即线程安全)。如果共享数据都是只读的，那么没问题，因为只读操作不会影响到数据，更不会涉及对数据的修改，所以所有线程都会获得同样的数据。但是，当一个或多个线程要修改共享数据时，就会产生很多潜在的麻烦。比如：

代码演示

#include<iostream>
#include<thread>
using namespace std;
unsigned long sum = 0L;
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;
}

运行结果 

C++98中传统的解决方式：可以对共享修改的数据可以加锁保护。

代码演示

#include<iostream>
#include<thread>
#include<mutex>
using namespace std;

mutex mtx;// 头文件#include<mutex>
unsigned long sum = 0L;
void fun(size_t num)
{
	mtx.lock();// 上锁
	for (size_t i = 0; i < num; ++i)
	{
		sum++;
	}
	mtx.unlock();// 解锁
}
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;
}

运行结果 

虽然加锁可以解决，但是加锁有一个缺陷就是：只要一个线程在对sum++时，其他线程就会被阻
塞，会影响程序运行的效率，而且锁如果控制不好，还容易造成死锁。

因此C++11中引入了原子操作。所谓原子操作：即不可被中断的一个或一系列操作，C++11引入
的原子操作类型，使得线程间数据的同步变得非常高效。

 注意：需要使用以上原子操作变量时，必须添加头文件<atomic>

代码演示

#include<iostream>
#include<thread>
#include<atomic>
using namespace std;

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;
}

运行结果 

在C++11中，程序员不需要对原子类型变量进行加锁解锁操作，线程能够对原子类型变量互斥的
访问。更为普遍的，程序员可以使用atomic类模板，定义出需要的任意原子类型。 

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

注意：原子类型通常属于"资源型"数据，多个线程只能访问单个原子类型的拷贝，因此在C++11
中，原子类型只能从其模板参数中进行构造，不允许原子类型进行拷贝构造、移动构造以及
operator=等，为了防止意外，标准库已经将atmoic模板类中的拷贝构造、移动构造、赋值运算
符重载默认删除掉了。

#include<iostream>
#include<atomic>
using namespace std;
int main()
{
	atomic<int> a1(0);
	//atomic<int> a2(a1);    // 拷贝构造编译失败
	atomic<int> a2(0);
	//a2 = a1;               // 赋值重载编译失败
	return 0;
}

1.4 lock_guard与unique_lock


在多线程环境下，如果想要保证某个变量的安全性，只要将其设置成对应的原子类型即可，即高效又不容易出现死锁问题。但是有些情况下，我们可能需要保证一段代码的安全性，那么就只能通过锁的方式来进行控制。
比如：一个线程对变量number进行加一100次，另外一个减一100次，每次操作加一或者减一之
后，输出number的结果，要求：number最后的值为0。

代码演示

#include<iostream>
#include<thread>
using namespace std;
int number = 0;
mutex g_lock;
int ThreadProc1()
{
	g_lock.lock();
	for (int i = 0; i < 100; i++)
	{
		++number;
		cout << "thread 1 :" << number << endl;
	}
	g_lock.unlock();
	return 0;
}
int ThreadProc2()
{
	g_lock.lock();
	for (int i = 0; i < 100; i++)
	{
		--number;
		cout << "thread 2 :" << number << endl;
	}
	g_lock.unlock();
	return 0;
}
int main()
{
	thread t1(ThreadProc1);
	thread t2(ThreadProc2);
	t1.join();
	t2.join();
	cout << "number:" << number << endl;
	system("pause");
	return 0;
}

运行结果  

上述代码的缺陷：锁控制不好时，可能会造成死锁，最常见的比如在锁中间代码返回，或者在锁的范围内抛异常。因此：C++11采用RAII的方式对锁进行了封装，即lock_guard和unique_lock。

class LockGuard
{
public:
	// 不支持拷贝构造，因此需要将成员变量设为引用变量
	// 构造上锁
	LockGuard(mutex& mtx)
		:_mtx(mtx)
	{
		_mtx.lock();
	}
	~LockGuard()
	{
		_mtx.unlock();
	}
private:
	mutex& _mtx;
};

1.4.1 mutex的种类


在C++11中，Mutex总共包了四个互斥量的种类：

1. std::mutex
C++11提供的最基本的互斥量，该类的对象之间不能拷贝，也不能进行移动。mutex最常用的三个函数：

函数名函数功能
lock()上锁：锁住互斥量
unlock()解锁：释放对互斥量的所有权
try_lock()尝试锁住互斥量，如果互斥量被其他线程占有，则当前线程也不会被阻塞

注意，线程函数调用lock()时，可能会发生以下三种情况：
如果该互斥量当前没有被锁住，则调用线程将该互斥量锁住，直到调用 unlock之前，

  • 该线程一直拥有该锁
  • 如果当前互斥量被其他线程锁住，则当前的调用线程被阻塞住
  • 如果当前互斥量被当前调用线程锁住，则会产生死锁(deadlock)

线程函数调用try_lock()时，可能会发生以下三种情况：

  • 如果当前互斥量没有被其他线程占有，则该线程锁住互斥量，直到该线程调用 unlock释放互斥量
  • 如果当前互斥量被其他线程锁住，则当前调用线程返回 false，而并不会被阻塞掉
  • 如果当前互斥量被当前调用线程锁住，则会产生死锁(deadlock)

2. std::recursive_mutex

其允许同一个线程对互斥量多次上锁（即递归上锁），来获得对互斥量对象的多层所有权，释放互斥量时需要调用与该锁层次深度相同次数的 unlock()，除此之外，std::recursive_mutex 的特性和 std::mutex 大致相同。


3. std::timed_mutex

比 std::mutex 多了两个成员函数，try_lock_for()，try_lock_until() 。

  • try_lock_for()

                接受一个时间范围，表示在这一段时间范围之内线程如果没有获得锁则被阻塞住（与std::mutex 的 try_lock() 不同，try_lock 如果被调用时没有获得锁则直接返回false），如果在此期间其他线程释放了锁，则该线程可以获得对互斥量的锁，如果超时（即在指定时间内还是没有获得锁），则返回 false。

  • try_lock_until()

                接受一个时间点作为参数，在指定时间点未到来之前线程如果没有获得锁则被阻塞住，如果在此期间其他线程释放了锁，则该线程可以获得对互斥量的锁，如果超时（即在指定时间内还是没有获得锁），则返回 false。


4. std::recursive_timed_mutex

1.4.2 lock_guard


std::lock_gurad 是 C++11 中定义的模板类。定义如下：

template<class _Mutex>
class lock_guard
{
public:
	// 在构造lock_gard时，_Mtx还没有被上锁
	explicit lock_guard(_Mutex& _Mtx)
		: _MyMutex(_Mtx)
	{
		_MyMutex.lock();
	}
	// 在构造lock_gard时，_Mtx已经被上锁，此处不需要再上锁
	lock_guard(_Mutex& _Mtx, adopt_lock_t)
		: _MyMutex(_Mtx)
	{}
	~lock_guard() _NOEXCEPT
	{
		_MyMutex.unlock();
	}
	lock_guard(const lock_guard&) = delete;
	lock_guard& operator=(const lock_guard&) = delete;
private:
	_Mutex& _MyMutex;
};

通过上述代码可以看到，lock_guard类模板主要是通过RAII的方式，对其管理的互斥量进行了封
装，在需要加锁的地方，只需要用上述介绍的任意互斥体实例化一个lock_guard，调用构造函数
成功上锁，出作用域前，lock_guard对象要被销毁，调用析构函数自动解锁，可以有效避免死锁
问题。
lock_guard的缺陷：太单一，用户没有办法对该锁进行控制，因此C++11又提供了unique_lock。

1.4.3 unique_lock

与lock_gard类似，unique_lock类模板也是采用RAII的方式对锁进行了封装，并且也是以独占所有权的方式管理mutex对象的上锁和解锁操作，即其对象之间不能发生拷贝。在构造(或移动(move)赋值)时，unique_lock 对象需要传递一个 Mutex 对象作为它的参数，新创建的unique_lock 对象负责传入的 Mutex 对象的上锁和解锁操作。使用以上类型互斥量实例化unique_lock的对象时，自动调用构造函数上锁，unique_lock对象销毁时自动调用析构函数解锁，可以很方便的防止死锁问题。
与lock_guard不同的是，unique_lock更加的灵活，提供了更多的成员函数：

  • 上锁/解锁操作：lock、try_lock、try_lock_for、try_lock_until和unlock
  • 修改操作：移动赋值、交换(swap：与另一个unique_lock对象互换所管理的互斥量所有权)、释放(release：返回它所管理的互斥量对象的指针，并释放所有权)
  • 获取属性：owns_lock(返回当前对象是否上了锁)、operator bool()(与owns_lock()的功能相同)、mutex(返回当前unique_lock所管理的互斥量的指针)。

1.5 支持两个线程交替打印，一个打印奇数，一个打印偶数


本节主要演示了condition_variable的使用，condition_variable熟悉我们linux课程已经讲过了，他们用来进行线程之间的互相通知。condition_variable和Linux posix的条件变量并没有什么大的区别，主要还是面向对象实现的。

代码演示

#include<iostream>
#include<thread>
#include<mutex>
#include<condition_variable>
using namespace std;

// 两个线程交替打印，一个打印奇数，一个打印偶数
// [0 - n)
int main()
{
	mutex mtx;
	condition_variable c;
	int n = 100;
	bool flag = true;

	// 保证第一个打印的是0，不管是什么顺序
	thread t1([&]() {
		int i = 0;
		while (i < n)
		{
			unique_lock<mutex> lock(mtx);
			// flag == true 不会阻塞
			// flag == false 一直阻塞
			while (!flag)
				c.wait(lock);
			
			cout << i << endl;

			flag = false;
			i += 2;

			// 唤醒线程
			c.notify_one();
		}
		});
	// 休眠1秒
	this_thread::sleep_for(std::chrono::milliseconds(1000));

	thread t2([&]() {
		int j = 1;
		while (j < n)
		{
			unique_lock<mutex> lock(mtx);

			// flag == true 一直阻塞
			// flag == false 不会阻塞
			while (flag)
				c.wait(lock);

			cout << j << endl;

			flag = true;
			j += 2;

			// 唤醒线程
			c.notify_one();
		}
		});

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

	return 0;
}

运行结果 

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

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

相关文章

python-小理的三角形

python-小理的三角形

题目描述 小理有一个数组长度大小为 n &#xff0c;数组中有 n 个正整数。 现在小理请你从其中选出三个元素&#xff08;注意选择元素的下标不能相同&#xff0c;但是其值可以相同&#xff09;组成一个三角形。 无法做到&#xff0c;请输出一行一个字符串"No solution&quo…
阅读更多...
SQL进阶技巧：每年在校人数统计 | 区间重叠问题

SQL进阶技巧：每年在校人数统计 | 区间重叠问题

目录 0 问题分析 1 数据准备 2 问题分析 3 小结 区间重叠问题 0 问题分析 有一个录取学生人数表 in_school_stu&#xff0c;记录的是每年录取学生的人数及录取学生的学制&#xff0c;计算每年在校学生人数。 1 数据准备 create table in_school_stu as ( select stack(5,…
阅读更多...
【平渊网络】副业项目拆解：视频借鉴式搬运项目 | 搞笑视频跨平台 “借鉴式” 搬运项目思路 | 抖音防查重机制基础

【平渊网络】副业项目拆解：视频借鉴式搬运项目 | 搞笑视频跨平台 “借鉴式” 搬运项目思路 | 抖音防查重机制基础

目录 项目介绍 实操&#xff1a;账号准备 素材制作教学 防查重机制基础 项目介绍 只分享实操干货&#xff0c;不浪费时间。如果你没有2台手机&#xff0c;或者手机不支持分身就不用往下读了&#xff0c;这个项目大概率是做不出流量的。 项目是情感聊天对话的变种&#xff…
阅读更多...
C++ DLL DEMO

C++ DLL DEMO

头文件dlltest.h #pragma once #include "pch.h" #include <iostream> #include <fstream> #include <iomanip> #include <string> #include <bitset>extern "C" __declspec(dllexport) void debugService(uint32_t debugF…
阅读更多...
【全网最全】2024年数学建模国赛B题31页完整建模过程+成品论文+matlab/python代码等（后续会更新

【全网最全】2024年数学建模国赛B题31页完整建模过程+成品论文+matlab/python代码等（后续会更新

您的点赞收藏是我继续更新的最大动力&#xff01; 一定要点击如下的卡片&#xff0c;那是获取资料的入口&#xff01; 2024数学建模国赛B题 【全网最全】2024年数学建模国赛B题31页完整建模过程成品论文matlab/python代码等&#xff08;后续会更新「首先来看看目前已有的资料…
阅读更多...
【计算机图形学】《五讲速通CG重点》第三讲-Rendering

【计算机图形学】《五讲速通CG重点》第三讲-Rendering

如果这篇文章对你有帮助&#xff0c;欢迎点赞与收藏~ 目录 Rasterization 1 Points 2 Line 2.1 DDA&#xff08;差分&#xff09; 2.2 Bresenham’s algorithm: 2.3 Mid-point algorithm (0-45) 3 Triangles 4 Polygon 5 Triangulation 6 Interpolation 7 Anti-alia…
阅读更多...
运动耳机哪个牌子的好？五大选购技巧助你轻松购买

运动耳机哪个牌子的好？五大选购技巧助你轻松购买

作为一名专注运动装备的测评专家&#xff0c;我曾深入体验了多款骨传导耳机&#xff0c;发现市场上不少品牌并未如广告所宣称的那般出色&#xff0c;部分低质或不专业的骨传导耳机在使用时不仅舒适度欠佳&#xff0c;还可能因设计缺陷导致声音泄露严重&#xff0c;非常影响使用…
阅读更多...
共赢算力未来，华宇TAS应用中间件获“鲲鹏原生开发认证”

共赢算力未来，华宇TAS应用中间件获“鲲鹏原生开发认证”

9月2日&#xff0c;华为在北京中关村国家自主创新示范区会议中心举办了以“鲲鹏原生&#xff0c;力算未来”为主题的鲲鹏原生开发伙伴圈层活动&#xff0c;旨在聚集鲲鹏生态合作伙伴&#xff0c;搭建交流平台&#xff0c;加强产业圈各方紧密合作&#xff0c;抓住产业机遇&#…
阅读更多...
Canvas艺术之旅：了解几个绘制基本图形的 API

Canvas艺术之旅：了解几个绘制基本图形的 API

了解几个绘制基本图形的 API Canvas 是 HTML5 提供的绘画 API&#xff0c;可以用于在 Web 页面上绘制各种基本图形。本文介绍一些 Canvas 绘制基本图形的 API&#xff1a; 前置条件 注意&#xff1a;本文章所提供的代码示例默认已经进行了 canvas 元素定义&#xff0c;DOM 获…
阅读更多...
Java项目: 基于SpringBoot+mybatis+maven+mysql教师工作量管理系统(含源码+数据库+毕业论文)

Java项目: 基于SpringBoot+mybatis+maven+mysql教师工作量管理系统(含源码+数据库+毕业论文)

一、项目简介 本项目是一套基于SpringBootmybatismavenmysql教师工作量管理系统 包含&#xff1a;项目源码、数据库脚本等&#xff0c;该项目附带全部源码可作为毕设使用。 项目都经过严格调试&#xff0c;eclipse或者idea 确保可以运行&#xff01; 该系统功能完善、界面美观…
阅读更多...
日志框架log4j打印异常堆栈信息携带traceId，方便接口异常排查

日志框架log4j打印异常堆栈信息携带traceId，方便接口异常排查

一、异常堆栈无traceId 排查定位问题异常痛苦 在日常项目开发中&#xff0c;我们会自定义一个traceId方便&#xff0c;链路追踪。在log4j2.xml 我们可能是这样去配置日志打印格式。 <Console name"CONSOLE" target"SYSTEM_OUT"><PatternLayoutpa…
阅读更多...
python学习第六节：使用python制作九九乘法表和学生管理系统

python学习第六节：使用python制作九九乘法表和学生管理系统

python学习第六节&#xff1a;使用python制作九九乘法表和学生管理系统 通过前面五节的了解&#xff0c;已经大概知道python的语法以及基础函数&#xff0c;下面是简单的两个小程序。不会做没关系&#xff0c;看得懂就可以了&#xff0c;如果能够自己加工举一反三那就更好了。 …
阅读更多...
计算机网络 TCP/IP协议篇

计算机网络 TCP/IP协议篇

今天学习了TCP/IP协议的相关知识&#xff0c;学习笔记如下&#xff1a; 在学习之前&#xff0c;我们先抛出几个问题&#xff0c;什么是TCP/IP协议簇&#xff1f;TCP/IP协议簇是怎么工作的&#xff1f; TCP/IP模型 协议分层 每层通过协议完成各自特定的功能上层依赖下层提供…
阅读更多...
智能对决：提示词攻防中的AI安全博弈

智能对决：提示词攻防中的AI安全博弈

智能对决&#xff1a;提示词攻防中的AI安全博弈 在2024年上海AIGC开发者大会上&#xff0c;知名提示词爱好者工程师云中嘉树发表了关于AI提示词攻防与安全博弈的精彩演讲。他深入探讨了当前AI产品的安全现状&#xff0c;提示词攻击的常见手段及其应对策略。本文将对他的演讲进…
阅读更多...
【每日一题】LeetCode 84.柱状图中最大的矩形（栈、数组、单调栈）

【每日一题】LeetCode 84.柱状图中最大的矩形（栈、数组、单调栈）

【每日一题】LeetCode 84.柱状图中最大的矩形&#xff08;栈、数组、单调栈&#xff09; 题目描述 给定 n 个非负整数&#xff0c;用来表示柱状图中各个柱子的高度。每个柱子彼此相邻&#xff0c;且宽度为 1 。求在该柱状图中&#xff0c;能够勾勒出来的矩形的最大面积。 这…
阅读更多...
Linux小程序：进度条

Linux小程序：进度条

目录 一、换行与回车 二、缓冲区 三、倒计时代码 四、进度条实现 实现进度条程序&#xff0c;首先需要两个预备知识&#xff1a; 1.换行与回车 2.缓存区 一、换行与回车 我们通常使用\n作为换行符&#xff0c;但实际上\n是换行回车两种效果的结合&#xff0c;因此我们需…
阅读更多...
.iso文件怎么打开？

.iso文件怎么打开？

在日常使用电脑的过程中&#xff0c;很多用户都会遇到.iso文件&#xff0c;尤其是在安装软件、操作系统或者备份光盘内容时。那么&#xff0c;什么是.iso文件&#xff1f;该如何打开它&#xff1f;本文将为大家详细解答这些问题&#xff0c;帮助大家轻松处理.iso文件。 什么是.…
阅读更多...
IEEE TRO 人形机器人遥操作的综述

IEEE TRO 人形机器人遥操作的综述

人形机器人的遥操作结合了人类的认知技能和领域专业知识以及人形机器人的物理能力。这种人形机器人的操作多功能性使它们成为远程环境中各种应用的理想平台。然而&#xff0c;人形机器人的复杂性给遥操作带来了挑战&#xff0c;尤其是在通信受限的非结构化动态环境中。尽管在过…
阅读更多...
【2024国赛B题】高教杯全国大学生数学建模国赛建模过程+完整代码论文全解全析

【2024国赛B题】高教杯全国大学生数学建模国赛建模过程+完整代码论文全解全析

你是否在寻找数学建模比赛的突破点&#xff1f;数学建模进阶思路&#xff01; 作为经验丰富的数学建模团队&#xff0c;我们将为你带来2024国赛数学建模竞赛&#xff08;B题&#xff09;的全面解析。这个解决方案包不仅包括完整的代码实现&#xff0c;还有详尽的建模过程和解析…
阅读更多...
pdf怎么删除其中一页？这5个pdf编辑方法新手都在用，建议收藏

pdf怎么删除其中一页？这5个pdf编辑方法新手都在用，建议收藏

pdf怎么删除其中一页&#xff1f;在日常的工作和学习生活中&#xff0c;我们经常会遇到需要处理PDF文件的情况。有时候&#xff0c;我们在处理PDF文件时&#xff0c;发现某些页面内容不再需要&#xff0c;想从PDF中删除特定的页面。然而&#xff0c;很多小伙伴对PDF的编辑和修改…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023