C++并发编程 -3.同步并发操作

本文介绍如何使用条件变量控制并发的同步操作、C++ 并发三剑客，函数式编程

一.条件变量

1.概念

        C++条件变量（condition variable）是一种多线程编程中常用的同步机制，用于线程间的通信和协调。它允许一个或多个线程等待某个条件的发生，当条件满足时，线程被唤醒并继续执行。

        在C++中，条件变量通常与互斥锁（mutex）一起使用，以确保线程之间的安全访问共享资源。互斥锁用于保护共享资源的访问，而条件变量用于在某个条件满足时通知等待的线程。

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>std::mutex mtx;
std::condition_variable cv;
bool isReady = false;void workerThread()
{std::unique_lock<std::mutex> lock(mtx);while (!isReady){cv.wait(lock); // 等待条件变量满足}std::cout << "Worker thread is awake!" << std::endl;
}int main()
{std::thread worker(workerThread);std::this_thread::sleep_for(std::chrono::seconds(2)); // 模拟一些耗时操作{std::lock_guard<std::mutex> lock(mtx);isReady = true;cv.notify_one(); // 唤醒等待的线程}worker.join();return 0;
}

        主线程创建了一个工作线程，并在工作线程中等待条件变量isReady为true。主线程在等待一段时间后，将isReady设置为true，并通过cv.notify_one()唤醒工作线程。工作线程在等待期间调用cv.wait(lock)，这会使线程进入等待状态，直到条件变量被唤醒。一旦条件满足，工作线程被唤醒并输出消息。

        其中wait参数有三种使用方式：

waitwait_forwait_until
函数原型void wait(std::unique_lock<std::mutex>& lock);template< class Rep, class Period > std::cv_status wait_for(std::unique_lock<std::mutex>& lock, const std::chrono::duration<Rep, Period>& rel_time);template< class Clock, class Duration > std::cv_status wait_until(std::unique_lock<std::mutex>& lock, const std::chrono::time_point<Clock, Duration>& abs_time);
功能调用wait释放锁，等待notify。被唤醒后加锁

1.调用wait释放锁，等待notify。被唤醒后加锁。

2.等待时间超过指定的相对时间，超时后继续加锁。

1.调用wait释放锁，等待notify。被唤醒后加锁。

2.等待时间超过指定的相对时间，无论是否超时仍加锁。

3.等待超过指定时间

返回值无

等待时间内被唤醒，则返回std::cv_status::no_timeout；

如果等待时间超时，则返回std::cv_status::timeout

与waitfor一致
示例 
cv.wait(lock, []{ return isDataReady; });

 
cv.wait_for(lock, std::chrono::seconds(5), []{ return isDataReady; }

 
    auto timeout = std::chrono::steady_clock::now() + std::chrono::seconds(5);cv.wait_until(lock, timeout, []{ return isDataReady; })

2.使用条件变量构建线程安全的栈区

        回顾：

        在第三章节 -构建线程安全的栈区  为了避免数据竞争，对于pop操作在线程中调用empty判断是否为空，如果不为空，则pop，因为empty和pop内部分别加锁，是两个原子操作，导致pop时可能会因为其他线程提前pop导致队列为空，从而引发崩溃。

void push(T new_value)
{std::lock_guard<std::mutex> lock(m);data.push(std::move(new_value));
}T pop()
{std::lock_guard<std::mutex> lock(m);auto element = data.top();data.pop();return element;
}threadsafe_stack1<int> safe_stack;
safe_stack.push(1);
std::thread t1([&safe_stack]() 
{if (!safe_stack.empty()) {std::this_thread::sleep_for(std::chrono::seconds(1));safe_stack.pop();}
});
std::thread t2([&safe_stack]() 
{if (!safe_stack.empty()) {std::this_thread::sleep_for(std::chrono::seconds(1));safe_stack.pop();}
});

                 

        通过添加《传入引用》或《返回弹出元素的指针》来解决上面异常。但是两种方式都存在一定的弊端：

        传入引用弊端是需要在函数外部构建临时变量影响效率且需要抛出空栈。

        返回智能指针异常下会导致空指针产生。

        这么都不是很友好，所以我们可以通过条件变量完善之前的程序，重新实现一个线程安全队列。

#include <iostream>
#include <thread>
#include <stack>
#include <memory>
#include <mutex>
#include <condition_variable>using namespace std;template<typename T>
class threadQueue
{
public:threadQueue(): mutx(), condVar(), stackQueue(){};~threadQueue(){};void push(T value){lock_guard<mutex> lk(mutx);stackQueue.push(value);condVar.notify_one();}void waitAndpop(T &stackQueue_){unique_lock<mutex> lk(mutx);/*wait函数第二个参数确保队列有数据才进行条件变量后续操作，相当于增加一层判断，更加准确*/condVar.wait(lk, [this](){return !stackQueue.empty();});stackQueue_ = stackQueue.top();stackQueue.pop();}shared_ptr<T> waitAndPop(){unique_lock<mutex> lk(mutx);condVar.wait(lk, [this](){return !stackQueue.empty();});shared_ptr<T> res = make_shared<T>(stackQueue.top());stackQueue.pop();return res;}bool tryPop(T &value){lock_guard<mutex> lk(mutx);if(stackQueue.empty()){return false;}value = stackQueue.top();stackQueue.pop();return true;}shared_ptr<T> tryPop(){lock_guard<mutex> lk(mutx);if (stackQueue.empty())return std::shared_ptr<T>();shared_ptr<T> res = make_shared<T>(stackQueue.top());stackQueue.pop();return res;}private:mutable mutex mutx;condition_variable condVar;stack<T> stackQueue;
};mutex mutxThread;template<typename T>
void funcProducer(threadQueue<T> &thdQueue)
{for(;;){for(size_t i = 0; i < __LONG_MAX__; i++){thdQueue.push(i);lock_guard<mutex> lk(mutxThread);cout<<"funcProducer:"<<i<<endl;this_thread::sleep_for(chrono::milliseconds(100));}}
}template<typename T>
void funcWorker1(threadQueue<T> &thdQueue)
{for(;;){auto data = thdQueue.waitAndPop();lock_guard<mutex> lk(mutxThread);cout<<"funcWorker1 waitAndpop:"<<*(data)<<endl;// this_thread::sleep_for(chrono::milliseconds(500));}
}template<typename T>
void funcWorker2(threadQueue<T> &thdQueue)
{for(;;){auto data = thdQueue.tryPop();if(data != nullptr){lock_guard<mutex> lk(mutxThread);cout<<"funcWorker2 waitAndpop:"<<*(data)<<endl;}// this_thread::sleep_for(chrono::milliseconds(500));}
}int main()
{threadQueue<int> thdQueue;thread t1(funcProducer<int>, ref(thdQueue));thread t2(funcWorker1<int>, ref(thdQueue));thread t3(funcWorker2<int>, ref(thdQueue));t1.join();t2.join();t3.join();
}

二.C++ 并发三剑客

        简单介绍一下future, promise和async三者之间的关系。其具体实现请看本章节第四小节

1.async

        std::async 是一个用于异步执行函数的模板函数，它返回一个 std::future 对象，该对象用于获取函数的返回值。其主要应用于I/O密集型任务，如网络请求或文件读写，其中操作可能需要等待，但CPU不需要做太多工作.(thread适用于CPU密集型任务)

        async可选填参数：

        指定launch::async：表示任务执行在另一线程。

        指定launch::deferred：表示延迟执行任务，调用get或者wait时才会执行，不会创建线程，惰性执行在当前线程。

        不填写或同时指定：属于未定义行为，编译器会根据实际情况决定采用哪种策略（通常创建线程）

1.1 async异步任务

        async启用异步执行后，在其内部会创建一个线程，任务完成后线程自动销毁，不需要join等操作。


#include <iostream>
#include <thread>
#include <memory>
#include <future>using namespace std;void func()
{int i = 0;for(;;){cout<<"func"<<endl;this_thread::sleep_for(chrono::seconds(1));if(++i == 10) {break;}}cout<<" thread end"<<endl;
}int main()
{std::future<void> the_answer=std::async(launch::async, func);//deferredfor(int i = 0; i < 15; ++i){cout<<"main run"<<endl;this_thread::sleep_for(chrono::seconds(1));}return 1;
}

  刚运行时可以看到存在两个线程

  线程退出后：

1.2 async延时执行

        当指定launch::deferred表示延迟执行任务，调用get或者wait时才会在调用线程中执行。                 std::future::get() 和 std::future::wait() 是 C++ 中用于处理异步任务的两个方法.

1.2.1 future::get()

        这是一个阻塞调用，用于获取 std::future 对象表示的值或异常。如果异步任务还没有完成，get() 会阻塞当前线程，直到任务完成。如果任务已经完成，get() 会立即返回任务的结果。get() 只能调用一次，因为它会移动或消耗掉 std::future 对象的状态。一旦 get() 被调用，std::future 对象就不能再被用来获取结果。如果调用两次，会出现如下结果：

#include <iostream>
#include <thread>
#include <memory>
#include <future>using namespace std;void func()
{cout<<"func"<<endl;
}int main()
{std::future<void> the_answer=std::async(launch::deferred, func);//deferredcout<<"main run"<<endl;this_thread::sleep_for(chrono::seconds(1));the_answer.get();the_answer.get();return 1;
}

                 

        为避免多次调用get造成异常，尽量使用wait

1.2.2 future::wait()

        std::future::wait() 也是一个阻塞调用，但它与 get() 的主要区别在于 wait() 不会返回任务的结果。它只是等待异步任务完成。如果任务已经完成，wait() 会立即返回。如果任务还没有完成，wait() 会阻塞当前线程，直到任务完成。与 get() 不同，wait() 可以被多次调用，它不会消耗掉 std::future 对象的状态。

#include <iostream>
#include <thread>
#include <memory>
#include <future>using namespace std;int func()
{std::this_thread::sleep_for(std::chrono::milliseconds(1000));cout<<"func"<<endl;return 10;
}int main()
{future<int> the_answer = async(launch::deferred, func);cout<<"main run"<<endl;auto start = std::chrono::high_resolution_clock::now(); the_answer.wait();the_answer.wait();auto end = std::chrono::high_resolution_clock::now();auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start); cout << "the_answer.wait run time: " << duration.count() << " ms" << endl;return 1;
}

         

可以看到只运行了1000ms， 当第一个wait运行结束表示任务执行结束,而第二个wait会立马返回。

waitget
阻塞线程，知道任务运行完毕阻塞线程，知道任务运行完毕
可多次调用，当任务执行完毕后wait将不在起作用，会立马返回。不可多次调用，异常
执行任务，不获取结果执行任务，获取结果
  •  也可以通过wait_for(std::chrono::seconds(0)(要求任务立马返回)，判断任务是否已经完成
if (the_answer.wait_for(std::chrono::seconds(0)) == std::future_status::ready)
{cout<<"task already over"<<endl;return 0;
}

2.promise和packaged_task

        promise和packaged_task都是C++中的异步编程工具，用于在多线程环境下进行任务的分离和结果的传递。

        promise是一种用于在一个线程中产生结果，并在另一个线程中获取结果的机制。它允许一个线程（称为"提供者"）在某个时间点设置一个值或异常，而另一个线程（称为"消费者"）在需要时获取该值或异常。

        packaged_task是一种将可调用对象（如函数、函数对象或Lambda表达式）封装为一个可以异步执行的任务的机制。

        两者都是与future结合使用，通过future获取结果或者值。

2.1.future与packaged_task

        packaged_task是一个可调用目标，它包装了一个任务，该任务可以在另一个线程上运行。它可以捕获任务的返回值或异常，并将其存储在future对象中，以便以后使用。

        使用future和packaged_task通常的做法是：

1)  创建一个std::packaged_task对象，该对象包装了要执行的任务。

funciton my_task
packaged_task<int()> task(my_task);

2)  调用packaged_task对象的get_future()方法，该方法返回一个与任务关联的future对象。

future<int> result = task.get_future();

3)  在另一个线程上调用std::packaged_task对象的operator()，以执行任务。

 thread t(move(task));

4)   在需要任务结果的地方，调用与任务关联的future对象的get()方法，以获取任务的返回值或异常。

