【C++】封装unordered_map和unordered_set（用哈希桶实现）

2023-09-13 14:17:55

前言：
       前面我们学习了unordered_map和unordered_set容器，比较了他们和map、set的查找效率，我们发现他们的效率比map、set高，进而我们研究他们的底层是由哈希实现。哈希是一种直接映射的方式，所以查找的效率很快。与学习红黑树和map、set的思路一样，我们现在学完了unordered_map和unordered_set，本章将模拟实现底层结构来封装该容器！

    作者建议在阅读本章前，可以先去看一下前面的红黑树封装map和set——红黑树封装map和set

这两篇文章都重在强调泛型编程的思想，上一篇由于是初认识，作者讲解的会更详细一点~

目录

（一）如何复用一个哈希桶

1、结点的定义：

2、两个容器各自的模板参数类型​编辑

3、改造哈希桶

（二）哈希桶的迭代器的模拟实现

1、begin()和end()的模拟实现

2、operator*和operator->及operator!=和operator==的模拟实现 

3、operator ++的模拟实现

（三）迭代器和改造哈希桶的总代码

（四）封装unordered_map和unordered_set

（一）如何复用一个哈希桶

我们学习过知道，unordered_map和unordered_set容器存放的结点并不一样，为了让它得到复用，我们就需要对哈希桶进行改造，将哈希桶改造的更加泛型一点，既符合Key模型，也符合Key_Value模型。

1、结点的定义：

 所以我们这里还是和封装map和set时一样，无论是Key还是Key_Value，都用一个类型T来接收，这里高维度的泛型哈希表中，实现还是用的是Kye_Value模型，K是不能省略的，同样的查找和删除要用，故我们可以引出两个容器各自模板参数类型。

2、两个容器各自的模板参数类型

如何取到想要的数据：

  • 我们给每个容器配一个仿函数
  • 各传不同的仿函数，拿到想要的不同的数据

同时我们再给每个容器配一个哈希函数。

3、改造哈希桶

通过上面1和2，我们可以把各自存放的数据泛化成data：

这样我们哈希桶的模板参数算是完成了

  • 哈希函数我们可以自由选择并传
  • 仿函数在各自容器的封装中实现，用于比较时我们可以取出各自容器想要的数据

我们把上一篇文章封装的哈希桶拿来改造：

//K --> 键值Key，T --> 数据
//unordered_map ->HashTable<K, pair<K, V>, MapKeyOfT> _ht;
//unordered_set ->HashTable<K, K, SetKeyOfT> _ht;
template<class K, class T, class KeyOfT, class HashFunc>
class HashTable
{
	template<class K, class T, class KeyOfT, class HashFunc>
	friend class __HTIterator;

	typedef HashNode<T> Node;
public:
	typedef __HTIterator<K, T, KeyOfT, HashFunc> iterator;

	iterator begin()
	{
		for (size_t i = 0; i < _tables.size(); i++)
		{
			Node* cur = _tables[i];
			if (cur)
			{
				return iterator(cur, this);
			}
		}

		return end();
	}

	iterator end()
	{
		return iterator(nullptr, this);
	}

	~HashTable()
	{
		for (size_t i = 0; i < _tables.size(); i++)
		{
			Node* cur = _tables[i];
			while (cur)
			{
				Node* next = cur->_next;
				delete cur;
				cur = next;
			}

			_tables[i] = nullptr;
		}
	}

	size_t GetNextPrime(size_t prime)
	{
		const int PRIMECOUNT = 28;
		static const size_t primeList[PRIMECOUNT] =
		{
			53,         97,         193,       389,       769,
			1543,       3079,       6151,      12289,     24593,
			49157,      98317,      196613,    393241,    786433,
			1572869,    3145739,    6291469,   12582917,  25165843,
			50331653,   100663319,  201326611, 402653189, 805306457,
			1610612741, 3221225473, 4294967291
		};

		//获取比prime大那一个素数
		size_t i = 0;
		for (i = 0; i < PRIMECOUNT; i++)
		{
			if (primeList[i] > prime)
				return primeList[i];
		}

		return primeList[i];
	}

