java 并发编程实践里面的建立高速缓存的各个版本...

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

/*
 * 版本4 备忘录的技术
 */
public class Memorizer4<A, V> implements Computeable<A, V> {

	private final Computeable<A, V> c; // 真正负责计算的对象 组合的设计模式

	private final ConcurrentHashMap<A, Future<V>> cache = new ConcurrentHashMap<A, Future<V>>();
	//将一个线程作为 值放入map 这个线程可以有返回值  
	// f.get() 是一个阻塞的方法 等待计算线程完成

	public Memorizer4(Computeable<A, V> c) {
		this.c = c;
	}

	@Override
	public V compute(final A arg) throws InterruptedException {
		Future<V> task = cache.get(arg);
		if (task == null) {
			Callable<V> eval = new Callable<V>() {
				@Override
				public V call() throws Exception {
					return c.compute(arg);
				}

			};

			FutureTask<V> ft = new FutureTask<V>(eval);
		/*	task = ft;
			cache.put(arg, task);
			ft.run(); // 调用c.compute 发生在这里
*/		      
			task = cache.putIfAbsent(arg, ft);//是concurrentmap增强的原子操作,再次检查一遍 传说中的double-check??

			if (task == null) {
				task = ft;
				ft.run();
			}
			
			}
		try {
			return task.get();
		} catch (ExecutionException e) {
			// throw launderThrowable(e.getCause()); 这里的异常处理不合理 我不知道怎么做s
			return null;
		}

	}

}

 看别人是怎样一步一步完善程序...提高性能的....

public interface Computeable<A, V> {
	public V compute(A arg) throws InterruptedException;
}

 

import java.math.BigInteger;

public class ExpensiveFunction implements Computeable<String,BigInteger> {
      //真正用来负责计算的类
	@Override
	public BigInteger compute(String arg) throws InterruptedException {
		//after deep thought 呵呵 外国人真幽默
		return new BigInteger(arg);
	}

}

 

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

/*
 * 版本1 备忘录的技术
 */
public class Memorizer1<A, V> implements Computeable<A, V> {
    
	private Computeable<A,V> c ; //真正负责计算的对象  组合的设计模式
	
	private Map<A,V> cache = new HashMap<A,V>(); //缓存 
	
	public Memorizer1(Computeable<A, V> c) {
		this.c = c;
	}
	@Override
	public synchronized  V compute(A arg) throws InterruptedException {
		V result = cache.get(arg);
		if(result != null) {
			return result;
		}
		result = c.compute(arg);
		cache.put(arg, result);
		return result ;
	}

}

 //这样做 并发性很低....

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/*
 * 版本2 备忘录的技术
 */
public class Memorizer2<A, V> implements Computeable<A, V> {
    
	private  final Computeable<A,V> c ; //真正负责计算的对象  组合的设计模式
	
	private final Map<A,V> cache = new ConcurrentHashMap<A,V>(); //缓存 
	
	public Memorizer2(Computeable<A, V> c) {
		this.c = c;
	}
	@Override
	public  V compute(A arg) throws InterruptedException {
		V result = cache.get(arg);
		if(result != null) {
			return result;
		}
		result = c.compute(arg);
		cache.put(arg, result);
		return result ;
	}

}//使用了ConcurrentHashMap

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

/*
 * 版本3 备忘录的技术
 */
public class Memorizer3<A, V> implements Computeable<A, V> {

	private final Computeable<A, V> c; // 真正负责计算的对象 组合的设计模式

	private final Map<A, Future<V>> cache = new ConcurrentHashMap<A, Future<V>>();
	//将一个线程作为 值放入map 这个线程可以有返回值  
	// f.get() 是一个阻塞的方法 等待计算线程完成

	public Memorizer3(Computeable<A, V> c) {
		this.c = c;
	}

	@Override
	public V compute(final A arg) throws InterruptedException {
		Future<V> task = cache.get(arg);
		if (task == null) {
			Callable<V> eval = new Callable<V>() {
				@Override
				public V call() throws Exception {
					return c.compute(arg);
				}

			};

			FutureTask<V> ft = new FutureTask<V>(eval);
			task = ft;
			cache.put(arg, task);
			ft.run(); // 调用c.compute 发生在这里 在本线程中执行
		}
		try {
			return task.get();
		} catch (ExecutionException e) {
			// throw launderThrowable(e.getCause()); 这里的异常处理不合理 我不知道怎么做s
			return null;
		}

	}

}

  

评论

1 楼 znlyj 2014-08-25  

这个缓存如何更新呢？