C++——多线程编程（从入门到放弃）

进程：运行中的程序
线程：进程中的进程
线程的最大数量取决于CPU的核心数

一、将两个函数添加到不同线程中

demo：两个函数test01()和test02()，实现将用户输入的参数进行打印输出1000次
将这两个函数均放到独立的线程t1和t2中，可实现独立的运作，与主函数独立执行

#include <thread>线程头文件
std::thread t1(test01, 10);创建线程t1，第一个参数为函数名，第二个参数为对应函数的参数；若函数没有参数，则不需要填入
if (t1.joinable())判断线程t1是否可以加入到主线程中，若可以加入，t1.join();则加入到主线程中
子线程加入到主线程可以保证主线程会等待子线程运行完毕之后再结束

t1.join();是将子线程t1则加入到主线程中
t1.detach();是将主线程main和子线程t1分离，确保主线程结束后，子线程仍可以再后台执行

t1.join();较为常用

#include <iostream>
#include <thread>
#include <string>void test01(int num)
{for (int i = 0; i < 1000; i++) {std::cout << "test01  " << num << " " << i << std::endl;// test01 10 0// test01 10 1// test01 10 2//...}
}void test02(std::string str) 
{for (int i = 0; i < 1000; i++){std::cout << "test02  " << str << " " << i << std::endl;// test02 hello beyond 0// test02 hello beyond 1// test02 hello beyond 2// ...}
}int main(int argc, char* argv[])
{//创建线程，把函数名和参数传递给线程std::thread t1(test01, 10);//第一个参数是函数名，第二个参数是该函数所需要的参数std::thread t2(test02, "hello beyond");//第一个参数是函数名，第二个参数是该函数所需要的参数if (t1.joinable()) //判断线程是否还在运行{//若没有将t1线程加入到主线程，则主线程结束时，t1线程也会结束，导致程序崩溃t1.join(); //等待线程结束；若不把线程t1加入到主进程中，则主进程不会等待t1进程结束之后再结束，若主进程结束了，项目结束//t1.detach(); //分离线程，主线程结束时，t1线程也会结束，不会导致程序崩溃；//join()和detach()的区别在于：join()等待线程结束，detach()分离线程，主线程结束时，t1线程不会结束，可以继续运行}if (t2.joinable()) {t2.join(); //等待线程结束；若不把线程t2加入到主进程中，则主进程不会等待t2进程结束之后再结束，若主进程结束了，项目结束}//主线程for (int i = 0; i < 1000; i++) {std::cout << "main  " << i << std::endl;}//就此开了三个线程（main()、t1、t2），三个线程并发执行return 0;
}

运行效果
在这里插入图片描述
可以看到线程t1和t2是并发执行的，执行完之后，主线程main才进行执行
这说明，在主线程main中，程序是按顺序执行的；而相互独立的线程是并行执行的

二、引用类型传入线程中

若要操作同一个变量，在函数中需要传入该变量的引用
若要加入到线程中，则需要通过std::ref(a)将变量a的引用加入到线程中，操作的都是该变量a，共享同一个变量a

#include <iostream>
#include <thread>
#include <string>void test01(int& num1) //引用传递
{for (int i = 0; i < 10; i++){num1++;}
}void test02(int num2) //值传递
{for (int i = 0; i < 10; i++){num2++;}
}int main(int argc, char* argv[])
{int num1 = 0;int num2 = 0;std::thread t1(test01, std::ref(num1));//引用传递std::thread t2(test02, num2);//值传递if (t1.joinable()) {t1.join();}	if (t2.joinable()) {t2.join();}	std::cout << "num1 = " << num1 << std::endl;// 输出结果为10std::cout << "num2 = " << num2 << std::endl;// 输出结果为0return 0;
}

三、锁和死锁

1，现象分析：

在这里插入图片描述
俩线程都对num进行自加10000次，期间会出现t1和t2线程同时拿到num，并自加，导致结果会重复多次，出现无效的自加效果

#include <iostream>
#include <thread>
#include <string>void test01(int& num) //引用传递
{for (int i = 0; i < 100000; i++){num++;}
}void test02(int& num) //值传递
{for (int i = 0; i < 100000; i++){num++;}
}int main(int argc, char* argv[])
{int num = 0;std::thread t1(test01, std::ref(num));//引用传递std::thread t2(test02, std::ref(num));//引用传递if (t1.joinable()) {t1.join();}	if (t2.joinable()) {t2.join();}	//按理说num应该是200000，但是由于线程并发执行，导致结果可能是100000，也可能是200000std::cout << "num = " << num << std::endl;return 0;
}

运行结果：
实际效果并不是20000
在这里插入图片描述

2，解决方法：加锁

#include <mutex>互斥锁头文件
std::mutex mtx;定义互斥锁
mtx.lock();加锁
mtx.unlock();解锁

在加锁和解锁之间的数据是不允许多个线程进行操作
当线程t1拿到num之后立马加锁，线程t2就无法获取num，直到线程t1解锁后，线程t2才可以拿到num

加锁操作保证多线程安全

#include <iostream>
#include <thread>
#include <string>
#include <mutex>std::mutex mtx;//定义互斥锁void test01(int& num) //引用传递
{for (int i = 0; i < 1000000; i++){mtx.lock();//加锁num++;mtx.unlock();//解锁}
}void test02(int& num) //值传递
{for (int i = 0; i < 1000000; i++){mtx.lock();//加锁num++;mtx.unlock();//解锁}
}int main(int argc, char* argv[])
{int num = 0;std::thread t1(test01, std::ref(num));//引用传递std::thread t2(test02, std::ref(num));//引用传递if (t1.joinable()) {t1.join();}	if (t2.joinable()) {t2.join();}	//按理说num应该是200000，但是由于线程并发执行，导致结果可能是100000，也可能是200000std::cout << "num = " << num << std::endl;return 0;
}

运行效果：
在这里插入图片描述

3，死锁现象

在这里插入图片描述

#include <iostream>
#include <thread>
#include <string>
#include <mutex>std::mutex mtx1, mtx2;//定义互斥锁void test01(int& num1,int &num2) //引用传递
{for (int i = 0; i < 10000; i++){mtx1.lock();//加锁num1++;mtx2.lock();//加锁num2++;mtx2.unlock();//解锁mtx1.unlock();//解锁}
}void test02(int& num1,int &num2) //值传递
{for (int i = 0; i < 10000; i++){mtx2.lock();//加锁num2++;mtx1.lock();//加锁num1++;mtx1.unlock();//解锁mtx2.unlock();//解锁}
}int main(int argc, char* argv[])
{int num1 = 0;int num2 = 0;std::thread t1(test01, std::ref(num1), std::ref(num2));//引用传递std::thread t2(test02, std::ref(num1), std::ref(num2));//引用传递if (t1.joinable()) {t1.join();}	if (t2.joinable()) {t2.join();}	//按理说num应该是200000，但是由于线程并发执行，导致结果可能是100000，也可能是200000std::cout << "run is over"<< std::endl;//死锁，永远不会执行std::cout << "num1=" << num1 << std::endl;std::cout << "num2=" << num2 << std::endl;return 0;
}

运行效果：
陷入死锁
在这里插入图片描述

4，死锁解决方法

方法一：要锁谁都锁谁

也就是互斥锁的先后顺序要一致，要都先锁num1就都先锁num1

#include <iostream>
#include <thread>
#include <string>
#include <mutex>std::mutex mtx1, mtx2;//定义互斥锁void test01(int& num1,int &num2) //引用传递
{for (int i = 0; i < 10000; i++){mtx1.lock();//加锁num1++;mtx2.lock();//加锁num2++;mtx2.unlock();//解锁mtx1.unlock();//解锁}
}void test02(int& num1,int &num2) //值传递
{for (int i = 0; i < 10000; i++){mtx1.lock();//加锁num1++;mtx2.lock();//加锁num2++;mtx2.unlock();//解锁mtx1.unlock();//解锁}
}int main(int argc, char* argv[])
{int num1 = 0;int num2 = 0;std::thread t1(test01, std::ref(num1), std::ref(num2));//引用传递std::thread t2(test02, std::ref(num1), std::ref(num2));//引用传递if (t1.joinable()) {t1.join();}	if (t2.joinable()) {t2.join();}	std::cout << "run is over"<< std::endl;std::cout << "num1=" << num1 << std::endl;std::cout << "num2=" << num2 << std::endl;return 0;
}

运行效果：
在这里插入图片描述

方法二：使用智能互斥锁

四、智能互斥锁

1，lock_guard

lock_guard会在其构造函数中自动加锁，在其析构函数中自动解锁
无需人为的去加锁解锁操作

std::mutex mtx1;定义互斥锁
std::lock_guard<std::mutex> lock1(mtx1);将互斥锁升级为智能互斥锁，是一个函数模板

#include <iostream>
#include <thread>
#include <string>
#include <mutex>std::mutex mtx1, mtx2;//定义互斥锁void test01(int& num1,int &num2) //引用传递
{for (int i = 0; i < 10000; i++){std::lock_guard<std::mutex> lock1(mtx1);num1++;num2++;}
}void test02(int& num1,int &num2) //值传递
{for (int i = 0; i < 10000; i++){std::lock_guard<std::mutex> lock1(mtx1);num1++;num2++;}
}int main(int argc, char* argv[])
{int num1 = 0;int num2 = 0;std::thread t1(test01, std::ref(num1), std::ref(num2));//引用传递std::thread t2(test02, std::ref(num1), std::ref(num2));//引用传递if (t1.joinable()) {t1.join();}	if (t2.joinable()) {t2.join();}	std::cout << "run is over"<< std::endl;std::cout << "num1=" << num1 << std::endl;std::cout << "num2=" << num2 << std::endl;return 0;
}

运行效果：
在这里插入图片描述

2，unique_lock（推荐使用）

lock_guard只支持自动加锁解锁操作
unique_lock不仅仅支持自动加锁解锁操作，还支持超时处理、延迟加锁、达到某些条件后进行加锁等操作

①将unique_lock直接替换lock_guard效果是一样的

自动加锁，自动解锁

#include <iostream>
#include <thread>
#include <string>
#include <mutex>std::mutex mtx1, mtx2;//定义互斥锁void test01(int& num1,int &num2) //引用传递
{for (int i = 0; i < 10000; i++){std::unique_lock<std::mutex> lock1(mtx1);num1++;num2++;}
}void test02(int& num1,int &num2) //值传递
{for (int i = 0; i < 10000; i++){std::unique_lock<std::mutex> lock1(mtx1);num1++;num2++;}
}int main(int argc, char* argv[])
{int num1 = 0;int num2 = 0;std::thread t1(test01, std::ref(num1), std::ref(num2));//引用传递std::thread t2(test02, std::ref(num1), std::ref(num2));//引用传递if (t1.joinable()) {t1.join();}	if (t2.joinable()) {t2.join();}	std::cout << "run is over"<< std::endl;std::cout << "num1=" << num1 << std::endl;std::cout << "num2=" << num2 << std::endl;return 0;
}

运行效果：
在这里插入图片描述

②手动上锁

std::unique_lock<std::mutex> lock1(mtx1,std::defer_lock);需要传入参数std::defer_lock
用户需要手动上锁，自动解锁
手动上锁是为了可以使用一些延迟上锁等互斥锁
之前的是常规互斥锁std::mutex mtx1;
例如：手动上锁的时候可以使用时间互斥锁std::timed_mutex mtx1;

std::timed_mutex mtx1;定义时间互斥锁
std::unique_lock<std::timed_mutex> lock1(mtx1, std::defer_lock);定义一个局部锁，使用defer_lock参数，表示不加锁，手动加锁，自动解锁
bool res = lock1.try_lock_for(std::chrono::milliseconds(100));尝试加锁，超时时间为100ms；如果加锁成功，则返回true，否则返回false

五、单例模式下的多线程使用

单例模式：全局只有一个实例，初始化操作只能执行一次
若在多线程中，就有可能被执行多次，此时需要使用call_once
常用的单例模式为日志类，只需要一次实例化对象

Singleton类实现了单例模式。通过std::call_once结合std::once_flag来保证Singleton类的构造函数只被调用一次，从而保证在多线程环境下只有一个Singleton实例被创建。在main函数中，创建了两个线程，这两个线程都调用Singleton::getInstance方法来获取单例实例，并调用showMessage方法。

#include <iostream>
#include <mutex>
#include <thread>class Singleton {
private:// 私有构造函数Singleton() {std::cout << "Singleton created." << std::endl;}static Singleton* instance;static std::once_flag flag;
public:// 获取单例实例的方法static Singleton* getInstance() {// 确保初始化只进行一次std::call_once(flag, []() {instance = new Singleton();});return instance;}void showMessage() {std::cout << "Singleton is working." << std::endl;}
};// 静态成员变量初始化
Singleton* Singleton::instance = nullptr;
std::once_flag Singleton::flag;// 线程函数
void threadFunction() {Singleton* single = Singleton::getInstance();single->showMessage();
}int main() {std::thread t1(threadFunction);std::thread t2(threadFunction);t1.join();t2.join();return 0;
}

六、条件变量的使用

生产者与消费者模型：
生产者（导师），消费者（导师的学生）
一个导师一般情况下会招多个学生，导师申请到国家基金或横向课题，将课题任务分成多个小块，依次分配给学生A、学生B、学生C等进行完成
导师将任务放到任务队列中，学生从任务队列中取出任务并完成，若任务队列中没有任务了，学生就可以等待一会儿（摸会儿鱼）。等导师又有新任务了，放入到任务队列中，并通知学生；学生收到通知，就不需要再等待了，开始去任务队列中取任务。
导师往任务队列中加入一个任务，因为是一个任务，所以只通知一次（notify_once），至于哪个学生去完成，导师不关心，但需要一个学生来进行完成；
导师往任务队列中加入了很多个任务，因为任务比较多，需要所有的学生进行完成（notify_all），把所有的学生都通知一遍。

极端例子，任务队列为空，导师放任务到任务队列的同时，学生来任务队列中取任务，学生发现任务队列中没任务，开始摸鱼，其实导师已经放入了一个任务

此时就需要加锁，并引入条件变量，导师往任务队列中放任务的时候加锁，放完之后发通知
学生从任务队列中取任务之前先判断任务队列中是否为空，若为空等待，直到收到导师发的通知之后再开始从任务队列中取任务

g_cv.wait(lock, bool);
参数一：互斥锁
参数二：布尔值，若为true则执行下一行，若为false则等待
一般这个bool值用lambda表达式设置

#include <iostream>
#include <mutex>
#include <thread>
#include <condition_variable>//引入条件变量头文件
#include <queue>//任务对列头文件std::queue<int> g_task_queue; //任务队列  导师将任务放到任务队列中，队列，先进先出，导师先放入的任务，学生先完成
std::condition_variable g_cv; //创建一个条件变量
std::mutex g_mutex; //创建一个互斥锁void Teacher()//导师（生产者），负责产生任务，并通知学生
{for (int i = 0; i < 10; i++) //导师将10个任务放入任务队列中{std::unique_lock<std::mutex> lock(g_mutex); //获取互斥锁g_task_queue.push(i); //将任务放入队列g_cv.notify_one();//通知学生，来一个学生完成这个任务//g_cv.notify_all();//通知所有学生完成这个任务std::cout << "Teacher produce task " << i << std::endl; //打印提示信息}//导师放任务到任务队列的速度别太快，睡个100msstd::this_thread::sleep_for(std::chrono::milliseconds(100)); //等待100ms，模拟学生完成任务
}void Students()//学生（消费者），负责消费任务，并等待通知
{while (true) //学生一直等待通知{std::unique_lock<std::mutex> lock(g_mutex); //获取互斥锁//等待通知，若队列为空，则阻塞等待bool is_empty = g_task_queue.empty();//判断队列是否为空//lambda表达式为ture，执行下一行；false，阻塞等待，直到条件变量调用notify_one来唤醒线程，该等待结束g_cv.wait(lock, []() {return !g_task_queue.empty(); //队列不为空，则返回true，通知学生}); //等待通知，若队列为空，则阻塞等待int task; //定义一个任务变量task = g_task_queue.front(); //取出队列头部的任务g_task_queue.pop(); //从队列中删除任务std::cout << "Student consume task " << task << std::endl; //打印提示信息}
}int main(int argc, char* argv[])
{std::thread t1(Teacher); //创建导师线程std::thread t2(Students); //创建学生线程if (t1.joinable()){t1.join(); //等待导师线程结束}if (t2.joinable()){t2.join(); //等待学生线程结束}return 0;
}

在这里插入图片描述

七、跨平台线程池

在这里插入图片描述
现准备好线程池，包括线程数组和任务队列，等待用户放任务到任务队列中，现场数组分配线程去任务队列中取任务完成

#include <iostream>
#include <mutex>
#include <thread>
#include <condition_variable>//引入条件变量头文件
#include <queue>//任务对列头文件
#include <vector>
#include <functional>//引入函数对象头文件class ThreadPool 
{
public:ThreadPool(int num_threads) :m_stop(false) {//往线程数组中添加num_threads个线程for (int i = 0; i < num_threads; ++i){// push_back()函数向线程数组中添加一个线程的时候会进行一个拷贝，因此这里使用emplace_back()函数，直接调用成员构造函数，避免拷贝// 比push_back()函数效率高，更加节省资源，避免了构造函数的调用m_threads.emplace_back([this](){while (true) {std::unique_lock<std::mutex> lock(m_mutex);//加锁//条件变量等待，直到有任务需要处理m_cv.wait(lock, [this]() {//如果线程池需要停止，或者任务对列为空，则返回false，通知线程等待//否则返回true，通知线程继续执行下一行代码return m_stop ||!m_tasks.empty();});//如果线程池需要停止，并且任务对列为空，则退出线程if (m_stop && m_tasks.empty()){return;}//线程池没有停止，任务对列不为空，则取出一个任务std::function<void()> task = m_tasks.front();//取出任务列表中的第一个任务m_tasks.pop();//取出任务列表中的第一个任务//取到任务之后解锁，让其他线程有机会去取任务lock.unlock();//解锁task();//执行任务}});}}~ThreadPool(){//指定锁的作用域{std::unique_lock<std::mutex> lock(m_mutex);//加锁//因为m_stop是多个线程共享的，所以在析构函数中需要加锁，确保线程安全m_stop = true;//设置线程池停止标志}m_cv.notify_all();//通知所有线程，线程池需要停止for (std::thread &t: m_threads){if (t.joinable())//如果线程还没有结束，则等待线程结束{t.join();}}}//向任务对列中添加任务template<typename F, typename... Args>//函数模板，可变参数模板void enqueue(F&& f, Args&&... args) {//&& 右值引用，可以避免拷贝，提高效率//& 左值引用，可以传引用，避免拷贝，提高效率//在函数模板里面，&& 表示万能引用（在函数模板中，&& 右值引用就是万能引用）//std::forward<F>(f)  转发函数对象，避免拷贝，提高效率std::function<void()> task = std::bind(std::forward<F>(f), std::forward<Args>(args)...);//使用bind函数，将任务封装成函数对象//对共享变量操作需要加锁，确保线程安全，指定锁的作用域{std::unique_lock<std::mutex> lock(m_mutex);m_tasks.emplace(std::move(task));//向任务对列中添加任务}//通知线程数组中的一个线程去取任务m_cv.notify_one();}
private:std::vector<std::thread> m_threads;//线程数组std::queue<std::function<void()>> m_tasks;//任务对列std::mutex m_mutex;//互斥锁//生产者生产任务，去通知线程数组，线程数组去指派线程去完成任务std::condition_variable m_cv;//条件变量 线程池符合生产者消费者模型，故需要条件变量；bool m_stop = false;//线程池是否停止
};int main(int argc, char* argv[])
{//10个任务（0-9），由3个线程去完成ThreadPool pool(3);//创建线程池，线程数为3//向任务对列中添加任务for (int i = 0; i < 10; ++i){pool.enqueue([i]() {std::cout << "Task " << i << " running on thread " << std::this_thread::get_id() << std::endl;std::this_thread::sleep_for(std::chrono::seconds(1));//休眠1秒，模拟任务执行时间std::cout << "Task " << i << " finished on thread " << std::this_thread::get_id() << std::endl;});   }return 0;
}

运行效果：
在这里插入图片描述

八、异步并发

1，async

无需手动去创建线程，当运行到std::future<int> f1 = std::async(std::launch::async, func);时，自动会有个异步线程去调用func函数，同时开启一个线程立马执行，通过f1.get()取到函数返回的结果

#include <iostream>
#include <future>int func()
{int num = 0;for (int i = 0; i < 10000; i++){num++;}return num;
}int main(int argc, char* argv[])
{//主线程和子线程同步，只不过主线程执行完func函数后，会直接输出结果//子线程执行完func函数后，会将结果存入f中，主线程通过f.get()获取结果//子线程执行func函数std::future<int> f1 = std::async(std::launch::async, func);//执行到这行代码时，func函数已经开始执行，但是并不等待func函数的结果，而是返回一个future对象，通过这个future对象可以获取func函数的结果std::cout << "main thread result:" << func() << std::endl;//主线程执行func函数，并打印结果//以上两者是同时执行的，主线程和子线程同步std::cout<< "async result:" << f1.get() << std::endl;//会将return的结果存放到f1中，通过f1.get()获取结果return 0;
}

运行效果：
在这里插入图片描述

2，future

async会立马自动调用线程执行，而future需要手动创建线程执行

std::packaged_task<int()> task(func);创建packaged_task对象task，包装func函数
std::future<int> f = task.get_future();创建future对象f，用于获取func函数的结果
std::thread t(std::move(task));将task的控制权移交给t线程，t线程负责执行task函数，并将结果存入f中

#include <iostream>
#include <future>int func()
{int num = 0;for (int i = 0; i < 10000; i++){num++;}return num;
}int main(int argc, char* argv[])
{std::packaged_task<int()> task(func);//创建task对象，包装func函数std::future<int> f = task.get_future();//创建future对象f，用于获取func函数的结果std::thread t(std::move(task));//将task的控制权移交给t线程，t线程负责执行task函数，并将结果存入f中；子线程t执行func函数，与主线程同步std::cout << "main thread result:" << func() << std::endl;//主线程执行func函数，并打印结果if (t.joinable()) {t.join();//等待子线程t线程结束}std::cout << "packaged_task result:" << f.get() << std::endl;//获取f中存放的func函数的结果return 0;
}

运行效果：
在这里插入图片描述

3，promise

场景：在主线程中获取子线程中通过promise所设置的值

#include <iostream>
#include <future>void func(std::promise<int>& prom)
{prom.set_value(42);//设置promise的值
}int main(int argc, char* argv[])
{std::promise<int> prom;//声明一个promise对象std::future<int> fut = prom.get_future();//promise对象会返回一个future对象，用于获取promise的值std::thread t(func, std::ref(prom));启动一个线程，并传入promise对象作为参数if (t.joinable()) {t.join();}std::cout << fut.get() << std::endl;//获取得到promise所设置的值return 0;
}

运行效果：
在这里插入图片描述

九、原子操作

atomic原子操作是一个模板类，用于在多线程中访问和修改共享变量，避免多线程中所出现的数据竞争现象的发生
原子操作和锁所处理的都是同一类问题
把变量设置为atomc类型，该变量自身自带线程安全操作，会自动加锁和解锁，且要比手动加锁解锁的速度更快

#include <iostream>
#include <thread>
#include <atomic>std::atomic<int> g_num_atomic = 0;//原子变量
int g_num = 0;//非原子变量void func()
{for (int i = 0; i < 1000000; ++i) {g_num_atomic++;g_num++;}
}int main(int argc, char* argv[])
{std::thread t1(func);std::thread t2(func);if (t1.joinable()) t1.join();if (t2.joinable()) t2.join();std::cout << "g_num = " << g_num << std::endl;//输出非原子变量的值，因为g_num是非原子变量，所以可能出现数据竞争，导致结果不准确std::cout << "g_num_atomic = " << g_num_atomic << std::endl;//输出原子变量的值return 0;
}

运行效果：
全局变量g_num是一个int，由于是多线程操作，故出现了数据竞争问题，导致数据不对
全局变量g_num_atomic是一个int型的原子变量，该变量会自动加锁和解锁，不会发生数据竞争问题
在这里插入图片描述

学习笔记参考来源：陈子青——C++11 多线程编程-小白零基础到手撕线程池
若有侵权联系立删

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

如若内容造成侵权/违法违规/事实不符，请联系长河编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

vue3+element-plus icons图标选择组件封装

vue3+element-plus icons图标选择组件封装

一、最终效果 二、参数配置 1、代码示例 <t-select-icon v-model"selectVlaue" />2、配置参数&#xff08;Attributes&#xff09;继承 el-input Attributes 参数说明类型默认值v-model绑定值string-prefixIcon输入框前缀iconstringSearchisShowSearch是否显…
阅读更多...
从角速度向量的角度理解姿态角速度和机体角速度的转换公式

从角速度向量的角度理解姿态角速度和机体角速度的转换公式

一、什么是姿态角速度 这是我从《多旋翼飞行器设计和控制》上截取的关于欧拉角的定义。无人机的姿态角速度即偏航角、俯仰角、滚转角的一次导数&#xff0c;分别是、、。 二、什么是机体角速度 这是我在网上随便找的图&#xff0c;展示了机体坐标系。这个坐标系与飞机固定连接&…
阅读更多...
【软件测试】详解测试中常用的几种测试方法

【软件测试】详解测试中常用的几种测试方法

目录 一、集成测试二、 系统测试三、验收测试四、回归测试 总结 一、集成测试 术语 集成测试是继组件测试之后的又一个层次。集成测试假定交给这个层次的测试对象已经经过了组件测试&#xff0c;并且任何组件内部的缺陷都已经尽可能地被纠正。 集成 开发人员、测试人员和专…
阅读更多...
6种常见位运算符+异或运算符的使用（加密、解密）

6种常见位运算符+异或运算符的使用（加密、解密）

一、位运算符 位运算符进行的是整数与整数之间的运算 1、右移运算符&#xff1a;>> &#xff08;1&#xff09;相当于对整数除以2 &#xff08;2&#xff09;举例&#xff1a; int num 2; System.out.println(num >> 1); 2、左移运算符&#xff1a;<< …
阅读更多...
定制智慧科技展厅方案：哪些细节是成功的秘诀？

定制智慧科技展厅方案：哪些细节是成功的秘诀？

随着数字科技浪潮的迅猛推进&#xff0c;智慧科技展厅跃升为科技成果展示与技术对话的前沿阵地。其策划与实施方案因而显得尤为关键。在此过程中&#xff0c;精雕细琢每一环节&#xff0c;确保创意与技术的无缝对接&#xff0c;成为不可或缺的要点。现在&#xff0c;让我们深入…
阅读更多...
《程序猿之设计模式实战 · 适配器模式》

《程序猿之设计模式实战 · 适配器模式》

&#x1f4e2; 大家好&#xff0c;我是 【战神刘玉栋】&#xff0c;有10多年的研发经验&#xff0c;致力于前后端技术栈的知识沉淀和传播。 &#x1f497; &#x1f33b; CSDN入驻不久&#xff0c;希望大家多多支持&#xff0c;后续会继续提升文章质量&#xff0c;绝不滥竽充数…
阅读更多...
《深入解析：水果销售数据库操作与查询技巧》

《深入解析：水果销售数据库操作与查询技巧》

文章目录 一、数据库结构与数据源插入1.1 创建数据库与表1.2 插入数据 二、基础数据查询2.1 查询客户信息2.2 查询供应商信息 三、查询优化与技巧3.1 使用LIMIT子句 四、高级查询技巧4.1 使用聚合函数4.2 连接查询4.3 使用子查询 五、案例分析5.1 客户订单详情查询 一、数据库结…
阅读更多...
MySQL篇（窗口函数/公用表达式（CTE））(持续更新迭代）

MySQL篇（窗口函数/公用表达式（CTE））(持续更新迭代）

目录 讲解一&#xff1a;窗口函数 一、简介 二、常见操作 1. sumgroup by常规的聚合函数操作 2. sum窗口函数的聚合操作 三、基本语法 1. Function(arg1,..., argn) 1.1. 聚合函数 sum函数&#xff1a;求和 min函数 &#xff1a;最小值 1.2. 排序函数 1.3. 跨行函数…
阅读更多...
DeiT(ICML2021)：Data-efficient image Transformer，基于新型蒸馏且数据高效的ViT！

DeiT(ICML2021)：Data-efficient image Transformer，基于新型蒸馏且数据高效的ViT！

Training data-efficient image transformers & distillation through attention&#xff1a;通过注意力训练数据高效的图像转换器和蒸馏 论文地址&#xff1a; https://arxiv.org/abs/2012.12877 代码地址&#xff1a; https://github.com/facebookresearch/deit 这篇论文…
阅读更多...
14.第二阶段x86游戏实战2-C++语言开发环境搭建-VisualStudio2017

14.第二阶段x86游戏实战2-C++语言开发环境搭建-VisualStudio2017

免责声明&#xff1a;内容仅供学习参考&#xff0c;请合法利用知识&#xff0c;禁止进行违法犯罪活动&#xff01; 本次游戏没法给 内容参考于&#xff1a;微尘网络安全 本人写的内容纯属胡编乱造&#xff0c;全都是合成造假&#xff0c;仅仅只是为了娱乐&#xff0c;请不要…
阅读更多...
vue-入门速通

vue-入门速通

setup是最早的生命周期&#xff0c;在vue2里边的data域可以使用this调用setup里面的数据&#xff0c;但是在setup里边不能使用thisvue项目的可执行文件是index&#xff0c;另外运行前端需要npm run vue的三个模块内需要三个不同的结构&#xff0c;里边放置js代码&#xff0c;注…
阅读更多...
2024/9/21 leetcode 21.合并两个有序链表 2.两数相加

2024/9/21 leetcode 21.合并两个有序链表 2.两数相加

目录 21.合并两个有序链表 题目描述 题目链接 解题思路与代码 2.两数相加 题目描述 题目链接 解题思路与代码 --------------------------------------------------------------------------- 21.合并两个有序链表 题目描述 将两个升序链表合并为一个新的 升序 链表并返…
阅读更多...
CVPT: Cross-Attention help Visual Prompt Tuning adapt visual task

CVPT: Cross-Attention help Visual Prompt Tuning adapt visual task

论文汇总 当前的问题 图1:在VTAB-1k基准测试上&#xff0c;使用预训练的ViT-B/16模型&#xff0c;VPT和我们的CVPT之间的性能和Flops比较。我们将提示的数量分别设置为1、10、20、50,100,150,200。 如图1所示&#xff0c;当给出大量提示时&#xff0c;VPT显示了性能的显著下降…
阅读更多...
【MySQL 04】数据类型

【MySQL 04】数据类型

目录 1.数据类型分类 2.数值类型 2.1 tinyint 类型 2.2 bit类型 2.3 float类型 2.4decimal 3.字符串类型 3.1 char类型 3.2 varchar类型 4.日期和时间类型 6. enum和set类型 6.1.enum和set类型简介&#xff1a; 6.2.enum和set的一般使用方法 6.3.用数字的方式…
阅读更多...
如何用AI实现自动更新文章？(全自动更新网站)

如何用AI实现自动更新文章？(全自动更新网站)

AI的诞生确实给我们的生活和工作都带来了很大的改变&#xff0c;从我自身来讲&#xff0c;也渐渐习惯了遇到事情先问问AI&#xff0c;不管是翻译、专业性问题、PPT制作、总结写作这些&#xff0c;确实帮我迅速理清了思路&#xff0c;也可以有很多内容的借鉴。 作为一个业余爱好…
阅读更多...
kismet和war driving具体准备（仅供无线安全学习）

kismet和war driving具体准备（仅供无线安全学习）

war driving准备 一台笔记本 一个最好是双频的网卡&#xff0c;单频搜集信号少 我自己买的是http://e.tb.cn/h.grI4EmkDLOqQXHG?tkKZ5g3RVeH6f 如果经济条件允许可以去买大功率天线&#xff08;我买的车载的 大概40db这样子 范围广&#xff09; http://e.tb.cn/h.grCM0CQ6L…
阅读更多...
Davinci 大数据可视化分析

Davinci 大数据可视化分析

Davinci 大数据可视化分析 一、Davinci 架构设计1.1 Davinci定义1.2 Davinci 应用场景 二、Davinci 安装部署2.1 部署规划2.2 前置环境准备2.3 Davinci部署2.3.1 物料准备2.3.2 安装配置 2.4 环境变量配置2.5 初始化数据库2.5.1 创建数据库及用户 2.5.2 建表2.6 初始化配置 三、…
阅读更多...
7天速成前端 ------学习日志 （继苍穹外卖之后）

7天速成前端 ------学习日志 （继苍穹外卖之后）

前端速成计划总结&#xff1a; 全26h课程&#xff0c;包含html&#xff0c;css&#xff0c;js&#xff0c;vue3&#xff0c;预计7天内学完。 起始日期&#xff1a;9.16 预计截止&#xff1a;9.22 每日更新&#xff0c;学完为止。 学前计划 课…
阅读更多...
使用IDA Pro动态调试Android APP

使用IDA Pro动态调试Android APP

版权归作者所有&#xff0c;如有转发&#xff0c;请注明文章出处&#xff1a;https://cyrus-studio.github.io/blog/ 关于 android_server android_server 是 IDA Pro 在 Android 设备上运行的一个调试服务器。 通过在 Android 设备上运行android_server&#xff0c;IDA Pro …
阅读更多...
IDEA 2024.3 EAP新特征早览！

IDEA 2024.3 EAP新特征早览！

0 前言 IntelliJ IDEA 2024.3 第一个 EAP 版本已发布&#xff0c;提前体验 下一个重大版本的一部分改进。 持续关注 EAP 更新&#xff0c;未来几周内将推出更多 IntelliJ IDEA 新功能。尝试这些新功能&#xff0c;分享您的反馈&#xff0c;共同完善 IDE。 1 AI 助手 1.1 内…
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023