	pair<iterator, bool> Insert(const T& data)
	{
		HashFunc hf;
		KeyOfT kot;

		iterator pos = Find(kot(data));
		if (pos != end())
		{
			return make_pair(pos, false);
		}

		//负载因子 == 1 扩容 -- 平均每个桶挂一个结点
		if (_tables.size() == _n)
		{
			//size_t newSize = _tables.size() == 0 ? 10 : _tables.size() * 2;
			size_t newSize = GetNextPrime(_tables.size());

			if (newSize != _tables.size())
			{
				vector<Node*> newTable;
				newTable.resize(newSize, nullptr);

				//遍历旧表
				for (size_t i = 0; i < _tables.size(); i++)
				{
					Node* cur = _tables[i];

					//再对每个桶挨个遍历
					while (cur)
					{
						Node* next = cur->_next;
						size_t hashi = hf(kot(cur->_data)) % newSize;

						//转移到新的表中
						cur->_next = newTable[hashi];
						newTable[hashi] = cur;
						cur = next;
					}

					//将原表置空
					_tables[i] = nullptr;
				}
				newTable.swap(_tables);
			}
			
		}

		size_t hashi = hf(kot(data));
		hashi %= _tables.size();

		//头插到对应的桶即可
		Node* newnode = new Node(data);
		newnode->_next = _tables[hashi];
		_tables[hashi] = newnode;

		//有效数据加一
		_n++;

		return make_pair(iterator(newnode, this), true);
	}

	iterator Find(const K& key)
	{
		if (_tables.size() == 0)
		{
			return iterator(nullptr, this);
		}

		KeyOfT kot;
		HashFunc hf;
		size_t hashi = hf(key);
		//size_t hashi = HashFunc()(key);

		hashi %= _tables.size();
		Node* cur = _tables[hashi];

		//找到指定的桶之后，顺着单链表挨个找
		while (cur)
		{
			if (kot(cur->_data) == key)
			{
				return iterator(cur, this);
			}

			cur = cur->_next;
		}

		//没找到返回空
		return iterator(nullptr, this);
	}

	bool Erase(const K& key)
	{
		if (_tables.size() == 0)
		{
			return false;
		}

		HashFunc hf;
		KeyOfT kot;
		size_t hashi = hf(key);
		hashi %= _tables.size();

		//单链表删除结点
		Node* prev = nullptr;
		Node* cur = _tables[hashi];
		while (cur)
		{
			if (kot(cur->_data) == key)
			{
				//头删
				if (prev == nullptr)
				{
					_tables[hashi] = cur->_next;
				}
				else
				{
					prev->_next = cur->_next;
				}

				delete cur;

				return true;
			}

			prev = cur;
			cur = cur->_next;
		}

		return false;
	}
private:
	//指针数组
	vector<Node*> _tables;
	size_t _n = 0;
};

主要改造的地方就是上述所注意的地方：

  • 比较时需要调用各自的仿函数
  • 调用外部传的哈希函数

还有对扩容的二次思考：

研究表明：除留余数法，最好模一个素数

  • 通过查STL官方库我们也发现，其提供了一个取素数的函数
  • 所以我们也提供了一个，直接拷贝过来
    • 这样我们在扩容时就可以每次给素数个桶
    • 在扩容时加了一条判断语句是为了防止素数值太大，过分扩容容易直接把空间(堆)干崩了

（二）哈希桶的迭代器的模拟实现

1、begin()和end()的模拟实现

  • 以第一个桶中第一个不为空的结点为整个哈希桶的开始结点
  • 以空结点为哈希桶的结束结点

2、operator*和operator->及operator!=和operator==的模拟实现 

这两组和之前实现的一模一样，大家自行理解。

3、operator ++的模拟实现

注：

  • 这里要在哈希桶的类外面访问其私有成员
  • 我们要搞一个友元类
  • 迭代器类是哈希桶类的朋友
  • 这样就可以访问了

 

