几种常见类型Cache的实现

最新推荐文章于 2023-09-10 11:10:56 发布
最新推荐文章于 2023-09-10 11:10:56 发布
阅读量3.4k 收藏 4
点赞数 1
分类专栏： Cache java基础应用 多线程 文章标签： cache object hashmap random class null
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/iiii1986/article/details/6713157
版权

        总述：Cache的实现有多种多样，基本上各个java开源框架都有自己的实现，而使用的最多的三种Cache类型是：FIFO(先入先出)、Random(随机)和LRU(最近最少使用)。上述分类主要是指Cache在存储已满时抛弃已有数据来缓存新添加的数据所选取的策略。Cache用来缓存数据的数据结构大多数是采用HashMap，以便快速存取。有些Cache的实现还设置有对象的缓存时间等，以期达到更细致的控制。

        在后面，提供了一个Cache的简略实现版本，抽象出一个简单的Cache接口，一个抽象的AbstractCache类，和上述三种类型Cache的具体实现，其中对于FIFO类型的Cache，提供了Array和List两种实现方式，相比较而言，List的效率更高。而LRU类型的Cache则是在List型FIFO的Cache基础之上再行封装的。时间复杂度上，Cache中缓存数据的读取主要依赖于HashMap的读取效率；写入缓存数据时，FIFO类型的List实现方式和Random类型为O(1)，FIFO类型的Array实现方式为O(n)，LRU类型最坏的时间复杂度为O(n)。空间复杂度上，LRU>list方式的FIFO>Array方式的FIFO=Random，不过List形式在内存分配上比Array形式更灵活。

Cache接口：

package com.lee.java.learning.cache;

/**
 * An interface defining the basic functions of a cache.
 * This cache can store the element by the key.
 * and also it can read the element from the cache by special key.
 * Except that, It provide methods to Get the size and capacity of
 * the cache, and judge a element exists in the cache or not.
 *
 * @version 1.0
 * @author lili06
 *
 */
public interface Cache {

	/**
	 * Add a element into cache by special key
	 * @param key
	 * @param value
	 */
	public void addElement(Object key, Object value);

	/**
	 * Read the element from the cache by special key
	 * @param key
	 * @return
	 */
	public Object getElement(Object key);

	/**
	 * If a element attached with the special key has been cached,
	 * this method return true, otherwise false.
	 * @param key
	 * @return
	 */
	public boolean isExist(Object key);

	/**
	 * Return the number of elements have been cached in the cache. not to be confused with
	 * the {@link #capacity()} which returns the number
	 * of elements that can be held in the cache at one time.
	 * @return the number of value object cached at one time
	 */
	public int size();

	/**
	 * Returns the maximum number of elements that can be cached at one time.
	 * <p>
	 * @return The maximum number of elements that can be cached at one time.
	 */
	public int capacity();

	/**
	 * Clear all the  cached elements.
	 */
	public void clear();

}

AbstractCache抽象类：

package com.lee.java.learning.cache;

import java.io.Serializable;
import java.util.HashMap;
import java.util.List;

public abstract class AbstractCache implements Cache, Serializable {

	private static final long serialVersionUID = 2046841211971587188L;

	public static final int DEFAULT_CAPACITY = 20;

	int size;
	int capacity;
	HashMap cacheMap;

	AbstractCache(int capacity) {
		size = 0;
		if(capacity <= 0) {
			throw new RuntimeException("the cache capacity must be a positive integer...");
		}
		this.capacity = capacity;
		cacheMap = new HashMap(capacity);
	}

	public abstract void addElement(Object key, Object value);

	public synchronized Object getElement(Object key) {
		Object obj = null;
		obj = cacheMap.get(key);
		if(obj != null) {
			return ((CacheEntity)obj).value;
		}

		return null;
	}

	public synchronized void clear() {
		cacheMap.clear();
		size = 0;
	}

	public synchronized boolean isExist(Object key) {
		if(getElement(key) != null) {
			return true;
		}

		return false;
	}

	public final synchronized int size() {
		return size;
	}

