【原创】分布式之缓存击穿 【原创】自己动手实现静态资源服务器 【原创】自己动手实现JDK动态代理
【原创】分布式之缓存击穿
什么是缓存击穿
在谈论缓存击穿之前，我们先来回忆下从缓存中加载数据的逻辑，如下图所示
因此，如果黑客每次故意查询一个在缓存内必然不存在的数据，导致每次请求都要去存储层去查询，这样缓存就失去了意义。如果在大流量下数据库可能挂掉。这就是缓存击穿。
场景如下图所示:
我们正常人在登录首页的时候，都是根据userID来命中数据，然而黑客的目的是破坏你的系统，黑客可以随机生成一堆userID,然后将这些请求怼到你的服务器上，这些请求在缓存中不存在，就会穿过缓存，直接怼到数据库上,从而造成数据库连接异常。
解决方案
在这里我们给出三套解决方案，大家根据项目中的实际情况，选择使用.
讲下述三种方案前，我们先回忆下redis的setnx方法
SETNX key value
将 key 的值设为 value ，当且仅当 key 不存在。
若给定的 key 已经存在，则 SETNX 不做任何动作。
SETNX 是『SET if Not eXists』(如果不存在，则 SET)的简写。
可用版本：>= 1.0.0
时间复杂度： O(1)
返回值： 设置成功，返回 1。设置失败，返回 0 。
效果如下
redis> EXISTS job # job 不存在
(integer) 0
redis> SETNX job "programmer" # job 设置成功
(integer) 1
redis> SETNX job "code-farmer" # 尝试覆盖 job ，失败
(integer) 0
redis> GET job # 没有被覆盖
"programmer"1、使用互斥锁
该方法是比较普遍的做法，即，在根据key获得的value值为空时，先锁上，再从数据库加载，加载完毕，释放锁。若其他线程发现获取锁失败，则睡眠50ms后重试。
至于锁的类型，单机环境用并发包的Lock类型就行，集群环境则使用分布式锁( redis的setnx)
集群环境的redis的代码如下所示:
String get(String key) {
String value = redis.get(key);
if (value == null) {
if (redis.setnx(key_mutex, "1")) {
// 3 min timeout to avoid mutex holder crash
redis.expire(key_mutex, 3 * 60)
value = db.get(key);
redis.set(key, value);
redis.delete(key_mutex);
} else {
//其他线程休息50毫秒后重试
Thread.sleep(50);
get(key);
}
}
} 优点:
- 思路简单
- 保证一致性
缺点
- 代码复杂度增大
- 存在死锁的风险
2、异步构建缓存
在这种方案下，构建缓存采取异步策略，会从线程池中取线程来异步构建缓存，从而不会让所有的请求直接怼到数据库上。该方案redis自己维护一个timeout，当timeout小于System.currentTimeMillis()时，则进行缓存更新，否则直接返回value值。
集群环境的redis代码如下所示:
String get(final String key) {
V v = redis.get(key);
String value = v.getValue();
long timeout = v.getTimeout();
if (v.timeout <= System.currentTimeMillis()) {
// 异步更新后台异常执行
threadPool.execute(new Runnable() {
public void run() {
String keyMutex = "mutex:" + key;
if (redis.setnx(keyMutex, "1")) {
// 3 min timeout to avoid mutex holder crash
redis.expire(keyMutex, 3 * 60);
String dbValue = db.get(key);
redis.set(key, dbValue);
redis.delete(keyMutex);
}
}
});
}
return value;
} 优点:
- 性价最佳，用户无需等待
缺点
- 无法保证缓存一致性
3、布隆过滤器
1、原理
布隆过滤器的巨大用处就是，能够迅速判断一个元素是否在一个集合中。因此他有如下三个使用场景:
- 网页爬虫对URL的去重，避免爬取相同的URL地址
- 反垃圾邮件，从数十亿个垃圾邮件列表中判断某邮箱是否垃圾邮箱（同理，垃圾短信）
- 缓存击穿，将已存在的缓存放到布隆过滤器中，当黑客访问不存在的缓存时迅速返回避免缓存及DB挂掉。
OK，接下来我们来谈谈布隆过滤器的原理
其内部维护一个全为0的bit数组，需要说明的是，布隆过滤器有一个误判率的概念，误判率越低，则数组越长，所占空间越大。误判率越高则数组越小，所占的空间越小。
假设，根据误判率，我们生成一个10位的bit数组，以及2个hash函数（f1,f2f1,f2），如下图所示(生成的数组的位数和hash函数的数量，我们不用去关心是如何生成的，有数学论文进行过专业的证明)。
假设输入集合为(N1,N2N1,N2),经过计算f1(N1)f1(N1)得到的数值得为2，f2(N1)f2(N1)得到的数值为5，则将数组下标为2和下表为5的位置置为1，如下图所示
同理，经过计算f1(N2)f1(N2)得到的数值得为3，f2(N2)f2(N2)得到的数值为6，则将数组下标为3和下表为6的位置置为1，如下图所示
这个时候，我们有第三个数N3N3，我们判断N3N3在不在集合(N1,N2N1,N2)中，就进行f1(N3)，f2(N3)f1(N3)，f2(N3)的计算
- 若值恰巧都位于上图的红色位置中，我们则认为，N3N3在集合(N1,N2N1,N2)中
- 若值有一个不位于上图的红色位置中，我们则认为，N3N3不在集合(N1,N2N1,N2)中
以上就是布隆过滤器的计算原理，下面我们进行性能测试，
2、性能测试
代码如下:
(1)新建一个maven工程，引入guava包
<dependencies>
<dependency>
<groupId>com.google.guava</groupId>
<artifactId>guava</artifactId>
<version>22.0</version>
</dependency>
</dependencies> (2)测试一个元素是否属于一个百万元素集合所需耗时
package bloomfilter;
import com.google.common.hash.BloomFilter;
import com.google.common.hash.Funnels;
import java.nio.charset.Charset;
public class Test {
private static int size = 1000000;
private static BloomFilter<Integer> bloomFilter = BloomFilter.create(Funnels.integerFunnel(), size);
public static void main(String[] args) {
for (int i = 0; i < size; i++) {
bloomFilter.put(i);
}
long startTime = System.nanoTime(); // 获取开始时间
//判断这一百万个数中是否包含29999这个数
if (bloomFilter.mightContain(29999)) {
System.out.println("命中了");
}
long endTime = System.nanoTime(); // 获取结束时间
System.out.println("程序运行时间： " + (endTime - startTime) + "纳秒");
}
}
输出如下所示
命中了
程序运行时间： 219386纳秒也就是说，判断一个数是否属于一个百万级别的集合，只要0.219ms就可以完成，性能极佳。
(3)误判率的一些概念
首先，我们先不对误判率做显示的设置，进行一个测试，代码如下所示
package bloomfilter;
import java.util.ArrayList;
import java.util.List;
import com.google.common.hash.BloomFilter;
import com.google.common.hash.Funnels;
public class Test {
private static int size = 1000000;
private static BloomFilter<Integer> bloomFilter = BloomFilter.create(Funnels.integerFunnel(), size);
public static void main(String[] args) {
for (int i = 0; i < size; i++) {
bloomFilter.put(i);
}
List<Integer> list = new ArrayList<Integer>(1000);
//故意取10000个不在过滤器里的值，看看有多少个会被认为在过滤器里
for (int i = size + 10000; i < size + 20000; i++) {
if (bloomFilter.mightContain(i)) {
list.add(i);
}
}
System.out.println("误判的数量：" + list.size());
}
}
输出结果如下
误判对数量：330如果上述代码所示，我们故意取10000个不在过滤器里的值，却还有330个被认为在过滤器里，这说明了误判率为0.03.即，在不做任何设置的情况下，默认的误判率为0.03。
下面上源码来证明：
接下来我们来看一下，误判率为0.03时，底层维护的bit数组的长度如下图所示
将bloomfilter的构造方法改为
private static BloomFilter<Integer> bloomFilter = BloomFilter.create(Funnels.integerFunnel(), size,0.01);即，此时误判率为0.01。在这种情况下，底层维护的bit数组的长度如下图所示
由此可见，误判率越低，则底层维护的数组越长，占用空间越大。因此，误判率实际取值，根据服务器所能够承受的负载来决定，不是拍脑袋瞎想的。
3、实际使用
redis伪代码如下所示
String get(String key) {
String value = redis.get(key);
if (value == null) {
if(!bloomfilter.mightContain(key)){
return null;
}else{
value = db.get(key);
redis.set(key, value);
}
}
return value；
} 优点:
- 思路简单
- 保证一致性
- 性能强
缺点
- 代码复杂度增大
- 需要另外维护一个集合来存放缓存的Key
- 布隆过滤器不支持删值操作
总结
在总结部分，来个漫画把。希望对大家找工作有帮助
【原创】自己动手实现静态资源服务器
引言
本文利用java自带的socket编程实现了一个简单的静态资源服务器，可以响应静态资源。本文一共有两个版本的源码。第一个版本名为Server_v1，该版本实现了一个简单的socket的服务器，帮助读者回忆socket编程。第二个版本名为Server_v2，该版本是对第一版的改良，给出了改良思路，做出了必要的封装，让其能够响应css、html、jpg等静态资源。
版本一
该版本实现一个简单的socket服务器，针对浏览器的请求，能够返回相应的页面。
其源码如下：
package mytomcat_v1;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Date;
/**
*
* @author zhengrongjun
* @version v1.0
*/
public class Server_V1 {
public static void main(String[] args) {
ServerSocket serverSocket = null;
Socket client = null;
try {
serverSocket = new ServerSocket(9999);
// 不断接收客户连接
while (true) {
// 服务器阻塞等待客户端socket连接过来
client = serverSocket.accept();
// 对客户端里面端请求信息进行处理
InputStream in = client.getInputStream();
// 定义一个读取缓冲池 主要是在inputstram流中读取字节
byte[] buff = new byte[1024];
int len = in.read(buff);
if (len > 0) {
String msg = new String(buff, 0, len);
System.out.println("===="+msg+"======");
OutputStream out = client.getOutputStream();
//构建响应信息
StringBuffer sb = new StringBuffer();
sb.append("HTTP/1.1 200 OK\n");
sb.append("Content-Type: text/html; charset=UTF-8\n");
sb.append("\n");
String html="<html><head><title>卖烧饼咯</title></head></html><body>小曲经常在"
+"<font size='14' color='red'>"
+new Date()
+"</font>"
+"<br/>卖烧饼</body></html>";
sb.append(html);
out.write(sb.toString().getBytes());
out.flush();
out.close();
}
}
} catch (Exception e) {
}
}
}
执行效果如下图所示，打开chrome浏览器，在导航栏输入
http://localhost:9999/docs/index.html显示如下图所示
控制台输出如下图所示
====GET /docs/index.html HTTP/1.1
Host: localhost:9999
Connection: keep-alive
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_2) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/65.0.3325.181 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8
Accept-Encoding: gzip, deflate, br
Accept-Language: zh-CN,zh;q=0.9
======版本二
该版本在版本一的基础上进行优化，使其能够有效的响应静态资源
步骤一
先看第一部分代码优化，如下图所示
红框的部分，我们可以理解为对请求信息对处理，因此我们模仿Tomcat构造一个HttpRequst来处理这一段逻辑。
另外，我们需要对静态资源进行响应，因此我们需要获取输入内容的静态资源地址，即以下部分的内容。
获取以上红框请求地址内容的代码如下
uri = msg.substring(msg.indexOf("/"),msg.indexOf("HTTP/1.1") - 1);综上所述，我们有HttpRequest类如下所示
package mytomcat_v2;
import java.io.IOException;
import java.io.InputStream;
/**
* 对客户端进行处理对业务类
*
* @author zhengrongjun
*
*/
public class HttpRequest {
private String uri;
public String getUri() {
return uri;
}
public HttpRequest(InputStream in) throws IOException {
// 对我们对请求字节流进行解析
resolverRequest(in);
}
private void resolverRequest(InputStream in) throws IOException {
// TODO Auto-generated method stub
byte[] buff = new byte[1024];
int len = in.read(buff);
if (len > 0) {
String msg = new String(buff, 0, len);
System.out.println("====" + msg + "======");
// 解析出来 uri
uri = msg.substring(msg.indexOf("/"), msg.indexOf("HTTP/1.1") - 1);
} else {
System.out.println("bad Request!");
}
}
}
步骤二
接下来是第二部分的代码优化，如下图所示
以上红框部分主要是对输出信息进行响应，我们模仿tomcat构造一个HttpResponse对象封装该部分逻辑。
另外，我们获取用户请求的资源文件路径，根据该路径找到相应静态文件。将该文件写入文件流，输出。
因此，我们有HttpResponse对象如下所示
package mytomcat_v2;
/**
* 封装http响应信息
* @author zhengrongjun
*
*/
import java.io.FileInputStream;
import java.io.IOException;
import java.io.OutputStream;
public class HttpResponse {
private OutputStream os = null;
public HttpResponse(OutputStream os) {
this.os = os;
}
public void writerFile(String path) throws IOException {
FileInputStream fileInputStream = new FileInputStream(path);
byte[] buff = new byte[1024];
int len = 0;
// 构建响应信息
StringBuffer sb = new StringBuffer();
sb.append("HTTP/1.1 200 OK\n");
sb.append("Content-Type: text/html; charset=UTF-8\n");
sb.append("\n");
os.write(sb.toString().getBytes());
while ((len = fileInputStream.read(buff)) != -1) {
os.write(buff, 0, len);
}
fileInputStream.close();
os.flush();
os.close();
}
}
步骤三
接下来我们构建测试类，构建之前我们先去找一些静态资源文件。作者直接去apache的官网下把tomcat给下了下来，然后去如下目录拷贝静态资源文件
apache-tomcat-8.5.28/webapps/docs将整个docs 文件夹拷贝至你的项目的根目录下
apache-tomcat-8.5.28/webapps/ROOT/favicon.ico将favicon.ico图片拷贝至你的根目录下
静态资源在你的项目中的结构如下图所示
现在上我们的Server_V2的代码
package mytomcat_v2;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Date;
/**
*
* @author zhengrongjun
* @version v2.0
*/
public class Server_V2 {
public static void main(String[] args) {
ServerSocket serverSocket = null;
Socket client = null;
try {
serverSocket = new ServerSocket(9999);
// 不断接收客户连接
while (true) {
// 服务器阻塞等待客户端socket连接过来
client = serverSocket.accept();
// =========请求类处理=======
InputStream in = client.getInputStream();
HttpRequest request = new HttpRequest(in);
String requestUri = request.getUri();
// =========响应类处理=======
OutputStream os = client.getOutputStream();
HttpResponse response = new HttpResponse(os);
//请求格式是/html/login.html这种，需要把开头的/删除
response.writerFile(requestUri.substring(1));
client.close();
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
测试结果如下：
在浏览器输入
http://localhost:9999/docs/ssl-howto.html效果如下
你会惊奇的发现样式并不能识别，因此我们对响应头的部分逻辑进行修改
将
sb.append("HTTP/1.1 200 OK\n");
sb.append("Content-Type: text/html; charset=UTF-8\n");
sb.append("\n");部分修改为
if(path.endsWith("css")) {
sb.append("HTTP/1.1 200 OK\n");
sb.append("Content-Type: text/css; charset=UTF-8\n");
sb.append("\n");
}else {
sb.append("HTTP/1.1 200 OK\n");
sb.append("Content-Type: text/html; charset=UTF-8\n");
sb.append("\n");
}
继续启动测试，效果如下
已经能够正常显示
总结
本文给出了两个版本的静态资源的服务器源码，希望读者能够有所收获。
【原创】自己动手实现JDK动态代理
项目结构如下图所示，maven项目
1、JDK动态代理
先来一段jdk动态代理的demo，
首先创建一个接口，Person
package bean;
public interface Person {
public void eat();
}然后写一个实现类PersonImpl
package bean;
public class PersonImpl implements Person{
@Override
public void eat() {
// TODO Auto-generated method stub
System.out.println("time to eat ");
}
}然后写个使用类PersonInvocationHandler
package jdk;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class PersonInvocationHandler implements InvocationHandler {
private Object obj;
public PersonInvocationHandler(Object obj) {
this.obj = obj;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
// TODO Auto-generated method stub
System.out.println("before time to eat");
method.invoke(obj, args);
System.out.println("after time to eat");
return null;
}
}最后 再写个测试类
package jdk;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.lang.reflect.Proxy;
import sun.misc.ProxyGenerator;
import bean.Person;
import bean.PersonImpl;
public class jdkTest {
public static void main(String[] args) throws Exception {
PersonInvocationHandler personInvocationHandler = new PersonInvocationHandler(
new PersonImpl());
Person personProxy = (Person) Proxy.newProxyInstance(
PersonImpl.class.getClassLoader(),
PersonImpl.class.getInterfaces(), personInvocationHandler);
personProxy.eat();
}
}输出如下
before time to eat
time to eat
after time to eat接下里我们不使用JDK的API，自己实现一套代理类
2、自定义动态代理
先上测试类的代码，如下图所示，共有(1)(2)(3)处不同
针对(1)，我们有如下代码,先抄袭JDK的InvocationHandler，改个名字成为MyInvocationHandler
package custom;
import java.lang.reflect.Method;
public interface MyInvocationHandler {
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable;
}
编写一个JAVA类MyPersonInvocationHandler继承MyInvocationHandler，这段代码与PersonInvocationHandler的代码无异，如下所示
package custom;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class MyPersonInvocationHandler implements MyInvocationHandler {
private Object obj;
public MyPersonInvocationHandler(Object obj) {
this.obj = obj;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
// TODO Auto-generated method stub
System.out.println("before time to eat");
method.invoke(obj, args);
System.out.println("after time to eat");
return null;
}
}针对(2),我们实现一个自己的代理生成类MyProxy,其生成java代理类的步骤分为以下5步
- 生成java源碼
- 將源码输出到java文件中
- 将java文件编译成class文件
- 将class加载进jvm
- 返回代理类对象
具体代码如下
package custom;
import java.io.File;
import java.io.FileWriter;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import javax.tools.JavaCompiler;
import javax.tools.StandardJavaFileManager;
import javax.tools.ToolProvider;
public class MyProxy {
public static final String ln = "\r\n";
public static Object newProxyInstance(MyClassLoader myClassLoder,
Class<?>[] interfaces, MyInvocationHandler h) {
try{
// 1 java源碼
String src = generateSrc(interfaces);
// 2 將源码输出到java文件中
String filePath = MyProxy.class.getResource("").getPath();
System.out.println(filePath);
File f = new File(filePath + "$Proxy0.java");
FileWriter fw = new FileWriter(f);
fw.write(src);
fw.flush();
fw.close();
//3、将java文件编译成class文件
JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
StandardJavaFileManager manage = compiler.getStandardFileManager(null,null,null);
Iterable iterable = manage.getJavaFileObjects(f);
JavaCompiler.CompilationTask task = compiler.getTask(null,manage,null,null,null,iterable);
task.call();
manage.close();
//4、将class加载进jvm
Class proxyClass=myClassLoder.findClass("$Proxy0");
f.delete();
//5、返回代理类对象
Constructor constructor = proxyClass.getConstructor(MyInvocationHandler.class);
return constructor.newInstance(h);
}catch(Exception e){
e.printStackTrace();
}
return null;
}
private static String generateSrc(Class<?>[] interfaces) {
// TODO Auto-generated method stub
StringBuffer sb = new StringBuffer();
sb.append("package custom;" + ln);
sb.append("import java.lang.reflect.Method;" + ln);
sb.append("public class $Proxy0 implements " + interfaces[0].getName() + "{" + ln);
sb.append("private MyInvocationHandler h;"+ln);
sb.append("public $Proxy0(MyInvocationHandler h) { " + ln);
sb.append("this.h = h;"+ln);
sb.append("}" + ln);
for (Method m : interfaces[0].getMethods()) {
sb.append("public " + m.getReturnType().getName() + " "
+ m.getName() + "() {" + ln);
sb.append("try{" + ln);
sb.append("Method m = " + interfaces[0].getName()
+ ".class.getMethod(\"" + m.getName()
+ "\",new Class[]{});" + ln);
sb.append("this.h.invoke(this,m,null);" + ln);
sb.append("}catch(Throwable e){" + ln);
sb.append("e.printStackTrace();" + ln);
sb.append("}"+ln);
sb.append("}"+ln);
}
sb.append("}" + ln);
return sb.toString();
}
}
针对(3)，我们继承ClassLoader,实现一套自己的类加载机制MyClassLoader，如下所示,
package custom;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
public class MyClassLoader extends ClassLoader {
private File classPathfile;
public MyClassLoader() {
String classpth = MyClassLoader.class.getResource("").getPath();
classPathfile = new File(classpth);
}
@Override
public Class<?> findClass(String name) throws ClassNotFoundException {
String className = MyClassLoader.class.getPackage().getName() + "." +name;
if (classPathfile != null) {
File file = new File(classPathfile, name + ".class");
FileInputStream fileInputStream = null;
ByteArrayOutputStream outputStream = null;
try{
fileInputStream = new FileInputStream(file);
outputStream = new ByteArrayOutputStream();
byte[] buff = new byte[1024];
int len;
while((len=fileInputStream.read(buff))!=-1){
outputStream.write(buff, 0, len);
}
return defineClass(className, outputStream.toByteArray(), 0, outputStream.size());
}catch(Exception e){
e.printStackTrace();
}finally{
if(null!=fileInputStream){
try {
fileInputStream.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
if(null!=outputStream){
try {
outputStream.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
return null;
}
}最后测试类代码如下所示
package custom;
import java.lang.reflect.Proxy;
import custom.MyPersonInvocationHandler;
import bean.Person;
import bean.PersonImpl;
public class CustomTest {
public static void main(String[] args) {
MyPersonInvocationHandler personInvocationHandler = new MyPersonInvocationHandler(
new PersonImpl());
Person personProxy = (Person) MyProxy.newProxyInstance(
new MyClassLoader(), PersonImpl.class.getInterfaces(),
personInvocationHandler);
personProxy.eat();
}
}输出如何所示
before time to eat
time to eat
after time to eat
至此，我们已完全实现了一套自定义的jdk动态代理类
【原创】分布式之缓存击穿 【原创】自己动手实现静态资源服务器 【原创】自己动手实现JDK动态代理的更多相关文章
- 动态代理学习（一）自己动手模拟JDK动态代理
最近一直在学习Spring的源码,Spring底层大量使用了动态代理.所以花一些时间对动态代理的知识做一下总结. 我们自己动手模拟一个动态代理 对JDK动态代理的源码进行分析 文章目录 场景: 思路: ...
- JDK动态代理[3]----WeakCache缓存的实现机制
上一篇我们分析了Proxy类的内部是怎样产生代理类的,我们看到了Proxy内部用到了缓存机制,如果根据提供的类加载器和接口数组能在缓存中找到代理类就直接返回该代理类,否则会调用ProxyClassFa ...
- 【原创】自己动手实现JDK动态代理
项目结构如下图所示,maven项目 1.JDK动态代理 先来一段jdk动态代理的demo, 首先创建一个接口,Person package bean; public interface Person ...
- 【原创】JDK动态代理，此次之后，永生难忘。
动态代理,这个词在Java的世界里面经常被提起,尤其是对于部分(这里强调“部分”二字,因为有做了一两年就成大神的,实力强的令人发指,这类人无疑是非常懂动态代理这点小伎俩的)做了一两年新人来说,总是摸不 ...
- NodeJS4-7静态资源服务器实战_缓存
浏览器发出一个请求,服务器解析出响应的结果返回给浏览器. 缓存是怎么工作的? 用户发起请求,浏览器检查本地是否存在缓存,如果第一次请求没有缓存,那就向服务器发起请求,服务器协商缓存的内容并且返回响应, ...
- 自己动手实现JDK动态代理
出自:作者:孤独烟 http://rjzheng.cnblogs.com/ ------------------------------------------------------------- ...
- nginx静态资源缓存策略配置
1. 问题-背景 以前也经常用nginx,但用的不深,通常是简单的设置个location用来做反向代理.直到今天给客户做项目碰到缓存问题:客户有个app,只是用原生做了个壳,里面的内容都是用h5写的, ...
- Java Redis缓存穿透/缓存雪崩/缓存击穿，Redis分布式锁实现秒杀，限购等
package com.example.redisdistlock.controller; import com.example.redisdistlock.util.RedisUtil; impor ...
- Redis缓存雪崩、缓存穿透、缓存击穿、缓存降级、缓存预热、缓存更新
Redis缓存能够有效地加速应用的读写速度,就DB来说,Redis成绩已经很惊人了,且不说memcachedb和Tokyo Cabinet之流,就说原版的memcached,速度似乎也只能达到这个级别 ...
随机推荐
- Paxos，Raft，Zab一致性协议-Raft篇
Raft是一个一致性算法,旨在易于理解.它提供了Paxos的容错和性能.不同之处在于它被分解为相对独立的子问题,它清楚地解决了实际系统所需的所有主要部分.我们希望Raft能够为更广泛的受众提供共识,并 ...
- [ Luogu 3924 ] 康纳的线段树
\(\\\) \(Description\) 现在有一个线段树维护长为\(N\)的数列,实现方式是\(mid=((l+r)>>1)\),支持区间加,节点维护区间和. 共有\(M\)次区间加 ...
- grunt 全局使用
grunt 不同地方使用时需要将插件下载的当前文件夹,这是因为查找模块时是当前路径,这会造成多个工程使用时会需要下载多次,而这些东西又不应该存在于工程之中,所以应该将所有模块全局安装,然后在工程下面只 ...
- 搭建linux环境：如何在vmware安装linux虚拟机？？
本来不想再整一遍的,奈何分布式压测呀,呀呀呀呀呀呀 1.安装linux虚机 (1)在桌面上双击VMware Workstation图标后启动虚拟机,鼠标单击文件,选择新的虚拟机: (2)单击“next ...
- 一步一步实现基于GPU的pathtracer（三）：path tracing 简述
全局光照这个名词在计算机图形学里已经不算一个新名词了,现在一提到拟真度,很多人基本上都会去想到全局光照,这个名词上世纪七八十年代就有了,好像是由一个叫Jim Kajiya的大神在他那篇已经被引用了不知 ...
- (C/C++学习)15.C语言字符串和字符数组
说明:在C语言中字符串和字符数组有很多相似之处,却又有着一些不同.本文将针对其区别与联系,进行分析总结. 一.字符串 1.在C语言中,字符串是由双引号括起来的任意字符序列,如:"china& ...
- [LNOI2014]LCA(树链剖分)
BZOJ传送门 Luogu传送门 题目:给你一棵树,给你n个询问,每个询问要求输出$\sum_{i=l}^{r}depth(LCA(i,z))$ 细看看其实没有想象的那么难 大体思路: 1.对于每个询 ...
- chrome浏览器安装网页测试插件postman的图文介绍
用户在开发或者调试网络程序或者是网页B/S模式的程序的时候是需要一些方法来跟踪网页请求的,用户可以使用一些网络的监视工具比如著名的Firebug等网页调试工具.今天给大家介绍的这款网页调试工具不仅可以 ...
- python json、 pickle 、shelve 模块
json 模块 用于序列化的模块 json,用于字符串 和 python数据类型间进行转换 Json模块提供了四个功能:dumps.dump.loads.load #!/usr/bin/env pyt ...
- Linux 复习三
第三章Linux使用进阶 一.磁盘管理和文件系统 1.磁盘的基本概念:磁头(head).柱面(cylinder).扇区(sector) Linux系统中所有的设备被抽象成文件,存储在/dev目录下 设 ...