lesson9: C++多线程

news2024/11/23 15:36:52

1.线程库

1.1 thread类的简单介绍

C++11 中引入了对 线程的支持 了，使得 C++ 在 并行编程时 不需要依赖第三方库
而且在原子操作中还引入了 原子类 的概念。要使用标准库中的线程，必须包含 < thread > 头文件
函数名
功能
thread()
构造一个线程对象，没有关联任何线程函数，即没有启动任何线程
thread(fn, args1, args2, ...)
构造一个线程对象，并关联线程函数fn，args1，args2，...为线程函数的
参数
get_id()
获取线程id
jionable()
线程是否还在执行，joinable代表的是一个正在执行中的线程。
jion()
该函数调用后会 阻塞住线程 ，当该线程结束后，主线程继续执行
detach()
在创建线程对象后马上调用，用于把被创建线程与线程对象分离开，分离
的线程变为后台线程，创建的线程的"死活"就与主线程无关
  1. 线程是操作系统中的一个概念，线程对象可以关联一个线程，用来控制线程以及获取线程的
    状态。
  2. 当创建一个线程对象后，没有提供线程函数，该对象实际没有对应任何线程

1.2 线程对象关联线程函数

#include <iostream>
using namespace std;
#include <thread>
void ThreadFunc(int a)
{
	cout << "Thread1" << a << endl;
}
class TF
{
public:
	void operator()()
	{
		cout << "Thread3" << endl;
	}
};
int main()
{
	// 线程函数为函数指针
	thread t1(ThreadFunc, 10);

	// 线程函数为lambda表达式
	thread t2([](){cout << "Thread2" << endl; });

	// 线程函数为函数对象
	TF tf;
	thread t3(tf);

	t1.join();
	t2.join();
	t3.join();
	cout << "Main thread!" << endl;
	return 0;
}
  • 线程对象可以关联1.函数指针2.lambda表达式3.函数对象
  • 当创建一个线程对象后，没有提供线程函数，该对象实际没有对应任何线程

1.2.1 注意

  1. thread类是防拷贝的，不允许拷贝构造以及赋值，但是可以 移动构造 和 移动赋值 ，即将一个
    线程对象关联线程的状态转移给其他线程对象，转移期间不意向线程的执行。
  2. 可以通过jionable()函数判断线程是否是有效的，如果是以下任意情况，则线程无效
    1. 采用无参构造函数构造的线程对象
    2. 线程对象的状态已经转移给其他线程对象
    3. 线程已经调用jion或者detach结束

1.3 线程函数参数

#include<iostream>
#include<thread>
#include<mutex>
#include<condition_variable>
#include<vector>
#include<atomic>
using namespace std;

void Print(int n, int& x,mutex& mtx)
{
	for (int i = 0; i < n; ++i)
	{
		mtx.lock();
		cout <<this_thread::get_id()<<":"<< i << endl;
		std::this_thread::sleep_for(std::chrono::milliseconds(100));
		++x;
		mtx.unlock();
	}

}

