锁类型介绍

锁类型详解

在 《Mutex 详解》一文中我们主要介绍了 C++11 标准中的互斥量(Mutex)，并简单介绍了一下两种锁类型。本节将详细介绍一下 C++11 标准的的锁类型。

C++11 标准为我们提供了两种基本的锁类型，分别如下：

  • std::lock_guard，与 Mutex RAII 相关，方便线程对互斥量上锁。
  • std::unique_lock，与 Mutex RAII 相关，方便线程对互斥量上锁，但提供了更好的上锁和解锁控制。

另外还提供了几个与锁类型相关的 Tag 类，分别如下:

  • std::adopt_lock_t，一个空的标记类，定义如下：

struct adopt_lock_t {};


​       该类型的常量对象 `adopt_lock`（`adopt_lock` 是一个常量对象，定义如下：-   ```c++constexpr adopt_lock_t adopt_lock {};// constexpr 是 C++11 中的新关键字）通常作为参数传入给 `unique_lock` 或 `lock_guard` 的构造函数。```- `std::defer_lock_t`，一个空的标记类，定义如下：- ```c++struct defer_lock_t {};

该类型的常量对象 defer_lock，defer_lock 是一个常量对象，定义如下：

  • constexpr defer_lock_t defer_lock {};，// constexpr 是 C++11 中的新关键字

  • 通常作为参数传入给 unique_lock 或 lock_guard 的构造函数。

  • std::try_to_lock_t，一个空的标记类，定义如下：

  • struct try_to_lock_t {};

    该类型的常量对象 try_to_lock，try_to_lock 是一个常量对象，定义如下：

  •  constexpr try_to_lock_t try_to_lock {}; // constexpr 是 C++11 中的新关键字

通常作为参数传入给 unique_lock 或 lock_guard 的构造函数。后面我们会详细介绍以上三种 Tag 类型在配合 lock_gurad 与 unique_lock 使用时的区别。

std::lock_guard 介绍

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

template <class Mutex> class lock_guard;

lock_guard 对象通常用于管理某个锁(Lock)对象，因此与 Mutex RAII 相关，方便线程对互斥量上锁，即在某个 lock_guard 对象的声明周期内，它所管理的锁对象会一直保持上锁状态；而 lock_guard 的生命周期结束之后，它所管理的锁对象会被解锁(注：类似 shared_ptr 等智能指针管理动态分配的内存资源 )。

模板参数 Mutex 代表互斥量类型，例如 std::mutex 类型，它应该是一个基本的 BasicLockable 类型，标准库中定义几种基本的 BasicLockable 类型，分别 std::mutex, std::recursive_mutex, std::timed_mutex，std::recursive_timed_mutex 以及 std::unique_lock，std::unique_lock。(注：BasicLockable 类型的对象只需满足两种操作，lock 和 unlock，另外还有 Lockable 类型，在 BasicLockable 类型的基础上新增了 try_lock 操作，因此一个满足 Lockable 的对象应支持三种操作：lock，unlock 和 try_lock；最后还有一种 TimedLockable 对象，在 Lockable 类型的基础上又新增了 try_lock_for 和 try_lock_until 两种操作，因此一个满足 TimedLockable 的对象应支持五种操作：lock, unlock, try_lock, try_lock_for, try_lock_until)。

在 lock_guard 对象构造时，传入的 Mutex 对象(即它所管理的 Mutex 对象)会被当前线程锁住。在lock_guard 对象被析构时，它所管理的 Mutex 对象会自动解锁，由于不需要程序员手动调用 lock 和 unlock 对 Mutex 进行上锁和解锁操作，因此这也是最简单安全的上锁和解锁方式，尤其是在程序抛出异常后先前已被上锁的 Mutex 对象可以正确进行解锁操作，极大地简化了程序员编写与 Mutex 相关的异常处理代码。

值得注意的是，lock_guard 对象并不负责管理 Mutex 对象的生命周期，lock_guard 对象只是简化了 Mutex 对象的上锁和解锁操作，方便线程对互斥量上锁，即在某个 lock_guard 对象的声明周期内，它所管理的锁对象会一直保持上锁状态；而 lock_guard 的生命周期结束之后，它所管理的锁对象会被解锁。

std::lock_guard 构造函数

lock_guard 构造函数如下表所示：

locking (1) explicit lock_guard(mutex_type& m);
adopting (2) lock_guard(mutex_type& m, adopt_lock_t tag);
copy [deleted](3) lock_guard(const lock_guard&) = delete;
  1. locking 初始化，lock_guard 对象管理 Mutex 对象 m，并在构造时对 m 进行上锁（调用 m.lock()）。
  2. adopting 初始化，lock_guard 对象管理 Mutex 对象 m，与 locking 初始化(1) 不同的是， Mutex 对象 m 已被当前线程锁住。
  3. 拷贝构造，lock_guard 对象的拷贝构造和移动构造(move construction)均被禁用，因此 lock_guard 对象不可被拷贝构造或移动构造。

我们来看一个简单的例子(参考)：

    isting 3.6 Using std::lock() and std::lock_guard in a swap operationclass some_big_object;void swap(some_big_object& lhs,some_big_object& rhs);//一定要在外面声明一下，函数体在下面class X{private:some_big_object some_detail;std::mutex m;public:X(some_big_object const& sd):some_detail(sd){}friend void swap(X& lhs, X& rhs){if(&lhs==&rhs)return;/*lock_guard<mutex> lock_a(lhs.m);cout << "locked" << lhs.data << endl;std::chrono::seconds dura(1);std::this_thread::sleep_for(dura);lock_guard<mutex> lock_b(rhs.m);cout << "locked" << rhs.data << endl;*///当需要顺序加锁的时候，可以使用std::lock，但是没有std::unlock，所以需要向std::lock_guard中传入一个参数，只用来进行自动解锁std::lock(lhs.m,rhs.m); //自动先加锁mux_1，在加锁mux_2	std::lock_guard<std::mutex> lock_a(lhs.m,std::adopt_lock); //已经加锁了，不在需要加锁，需要自动解锁std::lock_guard<std::mutex> lock_b(rhs.m,std::adopt_lock);swap(lhs.some_detail,rhs.some_detail);//stL自带的fuction}};

上述例子中,注释部分就是产生死锁的关键因素:X类有一个友元的交换函数,此时有两个X类型的变量x1,x2,有两个不同的线程t1,t2,在t1中调用了swap(x1,x2),而在t2中调用了swap(x2,x1),此时就会出现互相等待的情形,造成死锁.解决方案则是使用std::lock来同时锁定两个或多个的锁. t1锁了x1,t2锁了x2.如果只有类。类中定义了友元函数，thread(swap),会提示找不到参数，要将函数在外面定义，或者在外面声明一下就可以了。

lock_guard 最大的特点就是安全易于使用，在异常抛出的时候通过 lock_guard 对象管理的 Mutex 可以得到正确地解锁。

请看下面例子(参考)：

#include <iostream>       // std::cout
#include <thread>         // std::thread
#include <mutex>          // std::mutex, std::lock_guard
#include <stdexcept>      // std::logic_errorstd::mutex mtx;void print_even (int x) {if (x%2==0) std::cout << x << " is even\n";else throw (std::logic_error("not even"));
}void print_thread_id (int id) {try {// using a local lock_guard to lock mtx guarantees unlocking on destruction / exception:std::lock_guard<std::mutex> lck (mtx);print_even(id);}catch (std::logic_error&) {std::cout << "[exception caught]\n";}
}int main ()
{std::thread threads[10];// spawn 10 threads:for (int i=0; i<10; ++i)threads[i] = std::thread(print_thread_id,i+1);for (auto& th : threads) th.join();return 0;
}

std::unique_lock 介绍

lock_guard 最大的特点就是安全简单，但是 lock_guard 最大的缺点也是简单，没有给程序员提供足够的灵活度，因此，C++11 标准中定义了另外一个与 Mutex RAII 相关类 unique_lock，该类与 lock_guard 类相似，也很方便线程对互斥量上锁，但它提供了更好的上锁和解锁控制。

顾名思义，unique_lock 对象以独占所有权的方式（ unique owership）管理 mutex 对象的上锁和解锁操作，所谓独占所有权，就是没有其他的 unique_lock 对象同时拥有某个 mutex 对象的所有权。

在构造(或移动(move)赋值)时，unique_lock 对象需要传递一个 Mutex 对象作为它的参数，新创建的 unique_lock 对象负责传入的 Mutex 对象的上锁和解锁操作。

std::unique_lock 对象也能保证在其自身析构时它所管理的 Mutex 对象能够被正确地解锁（即使没有显式地调用 unlock 函数）。因此，和 lock_guard 一样，这也是一种简单而又安全的上锁和解锁方式，尤其是在程序抛出异常后先前已被上锁的 Mutex 对象可以正确进行解锁操作，极大地简化了程序员编写与 Mutex 相关的异常处理代码。

值得注意的是，unique_lock 对象同样也不负责管理 Mutex 对象的生命周期，unique_lock 对象只是简化了 Mutex 对象的上锁和解锁操作，方便线程对互斥量上锁，即在某个 unique_lock 对象的声明周期内，它所管理的锁对象会一直保持上锁状态；而 unique_lock 的生命周期结束之后，它所管理的锁对象会被解锁，这一点和 lock_guard 类似，但 unique_lock 给程序员提供了更多的自由，我会在下面的内容中给大家介绍 unique_lock 的用法。

另外，与 lock_guard 一样，模板参数 Mutex 代表互斥量类型，例如 std::mutex 类型，它应该是一个基本的 BasicLockable 类型，标准库中定义几种基本的 BasicLockable 类型，分别 std::mutex, std::recursive_mutex, std::timed_mutex，std::recursive_timed_mutex 以及 std::unique_lock， std::unique_lock。(注：BasicLockable 类型的对象只需满足两种操作，lock 和 unlock，另外还有 Lockable 类型，在 BasicLockable 类型的基础上新增了 try_lock 操作，因此一个满足 Lockable 的对象应支持三种操作：lock，unlock 和 try_lock；最后还有一种 TimedLockable 对象，在 Lockable 类型的基础上又新增了 try_lock_for 和 try_lock_until 两种操作，因此一个满足 TimedLockable 的对象应支持五种操作：lock, unlock, try_lock, try_lock_for, try_lock_until)。

std::unique_lock 构造函数

std::unique_lock 的构造函数的数目相对来说比 std::lock_guard 多，其中一方面也是因为 std::unique_lock 更加灵活，从而在构造 std::unique_lock 对象时可以接受额外的参数。总地来说，std::unique_lock 构造函数如下：

default (1) unique_lock() noexcept;
locking (2) explicit unique_lock(mutex_type& m);
try-locking (3) unique_lock(mutex_type& m, try_to_lock_t tag);
deferred (4) unique_lock(mutex_type& m, defer_lock_t tag) noexcept;
adopting (5) unique_lock(mutex_type& m, adopt_lock_t tag);
locking for (6) template <class Rep, class Period> unique_lock(mutex_type& m, const chrono::duration<Rep,Period>& rel_time);
locking until (7) template <class Clock, class Duration> unique_lock(mutex_type& m, const chrono::time_point<Clock,Duration>& abs_time);
copy [deleted] (8) unique_lock(const unique_lock&) = delete;
move (9) unique_lock(unique_lock&& x);

下面我们来分别介绍以上各个构造函数：

  • (1) 默认构造函数，新创建的 unique_lock 对象不管理任何 Mutex 对象。
  • (2) locking 初始化，新创建的 unique_lock 对象管理 Mutex 对象 m，并尝试调用 m.lock() 对 Mutex 对象进行上锁，如果此时另外某个 unique_lock 对象已经管理了该 Mutex 对象 m，则当前线程将会被阻塞。
  • (3) try-locking 初始化，新创建的 unique_lock 对象管理 Mutex 对象 m，并尝试调用 m.try_lock() 对 Mutex 对象进行上锁，但如果上锁不成功，并不会阻塞当前线程。
  • (4) deferred 初始化，新创建的 unique_lock 对象管理 Mutex 对象 m，但是在初始化的时候并不锁住 Mutex 对象。 m 应该是一个没有当前线程锁住的 Mutex 对象。
  • (5) adopting 初始化，新创建的 unique_lock 对象管理 Mutex 对象 m， m 应该是一个已经被当前线程锁住的 Mutex 对象。(并且当前新创建的 unique_lock 对象拥有对锁(Lock)的所有权)。
  • (6) locking 一段时间(duration)，新创建的 unique_lock 对象管理 Mutex 对象 m，并试图通过调用 m.try_lock_for(rel_time) 来锁住 Mutex 对象一段时间(rel_time)。
  • (7) locking 直到某个时间点(time point)，新创建的 unique_lock 对象管理 Mutex 对象m，并试图通过调用 m.try_lock_until(abs_time) 来在某个时间点(abs_time)之前锁住 Mutex 对象。
  • (8) 拷贝构造 [被禁用]，unique_lock 对象不能被拷贝构造。
  • (9) 移动(move)构造，新创建的 unique_lock 对象获得了由 x 所管理的 Mutex 对象的所有权(包括当前 Mutex 的状态)。调用 move 构造之后， x 对象如同通过默认构造函数所创建的，就不再管理任何 Mutex 对象了。

综上所述，由 (2) 和 (5) 创建的 unique_lock 对象通常拥有 Mutex 对象的锁。而通过 (1) 和 (4) 创建的则不会拥有锁。通过 (3)，(6) 和 (7) 创建的 unique_lock 对象，则在 lock 成功时获得锁。

关于 unique_lock 的构造函数，请看下面例子(参考)：

#include <iostream>       // std::cout
#include <thread>         // std::thread
#include <mutex>          // std::mutex, std::lock, std::unique_lock// std::adopt_lock, std::defer_lock
std::mutex foo,bar;void task_a () {std::lock (foo,bar);         // simultaneous lock (prevents deadlock)std::unique_lock<std::mutex> lck1 (foo,std::adopt_lock);std::unique_lock<std::mutex> lck2 (bar,std::adopt_lock);std::cout << "task a\n";// (unlocked automatically on destruction of lck1 and lck2)
}void task_b () {// foo.lock(); bar.lock(); // replaced by:std::unique_lock<std::mutex> lck1, lck2;lck1 = std::unique_lock<std::mutex>(bar,std::defer_lock);lck2 = std::unique_lock<std::mutex>(foo,std::defer_lock);std::lock (lck1,lck2);       // simultaneous lock (prevents deadlock)std::cout << "task b\n";// (unlocked automatically on destruction of lck1 and lck2)
}

​

int main ()
{std::thread th1 (task_a);std::thread th2 (task_b);th1.join();th2.join();return 0;
}
std::unique_lock 移动(move assign)赋值操作

std::unique_lock 支持移动赋值(move assignment)，但是普通的赋值被禁用了，

move (1) unique_lock& operator= (unique_lock&& x) noexcept;
copy [deleted] (2) unique_lock& operator= (const unique_lock&) = delete;

移动赋值(move assignment)之后，由 x 所管理的 Mutex 对象及其状态将会被新的 std::unique_lock 对象取代。

如果被赋值的对象之前已经获得了它所管理的 Mutex 对象的锁，则在移动赋值(move assignment)之前会调用 unlock 函数释放它所占有的锁。

调用移动赋值(move assignment)之后， x 对象如同通过默认构造函数所创建的，也就不再管理任何 Mutex 对象了。请看下面例子(参考)：

#include <iostream>       // std::cout
#include <thread>         // std::thread
#include <mutex>          // std::mutex, std::unique_lockstd::mutex mtx;           // mutex for critical sectionvoid print_fifty (char c) {std::unique_lock<std::mutex> lck;         // default-constructedlck = std::unique_lock<std::mutex>(mtx);  // move-assigned// unique_lock& operator=(unique_lock&& u) noexcept; //will happenstd::cout << c; 
}    
int main ()
{std::thread th1 (print_fifty,'*');std::thread th2 (print_fifty,'$');    th1.join();th2.join();    return 0;
}
std::unique_lock 主要成员函数

本节我们来看看 std::unique_lock 的主要成员函数。由于 std::unique_lock 比 std::lock_guard 操作灵活，因此它提供了更多成员函数。具体分类如下：

  • 上锁/解锁操作：lock，try_lock，try_lock_for，try_lock_until 和 unlock
  • 修改操作：移动赋值(move assignment)(前面已经介绍过了)，交换(swap)（与另一个 std::unique_lock 对象交换它们所管理的 Mutex 对象的所有权），释放(release)（返回指向它所管理的 Mutex 对象的指针，并释放所有权）
  • 获取属性操作：owns_lock（返回当前 std::unique_lock 对象是否获得了锁）、operator bool()（与 owns_lock 功能相同，返回当前 std::unique_lock 对象是否获得了锁）、mutex（返回当前 std::unique_lock 对象所管理的 Mutex 对象的指针）。
std::unique_lock::lock std::unique_lock::unlock

互斥锁保证了线程间的同步，但是却将并行操作变成了串行操作，这对性能有很大的影响，所以我们要尽可能的减小锁定的区域，也就是使用细粒度锁。

这一点lock_guard做的不好，不够灵活，lock_guard只能保证在析构的时候执行解锁操作，lock_guard本身并没有提供加锁和解锁的接口，但是有些时候会有这种需求。看下面的例子。

请看下面例子(参考)：

 class foo {std::mutex _mu;     public:foo() {}~foo() {}void shared_print() {{std::lock_guard<std::mutex> guard(_mu);//do something 1}//do something 2{std::lock_guard<std::mutex> guard(_mu);// do something 3                }}};

上面的代码中，一个函数内部有两段代码需要进行保护，这个时候使用lock_guard就需要创建两个局部对象来管理同一个互斥锁（其实也可以只创建一个，但是锁的力度太大，效率不行），修改方法是使用unique_lock。它提供了lock()和unlock()接口，能记录现在处于上锁还是没上锁状态，在析构的时候，会根据当前状态来决定是否要进行解锁（lock_guard就一定会解锁）。上面的代码修改如下：

void shared_print() {std::unique_lock<std::mutex> guard(_mu);//do something 1guard.unlock(); //临时解锁//do something 2guard.lock(); //继续上锁// do something 3            // 结束时析构guard会临时解锁 这句话可要可不要，不写，析构的时候也会自动执行// guard.ulock();          
}

上面的代码可以看到，在无需加锁的操作时，可以先临时释放锁，然后需要继续保护的时候，可以继续上锁，这样就无需重复的实例化lock_guard对象，还能减少锁的区域。同样，可以使用std::defer_lock设置初始化的时候不进行默认的上锁操作：

void shared_print() {std::unique_lock<std::mutex> guard(_mu, std::defer_lock);//do something 1guard.lock();// do something protectedguard.unlock(); //临时解锁//do something 2guard.lock(); //继续上锁// do something 3          // 结束时析构guard会临时解锁
}
std::unique_lock::try_lock

上锁操作，调用它所管理的 Mutex 对象的 try_lock 函数，如果上锁成功，则返回 true，否则返回 false。

std::unique_lock::try_lock_for std::unique_lock::try_lock_until

上锁操作，调用它所管理的 Mutex 对象的 try_lock_for 函数，如果上锁成功，则返回 true，否则返回 false。

请看下面例子(参考)：

#include <iostream>       // std::cout
#include <chrono>         // std::chrono::milliseconds
#include <thread>         // std::thread
#include <mutex>          // std::timed_mutex, std::unique_lock, std::defer_lockstd::timed_mutex mtx;void fireworks () {std::unique_lock<std::timed_mutex> lck(mtx,std::defer_lock);// waiting to get a lock: each thread prints "-" every 200ms:while (!lck.try_lock_for(std::chrono::milliseconds(200))) {std::cout << "-";}// got a lock! - wait for 1s, then this thread prints "*"std::this_thread::sleep_for(std::chrono::milliseconds(1000));std::cout << "*\n";
}    
int main () {std::thread threads[10];// spawn 10 threads:for (int i=0; i<10; ++i)threads[i] = std::thread(fireworks);    for (auto& th : threads) th.join();    return 0;
}
std::unique_lock::release

返回指向它所管理的 Mutex 对象的指针，并释放所有权。

请看下面例子(参考)：

std::mutex mtx;
int count = 0;void print_count_and_unlock (std::mutex* p_mtx) {std::cout << "count: " << count << '\n';p_mtx->unlock();
}    
void task() {std::unique_lock<std::mutex> lck(mtx);++count;print_count_and_unlock(lck.release());
}
std::unique_lock::owns_lock std::unique_lock::operator bool()

返回当前 std::unique_lock 对象是否获得了锁。

bool()与 owns_lock 功能相同，返回当前 std::unique_lock 对象是否获得了锁。请看下面例子(参考)：

std::unique_lock<std::mutex> lck(mtx,std::try_to_lock);
// print '*' if successfully locked, 'x' otherwise: 
if (lck.owns_lock())    std::cout << '*';
if (lck)    std::cout << '*'; <--bool() 函数对象自动调用()返回类型bool
std::unique_lock::mutex

返回当前 std::unique_lock 对象所管理的 Mutex 对象的指针。

请看下面例子(参考)：

void print_ids (int id) {std::unique_lock<MyMutex> lck (mtx);std::cout << " locked mutex " << lck.mutex()->id() << '\n';
}

好了，本文先介绍到这里，我们基本上介绍完了 C++11 多线程编程中两种最基本的锁类型，后面我会继续更新有关 C++11 并发编程的博客，希望感兴趣的同学继续关注。

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

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

相关文章

力扣代码学习日记六

力扣代码学习日记六

Problem: 66. 加一 思路 给定一个由 整数 组成的 非空 数组所表示的非负整数&#xff0c;在该数的基础上加一。 最高位数字存放在数组的首位&#xff0c; 数组中每个元素只存储单个数字。 你可以假设除了整数 0 之外&#xff0c;这个整数不会以零开头。 示例 1&#xff1a; 输…
阅读更多...
Selenium浏览器自动化测试框架详解

Selenium浏览器自动化测试框架详解

selenium简介 介绍 Selenium [1] 是一个用于Web应用程序测试的工具。Selenium测试直接运行在浏览器中&#xff0c;就像真正的用户在操作一样。支持的浏览器包括IE&#xff08;7, 8, 9, 10, 11&#xff09;&#xff0c;Mozilla Firefox&#xff0c;Safari&#xff0c;Google C…
阅读更多...
抖店没有流量怎么办？如何提高店铺流量？醒醒团队经验分享！

抖店没有流量怎么办？如何提高店铺流量？醒醒团队经验分享！

我是电商珠珠 醒醒团队这个IP已经做了五年多的时间了&#xff0c;团队成员从原来的几个人到现在的70。我们从20年开始入驻抖店&#xff0c;到现在也已经三年多了。期间也会带着学员一起做店&#xff0c;大多数学员的问题就是店开了&#xff0c;但是一直没有流量&#xff0c;没…
阅读更多...
深度学习中数据的转换

深度学习中数据的转换

原始&#xff08;文本、音频、图像、视频、传感器等&#xff09;数据被转化成结构化且适合机器学习算法或深度学习模型使用的格式。 原始数据转化为结构化且适合机器学习和深度学习模型使用的格式&#xff0c;通常需要经历以下类型的预处理和转换&#xff1a; 文本数据&#xf…
阅读更多...
台式电脑电源功率越大越费电吗？装机选购多少W电源

台式电脑电源功率越大越费电吗？装机选购多少W电源

要组装一台电脑&#xff0c;我们首先需要选择硬件。 硬件搭配最关键的一点就是CPU和主板的兼容性。 硬件、电源等之间的平衡都需要仔细考虑。 那么台式电脑电源多大功率合适呢&#xff1f; 下面分享组装电脑电源瓦数选购指南&#xff0c;教您正确选择合适的电源瓦数。 让我们来…
阅读更多...
docker install private registry 【docker 安装 registry 仅证书认证】

docker install private registry 【docker 安装 registry 仅证书认证】

预备条件&#xff1a; 安装docker 我们设定镜像仓库域名为registry01.dev.com 配置/etc/hosts 192.168.23.51 registry01.dev.com安装 registry #!/bin/bashreg_ip$1 reg_n$2 reg_port$3if [ $# -eq 0 ]; thenecho "Usage: $0 [reg_ip] [registry_name]"echo &q…
阅读更多...
消息中间件篇之RabbitMQ-消息不丢失

消息中间件篇之RabbitMQ-消息不丢失

一、生产者确认机制 RabbitMQ提供了publisher confirm机制来避免消息发送到MQ过程中丢失。消息发送到MQ以后&#xff0c;会返回一个结果给发送者&#xff0c;表示消息是否处理成功。 当消息没有到交换机就失败了&#xff0c;就会返回publish-confirm。当消息没有到达MQ时&…
阅读更多...
防御保护--VPN

防御保护--VPN

目录 VPN的概述 VPN的分类 VPN的核心技术 --- 隧道技术 VPN其他常用技术 VPN的概述 VPN --- 虚拟专用网 --- 一般指依靠ISP或者其他NSP&#xff0c;也可以是企业自身&#xff0c;提供的一条虚拟网 络专线。这个虚拟的专线是逻辑上的&#xff0c;而不是物理上的&#xff0c;所…
阅读更多...
LeetCode 2583. 二叉树中的第 K 大层和

LeetCode 2583. 二叉树中的第 K 大层和

题目链接https://leetcode.cn/problems/kth-largest-sum-in-a-binary-tree/?envTypedaily-question&envId2024-02-23 和我上一篇发的博客类似&#xff0c;通过广度优先遍历二叉树&#xff0c;使用队列存每层的节点值&#xff0c; 最后再做处理&#xff0c;输出第K大层和 …
阅读更多...
书生·浦语大模型实战营第二节课作业

书生·浦语大模型实战营第二节课作业

使用 InternLM-Chat-7B 模型生成 300 字的小故事&#xff08;基础作业1&#xff09;。 熟悉 hugging face 下载功能&#xff0c;使用 huggingface_hub python 包&#xff0c;下载 InternLM-20B 的 config.json 文件到本地&#xff08;基础作业2&#xff09;。 下载过程 进阶…
阅读更多...
Nest.js权限管理系统开发（三）环境变量与配置文件

Nest.js权限管理系统开发（三）环境变量与配置文件

一般来说数据库的配置包含了一些敏感信息&#xff0c;不宜写在代码中提交到远程仓库&#xff0c;所以我们可以将配置写在配置文件中,然后提交 git 时候将生产环境的配置文件其忽略。我们可以新建.env和.env.prod两个文件分别存放开发与生产环境配置&#xff0c;也可以使用YAML等…
阅读更多...
java面试：分布式事务

java面试：分布式事务

文章目录 引言I 基础知识1.1 事务(Transaction)1.2 本地事务1.3 分布式事务II 分布式理论2.1 CAP原理2.2 BASE理论2.3 刚柔事务2.4 解决分布事务模型2.5 2PC2.6 3PC2.7 TCC（Try-Confirm-Cancel）补偿事务III Seata 分布式事务
阅读更多...
美赛教程：如何参与并胜出数学建模竞赛

美赛教程：如何参与并胜出数学建模竞赛

一、引言 美国大学生数学建模竞赛&#xff08;MCM/ICM&#xff0c;通常被称为“美赛”&#xff09;是全球范围内最具影响力和挑战性的大学生数学建模竞赛之一。参与美赛不仅能锻炼大学生的数学建模、问题分析、团队协作和英文写作能力&#xff0c;还能为他们未来的学术和职业生…
阅读更多...
【Elasticsearch专栏 12】深入探索：Elasticsearch使用索引生命周期管理（ILM）自动化删除旧数据

【Elasticsearch专栏 12】深入探索：Elasticsearch使用索引生命周期管理（ILM）自动化删除旧数据

导言 在Elasticsearch中&#xff0c;随着数据的不断积累&#xff0c;管理旧数据成为了一个重要的问题。为了有效地管理这些数据&#xff0c;Elasticsearch提供了索引生命周期管理&#xff08;ILM&#xff09;功能。ILM允许根据索引的年龄、大小或其他条件自动执行一系列操作&a…
阅读更多...
2024-2-22 作业

2024-2-22 作业

作业要求&#xff1a; 复习前面知识点(指针、结构体、函数)整理思维导图顺序表(按位置插入、按位置删除和去重、重新写)理解链表的代码&#xff0c;尝试写一下链表的尾插和输出 1.复习前面知识点(指针、结构体、函数) 2.整理思维导图 3.顺序表(按位置插入、按位置删除和去重、…
阅读更多...
J7 - 对于ResNeXt-50算法的思考

J7 - 对于ResNeXt-50算法的思考

&#x1f368; 本文为&#x1f517;365天深度学习训练营 中的学习记录博客&#x1f356; 原作者&#xff1a;K同学啊 | 接辅导、项目定制 J6周有一段代码如下 思考过程 首先看到这个问题的描述&#xff0c;想到的是可能使用了向量操作的广播机制然后就想想办法验证一下&…
阅读更多...
Vue 图片轮播第三方库 介绍

Vue 图片轮播第三方库 介绍

Vue图片轮播是一种在网页上以自动或手动方式展示图片的组件&#xff0c;常用于产品展示、网站banner等场景。有许多第三方库可以帮助Vue开发者轻松实现图片轮播功能。以下是一些流行的Vue图片轮播第三方库的介绍&#xff1a; 1. Vue-awesome-swiper - **简介**&#xff1a;V…
阅读更多...
数字化转型导师坚鹏：县域数字化转型案例研究

数字化转型导师坚鹏：县域数字化转型案例研究

县域数字化转型案例研究 课程背景&#xff1a; 很多县级政府存在以下问题&#xff1a; 不清楚县域数字化转型的发展模式 不清楚县域数字化转型的成功案例 课程特色&#xff1a; 针对性强 实用性强 创新性强 学员收获: 学习县域数字化转型的发展模式。 学习县…
阅读更多...
链表-----节点最大值，累加和，统计节点个数，逆序数据建立链表以及回文字符串

链表-----节点最大值，累加和，统计节点个数，逆序数据建立链表以及回文字符串

链表-节点最大值 本题要求实现一个函数&#xff0c;遍历一个不带头节点的链表&#xff0c;求链表节点数据的最大值 节点类型定义&#xff1a; struct node { int ch ; struct node *next ;} 函数接口定义&#xff1a; 在这里描述函数接口。例如&#xff1a; int max_node( …
阅读更多...
C/C++的内存管理（2）——new与delete的内核与本质

C/C++的内存管理（2）——new与delete的内核与本质

内存管理 operator new 与 operator delete函数回看new与delete的实现内置类型自定义类型 常见面试题 我们已经知道了new与delete的用法及其好处&#xff0c;发现它似乎与C语言中的动态内存开辟的函数&#xff08;malloc/calloc/realloc&#xff09;不同 在这里我们特别指出&am…
阅读更多...
最新文章

Copyright @ 2022~2023