面试—C++《智能指针》常考点

这篇具有很好参考价值的文章主要介绍了面试—C++《智能指针》常考点。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

目录

1.为什么需要智能指针

2. 内存泄漏

2.1 什么是内存泄漏,内存泄漏的危害

2.2 内存泄漏分类

2.3 如何检测内存泄漏

2.4如何避免内存泄漏

3.智能指针的使用及原理

3.3 std::auto_ptr

3.4 std::unique_ptr

3.5 std::shared_ptr 


1.为什么需要智能指针

下面我们先分析一下下面这段程序有没有什么内存方面的问题?

int div()
{
	int a, b;
	cin >> a >> b;
	if (b == 0)
		throw invalid_argument("除0错误");
	return a / b;
}
void Func()
{
	// 1、如果p1这里new 抛异常会如何?
	// 2、如果p2这里new 抛异常会如何?
	// 3、如果div调用这里又会抛异常会如何?
	int* p1 = new int;
	int* p2 = new int;
	cout << div() << endl;
	delete p1;
	delete p2;
}
int main()
{
	try
	{
		Func();
	}
	catch (exception& e)
	{
		cout << e.what() << endl;
	}
	return 0;
}

上面的三种情况会有内存泄漏的问题

2. 内存泄漏

2.1 什么是内存泄漏,内存泄漏的危害

什么是内存泄漏:内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。内
存泄漏并不是指内存在物理上的消失,而是应用程序分配某段内存后,因为设计错误,失去了对
该段内存的控制,因而造成了内存的浪费。
内存泄漏的危害:长期运行的程序出现内存泄漏,影响很大,如操作系统、后台服务等等,出现
内存泄漏会导致响应越来越慢,最终卡死。

void MemoryLeaks()
{
 // 1.内存申请了忘记释放
 int* p1 = (int*)malloc(sizeof(int));
 int* p2 = new int;
 // 2.异常安全问题
 int* p3 = new int[10];
 Func(); // 这里Func函数抛异常导致 delete[] p3未执行,p3没被释放.
 delete[] p3;
}

2.2 内存泄漏分类

C/C++程序中一般我们关心两种方面的内存泄漏:
堆内存泄漏(Heap leak)
堆内存指的是程序执行中依据须要分配通过malloc / calloc / realloc / new等从堆中分配的一
块内存,用完后必须通过调用相应的 free或者delete 删掉。假设程序的设计错误导致这部分
内存没有被释放,那么以后这部分空间将无法再被使用,就会产生Heap Leak。
系统资源泄漏
指程序使用系统分配的资源,比方套接字、文件描述符、管道等没有使用对应的函数释放
掉,导致系统资源的浪费,严重可导致系统效能减少,系统执行不稳定。

2.3 如何检测内存泄漏

在linux下内存泄漏检测:linux下几款内存泄漏检测工具
在windows下使用第三方工具:VLD工具说明
其他工具:内存泄漏工具比较

2.4如何避免内存泄漏

1. 工程前期良好的设计规范,养成良好的编码规范,申请的内存空间记着匹配的去释放。ps:
这个理想状态。但是如果碰上异常时,就算注意释放了,还是可能会出问题。需要下一条智
能指针来管理才有保证。
2. 采用RAII思想或者智能指针来管理资源。
3. 有些公司内部规范使用内部实现的私有内存管理库。这套库自带内存泄漏检测的功能选项。
4. 出问题了使用内存泄漏工具检测。
总结一下:
内存泄漏非常常见,解决方案分为两种:

1、事前预防型。如智能指针等。2、事后查错型。如泄漏检测工具。

3.智能指针的使用及原理

RAII(Resource Acquisition Is Initialization)是一种利用对象生命周期来控制程序资源(如内存、文件句柄、网络连接、互斥量等等)的简单技术。
在对象构造时获取资源,接着控制对资源的访问使之在对象的生命周期内始终保持有效,最后在
对象析构的时候释放资源。借此,我们实际上把管理一份资源的责任托管给了一个对象。这种做
法有两大好处:
不需要显式地释放资源。
采用这种方式,对象所需的资源在其生命期内始终保持有效