思路：

  • 判断一个桶中的数据是否遍历完
  • 如果所在的桶没有遍历完，在该桶中返回下一个结点指针
  • 如果所在的桶遍历完了，进入下一个桶
  • 判断下一个桶是否为空
  • 非空返回桶中第一个节点
  • 空的话就遍历一个桶
  • 后置++和之前一眼老套路，不赘述

注意：

unordered_map和unordered_set是不支持反向迭代器的，从底层结构我们也能很好的理解（单链表找不了前驱）所以不支持实现迭代器的operator- -

最后注意一点，我们需要知道哈希桶大小，所以不仅要传结点地址，还要传一个哈希桶，这样才能知道其大小，除此，由于哈希桶改造在后面，所以我们要在前面声明一下：

（三）迭代器和改造哈希桶的总代码

#include<vector>
#include<string>
#include<iostream>
using namespace std;

template<class K>
struct DefaultHash
{
	size_t operator()(const K& key)
	{
		return (size_t)key;
	}
};

template<>
struct DefaultHash<string>
{
	size_t operator()(const string& key)
	{
		//BKDR
		size_t hash = 0;
		for (auto ch : key)
		{
			hash = hash * 131 + ch;
		}

		return hash;
	}
};

namespace Bucket
{
	template<class T>
	struct HashNode
	{
		T _data;
		HashNode<T>* _next;

		HashNode(const T& data)
			:_data(data)
			, _next(nullptr)
		{}
	};

	template<class K, class T, class KeyOfT, class HashFunc>
	class HashTable;

	//哈希桶的迭代器
	template<class K, class T, class KeyOfT, class HashFunc>
	class __HTIterator
	{
		typedef HashNode<T> Node;
		typedef __HTIterator<K, T, KeyOfT, HashFunc> Self;
	public:
		Node* _node;

		__HTIterator() {};

		//编译器的原则是向上查找（定义必须在前面，否则必须先声明）
		HashTable<K, T, KeyOfT, HashFunc>* _pht;

		__HTIterator(Node* node, HashTable<K, T, KeyOfT, HashFunc>* pht)
			:_node(node)
			, _pht(pht)
		{}

		Self& operator++()
		{
			if (_node->_next)
			{
				_node = _node->_next;
			}
			else//当前桶已经走完了，要走下一个桶
			{
				KeyOfT kot;
				HashFunc hf;
				size_t hashi = hf(kot(_node->_data)) % _pht->_tables.size();
				hashi++;

				//找下一个不为空的桶 -- 访问到了哈希表中私有的成员（友元）
				for (; hashi < _pht->_tables.size(); hashi++)
				{
					if (_pht->_tables[hashi])
					{
						_node = _pht->_tables[hashi];
						break;
					}
				}

				//没有找到不为空的桶，用nullptr去做end标识
				if (hashi == _pht->_tables.size())
				{
					_node = nullptr;
				}
			}

			return *this;
		}

		T& operator*()
		{
			return _node->_data;
		}

		T* operator->()
		{
			return &_node->_data;
		}

		bool operator!=(const Self& s) const
		{
			return _node != s._node;
		}

		bool operator==(const Self& s) const
		{
			return _node == s._node;
		}
	};

	//K --> 键值Key，T --> 数据
	//unordered_map ->HashTable<K, pair<K, V>, MapKeyOfT> _ht;
	//unordered_set ->HashTable<K, K, SetKeyOfT> _ht;
	template<class K, class T, class KeyOfT, class HashFunc>
	class HashTable
	{
		template<class K, class T, class KeyOfT, class HashFunc>
		friend class __HTIterator;

		typedef HashNode<T> Node;
	public:
		typedef __HTIterator<K, T, KeyOfT, HashFunc> iterator;

		iterator begin()
		{
			for (size_t i = 0; i < _tables.size(); i++)
			{
				Node* cur = _tables[i];
				if (cur)
				{
					return iterator(cur, this);
				}
			}

			return end();
		}

		iterator end()
		{
			return iterator(nullptr, this);
		}

		~HashTable()
		{
			for (size_t i = 0; i < _tables.size(); i++)
			{
				Node* cur = _tables[i];
				while (cur)
				{
					Node* next = cur->_next;
					delete cur;
					cur = next;
				}

				_tables[i] = nullptr;
			}
		}