	public final synchronized int capacity() {
		return capacity;
	}

	public final synchronized boolean isFull() {
		return size == capacity;
	}

	static class CacheEntity {
		Object key;
		Object value;

		CacheEntity() {
			key = null;
			value = null;
		}
	}

}

CacheRandom实现类：

package com.lee.java.learning.cache;

import java.util.Random;

public class CacheRandom extends AbstractCache {

	private static final long serialVersionUID = -3906908597773607461L;

	private Random random;
	private RandomCacheEntity[] cache;

	public CacheRandom() {
		this(AbstractCache.DEFAULT_CAPACITY);
	}

	public CacheRandom(int capacity) {
		super(capacity);
		random = new Random(System.currentTimeMillis());
		cache = new RandomCacheEntity[capacity];
		for(int i=0; i<capacity; i++) {
			cache[i] = new RandomCacheEntity(i);
		}
	}

	@Override
	public synchronized void addElement(Object key, Object value) {
		int index = 0;
		Object obj = null;
		obj = cacheMap.get(key);

		if(obj != null) {
			RandomCacheEntity entity = (RandomCacheEntity)obj;
			entity.value = value;

			return;
		}

		if(!isFull()) {
			index = size;
			size++;
		}else {
			index = random.nextInt(capacity);
			cacheMap.remove(cache[index].key);
		}

		cache[index].key = key;
		cache[index].value = value;
		cacheMap.put(key, cache[index]);
	}

	@Override
	public synchronized void clear() {
		super.clear();
		for(int i=0; i<capacity; i++) {
			cache[i] = new RandomCacheEntity(i);
		}
	}

	static class RandomCacheEntity extends CacheEntity {
		int index;

		RandomCacheEntity(int index) {
			this.index = index;
		}
	}

}

ArrayCacheFIFO实现类：

package com.lee.java.learning.cache;

public class ArrayCacheFIFO extends AbstractCache {

	private static final long serialVersionUID = -4299736285228473989L;

	private int current = 0;
	private ArrayCacheEntity[] cache;

	public ArrayCacheFIFO() {
		this(AbstractCache.DEFAULT_CAPACITY);
	}

	public ArrayCacheFIFO(int capacity) {
		super(capacity);
		cache = new ArrayCacheEntity[capacity];
		for(int i=0; i<capacity; i++) {
			cache[i] = new ArrayCacheEntity(i);
		}
	}

	@Override
	public synchronized void addElement(Object key, Object value) {
		int index = current;
		Object obj = null;
		obj = getElement(key);

		if(obj != null) {
			ArrayCacheEntity entity = (ArrayCacheEntity)obj;
			updateOrder(entity, value);
			return;
		}

		if(!isFull()) {
			index = size;
			size++;
		}else {
			index = current;
			if(++current >= capacity) {
				current = 0;
			}

			cacheMap.remove(cache[index].key);
		}

		cache[index].key = key;
		cache[index].value = value;
		cacheMap.put(key, cache[index]);
	}

