【C++11 —— 线程库】

devtools/2024/9/20 7:27:29/ 标签: c++, 开发语言

C++11 —— 线程库

  • thread类介绍
  • 线程函数参数
  • 原子性操作库(atomic)
  • lock_guard与unique_lock
    • mutex的种类
    • lock_guard
    • unique_lock
  • 两个线程交替打印奇偶数

thread类介绍

在C++11之前，涉及到多线程的问题，都是和平台相关的，比如windows和Linux下各有自己的接口，这使得代码的可移植性比较差。 C++11的线程库提供了对多线程编程的支持，使得程序能够并发执行多个任务。从而不再需要依赖于第三方库，而且在原子操作中引入了原子类的概念。在使用标准库里的线程，必须包含<thread>头文件。主要的组件包括：

  • 线程 (std::thread)
  • 互斥量 (std::mutex)
  • 条件变量 (std::condition_variable)
  • 原子操作 (std::atomic)
  • 未来和承诺 (std::future 和 std::promise)

基本函数：

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

注意：

  1. 线程是操作系统中的一个概念，线程对象可以关联一个线程，用来控制线程以及获取线程的状态。
  2. 当创建一个线程对象后，没有提供线程函数，该对象实际没有对应任何线程。
#include <thread>int main()
{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;
  1. 当创建一个线程对象后，并且给线程关联线程函数，该线程就被启动，与主线程一起运行。
    线程函数一般情况下可按照以下三种方式提供：
    • 函数指针
    • lambda表达式
    • 函数对象
#include <iostream> // 引入输入输出流库
#include <thread>   // 引入线程库using namespace std; // 使用标准命名空间// 线程函数，接受一个整数参数并打印
void ThreadFunc(int a) {cout << "Thread1 -> " << a << endl; // 打印线程1的输出
}// 定义一个类TF，重载了()运算符
class TF {
public:// 当对象被调用时执行的函数void operator()() {cout << "Thread3" << endl; // 打印线程3的输出}
};int main() {// 创建一个线程，传入函数指针和参数10thread t1(ThreadFunc, 10);// 创建一个线程，传入lambda表达式thread t2([]() {cout << "Thread2" << endl; // 打印线程2的输出});// 创建一个TF类的对象TF tf;// 创建一个线程，传入函数对象tfthread t3(tf);	//传入tf对象，该对象的operator()会被自动调用// 等待线程t1完成t1.join();// 等待线程t2完成t2.join();// 等待线程t3完成t3.join();// 打印主线程的输出cout << "main thread ..." << endl;return 0; // 返回0，表示程序正常结束
}

在这里插入图片描述
4. thread类是防拷贝的，不允许拷贝构造以及赋值，但是可以移动构造和移动赋值，即将一个线程对象关联线程的状态转移给其他线程对象，转移期间不影响线程的执行。这种设计确保了每个线程对象只能与一个线程执行关联，避免了潜在的资源竞争和不确定性。

void ThreadFunc(int a)
{cout << "Thread -> " << a << endl;
}int main()
{//创建一个线程对象t1，执行ThreadFunc并传入10thread t1(ThreadFunc, 10);//移动t1到t2thread t2 = move(t1);//检查t1是否可以继续使用if (!t1.joinable()){cout << "t1在move之后不再运行" << endl;}//等待t2完成t2.join();cout << "main thread..." << endl;return 0;
}

在这里插入图片描述

  1. 可以通过 joinable() 函数判断线程是否是有效的，如果是以下任意情况，则线程无效
    • 采用无参构造函数构造的线程对象
    • 线程对象的状态已经转移给其他线程对象
    • 线程已经调用join或者detach结束

并发与并行的区别？

并发 (Concurrency)
并发指的是在同一时间段内处理多个任务。它强调的是任务之间的交替执行，通常在单核处理器上实现。虽然在某一时刻只有一个任务在执行，但系统通过快速切换任务，使得多个任务看起来像是同时进行。例如，当一个程序在等待用户输入时，它可以在后台处理其他任务，这种情况下我们称之为并发。
例子:
想象一个人在吃饭，突然接到电话。他先放下筷子去接电话，然后再继续吃饭。在这个过程中，虽然他不能同时吃饭和接电话，但他能够在同一时间段内处理这两个任务，这就是并发。

并行 (Parallelism)
并行则是指在同一时刻同时执行多个任务。它通常需要多核或多处理器系统来实现，允许多个任务真正同时运行而不互相干扰。例如，在一个四核CPU上，可以同时运行四个不同的程序，每个程序都在独立的核心上执行。
例子
继续以上的例子，如果有两个人坐在同一张桌子上，一个人吃饭，另一个人打电话，他们可以同时进行各自的活动，这就是并行。

线程函数参数

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


void ThreadFunc1(int& x)
{x += 10;
}void ThreadFunc2(int* x)
{*x += 10;
}int main()
{int a = 10;//在线程t1中修改a的值失败，因为虽然线程函数的参数是引用方式，但是实际上传入的是线程栈中的拷贝，并非a本身。/*thread t1(ThreadFunc1, a);		会编译失败t1.join();cout << "a: " << a << endl;cout << "--------------" << endl;*///可以通过传入ref函数来修改a的值thread t2(ThreadFunc1, ref(a));t2.join();cout << "a: " << a << endl;cout << "--------------" << endl;//地址的拷贝thread t3(ThreadFunc2, &a);t3.join();cout << "a: " << a << endl;return 0;
}

在这里插入图片描述

当类成员函数作为线程参数时：

class MyClass
{
public:void memberFunction(int value){cout << "Value: " << value << ", from Thread: " << this_thread::get_id() << endl;}void startThread(int value){thread t (&MyClass::memberFunction, this, value);t.join();}
};int main()
{MyClass  obj;obj.startThread(42);return 0;
}

在这里插入图片描述
注意：如果是类成员函数作为线程参数时，必须将this作为线程函数参数。

原子性操作库(atomic)

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

#include <iostream>
using namespace std;
#include <thread>
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, 100000);thread t2(fun, 100000);t1.join();t2.join();cout << "After joining,sum = " << sum << std::endl;return 0;
}