// 使用RAII思想设计的SmartPtr类
template<class T>
class SmartPtr 
{
public:
	//RAII
	SmartPtr(T* ptr = nullptr)
		: _ptr(ptr)
	{}
	~SmartPtr()
	{
		delete[] _ptr;
		cout << "delete[]:" << _ptr << endl;
	}
	//像指针一样:
	T* operator->()
	{
		return _ptr;
	}
	T& operator*()
	{
		return *_ptr;
	}
private:
	T* _ptr;
};
int div()
{
	int a, b;
	cin >> a >> b;
	if (b == 0)
		throw invalid_argument("除0错误");
	return a / b;
}
void Func()
{
	SmartPtr<int> sp1(new int[10]);
	SmartPtr<int> sp2(new int[10]);
	cout << div() << endl;
}
int main()
{
	try 
	{
		Func();
	}
	catch (const exception& e)
	{
		cout << e.what() << endl;
	}
	return 0;
}

运行截图:

面试—C++《智能指针》常考点

3.3 std::auto_ptr

std::auto_ptr文档

C++98版本的库中就提供了auto_ptr的智能指针。下面演示的auto_ptr的使用及问题。
auto_ptr的实现原理:管理权转移的思想,下面简化模拟实现了一份ns::auto_ptr来了解它的原理

// C++98 管理权转移 auto_ptr
namespace ns
{
	template<class T>
	class auto_ptr
	{
	public:
		auto_ptr(T* ptr)
			:_ptr(ptr)
		{}
		auto_ptr(auto_ptr<T>& sp)
			:_ptr(sp._ptr)
		{
			// 管理权转移
			sp._ptr = nullptr;
		}
		auto_ptr<T>& operator=(auto_ptr<T>& ap)
		{
			// 检测是否为自己给自己赋值
			if (this != &ap)
			{
				// 释放当前对象中资源
				if (_ptr)
					delete _ptr;
				// 转移ap中资源到当前对象中
				_ptr = ap._ptr;
				ap._ptr = NULL;
			}
			return *this;
		}
		~auto_ptr()
		{
			if (_ptr)
			{
				cout << "delete:" << _ptr << endl;
				delete _ptr;
			}
		}
		// 像指针一样使用
		T& operator*()
		{
			return *_ptr;
		}
		T* operator->()
		{
			return _ptr;
		}
	private:
		T* _ptr;
	};
}
 //结论:auto_ptr是一个失败设计,很多公司明确要求不能使用auto_ptr
int main()
{
	ns::auto_ptr<int> sp1(new int);
	ns::auto_ptr<int> sp2(sp1); // 管理权转移
	// sp1悬空
	*sp2 = 10;
	cout << *sp2 << endl;
	cout << *sp1 << endl;
	return 0;
}

运行截图:

面试—C++《智能指针》常考点

3.4 std::unique_ptr

C++11中开始提供更靠谱的unique_ptr

unique_ptr官方文档

unique_ptr的实现原理:简单粗暴的防拷贝,下面简化模拟实现了一份unique_ptr来了解它的原

namespace ns
{
	template<class T>
	class unique_ptr
	{
	public:
		unique_ptr(T* ptr)
			:_ptr(ptr)
		{}
		~unique_ptr()
		{
			if (_ptr)
			{
				cout << "delete:" << _ptr << endl;
				delete _ptr;
			}
		}
		// 像指针一样使用
		T& operator*()
		{
			return *_ptr;
		}
		T* operator->()
		{
			return _ptr;
		}
		unique_ptr(const unique_ptr<T>& sp) = delete;
		unique_ptr<T>& operator=(const unique_ptr<T>& sp) = delete;
	private:
		T* _ptr;
	};
}
int main()
{
	 ns::unique_ptr<int> sp1(new int);
	 ns::unique_ptr<int> sp2(sp1);

	 std::unique_ptr<int> sp1(new int);
	 std::unique_ptr<int> sp2(sp1);

 return 0;
}

运行截图:

面试—C++《智能指针》常考点

3.5 std::shared_ptr 

C++11中开始提供更靠谱的并且支持拷贝的shared_ptr

std::shared_ptr文档

shared_ptr的原理:是通过引用计数的方式来实现多个shared_ptr对象之间共享资源。

1. shared_ptr在其内部,给每个资源都维护了着一份计数,用来记录该份资源被几个对象共享。
2. 在对象被销毁时(也就是析构函数调用),就说明自己不使用该资源了,对象的引用计数减一。
3. 如果引用计数是0,就说明自己是最后一个使用该资源的对象,必须释放该资源;
4. 如果不是0,就说明除了自己还有其他对象在使用该份资源,不能释放该资源,否则其他对象就成野指针了。

