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.xdnf.cn/news/142397.html

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

相关文章

【优化器】Optimizer——深度学习中的优化器是什么作用呢？

【优化器】Optimizer——深度学习中的优化器是什么作用呢？

【优化器】Optimizer——深度学习中的优化器是什么作用呢&#xff1f; 【优化器】Optimizer——深度学习中的优化器是什么作用呢&#xff1f; 文章目录 【优化器】Optimizer——深度学习中的优化器是什么作用呢&#xff1f;1.什么是优化器&#xff1f;梯度下降法3. 常见的优化…
阅读更多...
在typescript浏览器端中调用C++编写的函数，WebAssembly传递指针类型的参数，以及处理指针类型的返回值。

在typescript浏览器端中调用C++编写的函数，WebAssembly传递指针类型的参数，以及处理指针类型的返回值。

首先要在Cmake工程中的cmakelists.txt文件中引入Emscripten工具链&#xff1a; set(CMAKE_TOOLCHAIN_FILE "D:/CppPkg/emsdk/upstream/emscripten/cmake/Modules/Platform/Emscripten.cmake")直接看C代码&#xff1a; #include <emscripten/emscripten.h> #i…
阅读更多...
鸿蒙开发之ArkTS 基础六 对象

鸿蒙开发之ArkTS 基础六 对象

什么是对象的呢&#xff1f;就是描述物体的特征和行为&#xff0c;是可以存储多种数据的容器 对象的定义和使用 let 对象名称: 对象结构类型 值 通过interface 关键字来约定对象结构类型,语法结构如下&#xff1a; interface 对象名{ 属性1&#xff1a;类型 属性2&#…
阅读更多...
11.01类的定义和对象的使用（练习）

11.01类的定义和对象的使用（练习）

类的定义 类名&#xff1a;手机(Phone) 成员变量&#xff1a;品牌(brand&#xff09;&#xff0c;价格&#xff08;price&#xff09; 成员方法&#xff1a;打电话(calL)&#xff0c;发短信&#xff08;sendMessage&#xff09; 调用类变量和方法
阅读更多...
基于SpringBoot+Vue+MySQL的高校心理教育辅导系统

基于SpringBoot+Vue+MySQL的高校心理教育辅导系统

系统展示 用户前台界面 管理员后台界面 系统背景 随着社会的快速发展&#xff0c;大学生群体面临着日益复杂的学习、生活及就业压力&#xff0c;心理健康问题日益凸显。传统的面对面心理咨询方式因时间、空间等限制&#xff0c;难以满足学生多样化的需求。因此&#xff0c;利用…
阅读更多...
基于spring的ssm整合

基于spring的ssm整合

目录 基于spring的ssm整合 Spring 框架 SpringMVC 框架 MyBatis 框架 1.创建项目 2.导入依赖 3.导入sql 4.创建jdbc.propries文件 1&#xff09;mysql8以下 2&#xff09;mysql8以上的 5.创建mybatis-config.xml配置文件 6.创建spring-Config.xml文件 7.创建项目所需包和类 1&a…
阅读更多...
2024-1.2.12-Android-Studio配置

2024-1.2.12-Android-Studio配置

本地博客: https://k1t0111.github.io/ K1T0 最近在做一些app方向的移动技术开发学习&#xff0c;但是由于AS的配置问题&#xff0c;市面上找不到最新的2024版本的AS的相关配置。笔者也是踩了很多坑&#xff0c;因此想写一篇文章记录一下最新的AS 2024 1.2.12的对应java环境的一…
阅读更多...
Html css样式总结

Html css样式总结

1.Html css样式总结 1.1. 定位position 布局是html中非常重要的一部分&#xff0c;而定位在页面布局中也是使用频率很高的方法&#xff0c;本章节为定位在布局中的使用技巧和注意事项。   position定位有4个属性&#xff0c;分别是static(默认&#xff09;&#xff0c;absol…
阅读更多...
CLIP论文中关键信息记录

CLIP论文中关键信息记录

由于clip论文过长&#xff0c;一直无法完整的阅读该论文&#xff0c;故而抽取论文中的关键信息进行记录。主要记录clip是如何实现的的&#xff08;提出背景、训练数据、设计模式、训练超参数、prompt的作用&#xff09;&#xff0c;clip的能力&#xff08;clip的模型版本、clip…
阅读更多...
感知器神经网络

感知器神经网络

1、原理 感知器是一种前馈人工神经网络&#xff0c;是人工神经网络中的一种典型结构。感知器具有分层结构&#xff0c;信息从输入层进入网络&#xff0c;逐层向前传递至输出层。根据感知器神经元变换函数、隐层数以及权值调整规则的不同&#xff0c;可以形成具有各种功能特点的…
阅读更多...
学习笔记 韩顺平 零基础30天学会Java（2024.9.15）

学习笔记 韩顺平 零基础30天学会Java（2024.9.15）