上面这段代码使用了两个线程来并发地增加全局变量 sum 的值，因为没有保护机制，并且+的动作并非是元子的，所以会导致结果出异常的情况。
在这里插入图片描述
C++98中传统的解决方式：可以对共享修改的数据可以加锁保护。


void fun(size_t num)
{for (size_t i = 0; i < num; ++i){m.lock();m.unlock();}	sum++;}

在这里插入图片描述

虽然加锁可以解决，但是加锁有一个缺陷就是：只要一个线程在对sum++时，其他线程就会被阻塞，会影响程序运行的效率，而且锁如果控制不好，还容易造成死锁。
因此C++11中引入了原子操作。所谓原子操作：即不可被中断的一个或一系列操作，C++11引入的原子操作类型，使得线程间数据的同步变得非常高效。

在这里插入图片描述
注意：需要使用以上原子操作变量时，必须添加头文件

#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, 100000);thread t2(fun, 100000);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 <atomic>
int main()
{
atomic<int> a1(0);
//atomic<int> a2(a1); // 编译失败
atomic<int> a2(0);
//a2 = a1; // 编译失败
return 0;
}

lock_guard与unique_lock

在多线程环境下，如果想要保证某个变量的安全性，只要将其设置成对应的原子类型即可，即高效又不容易出现死锁问题。但是有些情况下，我们可能需要保证一段代码的安全性，那么就只能通过锁的方式来进行控制。

比如：一个线程对变量number进行加一100次，另外一个减一100次，每次操作加一或者减一之后，输出number的结果，要求：number最后的值为1。

可以声明一个全局变量number，分别通过两个线程来对这个变量进行++与--运算，并且每次操作后打印当前number值。


#include <thread>
#include <mutex>
int number = 0;
mutex g_lock;
int ThreadProc1()
{for (int i = 0; i < 100; i++){g_lock.lock();++number;cout << "thread 1 :" << number << endl;g_lock.unlock();}return 0;
}
int ThreadProc2()
{for (int i = 0; i < 100; i++){g_lock.lock();--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;return 0;
}

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


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

mutex的种类

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

  1. std::mutex

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

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

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

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

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

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

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

  1. 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。
  1. std::recursive_timed_mutex
    它结合了递归锁和定时锁的特性。当多个线程可能同时请求对同一资源的访问，但又希望能够控制等待时间时，使用定时功能可以避免长时间阻塞。

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。

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所管理的互斥量的指针)。