面试—C++《智能指针》常考点

namespace ns
{
	template<class T>
	class shared_ptr
	{
	public:
		shared_ptr(T* ptr = nullptr)
			:_ptr(ptr)
			, _pRefCount(new int(1))
		{}
		shared_ptr(const shared_ptr<T>& sp)
			:_ptr(sp._ptr)
			, _pRefCount(sp._pRefCount)
		{
			++(*_pRefCount);
		}
		void Release()
		{
			if (--(*_pRefCount) == 0)
			{
				cout << "delete:" << _ptr << endl;
				delete _ptr;
				delete _pRefCount;
			}
		}
		shared_ptr<T>& operator=(const shared_ptr<T>& sp)
		{
			//if (this != &sp)
			if (_ptr != sp._ptr)
			{
				Release();
				_ptr = sp._ptr;
				_pRefCount = sp._pRefCount;
				++(*_pRefCount);
			}
			return *this;
		}
		~shared_ptr()
		{
			Release();
		}
		// 像指针一样使用
        int use_count()
		{
			return *_pRefCount;
		}
		T* get() const
		{
			return _ptr;
		}
		T& operator*()
		{
			return *_ptr;
		}
		T* operator->()
		{
			return _ptr;
		}
	private:
		T* _ptr;
		int* _pRefCount;
	};
}
int main()
{
	ns::shared_ptr<int> sp1(new int(10));
	ns::shared_ptr<int> sp2(sp1);
	ns::shared_ptr<int> sp3(sp2);

	ns::shared_ptr<int> sp4(new int(10));
	ns::shared_ptr<int> sp5(sp4);
	sp1 = sp5;
	return 0;
}

 运行截图:

面试—C++《智能指针》常考点

存在的问题:当多个线程同时进行拷贝的时候就会出现数据不一致的问题

int main()
{
	int n = 1000;
	ns::shared_ptr<int>sp1(new int(10));
	thread t1([&]()
		{
			for (int i = 0; i < n; i++)
			{
				ns::shared_ptr<int> sp2(sp1);
			}
		});
	thread t2([&]()
		{
			for (int i = 0; i < n; i++)
			{
				ns::shared_ptr<int> sp3(sp1);
			}
		});
	t1.join();
	t2.join();
	cout << sp1.use_count() << endl;
	cout << sp1.get() << endl;

	return 0;
}

运行截图:

面试—C++《智能指针》常考点

 解决方式:在对象拷贝的过程中进行加锁

面试—C++《智能指针》常考点

namespace ns
{
	template<class T>
	class shared_ptr
	{
	public:
		shared_ptr(T* ptr = nullptr)
			:_ptr(ptr)
			, _pRefCount(new int(1))
			,_pmut(new mutex)
		{}
		shared_ptr(const shared_ptr<T>& sp)
			:_ptr(sp._ptr)
			, _pRefCount(sp._pRefCount)
			, _pmut(sp._pmut)
		{
			_pmut->lock();
			++(*_pRefCount);
			_pmut->unlock();

		}
		void Release()
		{
			//释放锁
			bool flag = false;
			_pmut->lock();
			if (--(*_pRefCount) == 0)
			{
				cout << "delete:" << _ptr << endl;
				delete _ptr;
				delete _pRefCount;
				flag = true;
			}
			_pmut->unlock();
			if (flag)
				delete _pmut;
		}
		shared_ptr<T>& operator=(const shared_ptr<T>& sp)
		{
			if (_ptr != sp._ptr)
			{
				Release();
				_ptr = sp._ptr;
				_pRefCount = sp._pRefCount;
				_pmut->lock();
				++(*_pRefCount);
				_pmut->unlock();

			}
			return *this;
		}
		int use_count()
		{
			return *_pRefCount;
		}
		T* get() const
		{
			return _ptr;
		}
		~shared_ptr()
		{
			Release();
		}
		// 像指针一样使用
		T& operator*()
		{
			return *_ptr;
		}
		T* operator->()
		{
			return _ptr;
		}
	private:
		T* _ptr;
		int* _pRefCount;
		mutex* _pmut;
	};
}