int main()
{
	mutex m;
	int count = 0;
	thread t1(Print, 10, ref(count),ref(m));
	thread t2(Print, 10, ref(count),ref(m);

	t1.join();
	t2.join();

	cout << count << endl;

	return 0;
}

  •  线程函数的参数是先传递给thread的,并以值拷贝的方式拷贝到线程栈空间中的
  • 如果不给线程函数的参数不借助 ref函数
    • 即使线程参数为 引用类型 ，在线程中修改后也 不能修改外部实参 ，
    • 因为其实际引用的是线程栈中的拷贝，而不是外部实参 
#include<iostream>
#include<thread>
#include<mutex>
#include<condition_variable>
#include<vector>
#include<atomic>
using namespace std;

int main()
{
	mutex mtx;
	int x = 0;
	int n = 10;
	int m;
	cin >> m;

	vector<thread> v(m);
	//v.resize(m);

	for (int i = 0; i < m; ++i)
	{
		// 移动赋值给vector中线程对象
		v[i] = thread([&](){
			for (int i = 0; i < n; ++i)
			{
				mtx.lock();

				cout << this_thread::get_id() << ":" << i << endl;
				std::this_thread::sleep_for(std::chrono::milliseconds(100));
				++x;

				mtx.unlock();
			}
		});
	}

	for (auto& t : v)
	{
		t.join();
	}

	cout << x << endl;

	return 0;
}
  •  借助lambda表达式中的引用捕捉也可以实现上面那个函数,就可以不用借助ref函数

1.3.1 线程并行 && 并发的讨论 

  • 并行:任务的同时进行
  • 并发: 任务的调动和切换
  • 在这个函数中其实是并行的速度更快,因为线程切换十分耗时间

1.4 原子性操作库(atomic) 

多线程最主要的问题是共享数据带来的问题 ( 即线程安全 )
当一个或多个线程要 修改 共享数据时，就会产生很多潜在的麻烦 
#include<iostream>
#include<thread>
#include<mutex>
#include<condition_variable>
#include<vector>
#include<atomic>
using namespace std;

int main()
{
	mutex mtx;
	atomic<int> x = 0;
	// int x = 0;
	int n = 1000000;
	int m;
	cin >> m;

	vector<thread> v(m);
	for (int i = 0; i < m; ++i)
	{
		// 移动赋值给vector中线程对象
		v[i] = thread([&](){
			for (int i = 0; i < n; ++i)
			{
				// t1 t2 t3 t4
				++x;
			}
		});
	}

	for (auto& t : v)
	{
		t.join();
	}

	cout << x << endl;

	return 0;
}

 

  •  C++98中传统的解决方式：可以对共享修改的数据加锁保护
    • 加锁的问题: 这个线程执行的时候, 其他线程就会被阻塞，会影响程序运行的效率，而且锁如果控制不好，还容易造成死锁。
  • C++11 中使用atomic类模板，定义出需要的任意原子类型
    • 程序员 不需要 对原子类型变量进行 加锁解锁 操作，线程能够对原子类型变量互斥的访问。

1.4.1 注意 

#include <atomic>
int main()
{
     atomic<int> a1(0);
     //atomic<int> a2(a1);   // 编译失败
     atomic<int> a2(0);
     //a2 = a1;               // 编译失败
     return 0;
}
  • 原子类型通常属于"资源型"数据，多个线程只能访问单个原子类型的拷贝，
  • 因此在C++11 中，原子类型只能从其模板参数中进行构造，不允许原子类型进行拷贝构造、移动构造以及 operator=等，为了防止意外，标准库已经将atmoic模板类中的拷贝构造、移动构造、赋值运算符重载默认删除掉了 

1.5 lock_guard与unique_lock  

在 多线程 环境下， 原子性 只能保证 某个变量的安全性

在多线程环境下,而需要保证一段代码的安全性,就只能通过加锁的方式实现

1.5.1  lock_guard

#include<iostream>
#include<thread>
#include<mutex>
#include<condition_variable>
#include<vector>
#include<atomic>
using namespace std;

//RAII
template<class Lock>
class LockGuard
{
public:
	LockGuard(Lock& lk)
		:_lock(lk)
	{
		_lock.lock();
		cout << "thread:" << this_thread::get_id() << "加锁" << endl;
	}

	~LockGuard()
	{
		cout << "thread:" << this_thread::get_id() << "解锁" << endl << endl;
		_lock.unlock();
	}
private:
	Lock& _lock;// 成员变量是引用
};

int main()
{
	mutex mtx;
	atomic<int> x = 0;
	//int x = 0;
	int n = 100;
	int m;
	cin >> m;

	vector<thread> v(m);
	for (int i = 0; i < m; ++i)
	{
		// 移动赋值给vector中线程对象
		v[i] = thread([&](){
			for (int i = 0; i < n; ++i)
			{
				{
					lock_guard<mutex> lk(mtx);
					cout << this_thread::get_id() << ":" << i << endl;
				}

				std::this_thread::sleep_for(std::chrono::milliseconds(100));
			}
		});
	}

	for (auto& t : v)
	{
		t.join();
	}

	cout << x << endl;

	return 0;
}
  •  lock_guard类模板主要是通过RAII的方式，对其管理的互斥量进行了封装
  • 调用构造函数成功上锁，出作用域前，lock_guard对象要被销毁，调用析构函数自动解锁，可以有效避免死锁问题。
  • lock_guard 的 缺陷 ：太单一，用户没有办法对该锁进行控制

1.5.2 unique_lock 

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

1.6 支持两个线程交替打印，一个打印奇数，一个打印偶数

1.6.1 错误案例

#include<iostream>
#include<thread>
#include<mutex>
#include<condition_variable>
#include<vector>
#include<atomic>
using namespace std;

int main()
{
	int i = 0;
	int n = 100;
	mutex mtx;

	thread t1([&](){
		while (i < n)
		{
			mtx.lock();

			cout << this_thread::get_id() << ":" << i << endl;
			i += 1;

			mtx.unlock();
		}
	});

	this_thread::sleep_for(chrono::microseconds(100));

	thread t2([&](){
		while (i < n)
		{
			mtx.lock();

			cout << this_thread::get_id() << ":" << i << endl;
			i += 1;

			mtx.unlock();
		}
	});

	t1.join();
	t2.join();

	return 0;
}

  • 在线程切换的中间时间也会发现线程竞争抢锁的问题 

1.6.2 正确案例 

#include<iostream>
#include<thread>
#include<mutex>
#include<condition_variable>
#include<vector>
#include<atomic>
using namespace std;

int main()
{
	int i = 0;
	int n = 100;
	mutex mtx;
	condition_variable cv;// 条件变量
	bool ready = true;

	// t1打印奇数
	thread t1([&](){
		while (i < n)
		{
			{
				unique_lock<mutex> lock(mtx);
				cv.wait(lock, [&ready](){return !ready; });// 等待线程

				cout << "t1--" << this_thread::get_id() << ":" << i << endl;
				i += 1;

				ready = true;

				cv.notify_one();// 解除线程等待
			}

			//this_thread::yield();
			this_thread::sleep_for(chrono::microseconds(100));
		}
	});

	// t2打印偶数
	thread t2([&]() {
		while (i < n)
		{
			unique_lock<mutex> lock(mtx);
			cv.wait(lock, [&ready](){return ready; });

			cout <<"t2--"<<this_thread::get_id() << ":" << i << endl;
			i += 1;
			ready = false;

			cv.notify_one();
		}
	});

	this_thread::sleep_for(chrono::seconds(3));

	cout << "t1:" << t1.get_id() << endl;
	cout << "t2:" << t2.get_id() << endl;

	t1.join();
	t2.join();

	return 0;
}

 

  • cv.wait(lock, [&ready]() {return !ready; });
    • 当ready返回的是false时,这个线程就会阻塞
    • 阻塞当前线程,并自动调用lock.unlock()，允许其他锁定的线程继续执行
  •  cv.notify_one();
    • 唤醒当前线程并自动调用lock.lock();就只允许自己一个线程执行

1.7 shared_ptr的多线程问题

#include<iostream>
#include<thread>
#include<mutex>
#include<vector>
#include<atomic>
#include<memory>
using namespace std;

namespace bit
{
	template<class T>
	class shared_ptr
	{
	public:
		shared_ptr(T* ptr = nullptr)
			:_ptr(ptr)
			, _pRefCount(new int(1))
			, _pMutex(new mutex)
		{}

		shared_ptr(const shared_ptr<T>& sp)
			:_ptr(sp._ptr)
			, _pRefCount(sp._pRefCount)
			, _pMutex(sp._pMutex)
		{
			AddRef();
		}

		void Release()
		{
			bool flag = false;

			_pMutex->lock();
			if (--(*_pRefCount) == 0 && _ptr)
			{
				cout << "delete:" << _ptr << endl;
				delete _ptr;
				delete _pRefCount;

				flag = true;
			}
			_pMutex->unlock();

			if (flag)
				delete _pMutex;
		}

		void AddRef()
		{
			_pMutex->lock();

			++(*_pRefCount);

			_pMutex->unlock();
		}

		shared_ptr<T>& operator=(const shared_ptr<T>& sp)
		{
			if (_ptr != sp._ptr)
			{
				Release();

				_ptr = sp._ptr;
				_pRefCount = sp._pRefCount;
				_pMutex = sp._pMutex;
				AddRef();
			}

			return *this;
		}

		int use_count()
		{
			return *_pRefCount;
		}

		~shared_ptr()
		{
			Release();
		}

		// 像指针一样使用
		T& operator*()
		{
			return *_ptr;
		}

		T* operator->()
		{
			return _ptr;
		}

		T* get() const
		{
			return _ptr;
		}
	private:
		T* _ptr;
		int* _pRefCount;// 使用时需要加锁
		mutex* _pMutex;// 锁指针
	};
}

int main()
{
	// shared_ptr是线程安全的吗？
	bit::shared_ptr<double> sp1(new double(1.11));
	bit::shared_ptr<double> sp2(sp1);

	mutex mtx;

	vector<thread> v(2);
	int n = 100000;
	for (auto& t : v)
	{
		t = thread([&](){
			for (size_t i = 0; i < n; ++i)
			{
				// 拷贝是线程安全的
				bit::shared_ptr<double> sp(sp1);

				// 访问资源不是
				mtx.lock();
				(*sp)++;
				mtx.unlock();
			}
		});
	}

	for (auto& t : v)
	{
		t.join();
	}

	cout << sp1.use_count() << endl;
	cout << *sp1 << endl;

	return 0;
}

  •  在多线程中,shared_ptr也应该对自己的引用计数进行加锁处理

  • 在多线程中, shared_ptr的拷贝是线程安全的,但访问资源不是,所以访问资源也需要加锁

1.8 单例模式的多线程问题 

#include<iostream>
#include<thread>
#include<mutex>
using namespace std;
class Singleton
{
public:
	static Singleton* GetInstance()
	{
		// 保护第一次，后续不需要加锁
		// 双检查加锁
		if (_pInstance == nullptr)
		{
			unique_lock<mutex> lock(_mtx);
			if (_pInstance == nullptr)
			{
				_pInstance = new Singleton;
			}
		}

		return _pInstance;
	}

private:
	// 构造函数私有
	Singleton(){};

	// C++11
	Singleton(Singleton const&) = delete;
	Singleton& operator=(Singleton const&) = delete;

	static Singleton* _pInstance;
	static mutex _mtx;
};

Singleton* Singleton::_pInstance = nullptr;
mutex Singleton::_mtx; 

int main()
{
	Singleton::GetInstance();
	Singleton::GetInstance();

	return 0;
}
  •  在多线程的情况下, 第一次创建对象时也是需要加锁保护的

1.8.1 巧妙的解决方案

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

class Singleton
{
public:
	static Singleton* GetInstance()
	{
		static Singleton _s;// 局部的静态对象，第一次调用时初始化

		return &_s;
	}

private:
	// 构造函数私有
	Singleton() {};

	// C++11
	Singleton(Singleton const&) = delete;
	Singleton& operator=(Singleton const&) = delete;
};

int main()
{
	Singleton::GetInstance();
	Singleton::GetInstance();

	return 0;
}
  • 局部的静态对象，第一次调用时初始化
  • 在C++11之前是不能保证线程安全的
    静态对象的构造函数调用初始化并不能保证线程安全的原子性
  • C++11的时候修复了这个问题，所以这种写法，只能在支持C++11以后的编译器上玩

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

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

相关文章

LCD液晶屏接口静电浪涌保护用TVS/ESD二极管，如何选型？

LCD液晶屏接口静电浪涌保护用TVS/ESD二极管，如何选型？

LCD 液晶屏是Liquid Crystal Display 的简称&#xff0c;指将玻璃和LCD驱动器集成到一起的LCD显示产品&#xff0c;为用户提供了一个标准的LCD显示驱动接口&#xff0c;用户可以按照接口&#xff08;有4位、8位、VGA等不同类型&#xff09;要求进行操作来控制LCD正确显示。众所…
阅读更多...
Fsm onehot

Fsm onehot

module top_module(input in,input [9:0] state,output [9:0] next_state,output out1,output out2);assign out1(state[8]|state[9])?1:0;assign out2(state[9]|state[7])?1:0;assign next_state[0](state[0]&(~in)) |(state[1]&(~in)) |(state[2]&(~in)) |(sta…
阅读更多...
LVS+Keepalived 实验

LVS+Keepalived 实验

Keepalived 是什么 Keepalived 是一个基于VRRP协议来实现的LVS服务高可用方案&#xff0c;可以解决静态路由出现的单点故障问题的一款检查工具 在一个LVS服务集群中通常有主服务器&#xff08;MASTER&#xff09;和备份服务器&#xff08;BACKUP&#xff09;两种角色的服务器…
阅读更多...
ShardingSphere01-docker环境安装

ShardingSphere01-docker环境安装

使用docker安装数据库是一个非常好的选择&#xff0c;后续的读写分离、数据分片等功能的数据库都是由docker创建。 一、安装准备 1、前提条件 Docker可以运行在Windows、Mac、CentOS、Ubuntu等操作系统上 Docker支持以下的CentOS版本&#xff1a; CentOS 7 (64-bit)CentOS …
阅读更多...
LLM预训练大型语言模型Pre-training large language models

LLM预训练大型语言模型Pre-training large language models

在上一个视频中&#xff0c;您被介绍到了生成性AI项目的生命周期。 如您所见&#xff0c;在您开始启动您的生成性AI应用的有趣部分之前&#xff0c;有几个步骤需要完成。一旦您确定了您的用例范围&#xff0c;并确定了您需要LLM在您的应用程序中的工作方式&#xff0c;您的下…
阅读更多...
第59步 深度学习图像识别：误判病例分析（TensorFlow）

第59步 深度学习图像识别：误判病例分析（TensorFlow）

基于WIN10的64位系统演示 一、写在前面 本期内容对等于机器学习二分类系列的误判病例分析&#xff08;传送门&#xff09;。既然前面的数据可以这么分析&#xff0c;那么图形识别自然也可以。 本期以mobilenet_v2模型为例&#xff0c;因为它建模速度快。 同样&#xff0c;基…
阅读更多...
Linux下Jenkins安装 （最新）

Linux下Jenkins安装 （最新）

环境概述 随着软件开发需求及复杂度的不断提高&#xff0c;团队开发成员之间如何更好地协同工作以确保软件开发的质量已经慢慢成为开发过程中不可回避的问题。Jenkins自动化部署可以解决集成、测试、部署等重复性的工作&#xff0c;工具集成的效率明显高于人工操作&#xff1b…
阅读更多...
Android动画进阶指北

Android动画进阶指北

原文链接 Android Animation Advanced Tricks 前面的文章介绍了动画的基本使用方法&#xff0c;本文来聊一聊涉及到动画的高级技巧&#xff0c;以及一些非常优质的学习资源和动画三方库和框架。 页面之间的过渡动画 常规的动画都是针对某一页面上的某个元素做动画&#xff0c…
阅读更多...
3、Spring_容器执行

3、Spring_容器执行

容器执行点 1.整合 druid 连接池 添加依赖 <dependency><groupId>com.alibaba</groupId><artifactId>druid</artifactId><version>1.2.8</version> </dependency>1.硬编码方式整合 新建德鲁伊配置 <?xml version"1.…
阅读更多...
微信小程序 车牌号输入组件

微信小程序 车牌号输入组件

概述 一个小组件&#xff0c;用于方便用户输入车牌号码 详细 概述 有时候我们开发过程中会遇到需要用户输入车牌号的情况&#xff0c;让客户通过自带键盘输入&#xff0c;体验不好且容易出错&#xff0c;例如车牌号是不能输入O和I的&#xff0c;因此需要有一个自定义的键盘…
阅读更多...
FPGA中锁存器（latch）、触发器（flip-flop）以及寄存器（register）详解

FPGA中锁存器（latch）、触发器（flip-flop）以及寄存器（register）详解

文章目录 1 定义1.1 锁存器&#xff08;latch&#xff09;1.2 触发器&#xff08;flip-flop&#xff09;1.3 寄存器&#xff08;register&#xff09; 2 比较2.1 锁存器&#xff08;Latch&#xff09;危害即产生原因2.2 寄存器和锁存器的区别2.3 锁存器和触发器的区别 3 结构3.…
阅读更多...
dvwa环境搭建

dvwa环境搭建

靶场搭建 环境作用apache网站代理&#xff0c;部署网站php一种开源通用脚本语言&#xff0c;用来处理程序mysql数据库&#xff0c;用来存储数据 1.打开sever 2008&#xff0c;远程桌面连接&#xff0c;将文件拷贝到虚拟机&#xff0c;打开微软常用集合运行库&#xff0c;等待…
阅读更多...
「Vue｜网页开发｜前端开发」01 快速入门：用vue-cli快速写一个Vue的HelloWorld项目

「Vue｜网页开发｜前端开发」01 快速入门：用vue-cli快速写一个Vue的HelloWorld项目

本文主要介绍如何用vue开发的标准化工具vue-cli快速搭建一个符合实际业务项目结构的hello world网页项目并理解vue的代码文件结构以及页面渲染流程。 文章目录 一、准备工作&#xff1a;安装node.js二、项目搭建创建项目目录全局安装vue-cli使用Webpack初始化项目启动项目学会…
阅读更多...
RedisDesktopManager 连接redis

RedisDesktopManager 连接redis

redis查看是否启动成功 ps -ef | grep redis以上未启动成功 cd /usr/local/bin/ 切换根目录 sudo -i 开启服务端 ./redis-server /usr/local/redis/redis.conf 开启客户端 ./redis-cli
阅读更多...
Ganache 本地测试网远程连接

Ganache 本地测试网远程连接

文章目录 前言1. 安装Ganache2. 安装cpolar3. 创建公网地址4. 公网访问连接5. 固定公网地址 前言 Ganache 是DApp的测试网络&#xff0c;提供图形化界面&#xff0c;log日志等&#xff1b;智能合约部署时需要连接测试网络。 Ganache 是一个运行在本地测试的网络,通过结合cpol…
阅读更多...
MySQL如何进行表之间的关联更新

MySQL如何进行表之间的关联更新

在实际编程工作或运维实践中&#xff0c;对MySQL数据库表进行关联更新是一种比较常见的应用场景&#xff0c;比如在电商系统中&#xff0c;订单表里保存了商品名称的信息&#xff08;冗余字段设计&#xff09;&#xff0c;但如果商品名称发生变化&#xff0c;则需要通过关联商品…
阅读更多...
[已解决]SpringBoot 返回日期时间格式不正确

[已解决]SpringBoot 返回日期时间格式不正确

最近开发中不知道为什么&#xff0c;返回给前端的日期时间格式变成了这样子&#xff0c;晚了8小时&#xff0c;在网上找了解决办法&#xff1a; 原返回值&#xff1a; 需要修改的地方&#xff1a; 在application.yml中添加下面的代码&#xff0c;重启springboot项目即可。 sp…
阅读更多...
C++信息学奥赛1121：计算矩阵边缘元素之和

C++信息学奥赛1121：计算矩阵边缘元素之和

题解&#xff1a;i0 or j0 or in-1 or jm-1 or in-1 or jm-1 代码&#xff1a; #include<iostream> // 包含输入输出流库 #include<cmath> // 包含数学函数库 using namespace std; // 使用标准命名空间int main() {int n,m;cin>>n>>m; // 输入…
阅读更多...
2023年夏季《移动软件开发》实验报告一

2023年夏季《移动软件开发》实验报告一

姓名和学号&#xff1f;本实验属于哪门课程&#xff1f;中国海洋大学22夏《移动软件开发》实验名称&#xff1f;实验1&#xff1a;第一个微信小程序博客地址&#xff1f;XXXXXXXGithub仓库地址&#xff1f;https://github.com/enfantsRichesDeprimes/Mobile-Software-Developme…
阅读更多...
vue2+element-ui+springboot编写一个简单的CRUD和上传页面

vue2+element-ui+springboot编写一个简单的CRUD和上传页面

1.0先看效果图 2.0主功能页面展示 3.0新增功能 4.0更新功能 5.0接口错误提示 前端码云链接:https://gitee.com/xiaojianr/management/tree/master/ 前端拷贝完成需要使用:npm install 命令完成package.json依赖的下载 后端码云链接:https://gitee.com/xiaojianr/manage
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023