两个线程交替打印奇偶数

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>void Print()
{mutex mtx;condition_variable c;int n = 100;bool flag = true;thread t1([&](){int i = 0;while (i < n){unique_lock<mutex> lock(mtx);c.wait(lock, [&]()->bool {return flag; });cout << "thread 1 : " << i << endl;flag = false;i += 2;c.notify_one();}});thread t2([&](){int j = 1;while (j < n){unique_lock<mutex> lock(mtx);c.wait(lock, [&]()->bool {return !flag; });cout << "thread 2 : " << j << endl;flag = true;j += 2;c.notify_one();}});t1.join();t2.join();
}int main()
{Print();return 0;
}

这段代码使用了条件变量（std::condition_variable）和互斥量（std::mutex）来实现两个线程交替打印奇偶数。

  1. 在 Print() 函数内部，创建了一个互斥量 mtx 和一个条件变量 c。用于实现线程同步。
  2. 首先将flag设为true，控制线程1首先打印，打印1.
  3. 当线程1打印完之后，设置flag为false，同时使用notify_one()唤醒线程2。

wait函数原型
在C++11的std::condition_variable中，wait函数的原型如下:

template< class Predicate >
void wait( std::unique_lock<mutex>& lock, Predicate pred );

其中：

  • lock是一个对std::mutex的std::unique_lock引用，用于管理互斥量的锁。
  • pred是一个返回bool类型的可调用对象（如函数对象或lambda表达式），用于指定等待条件。

在上面的代码中:

c.wait(lock, [&]()->bool {return flag; });
  • lock是一个对std::mutex的std::unique_lock的引用，用于管理互斥量的锁。
  • [&]()->bool {return flag; }是一个lambda表达式，捕获外部变量flag的引用并返回它的值。这个lambda表达式就是pred参数。

当调用c.wait(lock, [&]()->bool {return flag; });时，它会执行以下步骤：

  1. 检查lambda表达式[&]()->bool {return flag; }的返回值。如果返回true，则wait函数立即返回，不会阻塞。
  2. 如果lambda表达式返回false，wait函数会释放lock 并阻塞当前线程。
  3. 当另一个线程调用notify_one()或notify_all()时，被阻塞的线程会被唤醒。
  4. 被唤醒的线程会 重新获取lock并再次检查lambda表达式的返回值。如果返回true，则wait函数返回；否则继续阻塞。

这个过程会一直重复，直到lambda表达式返回true或者线程被取消。使用lambda表达式作为pred参数可以方便地指定等待条件。


http://www.ppmy.cn/devtools/113063.html

相关文章

利用LlamaIndex构建ARG本地知识库

利用LlamaIndex构建ARG本地知识库

文章目录 1. 环境准备2. 启用诊断日志3. 配置本地模型4. 配置本地向量模型5. LlamaIndex全局配置6. 创建 PGVectorStore7. 从数据库加载数据8. 文本分割器: SpacyTextSplitter9. 配置管道10. 创建向量存储索引11 .指定响应模式&#xff0c;以及启用流式响应 在现代的人工智能应…
阅读更多...
【电脑组装】✈️从配置拼装到安装系统组装自己的台式电脑

【电脑组装】✈️从配置拼装到安装系统组装自己的台式电脑

目录 &#x1f378;前言 &#x1f37b;一、台式电脑基本组成 &#x1f37a;二、组装 &#x1f379;三、安装系统 &#x1f44b;四、系统设置 &#x1f440;五、章末 &#x1f378;前言 小伙伴们大家好&#xff0c;上篇文章分享了在平时开发的时候遇到的一种项目整合情况&…
阅读更多...
通信工程学习：什么是HFC混合光纤同轴电缆

通信工程学习：什么是HFC混合光纤同轴电缆

HFC&#xff1a;混合光纤同轴电缆 HFC&#xff08;Hybrid Fiber Coaxial&#xff09;混合光纤同轴电缆是一种结合了光纤与同轴电缆的宽带接入网技术。以下是对HFC混合光纤同轴电缆的详细解释&#xff1a; 一、HFC混合光纤同轴电缆的定义与概述 定义&#xff1a;HFC是一种结合光…
阅读更多...
windows系统docker装milvus向量数据库

