【C++11】多线程库 {thread线程库，mutex互斥锁库，condition_variable条件变量库，atomic原子操作库}

在C++11之前，涉及到多线程问题，都是和平台相关的，比如windows和linux下各有自己的接口，这使得代码的可移植性比较差。

//在C++98标准下，实现可移植的多线程程序 —— 条件编译
#ifdef _WIN32
	CreateThread(); //在windows系统下，调用windows多线程接口
	//......
#elif __linux__
	pthread_create(); //在linux系统下，调用pthread线程库接口
	//......
#endif

C++11中最重要的特性就是对多线程编程进行了支持，而且还引入了原子操作和原子类。

在这里插入图片描述

  1. 使得C++在并行编程时不需要依赖第三方库，thread库底层使用条件编译封装各种平台的多线程接口，增加了C++代码的可移植性。
  2. 将多线程接口封装成了类，体现了面向对象的程序设计方法。

一、thread 线程库

注意：要使用C++11标准库中的多线程接口，必须包含< thread >头文件。

1.1 成员函数介绍

thread线程对象可以关联一个线程，用来控制线程以及获取线程的状态。

thread类成员函数对应的pthread库函数函数功能使用方法
thread();——构造一个线程对象，没有关联任何线程函数，即没有启动任何线程thread类的默认构造，并没有创建出子线程。
template <class Fn, class… Args> thread (Fn&& fn, Args&&… args);pthread_create();构造一个线程对象，并关联线程函数fn；args1，args2，…为线程函数的参数万能应用和可变参数模板：线程函数fn可以传函数指针，函数对象，lambda表达式；线程函数的参数可以传任意类型，任意数量。
get_id();pthread_self();获取线程idget_id的返回值是自定义类型thread::id，id类重载了所有的关系运算符和流插入运算符(<<)，用于比较和输出线程id。如果不想通过thread类成员函数获取线程id，可以调用全局函数this_thread::get_id()
join();pthread_join();阻塞等待子线程——
joinable();——检查线程是否可以被join：如果线程已经被join或者已经被detach，则该函数返回false，否则返回true。如果该函数返回true，那么我们可以安全地调用join()函数来等待线程结束。如果该函数返回false，那么我们应该避免调用join()函数，否则会导致程序崩溃。
detach();pthread_detach();分离子线程，它的资源将在线程结束时自动释放，无需其他线程调用join函数来等待它的结束。——

线程对象的创建

当创建一个线程对象后，没有提供线程函数，该对象实际没有对应任何线程。

当创建一个线程对象后，并且给线程关联线程函数，该线程就被启动，与主线程一起运行。

线程函数一般情况下可按照以下三种方式提供：

  1. 函数指针
  2. lambda表达式
  3. 函数对象

线程对象的移动

thread类是防拷贝的，不允许拷贝构造以及拷贝赋值，因为拷贝线程是没有实际意义的。但是可以移动构造和移动赋值，即将一个线程对象关联线程的状态转移给其他线程对象，转移期间不影响线程的执行。

移动构造和移动赋值的意义：分离线程的创建和启动，可以先使用默认构造创建一个空线程对象，再在合适的时候使用移动赋值关联线程函数，启动线程。

在这里插入图片描述

测试程序：

// 创建多个线程求1~n的和：
int main()
{
	int m = 0;
	cin >> m;创建一个空线程对象
	vector<thread> vthds(m); // 调用thread类的默认构造，创建m个空线程对象
	vector<int> nums(m, 0);
	for (auto &e : nums)
	{
		cin >> e;
	}

	for (int i = 0; i < m; ++i)
	{
		// 调用thread类的移动赋值关联线程函数，启动线程
        // 这里用lambda表达式充当线程函数
		vthds[i] = thread([](int num){
			int sum = 0;
			for(int j = 1; j <= num; ++j)
			{
				sum += j;
			} 
            //调用全局函数this_thread::get_id获取线程id
			cout << "[" << this_thread::get_id() << "]: " << sum << endl; }, 
						  nums[i]); 
	}

	for (auto &t : vthds) // thread类禁用拷贝构造，所以必须加引用
	{
		t.join();
	}
}