int value = result.get();

示例：

#include <iostream>
#include <thread>
#include <memory>
#include <future>using namespace std;int my_task() {this_thread::sleep_for( chrono::seconds(5));cout << "my task run 5 s" <<  endl;return 42;
}
int main()
{// 创建一个包装了任务的  packaged_task 对象  packaged_task<int()> task(my_task);// 获取与任务关联的  future 对象  future<int> result = task.get_future();// cout<<"task.get_future()"<<task.get_future().get()<<endl;// 在另一个线程上执行任务  thread t(move(task));t.detach(); // 将线程与主线程分离，以便主线程可以等待任务完成  // 等待任务完成并获取结果  cout << "will get result"<<endl;int value = result.get();cout << "The result is: " << value <<  endl;}

                         

        在上面的示例中，我们创建了一个包装了任务的std::packaged_task对象，并获取了与任务关联的std::future对象。然后，我们在另一个线程上执行任务，并等待任务完成并获取结果。最后，我们输出结果。

2.2.future与promise
2.2.1 设置值

        packaged_task主要是异步过程中任务，promise在异步过程中处理数值。

#include <iostream>
#include <thread>
#include <future>void set_value(std::promise<int>& prom) {std::this_thread::sleep_for(std::chrono::seconds(2));// 设置结果为42prom.set_value(42);
}int main() {std::promise<int> prom;std::future<int> fut = prom.get_future();std::thread t(set_value, std::ref(prom));// 在主线程中等待结果int result = fut.get();std::cout << "Result: " << result << std::endl;t.join();return 0;
}

        值得注意的是在调用fut.get()方法时，如果promise的值还没有被设置，则该方法会阻塞当前线程，直到值被设置为止。