windows系统docker装milvus向量数据库

首先创建一个文件夹比如milvus,在创建如下文件 docker-compose.yml文件如下: version: 3.5services:etcd:container_name: milvus-etcdimage: quay.io/coreos/etcd:v3.5.5environment:- ETCD_AUTO_COMPACTION_MODErevision- ETCD_AUTO_COMPACTION_RETENTION1000- ETCD_QUOTA_B…
阅读更多...
2024.9.11（k8s环境搭建）

2024.9.11（k8s环境搭建）

一、k8s环境搭建 编号主机名称ip配置1k8s-master192.168.8.1772k8s-node1192.168.8.1783k8s-node2192.168.8.168 1、免密登录 [rootk8s-master ~]# ssh-keygen [rootk8s-master ~]# ssh-copy-id root192.168.8.178 [rootk8s-master ~]# ssh-copy-id root192.168.8.168 2、3台…
阅读更多...
解决：Vue3 - defineProps 设置默认值报错问题

解决：Vue3 - defineProps 设置默认值报错问题

目录 1&#xff0c;问题2&#xff0c;分析2.1&#xff0c;按报错提示信息测试2.2&#xff0c;测试 vue-i18n 3&#xff0c;解决 1&#xff0c;问题 使用 defineProps 指定默认值时报错&#xff0c;代码如下&#xff1a; <template><input type"text" :pla…
阅读更多...
数据结构（Day13）

数据结构（Day13）

一、学习内容 内存空间划分 1、一个进程启动后&#xff0c;计算机会给该进程分配4G的虚拟内存 2、其中0G-3G是用户空间【程序员写代码操作部分】【应用层】 3、3G-4G是内核空间【与底层驱动有关】 4、所有进程共享3G-4G的内核空间&#xff0c;每个进程独立拥有0G-3G的用户空间 …
阅读更多...
React项目中使用发布订阅模式

React项目中使用发布订阅模式

React项目中使用发布订阅模式 1.创建发布订阅器2.在组件中使用发布订阅器3. 订阅数据 发布订阅模式&#xff08;也称观察者模式&#xff09;是一种管理跨组件通信的有效方式&#xff0c;尤其是在不希望直接依赖于特定组件的情况下。这种模式允许一个对象&#xff08;发布者&…
阅读更多...
SAP B1 学习笔记 - 易混淆字段名（持续更新中）

SAP B1 学习笔记 - 易混淆字段名（持续更新中）

背景 在 SAP B1 的单据中&#xff0c;由于同一单据时常对应着多个后台表单&#xff0c;且后台表单内包含的字段信息往往远大于单据显示出来的&#xff0c;在配置时经常出现多个字段混淆、无系统信息提示字段名模糊的情况&#xff0c;这里总结常见的易混淆难查找的后台字段名。…
阅读更多...
Linux whereis和which的区别

Linux whereis和which的区别

功能概述 whereis命令 whereis主要用于查找二进制文件、源代码文件和手册页文件的位置。它会在特定的目录列表中查找&#xff0c;这些目录包括二进制文件目录&#xff08;如/bin、/sbin、/usr/bin、/usr/sbin等&#xff09;、源代码目录&#xff08;如/usr/src&#xff09;和手…
阅读更多...
C#/.NET/.NET Core技术前沿周刊 | 第 5 期（2024年9.9-9.15）

C#/.NET/.NET Core技术前沿周刊 | 第 5 期（2024年9.9-9.15）

前言 C#/.NET/.NET Core技术前沿周刊&#xff0c;你的每周技术指南针&#xff01;记录、追踪C#/.NET/.NET Core领域、生态的每周最新、最实用、最有价值的技术文章、社区动态、优质项目和学习资源等。让你时刻站在技术前沿&#xff0c;助力技术成长与视野拓宽。 欢迎投稿&…
阅读更多...
Taro + Vue 的 CSS Module 解决方案

Taro + Vue 的 CSS Module 解决方案

一、开启模块化配置 Taro 中内置了 CSS Modules 的支持&#xff0c;但默认是关闭的。如果需要开启使用&#xff0c;请先在编译配置中添加如下配置&#xff1a; weapp: {module: {postcss: {// css modules 功能开关与相关配置cssModules: {enable: true, // 默认为 false&…
阅读更多...
【C++知识扫盲】------初识命名空间

