【JAVA并发编程实战】5、构建高效且可伸缩的结果缓存

首先创建一个借口，用来表示耗费资源的计算

package cn.xf.cp.ch05;

public interface Computable<A, V>
{
V compute(A arg) throws Exception;
}

实现接口，实现计算过程

package cn.xf.cp.ch05;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.math.BigInteger;

public class ExpensiveFunction implements Computable<String, BigInteger>
{

@Override
public BigInteger compute(String arg) throws InterruptedException
{
//读取10个文件的和
BigInteger count = new BigInteger("0");
File file = null;
InputStreamReader is = null;
BufferedReader br = null;
try
{
file = new File(String.valueOf(arg));
is = new InputStreamReader(new FileInputStream(file));
br = new BufferedReader(is);
String line = "";
while((line = br.readLine()) != null)
{
String longdata[] = line.split(" ");
for(int j = 0; j < longdata.length; ++j)
{
//统计和
String temp = longdata[j];
BigInteger bitemp = new BigInteger(temp);
count = count.add(bitemp);
}
}
}
catch (Exception e)
{
e.printStackTrace();
}
finally
{
try
{
br.close();
is.close();
}
catch (IOException e)
{
e.printStackTrace();
}
}
//返回统计结果
return count;
}

@org.junit.Test
public void test()
{
String s = "132456789123456789326549873218746132165432176134653216874649761";
BigInteger bi = new BigInteger("0");

System.out.println(bi.add(new BigInteger("1")).toString());
}
}

功能实现1，这个不是现场安全的，就是一个简单的缓存机制，如果有就直接从缓存中获取，没有的话就添加到缓存中

package cn.xf.cp.ch05;

import java.util.HashMap;
import java.util.Map;

public class Memoizer1<A, V> implements Computable<A, V>
{
/**
* 这里使用hashmap来作为缓存对象，其实并不是一个好的选择，hashmap并不是一个线程安全的类
*/
private final Map<A, V> cache = new HashMap<A, V>();
private final Computable<A, V> c;

public Memoizer1(Computable<A, V> c)
{
//初始化C的值
this.c = c;
}

/**
*    由于hashmap并不是一个线程安全的，所以我们队这个操作加锁，避免意外
*    但是如果有一个问题，如果一个线程阻塞了这个方法，那么其他线程就无法通过这个方法获取到对应的缓存
*    那么就可能会造成使用缓存的结果却比不使用缓存更慢，性能并不会得到任何的提升
* @param arg
* @return
* @throws InterruptedException
*/
@Override
public synchronized V compute(A arg) throws Exception
{
V result = cache.get(arg);
if(result == null)
{
result = c.compute(arg);
//如果没有的话，那么就放到对应的缓存对象中
cache.put(arg, result);
}
return result;
}

}

功能实现2：添加一个future进行异步处理，就是把原来的数据计量分化到异步处理中，这样就不会产生阻塞在一个地方，造成其他线程等待很耗费资源的计算产生结果的问题

package cn.xf.cp.ch05;

import java.util.Map;
import java.util.concurrent.Callable;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;

public class Memoizer2<A, V> implements Computable<A, V>
{
private final Map<A, Future<V>>    cache    = new ConcurrentHashMap<A, Future<V>>();
private final Computable<A, V>    c;

public Memoizer2(Computable<A, V> c)
{
this.c = c;
}

/**
* 这个里面的复合操作，没有就添加future，是在底层的MAP对象上执行的，而map无法通过加锁来确定原子性
*/
@Override
public V compute(final A arg) throws Exception
{
Future<V> f = cache.get(arg);
if (f == null)
{
Callable<V> eval = new Callable<V>()
{
public V call() throws Exception
{
return c.compute(arg);
}
};
FutureTask<V> ft = new FutureTask<V>(eval);
f = ft;
cache.put(arg, ft);
ft.run(); // call to c.compute happens here
}
return f.get();
}

}

功能实现3：避免底层map的操作有影响，并防止缓存污染

package cn.xf.cp.ch05;

import java.util.concurrent.Callable;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;