	private void updateOrder(ArrayCacheEntity entity, Object value) {

		int index = entity.index;
		Object key = entity.key;

		if(!isFull()) {
			for(int i=index; i<size-1; i++) {
				 cache[i].key = cache[i+1].key;
				 cache[i].value = cache[i+1].value;
			}
			cache[size-1].key = key;
			cache[size-1].value = value;

			for(int i=index; i<size; i++) {
				cacheMap.put(cache[i].key, cache[i]);
			}
		}else {
			if(index == current) {
				cache[current].value = value;
				cacheMap.put(cache[current].key, cache[current]);
				if(++current >= capacity) {
					current = 0;
				}
			}else if(index < current) {
				if((current-index)*2 <= capacity) {
					for(int i=index; i<current-1; i++) {
						cache[i].key = cache[i+1].key;
						cache[i].value = cache[i+1].value;
					}
					cache[current-1].key = key;
					cache[current-1].value = value;

					for(int i=index; i<current; i++) {
						cacheMap.put(cache[i].key, cache[i]);
					}
				}else {
					for(int i=index; i > 0; i--) {
						cache[i].key = cache[i-1].key;
						cache[i].value = cache[i-1].value;
					}
					cache[0].key = cache[capacity-1].key;
					cache[0].value = cache[capacity-1].value;
					for(int i=capacity-1; i>current; i--) {
						cache[i].key = cache[i-1].key;
						cache[i].value = cache[i-1].value;
					}
					cache[current].key = key;
					cache[current].value = value;
					int i = index, count = capacity - (current - index - 1);
					while(count-- > 0) {
						i = (i+capacity) % capacity;
						cacheMap.put(cache[i].key, cache[i]);
						i--;
					}

					current++;
				}
			}else {
				if((index-current+1)*2 <= capacity) {
					for(int i=index; i>current; i--) {
						cache[i].key = cache[i-1].key;
						cache[i].value = cache[i-1].value;
					}
					cache[current].key = key;
					cache[current].value = value;
					for(int i=current; i<=index; i++) {
						cacheMap.put(cache[i].key, cache[i]);
					}

					current++;
				}else {
					for(int i=index; i<capacity-1; i++) {
						cache[i].key = cache[i+1].key;
						cache[i].value = cache[i+1].value;
					}
					cache[capacity-1].key = cache[0].key;
					cache[capacity-1].value = cache[0].value;
					for(int i=0; i<current-1; i++) {
						cache[i].key = cache[i+1].key;
						cache[i].value = cache[i+1].value;
					}
					cache[current-1].key = key;
					cache[current-1].value = value;
					int i = index, count = capacity - (index-current);
					while(count-- > 0) {
						i %= capacity;
						cacheMap.put(cache[i].key, cache[i]);
						i++;
					}
				}
			}
		}

	}

	@Override
	public synchronized void clear() {
		for(int i=0; i<cache.length; i++) {
			cache[i] = new ArrayCacheEntity(i);
		}
	}

	static class ArrayCacheEntity extends CacheEntity {
		int index;

		ArrayCacheEntity(int index) {
			this.index = index;
		}
	}

}

ListCacheFIFO实现类：

package com.lee.java.learning.cache;

public class ListCacheFIFO extends AbstractCache {

	private static final long serialVersionUID = -1804440082070314369L;

	protected ListCacheEntity head;

	public ListCacheFIFO() {
		this(AbstractCache.DEFAULT_CAPACITY);
	}

	public ListCacheFIFO(int capacity) {
		super(capacity);
		head = new ListCacheEntity();
		head.pre = head.next = head;
	}

	@Override
	public synchronized void addElement(Object key, Object value) {
		Object obj = null;
		obj = cacheMap.get(key);

		if(obj != null) {
			ListCacheEntity entity = (ListCacheEntity)obj;
			entity.value = value;

			// update order
			entity.pre.next = entity.next;
			entity.next.pre = entity.pre;
			entity.pre = entity.next = null;
			moveToFront(entity, head);

			cacheMap.put(key, entity);

			return;
		}

		if(!isFull()) {
			size++;
		}else {
			ListCacheEntity temp = head.next;
			temp.pre.next = temp.next;
			temp.next.pre = temp.pre;
			temp.pre = temp.next = null;
			cacheMap.remove(temp.key);
		}

		ListCacheEntity entity = new ListCacheEntity();
		entity.key = key;
		entity.value = value;
		moveToFront(entity, head);

		cacheMap.put(key, entity);
	}

	protected void moveToFront(ListCacheEntity movedEntity, ListCacheEntity desEntity) {
		desEntity.pre.next = movedEntity;
		movedEntity.pre = desEntity.pre;
		desEntity.pre = movedEntity;
		movedEntity.next = desEntity;
	}

	@Override
	public synchronized void clear() {
		super.clear();
		head.pre = head.next = head;
	}

	static class ListCacheEntity extends CacheEntity {
		ListCacheEntity pre;
		ListCacheEntity next;

		ListCacheEntity() {
			pre = next = null;
		}
	}

}

CacheLRU实现类：

package com.lee.java.learning.cache;