运行结果：

在这里插入图片描述

判断线程对象是否有效

可以通过jionable()函数判断线程是否是有效的，如果是以下任意情况，则线程无效

  1. 采用无参构造函数构造的线程对象
  2. 线程对象的状态已经转移给其他线程对象
  3. 线程已经调用jion或者detach结束

1.2 线程函数参数

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

// 线程函数的参数
#include <thread>

int k = 0;

void ThreadFunc1(int *x)
{
    *x += 10;
}

void ThreadFunc2(int &x)
{
    x += 10;
}

class A
{
public:
    int i = 10;
    static void ThreadFunc3()
    {
        k += 10;
    }
    void ThreadFunc4()
    {
        i += 101;
    }
};

int main()
{
    // 线程函数的参数可以传外部变量的地址（将地址拷贝到线程独立栈）
    thread t1(ThreadFunc1, &k);
    t1.join();
    cout << k << endl;

    // 线程函数的参数不能直接传外部变量的引用（实际引用的是线程栈中的拷贝）
    // thread t2(ThreadFunc2, k); // 在线程函数中对k修改，不会影响外部实参，有些编译器可能直接编译报错
    thread t2(ThreadFunc2, std::ref(k)); // 如果想要通过形参改变外部实参，必须借助std::ref()函数传引用
    t2.join();
    cout << k << endl;

    // 静态成员函数和普通函数类似，只是需要注明类域
    thread t3(A::ThreadFunc3); // 取静态成员函数的地址可以不加&
    t3.join();
    cout << k << endl;

    // 非静态成员函数作线程函数时，必须将this指针（调用对象的地址）作为线程函数的参数。
    A a;
    thread t4(&A::ThreadFunc4, &a); // 取非静态成员函数的地址必须加&
    t4.join();
    cout << a.i << endl;
    return 0;
}

运行结果：

在这里插入图片描述

std::ref()函数模板，用于保存变量的引用

在这里插入图片描述

1.3 this_thread 命名空间

this_thread是一个访问当前线程的函数集合

在这里插入图片描述

  • get_id：返回当前线程的线程ID

  • sleep_until：该线程休眠到某个时间点（绝对时间）

    参数：chrono::time_point类模板的实例化类型

    用法：sleep_until - C++ Reference (cplusplus.com)

  • sleep_for：该线程休眠持续某个时间段（相对时间）

    参数：chrono::duration类模板的实例化类型

    在这里插入图片描述

    用法：std::this_thread::sleep_for (std::chrono::seconds(1)); // 调用线程休眠1秒

    提示：chrono既是头文件，又是命名空间

  • yield：主动出让线程的时间片

二、mutex 互斥锁库

2.1 4个互斥量类型

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

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

在这里插入图片描述

// mutex
int main()
{
    mutex mtx;
    int x = 0;
    int n = 100000;

    auto threadfunc = [&, n]()
    {
        mtx.lock();
        for (int i = 0; i < n; ++i)
        {
            ++x;
        }
        mtx.unlock();
    };
    thread t1(threadfunc);
    thread t2(threadfunc);

    t1.join();
    t2.join();
    cout << x << endl;
    return 0;
}

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

  • 如果该互斥量当前没有被锁住，则调用线程将该互斥量锁住，直到调用 unlock之前，该线程一直拥有该锁

  • 如果当前互斥量被其他线程锁住，则当前的调用线程被阻塞住

  • 如果当前互斥量被当前调用线程锁住，则会产生死锁(deadlock)

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

  • 如果当前互斥量没有被其他线程占有，则该线程锁住互斥量，直到该线程调用 unlock释放互斥量
  • 如果当前互斥量被其他线程锁住，则当前调用线程返回 false，而并不会被阻塞掉
  • 如果当前互斥量被当前调用线程锁住，则会产生死锁(deadlock)
  1. std::recursive_mutex
    其允许同一个线程对互斥量多次上锁（即递归上锁），来获得对互斥量对象的多层所有权，释放互斥量时需要调用与该锁层次深度相同次数的 unlock()，除此之外，std::recursive_mutex 的特性和 std::mutex 大致相同。

