架构师训练营 Week5 学习总结

小高

关注

发布于: 2020 年 07 月 08 日

第一节课：分布式缓存

缓存：存储在计算机上的一个原始数据复制集，以便于访问。通常是 key-value 格式的，主要用来提高系统的响应性能的。

缓冲可以理解为一种提高读写的速度的通道，数据存储在通道中，提高存取速度。

种类：

硬件：CPU 缓存、操作系统缓存、数据库缓存、JVM 缓存
软件：CDN 缓存、代理与反向代理缓存、前端缓存、应用程序缓存、分布式对象缓存

常见的缓存算法（hash 表）：

将键进行哈希处理，得到值在数组中的索引，后续可以利用这个索引进行访问，时间复杂度是 O(1)。

缓存的关键指标：

缓存命中率：缓存是否有效依赖于能多少次重用同一个缓存响应业务请求，这个度量之变被称作缓存命中。假设十次缓存响应中，有 9 次成功响应，那么缓存命中率就是 90%。
缓存键集合大小：键的数量多少。键数量越少，缓存的命中效率越高
缓存可使用内存空间：缓存可使用的物理内存空间，缓存对象越多，缓存命中率越高。
缓存对象生存时间：缓存对象的有效时间，其越长，缓存对象被重用的可能性就越高。

常见缓存种类：

代理缓存

反向代理缓存

多层反向代理缓存

内容分发网络

CDN 同时配置静态文件和动态内容

通读缓存（给客户端返回缓存资源，并在请求命中缓存时获取实际数据，代理缓存、反向代理缓存、CDN 缓存）

旁路缓存

浏览器对象缓存本地对象缓存

本地对象缓存构建分布式集群

远程分布式对象缓存

案例：Memcached 分布式对象缓存

Java 访问其代码：

import com.danga.MemCached.MemCachedClient; //通用分布式缓存访问public class CommonCache<T> implements Cache<T> {	private static MemCachedClient memCachedClient = null; 	private String base = null; 	CommonCache(Class<T> t, MemCachedClient client) {		memCachedClient = client;		base = t.getSimpleName() + "-";	} 	public T get(String key) {		return (T) memCachedClient.get(base + key);	} 	public boolean set(String key, T value) {		return memCachedClient.set(base + key, value);	} 	@Override	public boolean update(String key, T value) {		return memCachedClient.replace(base + key, value);	} 	@Override	public boolean delete(String key) {		return memCachedClient.delete(base + key);	} 	@Override	public boolean add(String key, T value) {		return memCachedClient.add(base + key, value);	}}//分布式集群访问import com.danga.MemCached.MemCachedClient;import com.schooner.MemCached.SchoonerSockIOPool;import com.yx.cache.util.HashCodeUtil;import com.yx.task.ThreadPoolManager;     public class ClusterCache<T> implements Cache<T> {   private static MemCachedClient memCachedClient = null;        private static ThreadPoolManager taskManager = ThreadPoolManager    	.getInstance("cache");        private String base = null;        private SchoonerSockIOPool pool = SchoonerSockIOPool.getInstance();        ClusterCache(Class<T> t, MemCachedClient client) {    memCachedClient = client;    base = "i-" + t.getSimpleName() + "-";    }         @Override    public T get(String key) {    	T value = null;    	if (key == null) {    		return null;    	}    		key = base + key;    		if (pool.getServers().length < 2) {    			value = (T) memCachedClient.get(key);    		} else {    			int hashCode = HashCodeUtil.getHash(key);    			value = (T) memCachedClient.get(key, hashCode);    			if (value == null) {    				hashCode = this.getRehashCode(key, hashCode);    				value = (T) memCachedClient.get(key, hashCode);    				if (value != null) {// 如果在另外一台服务器上取到了缓存，则恢复第一台服务器    					UpdateTask task = new UpdateTask(key, value);    					taskManager.submit(task);    				}    			}    		}    		return value;    	}    	@Override    	public boolean set(String key, T value) {    		if (key == null) {    			return false;    		}    		key = base + key;    		boolean result = false;    		if (pool.getServers().length < 2) {    			result = memCachedClient.set(key, value);    		} else {    			int hashCode = HashCodeUtil.getHash(key);    			result = memCachedClient.set(key, value, hashCode);    			// if (result) {    			hashCode = getRehashCode(key, hashCode);    			memCachedClient.set(key, value, hashCode);    			// }    		}    		return result;    	}    	private int getRehashCode(String key, int oldHashcode) {    		String host = pool.getHost(key, oldHashcode);    		int rehashTries = 0;    		// if (result) {    		int hashCode = HashCodeUtil.getHash(rehashTries + key);    		while (host.equals(pool.getHost(key, hashCode))) {    			rehashTries++;    			hashCode = HashCodeUtil.getHash(rehashTries + key);    		}    		return hashCode;    	}    	@Override    	public boolean update(String key, T value) {    		if (key == null) {    			return false;    		}    		key = base + key;    		boolean result = false;    		if (pool.getServers().length < 2) {    			result = memCachedClient.replace(key, value);    		} else {    			int hashCode = HashCodeUtil.getHash(key);    			result = memCachedClient.replace(key, value, hashCode);    			// if (result) {    			hashCode = getRehashCode(key, hashCode);    			memCachedClient.replace(key, value, hashCode);    			// }    		}    		return result;    	}    	@Override    	public boolean delete(String key) {    		if (key == null) {    			return false;    		}    		key = base + key;    		boolean result = false;    		if (pool.getServers().length < 2) {    			result = memCachedClient.delete(key);    		} else {    			int hashCode = HashCodeUtil.getHash(key);    			result = memCachedClient.delete(key, hashCode, null);    			// if (result) {    			hashCode = this.getRehashCode(key, hashCode);    			memCachedClient.delete(key, hashCode, null);    			// }    		}    		return result;    	}    	@Override    	public boolean add(String key, T value) {    		if (key == null) {    			return false;    		}    		key = base + key;    		boolean result = false;    		if (pool.getServers().length < 2) {    			result = memCachedClient.add(key, value);    		} else {    			int hashCode = HashCodeUtil.getHash(key);    			result = memCachedClient.add(key, value, hashCode);    			// if (result) {    			hashCode = getRehashCode(key, hashCode);    			memCachedClient.add(key, value, hashCode);    			// }    		}    		return result;    	}    	static class UpdateTask implements Runnable {    		private String key;    		private Object value;    		UpdateTask(String key, Object value) {    			this.key = key;    			this.value = value;    		}    		@Override    		public void run() {    			memCachedClient.set(key, value, HashCodeUtil.getHash(key));    		}    	}    }