运行截图:

面试—C++《智能指针》常考点

此时解决了拷贝时引用计数数据不一致的问题,但是在访问资源的时候又存在线程安全的问题:

struct Date
{
	int _year = 0;
	int _month = 0;
	int _day = 0;
};
int main()
{
	int n = 10000;
	ns::shared_ptr<Date>sp1(new Date());
	thread t1([&]()
		{
			for (int i = 0; i < n; i++)
			{
				ns::shared_ptr<Date> sp2(sp1);
				sp2->_year++;
				sp2->_month++;
				sp2->_day++;
			}
		});
	thread t2([&]()
		{
			for (int i = 0; i < n; i++)
			{
				ns::shared_ptr<Date> sp3(sp1);
				sp3->_year++;
				sp3->_month++;
				sp3->_day++;
			}
		});
	t1.join();
	t2.join();
	cout << sp1.use_count() << endl;
	cout << sp1.get() << endl;
	cout << sp1->_year << endl;
	cout << sp1->_month << endl;
	cout << sp1->_day << endl;
	return 0;
}

运行截图:

面试—C++《智能指针》常考点

解决方案:在外部访问资源的时候给每个线程进行加锁:

int main()
{
	int n = 10000;
	mutex mut;
	ns::shared_ptr<Date>sp1(new Date());
	thread t1([&]()
		{
			for (int i = 0; i < n; i++)
			{
				mut.lock();
				ns::shared_ptr<Date> sp2(sp1);
				sp2->_year++;
				sp2->_month++;
				sp2->_day++;
				mut.unlock();
			}
		});
	thread t2([&]()
		{
			for (int i = 0; i < n; i++)
			{
				mut.lock();
				ns::shared_ptr<Date> sp3(sp1);
				sp3->_year++;
				sp3->_month++;
				sp3->_day++;
				mut.unlock();
			}
		});
	t1.join();
	t2.join();
	cout << sp1.use_count() << endl;
	cout << sp1.get() << endl;
	cout << sp1->_year << endl;
	cout << sp1->_month << endl;
	cout << sp1->_day << endl;
	return 0;
}

运行截图:

面试—C++《智能指针》常考点

总结:

shared_ptr 本身是线程安全的。(拷贝和析构时,引用计数++ --是线程安全的)

shared_ptr 管理资源的访问不是线程安全的,需要用的地方自行保护。

std::shared_ptr的循环引用

struct ListNode
{
	int _data;
	ns::shared_ptr<ListNode> _prev;
	ns::shared_ptr<ListNode> _next;
	~ListNode() { cout << "~ListNode()" << endl; }
};
int main()
{
	ns::shared_ptr<ListNode> node1(new ListNode);
	ns::shared_ptr<ListNode> node2(new ListNode);
	//不存在循环引用:
	cout << node1.use_count() << endl;
	cout << node2.use_count() << endl;
	//循环引用
	node1->_next = node2;
	node2->_prev = node1;
	cout << node1.use_count() << endl;
	cout << node2.use_count() << endl;
	return 0;
}

运行截图:

面试—C++《智能指针》常考点

循环引用分析:
1. node1和node2两个智能指针对象指向两个节点,引用计数变成1,我们不需要手动
delete。
2. node1的_next指向node2,node2的_prev指向node1,引用计数变成2。
3. node1和node2析构,引用计数减到1,但是_next还指向下一个节点。但是_prev还指向上
一个节点。
4. 也就是说_next析构了,node2就释放了。
5. 也就是说_prev析构了,node1就释放了。
6. 但是_next属于node的成员,node1释放了,_next才会析构,而node1由_prev管理,_prev
属于node2成员,所以这就叫循环引用,谁也不会释放。 

如图所示:

面试—C++《智能指针》常考点

解决方案:在引用计数的场景下,把节点中的_prev和_next改成weak_ptr就可以了 

简单模拟实现weak_ptr:

namespace ns
{
	template<class T>
	class weak_ptr
	{
	public:
		weak_ptr()
			:_ptr(nullptr){}
		weak_ptr(const shared_ptr<T>& sp)
			:_ptr(sp.get()) {}
		weak_ptr<T>& operator=(const shared_ptr<T>& sp)
		{
			_ptr = sp.get();
			return *this;
		}
		T& operator*()
		{
			return *_ptr;
		}
		T* operator->()
		{
			return _ptr;
		}
	private:
		T* _ptr;
	};
}