测试程序：

// recursize_mutex
int x = 0;

void threadfunc(int n, recursive_mutex *mtx)
{
    if(n == 0)
        return;
    mtx->lock();
    ++x;
    threadfunc(n-1, mtx); //允许同一个线程对互斥量多次上锁（即递归上锁）
    mtx->unlock(); //释放互斥量时需要调用与该锁层次深度相同次数的 unlock()
}

int main()
{
    recursive_mutex mtx; //定义一个递归互斥锁
    thread t1(threadfunc, 100000, &mtx);
    thread t2(threadfunc, 200000, &mtx);
    t1.join();
    t2.join();
    cout << x << endl;
    return 0;
}
  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

    结合recursive_mutex和timed_mutex的特点，不做介绍。

2.2 lock_guard

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

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

template<class _Mutex>
class lock_guard
{
public:
	// 在构造lock_gard时加锁
	explicit lock_guard(_Mutex& _Mtx)
	: _MyMutex(_Mtx)
	{
		_MyMutex.lock();
	}
	// 在构造lock_gard时，_Mtx已经被上锁，此处不需要再上锁
	lock_guard(_Mutex& _Mtx, adopt_lock_t)
	: _MyMutex(_Mtx)
	{}
    // 在析构lock_guard时解锁
	~lock_guard() _NOEXCEPT
	{
		_MyMutex.unlock();
	}
    // lock_guard不允许拷贝
	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。

2.3 unique_lock

与lock_gard类似，unique_lock类模板也是采用RAII的方式对锁进行了封装，并且也是以独占所有权的方式管理mutex对象的上锁和解锁操作，即其对象之间不能发生拷贝。

在构造(或移动(move)赋值)时，unique_lock 对象需要传递一个 Mutex 对象作为它的参数，新创建的unique_lock 对象负责传入的 Mutex 对象的上锁和解锁操作。使用以上类型互斥量实例化unique_lock的对象时，自动调用构造函数上锁，unique_lock对象销毁时自动调用析构函数解锁，可以很方便的防止死锁问题。

// lock_guard && unique_lock
int x = 0;
mutex mtx;

void threadfunc(int n)
{

    for (int i = 0; i < n; ++i)
    {
        try
        {
            // mtx.lock();
            // lock_guard和unique_lock会在构造时加锁，析构时解锁
            // lock_guard<mutex> lock(mtx);
            unique_lock<mutex> lock(mtx);
            ++x;
            // 抛异常，会跳过unlock函数使程序不能继续执行
            if (rand() % 3 == 0)
            {
                throw exception();
            }
            // mtx.unlock();
        }
        catch (const exception &e)
        {
            cerr << "抛异常" << endl;
        }
    };
}

int main()
{
    srand((unsigned int)time(nullptr));
    thread t1(threadfunc, 10);
    thread t2(threadfunc, 20);

    t1.join();
    t2.join();
    cout << x << endl;
    return 0;
}

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

三、condition_variable 条件变量库

本节主要演示了condition_variable的使用，condition_variable熟悉我们linux课程已经讲过了，他们用来进行线程之间的互相通知。condition_variable和Linux posix的条件变量并没有什么大的区别，主要还是面向对象实现的。

在这里插入图片描述

测试程序：

// 1~100，t1打印奇数，t2打印偶数
int main()
{
    mutex mtx;
    int x = 1;
    int n = 12345;
    // 1个共享资源，相同条件（奇或偶），定义1个条件变量
    condition_variable cv;
	// 创建并启动2个子线程
    thread t1([&, n]()
              {
                  while (x<=n)
                  {
                      unique_lock<mutex> lock(mtx);
                    // if(x > n) break; // 错误
                    // wait参数：unique_lock, 通关条件
                    cv.wait(lock, [&x](){return x%2 == 1;});
                    // 等效的实现方法：
                    //   while (!(x % 2 == 1)) // 防止伪唤醒
                    //   {
                    //       cv.wait(lock);
                    //   }
                    if(x > n) break; // 条件判断必须放在wait之后
                    cout << "[t1]" << ":" << x << endl;
                    ++x;
                    cv.notify_one();
                  } });

    thread t2([&, n]()
              {
                while(x<=n)
                {
                    unique_lock<mutex> lock(mtx);
                    cv.wait(lock, [&x](){return x%2 == 0;});
                    // 等效的实现方法：
                    // while(!(x%2 == 0)) // 阻塞条件
                    // {
                    //     cv.wait(lock);
                    // }
                    if(x > n) break;
                    cout << "[t2]" << ":" << x << endl;
                    ++x;
                    cv.notify_one();
                } });

    t1.join();
    t2.join();
    return 0;
}

运行结果：

在这里插入图片描述

如何确定条件变量的数量？

对于确定条件变量的数量，一般是根据要控制的共享资源或者线程的数量来确定的。如果有多个共享资源或者多个线程需要等待不同的条件来执行，就需要相应数量的条件变量。

如果要控制多个线程对同一个共享资源的访问，可以使用一个条件变量来控制所有线程的等待和唤醒。如果需要不同的条件来控制不同的线程，就需要针对不同的条件使用不同的条件变量。

总结：1个共享资源 + 相同条件 = 1个条件变量

四、atomic 原子操作库

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

对此，C++98中传统的解决方式：可以对共享修改的数据可以加锁保护。虽然加锁可以解决，但是加锁有一个缺陷就是：临界区代码必须串行执行，只要一个线程在执行临界区代码时，其他线程就会被阻塞，会影响程序运行的效率，而且锁如果控制不好，还容易造成死锁。

因此C++11中引入了原子操作（CAS）。所谓原子操作：即不可被中断的一个或一系列操作，C++11引入的原子操作类型，使得线程间数据的同步变得非常高效。

4.1 atomic库中的内置原子类型

在这里插入图片描述

在C++11中，程序员不需要对原子类型变量进行加锁解锁操作，线程能够对原子类型变量互斥的访问。

#include <iostream>
using namespace std;
#include <thread>
#include <atomic>

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

atomic库中的内置原子类型实际上是atomic类模板的实例化类型。

注意：需要使用以上原子操作变量时，必须添加头文件<atomic>

4.2 atomic类模板

更为普遍的，程序员可以使用atomic类模板，定义出需要的任意原子类型。

在这里插入图片描述

注意：原子类型通常属于"资源型"数据，多个线程只能访问单个原子类型的拷贝，因此在C++11中，原子类型只能从其模板参数中进行构造，不允许原子类型进行拷贝构造、移动构造以及operator=等，为了防止意外，标准库已经将atmoic模板类中的拷贝构造、移动构造、赋值运算符重载默认删除掉了。

#include <atomic>
int main()
{
	atomic<int> a1(0);
	//atomic<int> a2(a1); // 编译失败
	atomic<int> a2(0);
	//a2 = a1; // 编译失败
	return 0;
}

4.3 原子操作的原理及应用

CAS（Compare and Swap）操作是一种原子操作，用于实现并发控制。它的原理是：