		size_t GetNextPrime(size_t prime)
		{
			const int PRIMECOUNT = 28;
			static const size_t primeList[PRIMECOUNT] =
			{
				53,         97,         193,       389,       769,
				1543,       3079,       6151,      12289,     24593,
				49157,      98317,      196613,    393241,    786433,
				1572869,    3145739,    6291469,   12582917,  25165843,
				50331653,   100663319,  201326611, 402653189, 805306457,
				1610612741, 3221225473, 4294967291
			};

			//获取比prime大那一个素数
			size_t i = 0;
			for (i = 0; i < PRIMECOUNT; i++)
			{
				if (primeList[i] > prime)
					return primeList[i];
			}

			return primeList[i];
		}

		pair<iterator, bool> Insert(const T& data)
		{
			HashFunc hf;
			KeyOfT kot;

			iterator pos = Find(kot(data));
			if (pos != end())
			{
				return make_pair(pos, false);
			}

			//负载因子 == 1 扩容 -- 平均每个桶挂一个结点
			if (_tables.size() == _n)
			{
				//size_t newSize = _tables.size() == 0 ? 10 : _tables.size() * 2;
				size_t newSize = GetNextPrime(_tables.size());

				if (newSize != _tables.size())
				{
					vector<Node*> newTable;
					newTable.resize(newSize, nullptr);

					//遍历旧表
					for (size_t i = 0; i < _tables.size(); i++)
					{
						Node* cur = _tables[i];

						//再对每个桶挨个遍历
						while (cur)
						{
							Node* next = cur->_next;
							size_t hashi = hf(kot(cur->_data)) % newSize;

							//转移到新的表中
							cur->_next = newTable[hashi];
							newTable[hashi] = cur;
							cur = next;
						}

						//将原表置空
						_tables[i] = nullptr;
					}
					newTable.swap(_tables);
				}

			}

			size_t hashi = hf(kot(data));
			hashi %= _tables.size();

			//头插到对应的桶即可
			Node* newnode = new Node(data);
			newnode->_next = _tables[hashi];
			_tables[hashi] = newnode;

			//有效数据加一
			_n++;

			return make_pair(iterator(newnode, this), true);
		}

		iterator Find(const K& key)
		{
			if (_tables.size() == 0)
			{
				return iterator(nullptr, this);
			}

			KeyOfT kot;
			HashFunc hf;
			size_t hashi = hf(key);
			//size_t hashi = HashFunc()(key);

			hashi %= _tables.size();
			Node* cur = _tables[hashi];

			//找到指定的桶之后，顺着单链表挨个找
			while (cur)
			{
				if (kot(cur->_data) == key)
				{
					return iterator(cur, this);
				}

				cur = cur->_next;
			}

			//没找到返回空
			return iterator(nullptr, this);
		}

		bool Erase(const K& key)
		{
			if (_tables.size() == 0)
			{
				return false;
			}

			HashFunc hf;
			KeyOfT kot;
			size_t hashi = hf(key);
			hashi %= _tables.size();

			//单链表删除结点
			Node* prev = nullptr;
			Node* cur = _tables[hashi];
			while (cur)
			{
				if (kot(cur->_data) == key)
				{
					//头删
					if (prev == nullptr)
					{
						_tables[hashi] = cur->_next;
					}
					else
					{
						prev->_next = cur->_next;
					}

					delete cur;

					return true;
				}

				prev = cur;
				cur = cur->_next;
			}

			return false;
		}
	private:
		//指针数组
		vector<Node*> _tables;
		size_t _n = 0;
	};
}

（四）封装unordered_map和unordered_set

有了上面的哈希桶的改装，我们这里的对map和set的封装就显得很得心应手了。

unordered_map的封装：

#include "HashTable.h"

namespace zc
{
	template<class K, class V, class HashFunc = DefaultHash<K>>
	class unordered_map
	{
		struct MapKeyOfT
		{
			const K& operator()(const pair<K, V>& kv)
			{
				return kv.first;
			}
		};
	public:
		typedef typename Bucket::HashTable<K, pair<K, V>, MapKeyOfT, HashFunc>::iterator iterator;