2.2.2 设置异常

        promise还有一个set_exception()方法，用于设置异常。该方法接受std::exception_ptr参数，该参数可以通过调用std::current_exception()方法获取。


#include <iostream>
#include <thread>
#include <future>void set_exception(std::promise<int>& prom) {try {// 模拟一些可能抛出异常的操作throw std::runtime_error("Something went wrong");} catch (...) {// 捕获异常并设置到 promise 中prom.set_exception(std::current_exception());}
}int main() {std::promise<int> prom;std::future<int> fut = prom.get_future();std::thread t(set_exception, std::ref(prom));try {// 在主线程中等待结果int result = fut.get();std::cout << "Result: " << result << std::endl;} catch (const std::exception& e) {std::cout << "Exception caught: " << e.what() << std::endl;}t.join();return 0;
}

        set_exception 函数中,我们模拟了一些可能抛出异常的操作,并使用prom.set_exception (std::current_exception()) 将当前捕获的异常设置到 promise 中。在主线程中，我们使用 fut.get() 等待并获取结果。如果在另一个线程中发生了异常，我们可以在主线程中使用 try-catch 块捕获并处理异常。

3 future与shared_future

        当需要多个线程等待同一个执行结果时，需要使用std::shared_future。

        适合使用std::shared_future的场景，多个线程等待同一个异步操作的结果：

#include <iostream>
#include <thread>
#include <future>void myFunction(std::promise<int>&& promise) 
{std::this_thread::sleep_for(std::chrono::seconds(1));promise.set_value(42); // 设置 promise 的值
}
void threadFunction(std::shared_future<int> future) 
{try {int result = future.get();std::cout << "Result: " << result<<"this thread id:"<<std::this_thread::get_id() << std::endl;}catch (const std::future_error& e) {std::cout << "Future error: " << e.what() << std::endl;}
}
int main() 
{std::promise<int> promise;std::shared_future<int> future = promise.get_future();std::thread myThread1(myFunction, std::move(promise)); // 将 promise 移动到线程中// 使用 share() 方法获取新的 shared_future 对象  std::thread myThread2(threadFunction, future);std::thread myThread3(threadFunction, future);myThread1.join();myThread2.join();myThread3.join();return 0;
}

         

        在这个示例中，创建了一个std::promise<int>对象promise和一个与之关联的std::shared_future<int>对象future。然后，我们将promise对象移动到另一个线程myThread1中，该线程将执行myFunction函数，并在完成后设置promise的值。我们还创建了两个线程myThread2和myThread3，它们将等待future对象的结果。如果myThread1成功地设置了promise的值，那么future.get()将返回该值。这些线程可以同时访问和等待future对象的结果，而不会相互干扰。 

4. 自顶向下实现

4.1  用packaged_task实现async

        async异步任务相当于创建线程，不再予以实现。

        async延时执行示例如下:

#include <iostream>
#include <thread>
#include <future>
#include <functional>using Func = std::function<int(int)>;std::future<int> myAsync(Func task, int i)
{std::packaged_task<int(int)> packaged(task);std::future<int> fu = packaged.get_future();std::thread t(std::move(packaged), i);t.detach();return fu;
}int main()
{auto task = [](int i) { std::this_thread::sleep_for(std::chrono::seconds(1)); return i+100; };std::future<int> f = myAsync(task, 5);std::cout << f.get() << std::endl;return 0;
}

         async指定deferred 表示延时进行，其内部与上述内部实现类似，先使用packaged打包需要执行的任务，然后将任务与future绑定，将任务move到线程中，执行完毕后通过future.get获取任务执行结果。如此便满足第二章节图片内容结构。

4.2  使用promise实现packaged_task

          通过promise设置值来完成packaged_task反馈。

#include <iostream>
#include <thread>
#include <future>
#include <functional>//typename关键字在C++中的主要作用是告诉编译器某个名称是一个类型而不是变量或函数。
template<typename Type, typename... Args>
class myPackTask
{
public:myPackTask(std::function<Type(Args...)> _func):func_(_func){}std::future<Type> get_future(){return promise_.get_future();}void operator()(Args... args){Type result = func_(args...);promise_.set_value(result);}private:std::function<Type(Args...)> func_;std::promise<Type> promise_;
};int add(int a, int b) {return a + b;
}int main() {myPackTask<int, int, int> task(add);std::future<int> future = task.get_future(); std::thread thread(std::move(task), 2, 3);  int result = future.get();  std::cout << "Result: " << result << std::endl;thread.join();  // 等待线程结束return 0;
}
 4.3  实现promise

        其主要思想就是通过条件变量通知get所在线程调用的地方。

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>template<typename T>
class Promise {
public:Promise() : value(nullptr), ready(false) {}void set(const T& val) {std::unique_lock<std::mutex> lock(mutex);value = std::make_shared<T>(val);ready = true;condition.notify_all();}T get() {std::unique_lock<std::mutex> lock(mutex);condition.wait(lock, [this] { return ready; });return *value;}private:std::shared_ptr<T> value;bool ready;std::mutex mutex;std::condition_variable condition;
};int main() {Promise<int> promise;std::thread producer([&promise]() {std::this_thread::sleep_for(std::chrono::seconds(2));promise.set(42);});std::thread consumer([&promise]() {int result = promise.get();std::cout << "Got value: " << result << std::endl;});producer.join();consumer.join();return 0;
}

三.并行与函数式编程

以下内容摘自恋恋风尘，博主讲解C++并发非常不错，力荐

1 快速排序

        先使用C++ 设计一个快速排序方法

#include <iostream>
#include <thread>
#include <memory>
#include <future>template<typename T>
void quick_sort_recursive(T arr[], int start, int end) {if (start >= end) return;T key = arr[start];int left = start, right = end;while(left < right) {while (arr[right] >= key && left < right) right--;while (arr[left] <= key && left < right) left++;std::swap(arr[left], arr[right]);}if (arr[left] < key) {std::swap(arr[left], arr[start]);}quick_sort_recursive(arr, start, left - 1);quick_sort_recursive(arr, left + 1, end);
}
template<typename T>
void quick_sort(T arr[], int len) {quick_sort_recursive(arr, 0, len - 1);
}int main() {int num_arr[] = { 5,3,7,6,4,1,0,2,9,10,8 };int length = sizeof(num_arr) / sizeof(int);quick_sort(num_arr, length );std::cout << "sorted result is ";for (int i = 0; i < length; i++) {std::cout << " " << num_arr[i];}std::cout << std::endl;    
}

2 使用函数式编程快速排序

        函数式编程可以被看作是将函数视为数学中的公式。在函数式编程中，函数被视为一种纯粹的数学映射，它接受输入并产生输出，没有副作用或可变状态。这种思想源于数学中的函数概念，其中函数被定义为将输入映射到输出的关系。

        在第一小节实现快速排序是一种面向过程的编程方式，我们可以通过定义一个函数来实现快速排序算法。这个函数接受一个数组作为输入，并通过一系列的步骤来实现快速排序的逻辑。这些步骤包括选择基准元素、划分数组、递归调用等。

        而使用函数式编程，强调使用纯函数来构建程序，通过函数的组合和转换来处理数据。函数式编程避免使用可变状态和共享状态。

#include <iostream>
#include <thread>
#include <memory>
#include <future>
#include <list>
#include <algorithm>template<typename T>
std::list<T> sequential_quick_sort(std::list<T> input)
{if (input.empty()){return input;}std::list<T> result;//  ① 将input中的第一个元素放入result中，并且将这第一个元素从input中删除result.splice(result.begin(), input, input.begin());  //  ② 取result的第一个元素，将来用这个元素做切割，切割input中的列表。T const& pivot = *result.begin();    //  ③std::partition 是一个标准库函数，用于将容器或数组中的元素按照指定的条件进行分区，// 使得满足条件的元素排在不满足条件的元素之前。// 所以经过计算divide_point指向的是input中第一个大于等于pivot的元素auto divide_point = std::partition(input.begin(), input.end(),[&](T const& t) {return t < pivot; });    // ④ 我们将小于pivot的元素放入lower_part中std::list<T> lower_part;lower_part.splice(lower_part.end(), input, input.begin(),divide_point);  // ⑤我们将lower_part传递给sequential_quick_sort 返回一个新的有序的从小到大的序列//lower_part 中都是小于divide_point的值auto new_lower(sequential_quick_sort(std::move(lower_part)));    // ⑥我们剩余的input列表传递给sequential_quick_sort递归调用，input中都是大于divide_point的值。auto new_higher(sequential_quick_sort(std::move(input)));    //⑦到此时new_higher和new_lower都是从小到大排序好的列表//将new_higher 拼接到result的尾部result.splice(result.end(), new_higher);    //将new_lower 拼接到result的头部result.splice(result.begin(), new_lower);   return result;
}int main() {std::list<int> numlists = { 6,1,0,7,5,2,9,-1 };auto sort_result = sequential_quick_sort(numlists);std::cout << "sorted result is ";for (auto iter = sort_result.begin(); iter != sort_result.end(); iter++) {std::cout << " " << (*iter);}std::cout << std::endl;
}

3 并行处理快速排序

        在快速排序中，我们以某个数字作为基准（一般开头）, 分为前半部分和后半部分，然后前半部分和后半部分单独计算。 

        并行排序的思想是将前半部分（或后半部分）单独拷贝一份，置于async中（不指定启动方式，编译器会根据计算次数决定什么时候异步执行什么时候串行），进行并行计算

#include <iostream>
#include <thread>
#include <memory>
#include <future>
#include <list>
#include <algorithm>template<typename T>
std::list<T> parallel_quick_sort(std::list<T> input)
{if (input.empty()){return input;}std::list<T> result;result.splice(result.begin(), input, input.begin());T const& pivot = *result.begin();auto divide_point = std::partition(input.begin(), input.end(),[&](T const& t) {return t < pivot; });std::list<T> lower_part;lower_part.splice(lower_part.end(), input, input.begin(),divide_point);// ①因为lower_part是副本，所以并行操作不会引发逻辑错误，这里可以启动future做排序std::future<std::list<T>> new_lower(std::async(&parallel_quick_sort<T>, std::move(lower_part)));// ②auto new_higher(parallel_quick_sort(std::move(input)));    result.splice(result.end(), new_higher);    result.splice(result.begin(), new_lower.get());    return result;
}int main() 
{std::list<int> numlists = { 6,1,0,7,5,2,9,-1 };auto sort_result = parallel_quick_sort(numlists);std::cout << "sorted result is ";for (auto iter = sort_result.begin(); iter != sort_result.end(); iter++) {std::cout << " " << (*iter);}std::cout << std::endl;
}

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

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

相关文章

爬虫之正则表达式

爬虫之正则表达式

个人主页&#xff1a;Lei宝啊 愿所有美好如期而遇 概念&#xff1a; 正则表达式(regular expression)描述了一种字符串匹配的模式&#xff08;pattern&#xff09;&#xff0c;正则匹配是一个模糊的匹配(不是精确匹配) 如下四个方法经常使用&#xff1a; match()search()f…
阅读更多...
基于Java+SpringBoot+vue+elementui 实现即时通讯管理系统

基于Java+SpringBoot+vue+elementui 实现即时通讯管理系统

目录 系统简介效果图源码结构试用地址源码下载地址技术交流 博主介绍&#xff1a; 计算机科班人&#xff0c;全栈工程师&#xff0c;掌握C、C#、Java、Python、Android等主流编程语言&#xff0c;同时也熟练掌握mysql、oracle、sqlserver等主流数据库&#xff0c;能够为大家提供…
阅读更多...
Django学习笔记教程全解析:初步学习Django模型，初识API,以及Django的后台管理系统（Django全解析，保姆级教程）

Django学习笔记教程全解析:初步学习Django模型，初识API,以及Django的后台管理系统（Django全解析，保姆级教程）

把时间用在思考上是最能节省时间的事情。——[美]卡曾斯 导言 写在前面 本文部分内容引用的是Django官方文档&#xff0c;对官方文档进行了解读和理解&#xff0c;对官方文档的部分注释内容进行了翻译&#xff0c;以方便大家的阅读和理解。 概述 在上一篇文章里&#xff0…
阅读更多...
huggingface入门玩耍LLM Starter

huggingface入门玩耍LLM Starter

huggingface入门玩耍LLM Starter huggingface-cli 下载model 下载 本人macos系统&#xff0c;以下可参考 huggingface-cli 下载 brew install huggingface-climodel 下载 以 chatglm-6b 为例 huggingface-cli download --token hf_*** --resume-download THUDM/chatglm-6b-i…
阅读更多...
Typora＋PicGO＋腾讯云COS做图床

Typora＋PicGO＋腾讯云COS做图床

文章目录 Typora&#xff0b;PicGO&#xff0b;腾讯云COS做图床一、为什么使用图床二、Typora、PicGO和腾讯云COS介绍三、下载Typora和PicGOTyporaPicGO 四、配置Typora、PicGO和腾讯云COS腾讯云COS配置PicGO配置Typora配置 Typora&#xff0b;PicGO&#xff0b;腾讯云COS做图床…
阅读更多...
数据库设计、JDBC、数据库连接池

数据库设计、JDBC、数据库连接池

数据库设计 数据库设计概念 数据库设计就是根据业务 系统的具体需求&#xff0c;结合我们所选用的DBMS,为这个业务系统构造出最优的数据存储模型。建立数据库中的表结构以及表与表之间的关联关系的过程。有哪些表?表里有哪些字段?表和表之间有什么关系? 数据库设计的步骤…
阅读更多...
【C++学习手札】多态：掌握面向对象编程的动态绑定与继承机制（深入）

【C++学习手札】多态：掌握面向对象编程的动态绑定与继承机制（深入）

&#x1f3ac;慕斯主页&#xff1a;修仙—别有洞天 ♈️今日夜电波&#xff1a;世界上的另一个我 1:02━━━━━━️&#x1f49f;──────── 3:58 &#x1f504; ◀️ ⏸ ▶️ ☰ &am…
阅读更多...
Java+Swing+Txt实现通讯录管理系统

Java+Swing+Txt实现通讯录管理系统

目录 一、系统介绍 1.开发环境 2.技术选型 3.功能模块 4.系统功能 1.系统登录 2.查看联系人 3.新增联系人 4.修改联系人 5.删除联系人 5.工程结构 二、系统展示 1.登录页面 2.主页面 3.查看联系人 4.新增联系人 5.修改联系人 三、部分代码 Login FileUtils …
阅读更多...
2.18 day5/6 作业

2.18 day5/6 作业

作业&#xff1a; 以下是一个简单的比喻&#xff0c;将多态概念与生活中的实际情况相联系&#xff1a; 比喻&#xff1a;动物园的讲解员和动物表演 想象一下你去了一家动物园&#xff0c;看到了许多不同种类的动物&#xff0c;如狮子、大象、猴子等。现在&#xff0c;动物园…
阅读更多...
Kotlin基本语法 3 类

Kotlin基本语法 3 类

1.定义类 package classStudyclass Player {var name:String "jack"get() field.capitalize()set(value) {field value.trim()} }fun main() {val player Player()println(player.name)player.name " asdas "println(player.name)} 2.计算属性与防范…
阅读更多...
Java 学习和实践笔记（12）

Java 学习和实践笔记（12）

这个就比较有意思了&#xff01;所有的事情&#xff0c;拆分完之后&#xff0c;都有且只有这三种状态流程&#xff01; //TIP To <b>Run</b> code, press <shortcut actionId"Run"/> or // click the <icon src"AllIcons.Actions.Execute&…
阅读更多...
正大国际期货：日内交易

正大国际期货：日内交易

日内交易是一种交易模式&#xff0c;英文名字是daytrade,主要是指持仓时间短&#xff0c;不留过夜持仓的交易方式。日内交易捕捉入市后能够马上脱离入市成本的交易机会&#xff0c;入市之后如果不能马上获利&#xff0c;就准备迅速离场
阅读更多...
程序员可以做一辈子吗？大龄程序员出路在哪？

程序员可以做一辈子吗？大龄程序员出路在哪？

前言 随着2023年AI的出现&#xff0c;大家对待程序员工作有了一丝丝危机感&#xff0c;特别是今年整个IT行业进入了前所未有的寒冬期&#xff0c;让程序员不得不思考未来的职业发展。 甚至很多程序员一想到自己接近35岁&#xff0c;焦虑感油然而生&#xff0c;这也是大部分程…
阅读更多...
基于YOLOv7算法的高精度实时雾天车辆行人目标检测系统（PyTorch+Pyside6+YOLOv7）

基于YOLOv7算法的高精度实时雾天车辆行人目标检测系统（PyTorch+Pyside6+YOLOv7）

摘要&#xff1a;基于YOLOv7算法的高精度实时雾天车辆行人目标检测系统可用于日常生活中检测与定位bicycle、bus、car、motorbike和person&#xff0c;此系统可完成对输入图片、视频、文件夹以及摄像头方式的目标检测与识别&#xff0c;同时本系统还支持检测结果可视化与导出。…
阅读更多...
数据采集新纪元：Linux边缘计算技术在智慧工厂的应用解析

数据采集新纪元：Linux边缘计算技术在智慧工厂的应用解析

在当今全球智能制造的大潮下&#xff0c;Linux边缘计算网关正扮演着愈发重要的角色。它位于数据产生源头与云计算中心之间&#xff0c;为智慧工厂提供了关键的实时决策能力和高效的预测性维护解决方案。 以一家领先汽车零部件生产商为例&#xff0c;其高度自动化的生产线上的每…
阅读更多...
C/C++数据结构——剖析排序算法

C/C++数据结构——剖析排序算法

1. 排序的概念及其运用 1.1 排序的概念 https://en.wikipedia.org/wiki/Insertion_sorthttps://en.wikipedia.org/wiki/Insertion_sort 排序&#xff1a;所谓排序&#xff0c;就是使一串记录&#xff0c;按照其中的某个或某些关键字的大小&#xff0c;递增或递减的排列起来的…
阅读更多...
力扣hot2--哈希

力扣hot2--哈希

推荐博客&#xff1a; for(auto i : v)遍历容器元素_for auto 遍历-CSDN博客 字母异位词都有一个特点&#xff1a;也就是对这个词排序之后结果会相同。所以将排序之后的string作为key&#xff0c;将排序之后能变成key的单词组vector<string>作为value。 class Solution …
阅读更多...
探索未来科技前沿：深度学习的进展与应用

探索未来科技前沿：深度学习的进展与应用

深度学习的进展 摘要&#xff1a;深度学习作为人工智能领域的重要分支&#xff0c;近年来取得了巨大的进展&#xff0c;并在各个领域展现出惊人的应用潜力。本文将介绍深度学习的发展历程、技术原理以及在图像识别、自然语言处理等领域的应用&#xff0c;展望深度学习在未来的…
阅读更多...
SQL29 计算用户的平均次日留存率（lead函数的用法）

SQL29 计算用户的平均次日留存率（lead函数的用法）

代码 with t1 as(select distinct device_id,date --去重防止单日多次答题的情况from question_practice_detail ) select avg(if(datediff(date2,date1)1,1,0)) as avg_ret from (selectdistinct device_id,date as date1,lead(date) over(partition by device_id order by d…
阅读更多...
C++入门学习（二十八）跳转语句—continue语句

C++入门学习（二十八）跳转语句—continue语句

当在循环中遇到continue语句时&#xff0c;它会跳过当前迭代剩余的代码块&#xff0c;并立即开始下一次迭代。这意味着continue语句用于跳过循环中特定的执行步骤&#xff0c;而不是完全终止循环。 直接看一下下面的代码更清晰&#xff1a; 与上一节的break语句可以做一下对比…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023