  1. 读取共享变量的值。
  2. 比较共享变量的值与期望值是否相等，如果相等则执行第4步，否则执行第3步。
  3. 放弃操作，重新读取共享变量的值，然后再次比较。
  4. 将新值写入共享变量。

CAS操作的关键在于比较共享变量的值与期望值是否相等，如果相等则说明共享变量没有被其他线程修改，可以执行写入操作。如果不相等则说明共享变量已经被其他线程修改，需要重新读取共享变量的值并再次比较。这样就可以保证对共享变量的操作是原子的，避免了并发问题。

详细内容请阅读陈浩老师的文章：无锁队列的实现 {CAS操作的原理，无锁队列的链表实现，CAS的ABA问题，无锁队列的数组实现}-CSDN博客

4.4 加锁 VS 原子操作

加锁和原子操作都是用于处理多线程并发访问共享资源的工具，它们各自有一些优势和适用场景。

加锁的优点：

  1. 灵活性：锁提供了更灵活的线程同步机制，可以精确控制临界区的范围，避免不必要的同步。
  2. 可以实现复杂的线程同步逻辑：锁可以实现复杂的线程同步逻辑，比如读写锁、重入锁等，满足不同场景下的需求。
  3. 可以避免ABA问题：在一些情况下，锁能够避免CAS操作中可能出现的ABA问题。

原子操作的优点：