public class Memoizer3<A, V> implements Computable<A, V>
{

private final ConcurrentMap<A, Future<V>>    cache    = new ConcurrentHashMap<A, Future<V>>();
private final Computable<A, V>                c;

public Memoizer3(Computable<A, V> c)
{
this.c = c;
}

@Override
public V compute(final A arg) throws Exception
{
//不断循环，直到return
while (true)
{
Future<V> f = cache.get(arg);
if (f == null)
{
Callable<V> eval = new Callable<V>()
{
public V call() throws Exception
{
return c.compute(arg);
}
};
FutureTask<V> ft = new FutureTask<V>(eval);
/*
* 确定使用，这个避免重复添加
* 如果包含arg就返回，否则就把ft放入进去
*/
f = cache.putIfAbsent(arg, ft);
if (f == null)
{
f = ft;
ft.run();
}
}
try
{
//返回计算结果
return f.get();
}
catch (Exception e)
{
//计算失败，从缓存中移除，避免缓存污染，就是一个key返回一个空值，并返回从新运算
cache.remove(arg, f);
}
}
}

}

测试结果：

package cn.xf.cp.ch05;

import java.math.BigInteger;

public class MemeryTest
{
public static void main(String[] args) throws Exception
{
ExpensiveFunction ef = new ExpensiveFunction();
Memoizer1<String, BigInteger> m = new Memoizer1<String, BigInteger>(ef);
BigInteger bresult1 = new BigInteger("0");
BigInteger bresult2 = new BigInteger("0");
//比较不同方式统计10次1文件的时间比较
long start1 = System.nanoTime();
for(int i = 1; i <= 10; ++i)
{
bresult1 = bresult1.add(ef.compute(String.valueOf(1)));
}
long end1 = System.nanoTime();

long start2 = System.nanoTime();
for(int i = 1; i <= 10; ++i)
{
bresult2 = bresult2.add(m.compute(String.valueOf(1)));
}
long end2 = System.nanoTime();

System.out.println("统计文件1~10使用时间" + (end1 - start1) + "  大小是：" + bresult1.toString());

System.out.println("统计文件1,10次使用时间" + (end2 - start2) + "  大小是：" + bresult2.toString());
}

@org.junit.Test
public void test2() throws Exception
{
ExpensiveFunction ef = new ExpensiveFunction();
Memoizer2<String, BigInteger> m = new Memoizer2<String, BigInteger>(ef);
BigInteger bresult1 = new BigInteger("0");
BigInteger bresult2 = new BigInteger("0");
//比较不同方式统计10次1文件的时间比较
long start1 = System.nanoTime();
for(int i = 1; i <= 10; ++i)
{
bresult1 = bresult1.add(ef.compute(String.valueOf(1)));
}
long end1 = System.nanoTime();

long start2 = System.nanoTime();
for(int i = 1; i <= 10; ++i)
{
bresult2 = bresult2.add(m.compute(String.valueOf(1)));
}
long end2 = System.nanoTime();

System.out.println("统计文件1~10使用时间" + (end1 - start1) + "  大小是：" + bresult1.toString());

System.out.println("统计文件1,10次使用时间" + (end2 - start2) + "  大小是：" + bresult2.toString());

}

@org.junit.Test
public void test3() throws Exception
{

ExpensiveFunction ef = new ExpensiveFunction();
Memoizer3<String, BigInteger> m = new Memoizer3<String, BigInteger>(ef);
BigInteger bresult1 = new BigInteger("0");
BigInteger bresult2 = new BigInteger("0");
//比较不同方式统计10次1文件的时间比较
long start1 = System.nanoTime();
for(int i = 1; i <= 10; ++i)
{
bresult1 = bresult1.add(ef.compute(String.valueOf(1)));
}
long end1 = System.nanoTime();

long start2 = System.nanoTime();
for(int i = 1; i <= 10; ++i)
{
bresult2 = bresult2.add(m.compute(String.valueOf(1)));
}
long end2 = System.nanoTime();

System.out.println("统计文件1~10使用时间" + (end1 - start1) + "  大小是：" + bresult1.toString());

System.out.println("统计文件1,10次使用时间" + (end2 - start2) + "  大小是：" + bresult2.toString());

}
}

结果就是使用了缓存的话，速度会快10倍，这个决定于循环的次数

文件的话，就是简单的循环生成数据





三种测试结果，差不多，因为这里并没有使用到多线程进行测试，结果和单线程是一样的。