import com.lee.java.learning.cache.ListCacheFIFO.ListCacheEntity;

public class CacheLRU extends ListCacheFIFO {

	private static final long serialVersionUID = 1122993622171221931L;

	public CacheLRU() {
		this(ListCacheFIFO.DEFAULT_CAPACITY);
	}

	public CacheLRU(int capacity) {
		super(capacity);
		head = new CacheLRUEntity();
		head.pre = head.next = head;
	}

	@Override
	public synchronized void addElement(Object key, Object value) {
		Object obj = null;
		obj = cacheMap.get(key);

		if(obj != null) {
			CacheLRUEntity entity = (CacheLRUEntity)obj;
			entity.value = value;
			entity.count++;

			// update order
			CacheLRUEntity it = (CacheLRUEntity) entity.next;
			while(it != head && it.count <= entity.count) {
				it = (CacheLRUEntity)it.next;
			}
			if(it == entity.next) {
				// do nothing
			}else {
				entity.pre.next = entity.next;
				entity.next.pre = entity.pre;
				entity.pre = entity.next = null;
				moveToFront(entity, it);
			}

			cacheMap.put(key, entity);

			return;
		}

		if(!isFull()) {
			size++;
		}else {
			ListCacheEntity temp = head.next;
			temp.pre.next = temp.next;
			temp.next.pre = temp.pre;
			temp.pre = temp.next = null;
			cacheMap.remove(temp.key);
		}

		CacheLRUEntity entity = new CacheLRUEntity();
		entity.count = 1;
		entity.key = key;
		entity.value = value;

		CacheLRUEntity it = (CacheLRUEntity) head.next;
		while(it != head && it.count <= entity.count) {
			it = (CacheLRUEntity)it.next;
		}
		moveToFront(entity, it);

		cacheMap.put(key, entity);
	}

	@Override
	public synchronized Object getElement(Object key) {
		Object obj = null;
		obj = cacheMap.get(key);
		if(obj != null) {
			CacheLRUEntity entity = (CacheLRUEntity)obj;
			entity.count++;

			// update order
			CacheLRUEntity it = (CacheLRUEntity) entity.next;
			while(it != head && it.count <= entity.count) {
				it = (CacheLRUEntity)it.next;
			}
			if(it == entity.next) {
				// do nothing
			}else {
				entity.pre.next = entity.next;
				entity.next.pre = entity.pre;
				entity.pre = entity.next = null;
				moveToFront(entity, it);
			}

			return entity.value;
		}

		return null;
	}

	static class CacheLRUEntity extends ListCacheEntity {
		int count;

		CacheLRUEntity() {
			count = 0;
		}
	}

}

 

备注：具体的代码包可在http://download.csdn.net/source/3543311下载