  1. 性能：原子操作通常比加锁的方式具有更好的性能，因为它们通常使用底层硬件指令或者CAS操作来实现，避免了线程阻塞和用户态内核态切换的开销。
  2. 简单性：原子操作通常比加锁的方式更简单，使用起来更加方便，不容易出现死锁等问题。
  3. 可见性：原子操作通常能够保证操作的可见性，确保对共享变量的操作对其他线程是可见的。

在实际应用中，应根据具体的需求和场景来选择使用加锁还是原子操作。通常情况下，如果需要实现简单的原子操作，比如自增、自减等操作，原子操作是更好的选择；而如果需要复杂的线程同步逻辑或者需要精确控制临界区的范围，加锁是更合适的选择。

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

【C++】容器string的构造函数和迭代器

【C++】容器string的构造函数和迭代器

目录 1 什么是string 2 迭代器 2.1 迭代器的使用 2.2 auto关键字以及代码可读性 3 构造函数 1 什么是string 上图是C官网对于string的解释&#xff1a;string是表示字符序列的对象。 string本质是一个类&#xff0c;位于std的命名空间下&#xff0c;使用前需要包含头文件…
阅读更多...
十三.日志包设计

十三.日志包设计

十三.日志包设计 一.前言 在 Go 语言项目中自己设计日志包是非常重要的&#xff0c;原因如下&#xff1a;提高代码可读性和可维护性&#xff1a;良好的日志设计可以让代码更加易读和易于维护。日志可以帮助开发人员理解代码的运行过程&#xff0c;方便调试和错误排查。支持调…
阅读更多...
C语言二进制数（ZZULIOJ1068:二进制数）

C语言二进制数（ZZULIOJ1068:二进制数）

题目描述 将一个二进制数&#xff0c;转换为对应的十进制数。 输入&#xff1a;输入一个只含有’0’和’1’的字符串&#xff0c;以回车结束&#xff0c;表示一个二进制数。该二进制数无符号位&#xff0c;长度不超过31。 输出&#xff1a;输出一个整数&#xff0c;为该二进制数…
阅读更多...
实在智能携手中国电信翼支付，全球首款Agent智能体亮相2023数字科技生态大会

实在智能携手中国电信翼支付，全球首款Agent智能体亮相2023数字科技生态大会

11月10日-13日&#xff0c;中国电信与广东省人民政府联合主办的“2023数字科技生态大会”在广州隆重举行。本届大会以“数字科技焕新启航”为主题&#xff0c;邀请众多生态合作伙伴全方位展示数字科技新成果&#xff0c;包括数字新消费、产业数字化、智能电子、人工智能大模型等…
阅读更多...
阿里云服务器 手动搭建WordPress（CentOS 8）

阿里云服务器 手动搭建WordPress（CentOS 8）

前提条件 已创建Linux操作系统的ECS实例&#xff0c;并且手动部署LNMP环境&#xff0c;具体操作&#xff0c;请参见手动部署LNMP环境&#xff08;CentOS 8&#xff09;。本教程使用的相关资源版本如下。 实例规格&#xff1a;ecs.c6.large 操作系统&#xff1a;公共镜像CentO…
阅读更多...
【C++初阶】内存管理 初识模板

【C++初阶】内存管理 初识模板

目录 一、C/C内存分布二、C/C动态内存管理方式2.1 new和delete的用法2.2 new与malloc、delete与free比较2.3 较复杂场景分析 三、operator new与operator delete函数四、 new和delete的实现原理五、初识模板5.1 泛型编程5.2 函数模板5.2.1 概念5.2.2 写法5.2.3 不同类型时使用函…
阅读更多...
excel怎么能锁住行 和/或 列的自增长，保证粘贴公式的时候不自增长或者只有部分自增长

excel怎么能锁住行 和/或 列的自增长，保证粘贴公式的时候不自增长或者只有部分自增长

例如在C4单元格中输入了公式&#xff1a; 现在如果把C4拷贝到C5&#xff0c;D3会自增长为D4&#xff1a; 现在如果想拷贝的时候不自增长&#xff0c;可以先把光标放到C4单元格&#xff0c;然后按F4键&#xff0c;行和列的前面加上了$符号&#xff0c;锁定了&#xff1a; …
阅读更多...
MySQL优化(1)：B+树与索引

MySQL优化(1)：B+树与索引

作者简介&#xff1a;大家好&#xff0c;我是smart哥&#xff0c;前中兴通讯、美团架构师&#xff0c;现某互联网公司CTO 联系qq&#xff1a;184480602&#xff0c;加我进群&#xff0c;大家一起学习&#xff0c;一起进步&#xff0c;一起对抗互联网寒冬 对于60%的程序员而言&a…
阅读更多...
【智能家居】4、智能家居框架设计和代码文件工程建立

【智能家居】4、智能家居框架设计和代码文件工程建立

目录 一、智能家居项目框架 二、智能家居工厂模式示意 三、代码文件工程建立 SourceInsight创建新工程步骤 一、智能家居项目框架 二、智能家居工厂模式示意 三、代码文件工程建立 创建一个名为si的文件夹用于保存SourceInsight生成的文件信息&#xff0c;然后在SourceInsig…
阅读更多...
.Net6 部署到IIS示例

.Net6 部署到IIS示例

基于FastEndpoints.Net6 框架部署到IIS 环境下载与安装IIS启用与配置访问网站 环境下载与安装 首先下载环境安装程序&#xff0c;如下图所示,根据系统位数选择x86或者x64进行下载安装,网址&#xff1a;Download .NET 6.0。 IIS启用与配置 启用IIS服务 打开控制面板&#xff…
阅读更多...
学习css过渡动画-transition

学习css过渡动画-transition

文章目录 前言transition属性语法宽度改变效果透明度改变效果位置改变效果如有启发&#xff0c;可点赞收藏哟~ 前言 通常&#xff0c;当一个元素的样式属性值发生变化时&#xff0c;会立即看到页面发生变化。 css属性transition能让页面元素不是立即的、而是慢慢的从一种状态变…
阅读更多...
【Proteus仿真】【STM32单片机】公交车报站系统

【Proteus仿真】【STM32单片机】公交车报站系统

文章目录 一、功能简介二、软件设计三、实验现象联系作者 一、功能简介 本项目使用Proteus8仿真STM32单片机控制器&#xff0c;使用LCD12864显示模块、DS18B20温度传感器、DS1302时钟模块、按键、LED蜂鸣器、ULN2003、28BYJ48步进电机模块等。 主要功能&#xff1a; 系统运行…
阅读更多...
2022年6月 电子学会青少年软件编程 中小学生Python编程 等级考试一级真题答案解析（选择题）

2022年6月 电子学会青少年软件编程 中小学生Python编程 等级考试一级真题答案解析（选择题）

2022年6月Python编程等级考试一级真题解析 选择题（共25题，每题2分，共50分） 1、在Python编辑器中写好程序代码后，在Run菜单中，下列哪个命令可以用来执行程序 A、Check Module B、Run Module C、Python shell D、任意一个都可以 答案：B 考点分析：考查python编辑的…
阅读更多...
表白墙/留言墙 —— 中级SpringBoot项目，MyBatis技术栈MySQL数据库开发，练手项目前后端开发(带完整源码) 全方位全步骤手把手教学

表白墙/留言墙 —— 中级SpringBoot项目，MyBatis技术栈MySQL数据库开发，练手项目前后端开发(带完整源码) 全方位全步骤手把手教学

&#x1f9f8;欢迎来到dream_ready的博客&#xff0c;&#x1f4dc;相信你对这篇博客也感兴趣o (ˉ▽ˉ&#xff1b;) &#x1f4dc;表白墙/留言墙初级Spring Boot项目&#xff08;此篇博客的简略版&#xff0c;不带MyBatis数据库开发&#xff09; 目录 1、项目前端页面及项目…
阅读更多...
ER 图是什么

ER 图是什么

文章目录 前言什么是 ER图ER 图实例简化的 ER 图总结 前言 产品经理在梳理产业业务逻辑的过程中&#xff0c;非常重要的一项工作就是梳理各个业务对象之间的关系。如果涉及对象很对的时候&#xff0c;没有工具支持的话很难处理清楚。今天我们就来介绍一个梳理业务对象关系的工…
阅读更多...
前置语音群呼与语音机器人群呼哪个更好

前置语音群呼与语音机器人群呼哪个更好

最近通过观察自己接到的营销电话&#xff0c;通过语音机器人外呼的量应该有所下降。同时和客户交流获取到的信息&#xff0c;也是和这个情况类似&#xff0c;很多AI机器人群呼的量转向了OKCC前置语音群呼。询问原因&#xff0c;说是前置语音群呼转化更快&#xff0c;AI机器人群…
阅读更多...
头歌 MySQL数据库 - 初识MySQL

头歌 MySQL数据库 - 初识MySQL

本章内容是为了完成老师布置的作业&#xff0c;同时也是为了以后考试的时候方便复习。 数据库部分一条一条的写&#xff0c;可鼠标手动粘贴&#xff0c;除特定命令外未分大小写。 第1关&#xff1a;创建数据库 在操作数据库之前&#xff0c;需要连接它&#xff0c;输入命令&a…
阅读更多...
《Deep learning for fine-grained image analysis: A survey》阅读笔记

《Deep learning for fine-grained image analysis: A survey》阅读笔记

论文标题 《Deep learning for fine-grained image analysis: A survey》 作者 魏秀参&#xff0c;旷世研究院 初读 摘要 细粒度图像分析&#xff08;FGIA&#xff09;的任务是分析从属类别的视觉对象。 细粒度性质引起的类间小变化和类内大变化使其成为一个具有挑战性的…
阅读更多...
一起学docker系列之五docker的常用命令--操作容器的命令

一起学docker系列之五docker的常用命令--操作容器的命令

目录 前言1 启动容器2 查看容器3 退出容器4 启动已经停止的容器5 重启容器6 停止容器7 删除已经停止的容器8 启动容器说明和举例9 查看容器日志10 查看容器内运行的进程11 查看容器内部细节12 进入正在运行的容器并进行交互13 导入和导出容器结语 前言 当涉及到容器化技术&…
阅读更多...
对话芯动科技 | 助力云游戏 4K级服务器显卡的探索与创新

对话芯动科技 | 助力云游戏 4K级服务器显卡的探索与创新

2021年芯动科技推出了基于IMG BXT GPU IP的风华1号显卡。单块风华1号显卡可在台式机和云游戏中实现4K级别的性能&#xff0c;渲染能力达到5 TFLOPS&#xff0c;如果在服务器中同时运行两块显卡&#xff0c;性能还可翻倍。该显卡是为不断扩大的安卓云游戏市场量身定制的&#xf…
阅读更多...
最新文章

Copyright @ 2022~2023