【C++知识扫盲】------初识命名空间

在 C 中&#xff0c;using namespace std; 和 std:: 都与命名空间的使用相关。命名空间是为了防止不同库或模块中的同名符号&#xff08;函数、变量等&#xff09;发生冲突的机制。 1. std:: std:: 是用于访问 C 标准库中定义符号的前缀。std 代表标准&#xff08;standard&a…
阅读更多...
AI创意引擎：优化Prompt提示词的高效提问技巧

AI创意引擎：优化Prompt提示词的高效提问技巧

AI内容创作的精髓&#xff1a;提示词&#xff08;Prompt&#xff09; 在AI领域中&#xff0c;提示词&#xff08;Prompt&#xff09;是与模型沟通的关键工具。提示词不仅决定了AI生成内容的方向和质量&#xff0c;还在优化模型输出、提升用户体验中扮演着至关重要的角色。因此…
阅读更多...
HTTPS和HTTP区别是什么？

HTTPS和HTTP区别是什么？

HTTP和HTTPS是两种协议&#xff0c;分别是HyperText Transfer Protocol和HyperText Transfer Protocol Secure。 HTTPS还经常被称为HTTP over SSL或者HTTP over TSL&#xff0c;HTTPS经由HTTP进行通信&#xff0c;但利用SSL/TLS来加密数据包。 他们的区别主要由以下几个方面&…
阅读更多...
Git常用指令整理【新手入门级】【by慕羽】

Git常用指令整理【新手入门级】【by慕羽】

Git 是一个分布式版本控制系统&#xff0c;主要用于跟踪和管理源代码的更改。它允许多名开发者协作&#xff0c;同时提供了强大的功能来管理项目的历史记录和不同版本。本文主要记录和整理&#xff0c;个人理解的Git相关的一些指令和用法 文章目录 一、git安装 & 创建git仓…
阅读更多...
如何用Appium实现移动端UI自动化测试？

如何用Appium实现移动端UI自动化测试？

&#x1f345; 点击文末小卡片&#xff0c;免费获取软件测试全套资料&#xff0c;资料在手&#xff0c;涨薪更快 Appium是一个开源跨平台移动应用自动化测试框架。 既然只是想学习下Appium如何入门&#xff0c;那么我们就直奔主题。文章结构如下&#xff1a; 为什么要使用App…
阅读更多...
计算机毕业设计：Java体育成绩管理系统开题报告+源代码效果图

计算机毕业设计：Java体育成绩管理系统开题报告+源代码效果图

博主介绍&#xff1a;黄菊华老师《Vue.js入门与商城开发实战》《微信小程序商城开发》图书作者&#xff0c;CSDN博客专家&#xff0c;在线教育专家&#xff0c;CSDN钻石讲师&#xff1b;专注大学生毕业设计教育和辅导。 所有项目都配有从入门到精通的基础知识视频课程&#xff…
阅读更多...
OpenCV-上下采样

OpenCV-上下采样

文章目录 一&#xff0c;简介二、下采样&#xff08;Downsampling&#xff09;三、上采样&#xff08;Upsampling&#xff09;四、代码实现1.图像读取2.下采样3.上采样4.拉普拉斯金字塔 五、应用 一&#xff0c;简介 高斯金字塔是图像处理、计算机视觉和信号处理中常用的一项技…
阅读更多...
快人一步迅为LPDDR5版本瑞芯微RK3588核心板升级了

快人一步迅为LPDDR5版本瑞芯微RK3588核心板升级了

性能强--iTOP-3588开发板采用瑞芯微RK3588处理器&#xff0c;是全新一代ALoT高端应用芯片&#xff0c;采用8nm LP制程&#xff0c;搭载八核64位CPU&#xff0c;四核Cortex-A76和四核Cortex-A55架构&#xff0c;主频高达2.4GHZ&#xff0c;8GB内存&#xff0c;32GB EMMC。四核心…
阅读更多...
最新文章

Copyright @ 2022~2023

友情链接： 我的编程经验分享 一条长河网 尧图网站开发 尧图建网站