		iterator begin()
		{
			return _ht.begin();
		}

		iterator end()
		{
			return _ht.end();
		}

		pair<iterator, bool> insert(const pair<K, V>& kv)
		{
			return _ht.Insert(kv);
		}

		iterator find(const K& key)
		{
			return _ht.Find(key);
		}

		bool erase(const K& key)
		{
			return _ht.Erase(key);
		}

		V& operator[](const K& key)
		{
			pair<iterator, bool> ret = insert(make_pair(key, V()));
			return ret.first->second;
		}

	private:
		Bucket::HashTable<K, pair<K, V>, MapKeyOfT, HashFunc> _ht;
	};

	void test_map()
	{
		unordered_map<string, string> dict;
		dict.insert(make_pair("sort", "排序"));
		dict.insert(make_pair("left", "左边"));
		dict.insert(make_pair("left", "下面"));
		dict["string"];
		dict["left"] = "上面";
		dict["string"] = "字符串";

		unordered_map<string, string>::iterator it = dict.begin();
		while (it != dict.end())
		{
			cout << it->first << " " << it->second << endl;
			++it;
		}
		cout << endl;

		for (auto e : dict)
		{
			cout << e.first << " " << e.second << endl;
		}
	}

}

这里unordered_map中的operator[ ]我们知道其原理之后，模拟实现就非常方便，直接调用插入函数，控制好参数和返回值即可。

对unordered_set的封装：

#include "HashTable.h"

#include "HashTable.h"

namespace zc
{
	template<class K, class HashFunc = DefaultHash<K>>
	class unordered_set
	{
		
		struct SetKeyOfT
		{
			const K& operator()(const K& key)
			{
				return key;
			}
		};

	public:
		//2.48
		typedef typename Bucket::HashTable<K, K, SetKeyOfT, HashFunc>::iterator iterator;

		iterator begin()
		{
			return _ht.begin();
		}

		iterator end()
		{
			return _ht.end();
		}

		pair<iterator, bool> insert(const K& key)
		{
			return _ht.Insert(key);
		}

		iterator find(const K& key)
		{
			return _ht.Find(key);
		}

		bool erase(const K& key)
		{
			return _ht.Erase(key);
		}
	private:
		Bucket::HashTable<K, K, SetKeyOfT, HashFunc> _ht;
	};

	struct Date
	{
		Date(int year = 1, int month = 1, int day = 1)
			:_year(year)
			, _month(month)
			, _day(day)
		{}

		bool operator==(const Date& d) const
		{
			return _year == d._year
				&& _month == d._month
				&& _day == d._day;
		}

		int _year;
		int _month;
		int _day;
	};

	struct DateHash
	{
		size_t operator()(const Date& d)
		{
			//return d._year + d._month + d._day;
			size_t hash = 0;
			hash += d._year;
			hash *= 131;
			hash += d._month;
			hash *= 1313;
			hash += d._day;

			//cout << hash << endl;

			return hash;
		}
	};

	void test_set()
	{
		unordered_set<int> s;
		//set<int> s;
		s.insert(2);
		s.insert(3);
		s.insert(1);
		s.insert(2);
		s.insert(5);
		s.insert(12);

		unordered_set<int>::iterator it = s.begin();
		//auto it = s.begin();
		while (it != s.end())
		{
			cout << *it << " ";
			++it;
		}
		cout << endl;

		for (auto e : s)
		{
			cout << e << " ";
		}
		cout << endl;

		unordered_set<Date, DateHash> sd;
		sd.insert(Date(2022, 3, 4));
		sd.insert(Date(2022, 4, 3));
	}
}

最后大家可以利用代码中给的测试函数进行测试！

感谢你的阅读！

更多推荐

【Go 基础篇】Windows 开发常用 Dos 命令