iiii1986
关注
专栏目录
redis的五种数据类型
学Java，找哪吒
05-15 5万+
（1）Redis（Remote Dictionary Server 远程字段服务）是一个开源的使用ANSI C语言编写、支持网络、科技与内存亦可持久化的日志型、key-value数据库，并提供多种语言的API。（2）Redis是一个key-value存储系统，它支持存储的value类型相对更多，包括string、list、set、zset（sorted set --有序集合）和hash。这些数据结构都支持push/pop、add/remove及取交集并集和差集及更丰富的操作，而且这些操作都是原子性的。
Linux DMA、Page Cache、Buffer Cache 和零拷贝
私房菜
12-24 2051
磁盘可以说是计算机系统最慢的硬件之一，读写速度相差内存 10 倍以上，所以针对优化磁盘的技术非常的多，比如零拷贝、直接 I/O、异步 I/O 等等，这些优化的目的就是为了提高系统的吞吐量，另外操作系统内核中的磁盘高速缓存区，可以有效地减少磁盘的访问次数。这次，我们就以「文件传输」作为切入点，来分析 I/O 工作方式，以及如何优化传输文件的性能。
Cache和主存的三种映射方式
05-24
Cache和主存的三种映射方式
ASP.NET 缓存（Cache）介绍
aobc72208的博客
11-20 608
ASP.NET 缓存概述 通常，应用程序可以将那些频繁访问的数据，以及那些需要大量处理时间来创建的数据存储在内存中，从而提高性能。例如，如果应用程序使用复杂的逻辑来处理大量数据，然后再将数据作为用户频繁访问的报表返回，避免在用户每次请求数据时重新创建报表可以提高效率。同样，如果应用程序包含一个处理复杂数据但不需要经常更新的页，则在每次请求时服务器都重新创建该页会使工作效...
基本类型包装型的缓存值cache
iCoding91
04-15 1250
1.基本类型包装类型的缓存值 基本类型不包括：float,double bool缓存值：true，false char缓存值：0～127，故ASSII码里面的字符都有缓存 其它范围：－128～127 特殊的int：上限默认为127，但可通过-XX:AutoBoxCacheMax设置。 实现方式：定义了缓存数组(bool定义的是常量)，且为静态代码块，在类加载时即生成。 2...
cache 分类
最新发布
weixin_44020424的博客
09-10 276
《超标量处理器设计》《计算机体系结构量化研究方法》Cache指的是高速缓存简称缓存，原始意义是指访问速度比一般随机存取存储器（RAM）快的一种RAM，通常它不像系统主存那样使用DRAM技术，而使用昂贵但较快速的SRAM技术。在CPU中，Cache是介于内存和处理器之间的缓存，用于存放CPU即将可能使用的数据，当CPU要使用的数据在Cache中取到时，便不再需要到内存去存取数据，从而减少处理器访问内存的次数。
个人计算机主机上的高速缓冲存储器,高速缓冲存储器(Cache)一般用SRAM来实现
weixin_33983620的博客
07-04 2371
正确答案: B高速缓冲存储器(Cache)一般用SRAM来实现题目：下列叙述中，正确的是( )。解析：解析：内存与外存相比：内存速度快，容量小，价格高。硬盘、光盘和软盘均是外存，它们的存取速度比内存慢。举一反三的答案和解析：[多选题]下列软件中，不是操作系统的是______。MS-Office[单选题]计算机病毒实际上是一段寄生在其他程序上的通过复制进行传染的、破坏计算机功能和数据的特殊程序解析：...
Cache
aq7218的博客
09-01 5154
Cache失效的原因 强制性失效 (Compulsory miss): 当第一次访问一个块时，该块不在 Cache中, 需从下一级存储中调入 Cache, 这就是强制性失效。这种失效也称为冷启动失效，或首次访问失效。(增加块大小，预取) 容量失效 (Capacity miss): 如果程序执行时所需的块不能全部调入 Cache 中, 则当某些块被替换后, 若又重新被访问, 就会发生失效。这种失效称
Java认证：各类Cache机制的实现方法
08-10
本文将深入探讨几种常见的Java缓存机制的实现方法，包括OSCache、Java Caching System (JCS)、EHCache、JCache、ShiftOne、SwarmCache以及TreeCache/JBossCache和WhirlyCache。 1. OSCache： OSCache 是一款广泛...
【序列化】Kryo 的几种常见序列化实现方式，及其兼容性
一个被IT搞的
06-08 4646
Kryo 是啥 Kryo是Java生态中的一种序列化框架。许多软件组织在使用Dubbo（Dubbox）这套RPC框架时，经常会搭配使用 Kryo 作为其序列化方案。Kryo本身自带了很多针对 Java 原始数据类型 和 JDK常见类型的 序列化实现（如，DefaultSerializers）。它的姐妹工程 Kryo-Serializers 还提供很多额外的序列化实现。 Kryo 常见序列化实现方式 序列化/反序列化的兼容性问题 序列化/反序列化 最主要的是关注对象内容。大多数场景中，我们只会序列化对
ceph的 cache tier实现分析
Oshyn —— 乐而学，学而乐
06-14 3657
1 基本介绍 1.1 设计思想 数据的存储可划分为active和inactive两大类，active数据是小部分，会频繁访问，使用更高性能的底层存储介质进行存储；inactive的数据是全集，使用廉价的存储介质存储。这种分冷热的思想与CPU的多级缓存、操作系统的cache、各类软件系统的软件缓存是相通的，但ceph通过软件层面的配合，充分利用不同的硬件介质和软件存储模式，为上层用户提供透明统一...
Cache模拟器
05-26
　　程序使用C/C++混合编程，基本实现的Cache的模拟功能（通过读取trace文件得到相应的命中率），能够实现直接映射、全相联、组相联三种映射方式，其中全相联和组相联能够实现随机、LRU两种替换策略。目前三种映射方式均采用回写法，但已经定义了其它写策略的接口，可以很容易扩充。程序具有比较强的鲁棒性，能够接受一定范围的错误输入，并能够比较智能的提示用户输入。
常见四种和缓存相关的首部
9ian1i
10-02 888
第一种：Last-Modified/If-Modified-Since如果在服务器设置一个响应头 Last-Modified：该资源的更新时间，然后浏览器收到这个响应头以后，下次再请求这个资源的时候，会带上请求头 If-Modified-Since：上次从服务器缓存该资源的时间。服务器收到这个请求头以后会将两个时间点进行判断，如果服务器的时间更新，那么返回完整的响应数据，状态码为200，反之则只返回
如果系统中需要自己做cache,采用什么方式好呢
lily专栏
07-09 1662
引用： 我是做审计软件，需要采集大量的财务数据，并对其进行分析，这种海量数据不是一般，所以我一直在构思设计一套缓存。 其实数据库服务器、应用程序服务器都有缓存。那么我们所设计的缓存应该是针对系统的。楼上的一些方法都不太可取。这里，我提供一些我的思路吧。 系统需要缓存表现在两个方面，第一、频繁的数据库查询访问，而内容又往往相同；第二、海量的数据，又不能全部依靠内存。 我所思考的缓存来自于CPU的ca
Cache的理解
qq_44943193的博客
09-06 832
cache的一些基础知识和映射方法
使用hashmap实现简单内存cache
novenbersky的专栏
06-03 648
下面这个基于map的简单内存cache是在去年一个项目中编写的，主要参考了ibatis的cacheModel源码，不过最终没有采用。缓存的策略选择和应用的负载情况息息相关，当时根据应用系统jvm的full gc频率和用户访问频次较低的特点，采用了SoftReference+LRU的缓存策略。     import java.lang.ref.SoftReference; import ja
Google的CacheBuilder缓存
热门推荐
luzhensmart的专栏
06-17 2万+
1:refreshAfterWrite Guava Cache特性：对于同一个key，只让一个请求回源load数据，其他线程阻塞等待结果这种情况：如果缓存过期，恰好有多个线程读取同一个key的值，那么guava只允许一个线程去加载数据，其余线程阻塞。这虽然可以防止大量请求穿透缓存，但是效率低下。使用refreshAfterWrite可以做到：只阻塞加载数据的线程，其余线程返回旧数据。 2:...
第一节 缓存概念及分类
幽默工作室
05-03 1720
一、什么是数据库缓存 我们知道常见的数据库，比如oracle、mysql等，数据都是存放在磁盘中。虽然在数据库层也做了对应的缓存，但这种数据库层次的缓存一般针对的是查询内容，而且粒度也太小，一般只有表中数据没有变更的时候，数据库对应的cache才发挥了作用。但这并不能减少业务系统对数据库产生的增、删、查、改的庞大IO压力。所以数据库缓存技术在此诞生，实现热点数据的高速缓存，提高应用的响应速度，极大...
缓存的分类
busidihuang的博客
06-13 2333
缓存定义：存储在计算机上的一个原始数据复制集， 以便于访问。客户端缓存：页面缓存页面缓存有两层含义： 一个是页面自身对某些元素或全部元素进行缓存；另一层意思 是服务端将静态页面或动态页面的元素进行缓存， 然后给客户端使用。 这里的页面缓存指 的是页面自身的缓存或者离线应用缓存。页面缓存是将之前渲染的页面保存为文件， 当用户再次访问时可以避开网络连接， 从而减少负载， 提升性能和用户体验。 随着单页...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值