测试代码:

struct ListNode
{
	int _data;
    //可以指向/访问资源,但是不参与资源的管理,不增加引用计数
	ns::weak_ptr<ListNode> _prev;
	ns::weak_ptr<ListNode> _next;
	~ListNode() { cout << "~ListNode()" << endl; }
};
int main()
{
	ns::shared_ptr<ListNode> node1(new ListNode);
	ns::shared_ptr<ListNode> node2(new ListNode);
	cout << node1.use_count() << endl;
	cout << node2.use_count() << endl;
	node1->_next = node2;
	node2->_prev = node1;
	cout << node1.use_count() << endl;
	cout << node2.use_count() << endl;
	return 0;
}

运行截图:

面试—C++《智能指针》常考点

解决原理:

node1->_next = node2;和node2->_prev = node1时weak_ptr的_next和_prev不会增加node1和node2的引用计数。 

定址删除器

如果是new[]出来的对象,通过智能指针如何管理呢?

int main()
{
	ns::shared_ptr<string> sp2(new string[10]);
	return 0;
}

运行截图:

面试—C++《智能指针》常考点

解决方式:在析构的时候给类对象提供专门的删除器进行删除

//定址删除器:
template<class T>
struct Deletearray
{
	void operator()(const T* ptr)
	{
		delete[] ptr;
		cout << "delete[]" << endl;
	}
};
int main()
{
	//可以通过自定义的仿函数进行删除:
	std::shared_ptr<string> sp2(new string[10],Deletearray<string>());
	//也可以通过lambda表达式进行删除:
	std::shared_ptr<string> sp3(new string[10], [](string* ptr) {delete[] ptr; });
	return 0;
}

 运行截图:

面试—C++《智能指针》常考点

模拟实现库中的shared_ptr:

namespace ns
{
	template<class T>
	class default_delete
	{
	public:
		void operator()(const T* ptr)
		{
			delete ptr;
		}
	};
	template<class T,class D = default_delete<T>>
	class shared_ptr
	{
	public:
		shared_ptr(T* ptr = nullptr)
			:_ptr(ptr)
			, _pRefCount(new int(1))
			, _pmut(new mutex)
		{}
		shared_ptr(const shared_ptr<T>& sp)
			:_ptr(sp._ptr)
			, _pRefCount(sp._pRefCount)
			, _pmut(sp._pmut)
		{
			_pmut->lock();
			++(*_pRefCount);
			_pmut->unlock();

		}
		void Release()
		{
			//释放锁
			bool flag = false;
			_pmut->lock();
			if (--(*_pRefCount) == 0)
			{
				//cout << "delete:" << _ptr << endl;
				//delete _ptr;
				//转化为定址删除器进行删除
				_del(_ptr);
				delete _pRefCount;
				flag = true;
			}
			_pmut->unlock();
			if (flag)
				delete _pmut;
		}
		shared_ptr<T>& operator=(const shared_ptr<T>& sp)
		{
			if (_ptr != sp._ptr)
			{
				Release();
				_ptr = sp._ptr;
				_pRefCount = sp._pRefCount;
				_pmut = sp._pmut;
				_pmut->lock();
				++(*_pRefCount);
				_pmut->unlock();

			}
			return *this;
		}
		int use_count() const
		{
			return *_pRefCount;
		}
		T* get() const
		{
			return _ptr;
		}
		~shared_ptr()
		{
			Release();
		}
		// 像指针一样使用
		T& operator*()
		{
			return *_ptr;
		}
		T* operator->()
		{
			return _ptr;
		}
	private:
		T* _ptr;
		int* _pRefCount;
		mutex* _pmut;
		D _del;
	};
}
//定址删除器:
template<class T>
struct Deletearray
{
	void operator()(const T* ptr)
	{
		delete[] ptr;
		cout << "delete[]" << endl;
	}
};
int main()
{
	//可以通过自定义的仿函数进行删除:
	ns::shared_ptr<string,Deletearray<string>> sp2(new string[10]);
	return 0;
}

运行截图:

面试—C++《智能指针》常考点文章来源地址https://www.toymoban.com/news/detail-410168.html