介绍在计算机开发领域，命令行工具是开发者的得力助手，能够快速、高效地完成各种任务。在Windows操作系统中，DOS（DiskOperatingSystem）命令是一组强大的命令行工具，用于进行文件操作、目录管理、进程控制等各种操作。虽然现代开发环境提供了图形界面和可视化工具，但掌握常用的DOS命令仍然是一项必要的技能

SpringMVC中的自定义注解

目录简介注解（Annotation）在Java编程中的作用SpringMVC中的自定义注解Java注解是什么？为什么在Java开发中注解变得如此重要？Java注解分类1.标准注解（JDK基本注解）2.自定义注解JDK基本注解JDK元注解自定义注解如何使用自定义注解？案例1:获取类与方法上的注解值案例二:获取类属性上的注

前端构建工具 webpack 笔记

1、了解webpack1、定义：本质上，webpack是一个用于现代JavaScript应用程序的静态模块打包工具，当webpack处理应用它会在内部从一个或多个入口点构建一个依赖图(dependencygraph)，然后将你项目中所程序时，需的每一个模块组合成一个或多个bundles，它们均为静态资源，用于展示你的内

Flink 类型机制 及 Stream API和Table API类型推断和转换

注：本文使用flink版本是0.13一、类型体系Flink有两大API（1）streamAPI和（2）TableAPI,分别对应TypeInformation和DataType类型体系。1.1TypeInformation系统TypeInformation系统是使用Stream一定会用到的。TypeInformatio

Vue知识系列（7）每天10个小知识点

目录系列文章目录Vue知识系列（1）每天10个小知识点Vue知识系列（2）每天10个小知识点Vue知识系列（3）每天10个小知识点Vue知识系列（4）每天10个小知识点Vue知识系列（5）每天10个小知识点Vue知识系列（6）每天10个小知识点知识点61.**Vue**过滤器的概念、作用、特性、优点、缺点、区别、使用场

如何利用 MidJourney 进行 AI 艺术创作（详细教程）

文章目录什么是MidJourney?MidJourney入门第1步：设置Discord第2步：注册订阅MidJourney了解MidJourney的工具和功能在MidJourney中进行AI艺术创作Tips小技巧简明扼要使用样式和媒介组合概念关于MidJourney的思考什么是MidJourney?Midjourney

三维展示技术让未来项目更加裸眼3D可视化展示在观众面前

三维展示系统分为三维虚拟模型和三维实体模型，三维虚拟模型多为软件制图和后期成像进行展示供人们观赏，三维实体模型为采用各种可塑性材料根据三维虚拟模型制作出的实物，相比三维虚拟模型，三维实体模型更具有收藏与展示的价值，三维实体模型可用于楼盘展示，车型展示与人物艺术展示。现有技术中三维实体模型中的三维模型展示只有简单的保护罩

云原生Kubernetes：K8S存储卷

目录一、理论1.存储卷2.emptyDir存储卷3.hostPath卷4.NFS共享存储二、实验1.emptyDir存储卷2.hostPath卷3.NFS共享存储三、问题1.生成pod一直pending四、总结一、理论1.存储卷（1）概念容器磁盘上的文件的生命周期是短暂的,这就使得在容器中运行重要应用时会出现一些问题。

[2023.09.13]: Rust Lang，避不开的所有权问题

Rust的所有权问题，在我学Rust的时候就跳过了，因为我知道这玩意儿没有场景就不好理解。没想到场景很快就出现了。在开发Yew应用组件的时候，涉及到了事件，闭包，自然就引出了所有权问题。话不多说，下面让我们直接进入代码场景，去体验并了解Rust的所有权机制吧。下面这段代码是能够正常工作的。这段代码的逻辑意图也很简单，这

Linux MQTT智能家居项目（网络基础知识）

文章目录前言一、IP和端口的作用1.IP2.端口二、路由器的转发作用三、MQTT概念总结前言本篇文章带大家来做一个LinuxMQTT智能家居项目，这个项目将会讲解到网络的基础知识和MQTT协议一些相关的知识。一、IP和端口的作用1.IPIP（InternetProtocol）：IP是一种网络层协议，它负责在互联网中标识

Redis 面试题

