• C++异常

    目录

    1.C语言传统的处理错误的方式

    2.C++异常概念

    3.异常的用法

    3.1. 异常的抛出和捕获

    3.2. 异常的重新抛出 

    3.3. 异常安全

    3.4. 异常规范

    4. 自定义异常体系

    5.标准库异常体系

    6.异常的优缺点

    1.C语言传统的处理错误的方式

    C++之所以会有异常，原因是因为C语言处理错误方式的不足，而C语言，处理错误的方式：

    1. 终止程序。例如 assert， 缺陷：用户难以接受。如发生内存错误，除 0 错误时就会终止程序。
    2. 返回错误码。 缺陷：需要程序员自己去查找对应的错误。如系统的很多库的接口函数都是通过把错误码放到errno 中，表示错误
    实际中 C 语言基本都是使用返回错误码的方式处理错误，部分情况下使用终止程序处理非常严重的错误。

    2.C++异常概念

    异常是一种处理错误的方式，当一个函数发现自己无法处理的错误时就可以抛出异常，让函数的直接或间接的调用者处理这个错误。它允许程序在发生异常时跳过正常的执行流程，转而执行异常处理代码，从而改变程序的控制流。

    异常的相关概念：

    1. 异常类型（Exception Types）：异常类型是指表示不同异常情况的类或类型。在C++中，可以用任何类型作为异常类型，但通常使用自定义的异常类来代表特定的异常。异常类型应该适合异常的特定情况，并提供有关异常的额外信息。

    2. 抛出异常（Throwing Exceptions）：在程序中，当某些错误或异常情况发生时，可以使用throw关键字抛出一个异常。抛出的异常可以是特定的异常对象，也可以是异常类型的实例。

    3. 异常处理（Exception Handling）：异常处理是指在程序中捕获和处理异常的过程。通过使用try块和相应的catch块，可以指定某段代码的异常处理逻辑。当try块中的代码发生异常时，程序的控制流会转到与之匹配的catch块，并执行异常处理代码。如果没有找到匹配的catch块，异常将传播到调用栈中的上一层，直到找到一个匹配的catch块或程序终止。

    4. 异常对象（Exception Objects）：异常对象是在异常抛出时创建的表示异常情况的对象。它通常包含异常的相关信息，如错误代码、错误消息等。异常对象可以根据异常类型的定义进行自定义，并在异常处理过程中传递给相应的catch块。

    5. 异常规范（Exception Specification）：异常规范是指在函数声明或定义中指定函数可能抛出的异常类型。可以使用throw关键字和异常类型列表来声明函数的异常规范。在调用带有异常规范的函数时，编译器会进行静态检查，确保适当的异常处理。

    6. 标准异常类（Standard Exception Classes）：C++ 提供了一组标准异常类，位于头文件中。这些异常类派生自std::exception类，包括std::runtime_error、std::logic_error等，可以用于表示常见的异常情况

    使用异常机制可以帮助程序员处理和管理程序中的错误和异常情况。通过抛出异常对象，可以在程序中指示错误的发生并传递额外的信息。通过合理处理异常，可以使程序在异常情况下进行正确的清理和恢复操作，并提供更好的可靠性和稳定性。

    1. int main()
    2. {
    3. 	try
    4. 	{
    5. 		//要捕获异常的区域
    6. 	}
    7. 	catch (const Exception& e1)
    8. 	{
    9. 		// catch()块
    10. 	}
    11. 	catch (const Exception& e2)
    12. 	{
    13. 		// catch()块
    14. 	}
    15. 	catch (const Exception& e3)
    16. 	{
    17. 		// catch()块
    18. 	}
    19.     // ...
    20. 	return 0;
    21. }

    3.异常的用法

    3.1. 异常的抛出和捕获

    1. try：try关键字用于定义一个包含可能会引发异常的代码块，通常称为try块。try块中的代码用于封装可能抛出异常的语句或函数调用。

    2. catch：catch关键字用于定义一个异常处理块，用于捕获和处理由try块中抛出的异常。catch块包含异常处理代码，它能够匹配抛出异常的类型，并执行相应的处理逻辑。一个try块可以包含多个catch块，用于处理不同类型的异常。

    3. throw：throw关键字用于在程序中显式地抛出异常。当发生错误或异常情况时，可以使用throw关键字抛出一个异常对象或异常类型。抛出的异常将终止当前的正常执行流程，并传递到匹配的catch块来处理异常。

    异常的抛出和匹配原则
    1. 异常是通过抛出对象而引发的，该对象的类型决定了应该激活哪个catch的处理代码。
    2. 被选中的处理代码是调用链中与该对象类型匹配且离抛出异常位置最近的那一个。
    3. 抛出异常对象后，会生成一个异常对象的拷贝，因为抛出的异常对象可能是一个临时对象，所以会生成一个拷贝对象，这个拷贝的临时对象会在被catch以后销毁。（这里的处理类似于函数的传值返回）
    4. catch(...)可以捕获任意类型的异常，问题是不知道异常错误是什么。
    5. 实际中抛出和捕获的匹配原则有个例外，并不都是类型完全匹配，可以抛出的派生类对象，使用基类捕获，这个在实际中非常实用。
    在函数调用链中异常栈展开匹配原则
    1. 首先检查throw本身是否在try块内部，如果是再查找匹配的catch语句。如果有匹配的，则调到catch的地方进行处理。
    2. 没有匹配的catch则退出当前函数栈，继续在调用函数的栈中进行查找匹配的catch。
    3. 如果到达main函数的栈，依旧没有匹配的，则进程崩溃。上述这个沿着调用链查找匹配的
    catch子句的过程称为栈展开。所以实际中我们最后都要加一个catch(...)捕获任意类型的异
    常，否则当有异常没捕获，程序就会直接终止。
    4. 找到匹配的catch子句并处理以后，会继续沿着catch子句后面继续执行。

    例如下面的例子：

    1. double Division(double left, double right)
    2. {
    3. 	if (right == 0)
    4. 	{
    5.         // 当right为0时,会抛出异常
    6. 		throw "this is a error except 0";   
    7. 	}
    8. 	else
    9. 	{
    10. 		return left / right;
    11. 	}
    12. }
    13.  
    14. void Func1(void)
    15. {
    16. 	double x, y;
    17. 	std::cin >> x >> y;
    18. 	std::cout << Division(x, y) << std::endl;
    19. }
    20.  
    21. int main()
    22. {
    23. 	while (1)
    24. 	{
    25. 		try
    26. 		{
    27. 			Func1();
    28. 		}
    29. 		catch (const char *error_str)
    30. 		{
    31. 			std::cout << error_str << std::endl;
    32. 		}
    33. 	}
    34. 	return 0;
    35. }

    我们可以观察当发生异常时，进程的执行流程会发生什么样的变化？ 

    可以看到，当抛出异常时，它首先会在当前函数查找是否有匹配的catch块，如果有，就会调档当前栈帧的catch块，如果没有，会到上一级栈帧，继续查找与之匹配的catch块，直到main，如果main都没有与之匹配的catch块，那么进程会crash掉。

    1. double Division(double left, double right)
    2. {
    3. 	if (right == 0)
    4. 		throw "this is a error except 0";
    5. 	else
    6. 		return left / right;
    7. }
    8.  
    9. void Func1(void)
    10. {
    11. 	double x, y;
    12. 	std::cin >> x >> y;
    13. 	try
    14. 	{
    15. 		std::cout << Division(x, y) << std::endl;
    16. 	}
    17. 	catch (const char* error_msg)
    18. 	{
    19. 		std::cout << error_msg << std::endl;
    20. 	}
    21.  
    22. }
    23.  
    24. int main()
    25. {
    26. 	while (1)
    27. 	{
    28. 		try
    29. 		{
    30. 			Func1();
    31. 		}
    32. 		catch (const char *error_str)
    33. 		{
    34. 			std::cout << error_str << std::endl;
    35. 		}
    36. 	}
    37. 	return 0;
    38. }

    例如，上面的代码，当出现了除0错误，那么Division()会抛出异常：

    第一种情况：当Division()本身和main()都有与之匹配的catch块，那么此时抛出的异常会匹配谁的catch块呢？ 

    第二种情况：当Func1()和main()都有与之匹配的catch块，那么此时抛出的异常会匹配谁的catch块呢？ 

    可以看到，与我们之前的判断一致，当抛出异常时，如果这个异常在当前栈帧的try区域内，那么首先会检查当前函数栈帧是否有与之匹配的catch块，如果有，就会跳到当前栈帧的catch块，反之若没有，则会回到上级栈帧，查找是否有与之匹配的catch块。以此类推，直至main()，那么如果main也没有呢？

    如果从抛出异常所在的栈帧到main的栈帧都没有查找到匹配的catch块，那么进程会crash。例如，当我将上面main()的catch块更改为如下的时候：

    此时，如果发生了除0错误，由于此时没有匹配的catch块，则进程crash。 

    而对于某些不是特别严重的问题，如果没有catch块与之匹配，进程直接crash，对于用户而言，实际上是一种不好的方式的。因此为了防止这种问题，有了这种解决方案：

    1. // 由于异常可以随便抛,如果不规范抛异常,那么很有可能出现
    2. // 无法匹配的异常,因此这里的catch为了防止出现这种问题(可以捕获任意类型的异常)
    3. // 一般情况这个catch语句放在最后,防止一些异常没有被捕获,进程crash
    4. // 增强代码的健壮性
    5. catch (...)
    6. {
    7. 	std::cout << "Unknown error" << std::endl;
    8. }

    这个catch块，可以捕获throw抛出任意类型的异常，换句话说，这个catch块匹配任意类型的异常，那么上面的问题就可以解决了，即如果我没有显式与之匹配的catch，但此时进程不会crash，因为有catch(...)；但是也会随之带来问题：此时捕获的这个异常的信息我们是一无所知的，即这个异常是什么，我们是不确定的。

    虽然它有这个缺点，但对于以后我们处理异常时，这个最后的处理方案必须加上，可以理解为这是最后一道"闸口"，能够确保当我们遗漏了某些"异常"情况的时候，进程不会crash掉。

    上面时非正式的处理异常方式，正常情况下，我们应该这样处理异常：

    写了一个exception类，这个类里面包含两个信息，错误码和错误信息。

    1. namespace Xq
    2. {
    3. 	class exception
    4. 	{
    5. 	public:
    6. 		exception(const std::string& error_msg, int error_id)
    7. 		:_error_msg(error_msg)
    8. 		, _error_id(error_id)
    9. 		{}
    10.  
    11. 		const std::string& get_msg() const
    12. 		{
    13. 			return _error_msg;
    14. 		}
    15.  
    16. 		const int get_id() const
    17. 		{
    18. 			return _error_id;
    19. 		}
    20. 	private:
    21. 		std::string _error_msg;
    22. 		int _error_id;
    23. 	};
    24.  
    25. 	double Division(double left, double right)
    26. 	{
    27. 		if (right == 0)
    28. 		{
    29. 			throw(exception("this a error of except 0", 1));
    30. 		}
    31. 		else
    32. 			return left / right;
    33. 	}
    34. 	
    35. 	void Func1(void)
    36. 	{
    37. 		double x, y;
    38. 		std::cin >> x >> y;
    39. 		std::cout << Division(x, y) << std::endl;
    40. 	}
    41. }
    42.  
    43. int main()
    44. {
    45. 	while (1)
    46. 	{
    47. 		try
    48. 		{
    49. 			Xq::Func1();
    50. 		}
    51. 		catch (const Xq::exception& e)
    52. 		{
    53. 			std::cout << "error code:> " << e.get_id() << std::endl;
    54. 			std::cout << "error msg:> " << e.get_msg() << std::endl;
    55. 		}
    56. 		catch (...)
    57. 		{
    58. 			std::cout << "Unknown error" << std::endl;
    59. 		}
    60. 	}
    61. 	return 0;
    62. }

    当发生除0错误时，throw会抛异常，构造一个exception的匿名对象。

    但是这里有一个疑问，这个构造的局部对象直接传给了catch区，不是说出了函数栈帧局部对象会被销毁吗？在这里是怎么回事呢？

    首先，这个匿名局部对象出了作用域的确会被销毁，但是将对象传给catch这个过程类似于我们的传值返回的过程。throw构造的这个匿名局部对象会拷贝构造(如果实现了移动构造，那么就是移动构造)生成catch里的e对象。

    3.2. 异常的重新抛出 

    异常的重新抛出是指在catch块中捕获异常后，再次抛出该异常，使得其他的catch块或调用栈中的更高层次处理该异常。

    通常，在捕获异常的catch块中，程序员可以选择继续处理异常，或者将异常重新抛出，使得其他地方能够进一步处理该异常。重新抛出异常的目的是为了延续异常的传播，让异常能够被多个层次的catch块捕获，并根据不同的处理逻辑进行处理。

    重新抛出异常可以使用throw关键字，并在throw语句中提供捕获的异常对象或异常类型。

    例如下面的例子：

    1. double Division(double left, double right)
    2. {
    3. 	if (right == 0)
    4. 		throw "this is a error except 0";
    5. 	else 
    6. 		return left / right;
    7. }
    8.  
    9. void Func1(void)
    10. {
    11. 	int* arr = new int[10];
    12. 	double x, y;
    13. 	std::cin >> x >> y;
    14. 	std::cout << Division(x, y) << std::endl;
    15.  
    16. 	std::cout << "delete[] " << arr << std::endl;
    17.     delete[] arr;
    18. }
    19.  
    20. int main()
    21. {
    22. 	while (1)
    23. 	{
    24. 		try
    25. 		{
    26. 			Func1();
    27. 		}
    28. 		catch (const char *error_str)
    29. 		{
    30. 			std::cout << error_str << std::endl;
    31. 		}
    32. 		catch (...)
    33. 		{
    34. 			std::cout << "Unknown error" << std::endl;
    35. 		}
    36. 	}
    37. 	return 0;
    38. }

    那上面的代码有什么问题呢？ 

    当没有发生除0错误时，Division()不会抛异常，上面的代码没有问题。

    但是，如果发生了除0错误，此时就会带来一个问题 --- 内存泄漏。因为当发生了除0错误，Division会发生抛异常，此时就不会delete[] arr；造成了内存泄漏。

    因此为了解决上面的问题的，有人提出了，异常的重新抛出

    1. void Func1(void)
    2. {
    3. 	int* arr = new int[10];
    4. 	double x, y;
    5. 	std::cin >> x >> y;
    6. 	try
    7. 	{
    8. 		std::cout << Division(x, y) << std::endl;
    9. 	}
    10. 	catch (const char* str)
    11. 	{
    12. 		std::cout << "delete[] " << arr << std::endl;
    13. 		delete[] arr;
    14.  
    15. 		// 重新抛出异常
    16.         // 可以只使用 throw; 重新抛出当前异常
    17.         //throw;
    18.         //  或者使用 throw str; 重新抛出复制的异常对象
    19. 		throw str;
    20. 	}
    21.  
    22. 	std::cout << "delete[] " << arr << std::endl;
    23. 	delete[] arr;
    24. }

    但是，如果此时Division不止抛出一种异常呢？即： 

    1. double Division(double left, double right)
    2. {
    3. 	if (right == 0)
    4. 		throw "this is a error except 0";
    5. 	// 假设此时分母为1,也抛异常
    6. 	else if (right == 1)
    7. 		throw 1;
    8. 	else
    9. 		return left / right;
    10. }

    那么此时如果right == 1，Division也会抛异常，并且这个异常是一个新类型，难道说，我又在Func1添加一个catch(int x)吗？那如果再来一些异常类型呢？ 

    因此，为了防止出现这种问题，我们可以这样做：

    1. void Func1(void)
    2. {
    3. 	int* arr = new int[10];
    4. 	double x, y;
    5. 	std::cin >> x >> y;
    6. 	try
    7. 	{
    8. 		std::cout << Division(x, y) << std::endl;
    9. 	}
    10. 	catch (const char* str)
    11. 	{
    12. 		std::cout << "delete[] " << arr << std::endl;
    13. 		delete[] arr;
    14. 		// 重新抛出异常
    15. 		throw;
    16. 	}
    17.     // 捕获未匹配的异常类型
    18. 	catch (...)
    19. 	{
    20. 		std::cout << "delete[] " << arr << std::endl;
    21. 		delete[] arr;
    22. 		// 重新抛出异常
    23. 		throw;
    24. 	}
    25.  
    26. 	std::cout << "delete[] " << arr << std::endl;
    27. 	delete[] arr;
    28. }

    3.3. 异常安全

    构造函数完成对象的构造和初始化，最好不要在构造函数中抛出异常，否则可能导致对象不
    完整或没有完全初始化
    析构函数主要完成资源的清理，最好不要在析构函数内抛出异常，否则可能导致资源泄漏(内
    存泄漏、句柄未关闭等)
    C++中异常经常会导致资源泄漏的问题，比如在new和delete中抛出了异常，导致内存泄
    漏，在lock和unlock之间抛出了异常导致死锁，C++经常使用RAII来解决以上问题，关于RAII
    我们智能指针这节进行讲解。

    3.4. 异常规范

    1. 异常规格说明的目的是为了让函数使用者知道该函数可能抛出的异常有哪些。 可以在函数的后面接throw( 类型 ) ，列出这个函数可能抛掷的所有异常类型。
    2. 函数的后面接 throw() ，表示函数不抛异常。
    3. 若无异常接口声明，则此函数可以抛掷任何类型的异常。 
    1. // C++98:
    2. // 注意: 这里的异常声明并不是必须的,比较繁琐,
    3. // 实际中很多人没有去遵守规范,形同虚设
    4.  
    5. // 表示这个函数不会抛异常
    6. void func1() throw();
    7. // 表示这个函数可能会抛出type1或type2或type3的异常
    8. void func2() throw(type1, type2, type3);
    9. // 这里表示这个函数只会抛出bad_alloc的异常
    10. void* operator new (std::size_t size) throw (std::bad_alloc);
    11. // 这里表示这个函数不会抛出异常
    12. void* operator delete (std::size_t size, void* ptr) throw();
    13.  
    14. // C++11:
    15. // 如果一个函数明确了不抛异常,那么加noexcept
    16. void func3() noexcept;
    17. // 如果一个函数可能会抛异常，什么都不加
    18. void func4();
    19.  
    20. // 在这里经测试发现, 如果一个函数被noexcept声明了,但实际上却抛异常了
    21. // 编译器会报警告,但没有报错
    22. // 而如果此时捕获异常就会导致进程崩溃

    4. 自定义异常体系

    实际使用中很多公司都会自定义自己的异常体系进行规范的异常管理，因为一个项目中如果大家随意抛异常，那么外层的调用者基本就没办法玩了，所以实际中都会定义一套继承的规范体系。这样大家抛出的都是继承的派生类对象，捕获一个基类就可以了。 
    1. namespace Xq
    2. {
    3. 	class exception
    4. 	{
    5. 	public:
    6. 		exception(const std::string& error_msg, int error_id)
    7. 			:_error_msg(error_msg)
    8. 			, _error_id(error_id)
    9. 		{}
    10.         // 在这里为了构成多态
    11. 		virtual const std::string what() const
    12. 		{
    13. 			return _error_msg;
    14. 		}
    15. 		const int get_id() const
    16. 		{
    17. 			return _error_id;
    18. 		}
    19. 	protected:
    20. 		const std::string _error_msg;
    21. 		int _error_id;
    22. 	};
    23.  
    24. 	class sql_exception : public exception
    25. 	{
    26. 	public:
    27. 		sql_exception(const std::string& error_msg, int error_id, const std::string sql)
    28. 			:exception(error_msg, error_id)
    29. 			, _sql(sql)
    30. 			{}
    31.  
    32. 		virtual const std::string what() const
    33. 		{
    34. 			std::string ret = "sql_exception:";
    35. 			ret += _error_msg;
    36. 			ret += ": ";
    37. 			ret += _sql;
    38. 			return ret;
    39. 		}
    40. 	private:
    41. 		const std::string _sql;
    42. 	};
    43.  
    44. 	class cache_exception : public exception
    45. 	{
    46. 	public:
    47. 		cache_exception(const std::string& error_msg, int error_id)
    48. 			:exception(error_msg, error_id)
    49. 			{}
    50.  
    51. 		virtual const std::string what() const
    52. 		{
    53. 			std::string ret = "cache_exception: ";
    54. 			ret += _error_msg;
    55. 			return ret;
    56. 		}
    57. 	};
    58.  
    59. 	class http_exception : public exception
    60. 	{
    61. 	public:
    62. 		http_exception(const std::string& error_msg, int error_id, const std::string& type)
    63. 			:exception(error_msg, error_id)
    64. 			, _type(type)
    65. 		{}
    66.  
    67. 		virtual const std::string what() const
    68. 		{
    69. 			std::string ret = "http_exception: ";
    70. 			ret += _error_msg;
    71. 			ret += ": ";
    72. 			ret += _type;
    73. 			return ret;
    74. 		}
    75. 	private:
    76. 		const std::string _type;
    77. 	};
    78.  
    79. 	void sql_mgr(void)
    80. 	{
    81. 		if (rand() % 2 == 0)
    82. 		{
    83.             // 抛子类对象,父类对象去捕捉,构成多态
    84. 			throw sql_exception("没有权限", 5, "select * from name = 李四");
    85. 		}
    86. 	}
    87.  
    88. 	void cache_mgr(void)
    89. 	{
    90. 		if (rand() % 3 == 0)
    91. 		{
    92.             // 抛子类对象,父类对象去捕捉,构成多态
    93. 			throw cache_exception("没有权限", 10);
    94. 		}
    95. 		else if (rand() % 4 == 0)
    96. 		{
    97.             // 抛子类对象,父类对象去捕捉,构成多态
    98. 			throw cache_exception("没有该数据", 11);
    99. 		}
    100. 		sql_mgr();
    101. 	}
    102.  
    103. 	void http_serve(void)
    104. 	{
    105. 		if (rand() % 5 == 0)
    106. 		{
    107.             // 抛子类对象,父类对象去捕捉,构成多态
    108. 			throw http_exception("请求资源不存在", 20, "pos");
    109. 		}
    110. 		cache_mgr();
    111. 	}
    112. }
    113.  
    114. int main()
    115. {
    116. 	srand((unsigned int)time(nullptr));
    117. 	while (1)
    118. 	{
    119. 		try
    120. 		{
    121. 			Sleep(1000);
    122. 			Xq::http_serve();
    123. 		}
    124. 		catch (const Xq::exception& e)
    125. 		{
    126. 			std::cout << e.what() << std::endl;
    127. 		}
    128. 		catch (...)
    129. 		{
    130. 			std::cout << "Unknown error" << std::endl;
    131. 		}
    132. 	}
    133. 	return 0;
    134. }

    5.标准库异常体系

    C++ 提供了一系列标准的异常，定义在std::exception中，我们可以在程序中使用这些标准的异常。它们是以父 子类层次结构组织起来的，如下所示：

     说明：实际中我们可以可以去继承exception类实现自己的异常类。但是实际中很多公司像上面一样自己定义一套异常继承体系。因为C++标准库设计的不够好用。

    6.异常的优缺点

    C++ 异常的优点：
    1. 异常对象定义好了， 相比错误码的方式可以清晰准确的展示出错误的各种信息 ，甚至可以包含堆栈调用的信息，这样可以帮助更好的定位程序的 bug 。
    2. 返回错误码的传统方式有个很大的问题就是，在函数调用链中，深层的函数返回了错误，那么我们得层层返回错误，最外层才能拿到错误。
    3. 很多的第三方库都包含异常，比如 boost 、 gtest 、 gmock 等等常用的库，那么我们使用它们也需要使用异常。
    4. 部分函数使用异常更好处理，比如构造函数没有返回值，不方便使用错误码方式处理。比如T& operator这样的函数，如果 pos 越界了只能使用异常或者终止程序处理，没办法通过返回值表示错误。
    C++ 异常的缺点：
    1. 异常会导致程序的执行流乱跳，并且非常的混乱，并且是运行时出错抛异常就会乱跳。这会导致我们跟踪调试时以及分析程序时，比较困难。
    2. 异常会有一些性能的开销。当然在现代硬件速度很快的情况下，这个影响基本忽略不计。
    3. C++ 没有垃圾回收机制(申请的空间不需要自己释放)，资源需要自己管理。有了异常非常容易导致内存泄漏、死锁等异常安全问题。这个需要使用RAII 来处理资源的管理问题。
    4. C++ 标准库的异常体系定义得不好，导致大家各自定义各自的异常体系，非常的混乱。
    5. 异常尽量规范使用，否则后果不堪设想，随意抛异常，外层捕获的用户苦不堪言。所以异常规范有两点：一、抛出异常类型都继承自一个基类。二、函数是否抛异常、抛什么异常，都使用 func （）noexcept ; 的方式规范化。
    总结 ：异常总体而言，利大于弊，所以工程中我们还是鼓励使用异常的。另外 OO 的语言基本都是用异常处理错误，这也可以看出这是大势所趋。
  • 相关阅读:
    【操作系统】信号量机制（整型信号量、记录型信号量），用信号量实现进程互斥、同步、前驱关系
    2. 安装运行SQL语句的环境
    vue2 过滤器 自定义指令
    Vega Prime入门教程14.04：CDB测试
    Splashtop 与 Canopy 携手共同增强对物联网设备的远程管理
    Kafka系列之：安装具有安全认证的kafka-2.8.2分布式集群
    【MATLAB源码-第83期】基于matlab的MIMO中V-BALST结构ZF和MMSE检测算法性能误码率对比。
    慢 SQL 分析与优化
    强光LCD液晶显示屏检测装置太阳光模拟器系统
    Windows 0环和3环通信方式
  • 原文地址：https://blog.csdn.net/m0_62229058/article/details/133842868