到了这里,关于面试—C++《智能指针》常考点的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 0062__对象指针为NULL,为什么还是可以调用成员函数

    对象指针为NULL,为什么还是可以调用成员函数_空对象指针为什么能调用函数_一颗石头崽儿的博客-CSDN博客

    2024年02月10日
    浏览(42)
  • 为什么用python做人工智能,为什么人工智能用python

    大家好,给大家分享一下python人工智能为什么放到最后才学,很多人还不知道这一点。下面详细解释一下。现在让我们来看看! Source code download: 本文相关源码 一、为何人工智能(AI)首选Python? 读完这篇文章你就知道了。我们看谷歌的TensorFlow基本上所有的代码都是C++和Python,

    2024年02月22日
    浏览(71)
  • git将文件或目录添加进了.gitignore文件,为什么不生效?

    如题,之所以将文件添加进了.gitignore文件但不生效,是因为该文件已经被add进git仓库了,已经被git托管了,这时git就没法ignore了。解决办法是先用git rm --cached将这些文件从git仓库中取消托管并提交,然后.gitignore文件才会生效。详细见如下描述。 已经添加到git仓库中的文件,

    2024年02月03日
    浏览(52)
  • 面试题:为什么要合并 HTTP 请求?有什么好处?

    为什么要实现batch call? - 减少网络中的传输损耗 - 如何减少的? - 通过合并HTTP请求 - 合并HTTP请求是如何减少网络损耗的? 本文将解决这个问题。一起看看单个请求携载大量信息和多个请求携载小量信息对于整个时间的影响。 可以保持长连接,但是每个不同的请求之间,clien

    2024年01月19日
    浏览(46)
  • Redis为什么快?(面试常问)

    Redis 是一个开源的高性能内存数据库,特点是数据存储在内存中,操作时性能更高;还支持多种数据结构,String、Hash、list、set、zset等,key还支持自动过期。 Redis的好处 是因为数据存在内存中所以性能更高,还有因为是单线程操作,所以天然具有线程安全的特性,单线程又能

    2024年02月11日
    浏览(40)
  • 面试题:Kafka 为什么那么快?

    有人说:他曾在一台配置较好的机子上对 Kafka 进行性能压测,压测结果是 Kafka 单个节点的极限处理能力接近每秒 2000万 条消息,吞吐量达到每秒 600MB。 那 Kafka 为什么这么快?如何做到这个高的性能? 本篇文章主要从这 3 个角度来分析: 生产端 服务端 Broker 消费端 先来看下

    2024年01月22日
    浏览(52)
  • 面试官灵魂拷问:什么是MySQL索引?为什么需要索引?

    关系型数据库是一种采用关系模型存储数据的数据库系统。在关系型数据库中,数据被组织成一个或多个表格(也称为关系),每个表格包含多行记录,每行记录代表一组相关数据。每个表格都有一个定义该表格中数据的结构的模式,即表格的列和每个列的数据类型。关系型

    2024年02月09日
    浏览(59)
  • 为什么pycharm远程连接服务器运行时总会出现找不到文件或目录

    目录 解决方法 为什么会出现这样的问题 我们需要修改一个设置 具体步骤如下: 1、右下角点击它,选择interpreter setting  2、进入下图界面,点击箭头所指位置,选择show all 3、进入下图界面,选择你要修改的python interpreter,点哪个🖊进行修改    4、进入下图界面,默认情况下

    2024年02月15日
    浏览(66)
  • 大数据面试题:HBase为什么查询快

    面试题来源: 《大数据面试题 V4.0》 大数据面试题V3.0,523道题,679页,46w字 可回答:1)HBase为什么读快;2)HBase是根据rowkey查询,当数据量相当大的时候,是怎么读的很快的 参考答案: 1、基于LSM树的存储方式 HBase采用基于LSM树的存储方式,这种存储方式将数据分为内存和

    2024年02月12日
    浏览(42)
  • 面试官问:kafka为什么如此之快?

    天下武功,唯快不破。同样的,kafka在消息队列领域,也是非常快的,这里的块指的是kafka在单位时间搬运的数据量大小,也就是吞吐量,下图是搬运网上的一个性能测试结果,在同步发送场景下,单机Kafka的吞吐量高达17.3w/s,不愧是高吞吐量消息中间件的行业老大。 那究竟

    2024年02月07日
    浏览(41)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包