P557 泛型应用实例 P558 泛型使用细节1 P560 泛型使用细节2 P560 泛型课堂练习 代码见Exceise P561 自定义泛型类 对于第二点&#xff0c;因为不知道类型&#xff0c;所以不知道开辟多少空间&#xff0c;因此不能初始化 第三点&#xff0c;静态方法与类相关的&#xff0c;在类…
阅读更多...
LeetCode[中等] 189.轮转数组

LeetCode[中等] 189.轮转数组

给定一个整数数组 nums&#xff0c;将数组中的元素向右轮转 k 个位置&#xff0c;其中 k 是非负数。 思路 创建一个新数组&#xff0c;存储原数组旋转后的元素&#xff0c;然后将新数组中的元素复制回原数组。 public class Solution {public void Rotate(int[] nums, int k)…
阅读更多...
【docker】阿里云使用docker，2024各种采坑

【docker】阿里云使用docker，2024各种采坑

▒ 目录 ▒ &#x1f6eb; 导读需求开发环境 1️⃣ dial tcp: lookup on 8.8.8.8:53: no such host失败属于DNS问题 2️⃣ docker镜像配置配置最新镜像源 3️⃣ 【重点】阿里云专用获取自己的镜像加速器地址配置镜像地址 &#x1f6ec; 文章小结&#x1f4d6; 参考资料 &#x…
阅读更多...
一款强大的吉他乐谱编辑软件GuitarPro 8.2中文解锁版

一款强大的吉他乐谱编辑软件GuitarPro 8.2中文解锁版

GuitarPro 8.2中文解锁版是一款强大的吉他乐谱编辑软件&#xff0c;适合新手和专业乐手。它提供详尽教程和实用工具&#xff0c;助力初学者掌握吉他技巧&#xff1b;对于专业乐手&#xff0c;它精准记录音符和节奏&#xff0c;提供丰富编辑功能和音效处理。此外&#xff0c;软件…
阅读更多...
虽难必学系列：Netty

虽难必学系列：Netty

Netty 是一个基于 Java 的高性能、异步事件驱动的网络应用框架&#xff0c;广泛用于构建各类网络应用&#xff0c;尤其是在高并发、低延迟场景下表现出色。作为一个开源项目&#xff0c;Netty 提供了丰富的功能&#xff0c;使得开发者可以轻松构建协议服务器和客户端应用程序。…
阅读更多...
图像生成领域老牌的GAN模型简要回顾

图像生成领域老牌的GAN模型简要回顾

&#x1f367;背景 这篇文章内容很浅&#xff0c;只是个基础概念介绍&#xff0c;无深度分析。 生成对抗网络&#xff08;Generative Adversarial Networks&#xff0c;简称GAN&#xff09;是一种深度学习模型&#xff0c;由Ian Goodfellow等人在2014年提出&#xff0c;没错&…
阅读更多...
【路径规划】全局路径规划算法，基于RRT算法家族的改进

【路径规划】全局路径规划算法，基于RRT算法家族的改进

摘要 本项目对经典的 RRT* 算法进行了改进&#xff0c;开发了 Informed-RRT* 算法&#xff0c;用于高效的全局路径规划。Informed-RRT* 通过引入启发式搜索和路径优化策略&#xff0c;在经典 RRT* 的基础上显著提高了路径质量和搜索效率。该算法特别适用于复杂环境中的高维路径…
阅读更多...
信号的产生，保存与处理

信号的产生，保存与处理

1.信号的概念&#xff1a; 在生活中的信号&#xff1a;红绿灯&#xff0c;下课铃声&#xff0c;闹钟 红绿灯&#xff0c;你为什么认识红绿灯&#xff1f; 1.能识别红绿灯 2.能理解红灯绿灯黄灯 也就是说信号在还没产生的时候&#xff0c;我们已经认识信号并知道如何去处理…
阅读更多...
数据稀缺条件下的时间序列微分：符号回归(Symbolic Regression)方法介绍与Python示例

数据稀缺条件下的时间序列微分：符号回归(Symbolic Regression)方法介绍与Python示例

时间序列概况在日常生活和专业研究中都很常见。简而言之,时间序列概况是一系列连续的数据点 y(0), y(1), …, y(t) ,其中时间 t 的点依赖于时间 t-1 的前一个点(或更早的时间点)。 在许多应用中,研究者致力于预测时间序列概况的未来行为。存在各种建模方法。这些模型通常基于过…
阅读更多...
算法：76.最小覆盖子串

算法：76.最小覆盖子串

题目 链接&#xff1a;leetcode链接 思路分析&#xff08;滑动窗口&#xff09; 还是老样子&#xff0c;连续问题&#xff0c;滑动窗口哈希表 令t用的hash表为hash1&#xff0c;s用的hash表为hash2 利用hash表统计窗口内的个字符出现的个数&#xff0c;与hash1进行比较 选…
阅读更多...
最新文章

Copyright @ 2022~2023