Redis面试题Q:Redis有哪些优势？速度快，因为数据存在内存中支持丰富数据类型，支持string，list，set，sortedset，hash支持事务，操作都是原子性，所谓的原子性就是对数据的更改要么全部执行，要么全部不执行丰富的特性：可用于缓存，消息，按key设置过期时间，过期后将会自动删除单线程，单进程，采

热文推荐
  1. 11:STM32---spl通信

    目录一:SPL通信1:简历2:硬件电路3:移动数据图4:SPI时序基本单元A:开/终条件B:SPI时序基本单元A:模式0B:模式1C:模式2D:模式3C:SPl时序A:发送指令B:指定地址写C:指定地址读二:W25Q641:简历2:硬件电路3:W25Q64框图4:Flash操作注意事项5:指令集三:案例A:软件SPI读

  2. Ceph入门到精通-CEPH故障以其处理方法

    1.SlowOSDheartbeats#ceph-shealth:HEALTH_WARNSlowOSDheartbeatsonback(longest6181.010ms)SlowOSDheartbeatsonfront(longest5953.232ms)OSDs之间会相互测试（ping）访问速度，若两个OSDs之间

  3. Docker 常用命令

    帮助启动类命令1、启动docker：systemctlstartdocker2、停l止docker：systemctlstopdocker3、重启docker：systemctlrestartdocker4、查看docker状态：systemctlstatusdocker5、开机启动：systemctlenabledo

  4. 【Flink实战】Flink对接Kafka Connetor使用docker部署kafka

    🚀作者：“大数据小禅”🚀文章简介：Flink对接KafkaConnetor第一步使用docker部署kafka🚀欢迎小伙伴们点赞👍、收藏⭐、留言💬目录导航什么是DockerDocker常用命令Docker安装过程Docker部署kafka什么是DockerDocker是一个开源的容器化平台，用于将应用程序和其

  5. Kafka消费一致性和幂等性分析

    1、前言在分布式系统中，消息队列被广泛用于数据的传输和处理。其中，Kafka因其高吞吐量、可扩展性和容错性而备受关注。然而，在处理海量数据时，确保消息的一致性和幂等性十分重要。本文将通过代码示例，对Kafka消费一致性和幂等性进行分析。2、问题背景在Kafka消费过程中，消费者从消息队列中获取消息并处理。然而，在某些场

  6. 分布式面试题

    文章目录前言一、大型网站系统的特点二、拆分VS集群三、微服务VSSOA四、前后端完全分离与Rest规范总结前言大型网站系统的特点拆分VS集群微服务VSSOA前后端完全分离与Rest规范一、大型网站系统的特点高并发，大流量需要面对高并发用户，大流量访问。Google日均PV35亿，日IP访问数3亿；腾讯QQ的最大在线用户

  7. 简述现代加油站的智能防雷设计及其解决措施

    随着经济的发展，人民群众生活水平不断提高，汽车已经成为非常普通的代步工具，与其配套的汽车加油站也越来越多。据统计，目前，我国各种类型加油加气站将近10万座，其中中石油约有18000座，中石化约有28000多座，其他国有、民营和外资等约有46000多座。与此同时，加油站的安全问题显得更加重要。加油站是易燃易爆场所，属于第

  8. Selenium常用操作之单选复选框、下拉列表、键盘、截屏、断言、(显式隐式)等待

    目录1.窗口最大化2.单选框操作3.复选框操作4.下拉列表5.selenium三种等待6.键盘操作7.截屏8.断言9.Selenium操作JS弹窗控件10.鼠标悬停与释放1.窗口最大化driver.maximize_window()2.单选框操作driver.find_element_by_xpath("//input

  9. 【TCP】三次握手 与 四次挥手 详解

    三次握手与四次挥手1.三次握手2.四次挥手三次握手和四次挥手的区别在正常情况下，TCP要经过三次握手建立连接，四次挥手断开连接1.三次握手服务端状态转化：[CLOSED->LISTEN]服务器端调用listen后进入LISTEN状态，等待客户端连接；[LISTEN->SYN_RCVD]一旦监听到连接请求（同步报文段SY