java并发工具类构建高效且可伸缩的结果缓存

最新推荐文章于 2024-06-26 11:05:50 发布
最新推荐文章于 2024-06-26 11:05:50 发布
阅读量429 收藏
点赞数
分类专栏： thread
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liangwenmail/article/details/79298761
版权

代码：

接口：

package cn.concurrent.t12;

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


实现：

package cn.concurrent.t12;

import java.math.BigInteger;
import java.util.concurrent.Callable;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class Memoizer<A,V> implements Computable<A, V>{
	private final ConcurrentMap<A, FutureTask<V>> cache=new ConcurrentHashMap<A,FutureTask<V>>();
	private final Computable<A, V> c;
	
	public Memoizer(Computable<A, V> c) {
		this.c = c;
	}


	@Override
	public V compute(final A arg) throws InterruptedException {
		while(true){
			FutureTask<V> f = cache.get(arg);
			if(f==null){
				FutureTask<V> ff = new FutureTask<V>(new Callable<V>() {
					@Override
					public V call() throws Exception {
						System.out.println(Thread.currentThread().getName()+":::正在执行远程计算任务,参数="+arg);
						return c.compute(arg);
					}
				});
				
				f = cache.putIfAbsent(arg, ff);
				
				if(f==null){
					f=ff;
					ff.run();//在当前线程执行
				}
				
			}
			
			try {
				System.out.println(Thread.currentThread().getName()+">>>>>>>>>>>>>>>>>>>准备获取远程任务的结果,参数="+arg);
				return f.get();
			} catch (ExecutionException e) {
				cache.remove(arg); //执行失败的缓存清理掉
				Throwable cause = e.getCause();
				if(cause instanceof RuntimeException){
					throw (RuntimeException) cause;
				}else if(cause instanceof Error){
					throw (Error) cause;
				}else{
					throw new IllegalStateException("Not unchecked",cause);
				}
			}finally{
				synchronized ("1") {
					if(cache.size()>2   ){ //模拟最多缓存2个数据
						cache.clear();
						System.out.println(Thread.currentThread().getName()+"---清理了缓存");
					}else{
						System.out.println(Thread.currentThread().getName()+"---当前缓存量:"+cache.size()+",cache="+cache);
					}
						
				}
			}
			
		}
		
	}
	
	public static void main(String[] args) throws InterruptedException {
		final Memoizer<String, BigInteger> memoizer = new Memoizer<String,BigInteger>(new Computable<String,BigInteger>(){
			@Override
			public BigInteger compute(String arg) throws InterruptedException {
				Thread.sleep(2000);
				return new BigInteger(arg);
			}});

		
		new Thread(new Runnable() {
			
			@Override
			public void run() {
				// TODO Auto-generated method stub
				BigInteger compute=null;
				try {
					compute = memoizer.compute("1");
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				System.out.println(Thread.currentThread().getName()+"<<<得到了参数1的计算结果："+compute);
			}
		}).start();
		
		Thread.sleep(3000);
		
		new Thread(new Runnable() {
			
			@Override
			public void run() {
				// TODO Auto-generated method stub
				BigInteger compute=null;
				try {
					compute = memoizer.compute("a");
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				System.out.println(Thread.currentThread().getName()+"<<<得到了参数a的计算结果："+compute);
			}
		}).start();
		
		Thread.sleep(3000);
		
		new Thread(new Runnable() {
			
			@Override
			public void run() {
				// TODO Auto-generated method stub
				BigInteger compute=null;
				try {
					compute = memoizer.compute("2");
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				System.out.println(Thread.currentThread().getName()+"<<<得到了参数2的计算结果："+compute);
			}
		}).start();
		
		Thread.sleep(3000);
		
		new Thread(new Runnable() {
			
			@Override
			public void run() {
				// TODO Auto-generated method stub
				BigInteger compute=null;
				try {
					compute = memoizer.compute("3");
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				System.out.println(Thread.currentThread().getName()+"<<<得到了参数3的计算结果："+compute);
			}
		}).start();
		
		Thread.sleep(3000);
		
		new Thread(new Runnable() {
			
			@Override
			public void run() {
				// TODO Auto-generated method stub
				BigInteger compute=null;
				try {
					compute = memoizer.compute("2");
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				System.out.println(Thread.currentThread().getName()+"<<<得到了参数3的计算结果："+compute);
			}
		}).start();
	}

}


输出：

Thread-0:::正在执行远程计算任务,参数=1
Thread-0>>>>>>>>>>>>>>>>>>>准备获取远程任务的结果,参数=1
Thread-0---当前缓存量:1,cache={1=java.util.concurrent.FutureTask@4da9ec16}
Thread-0<<<得到了参数1的计算结果：1
Thread-1:::正在执行远程计算任务,参数=a
Thread-1>>>>>>>>>>>>>>>>>>>准备获取远程任务的结果,参数=a
Thread-1---当前缓存量:1,cache={1=java.util.concurrent.FutureTask@4da9ec16}
Exception in thread "Thread-1" java.lang.NumberFormatException: For input string: "a"
	at java.lang.NumberFormatException.forInputString(Unknown Source)
	at java.lang.Integer.parseInt(Unknown Source)
	at java.math.BigInteger.<init>(Unknown Source)
	at java.math.BigInteger.<init>(Unknown Source)
	at cn.concurrent.t12.Memoizer$2.compute(Memoizer.java:75)
	at cn.concurrent.t12.Memoizer$2.compute(Memoizer.java:1)
	at cn.concurrent.t12.Memoizer$1.call(Memoizer.java:28)
	at java.util.concurrent.FutureTask$Sync.innerRun(Unknown Source)
	at java.util.concurrent.FutureTask.run(Unknown Source)
	at cn.concurrent.t12.Memoizer.compute(Memoizer.java:36)
	at cn.concurrent.t12.Memoizer$4.run(Memoizer.java:104)
	at java.lang.Thread.run(Unknown Source)
Thread-2:::正在执行远程计算任务,参数=2
Thread-2>>>>>>>>>>>>>>>>>>>准备获取远程任务的结果,参数=2
Thread-2---当前缓存量:2,cache={1=java.util.concurrent.FutureTask@4da9ec16, 2=java.util.concurrent.FutureTask@11cf3710}
Thread-2<<<得到了参数2的计算结果：2
Thread-3:::正在执行远程计算任务,参数=3
Thread-3>>>>>>>>>>>>>>>>>>>准备获取远程任务的结果,参数=3
Thread-3---清理了缓存
Thread-3<<<得到了参数3的计算结果：3
Thread-4:::正在执行远程计算任务,参数=2
Thread-4>>>>>>>>>>>>>>>>>>>准备获取远程任务的结果,参数=2
Thread-4---当前缓存量:1,cache={2=java.util.concurrent.FutureTask@5f154718}
Thread-4<<<得到了参数3的计算结果：2


ConcurrentMap接口代替Map接口，因为它提供了 如果不存在就添加 的原子性操作，ConcurrentHashMap作为实现，比同步容器有更高的并发性。

FutureTask作为缓存的值，可以避免两个线程缓存相同的值，如果已经有线程缓存了某个key，另外一个线程调用cache.putIfAbsent方法不会返回null,则直接访问FutureTask.get获取结果。

ff.run 在当前线程执行计算，但是对于其他线程可以直接调用get获取结果。

结果分析：

Thread-0 由于缓存中还没有key=1的数据，把key=1的数据写缓存，进行了任务调用，返回结果。

Thread-1 由于缓存中还没有key=a的数据，把key=a的数据写缓存，进行任务调用，调用返回结果get方法时，抛出异常ExecutionException，清除这个缓存（因为执行失败了）。

Thread-2 同Thread-0。

Thread-3 同Thread-0，由于缓存上限设置为2个（测试用），清空缓存。

Thread-4 同Thread-0。

呵呵 没错，没有使用缓存，四个线程都进行任务调用，如果提高缓存上限，缓存不会清空，那么Thread-4就不会调用任务了，直接在缓存获取，因为key=2的数据在Thread-2使用过。


要争气
关注
专栏目录
缓存工具类
06-15
获取缓存，从缓存中移除， 写入缓存，获得一个Cache，没有则创建一个
深入浅出_Java并发工具包原理讲解
01-29
各种并发工具类：包括闭锁（CountDownLatch）、栅栏（CyclicBarrier）、信号量（Semaphore）、读写锁（ReentrantReadWriteLock）等，这些工具类提供了丰富的线程间协调和控制的机制，使得多线程之间的合作更加高效和...
构建java高效的缓存
稻草人的博客
12-16 1959
在项目的开发中，如果出现一些数据量较大且需要频繁读取而又很少改动场景时，基本上会考虑使用缓存，以降低数据库的压力，毕竟访问到数据库的数据是相当耗费资源。 说到缓存，大家可能更多先想到使用HashMap存储，代码如下： public Map cache = new HashMap(); public Object getData(String key){ Object data = cache
java:aocache:基于aspectJ实现的方法缓存工具
最新发布
10km的专栏
06-26 1401
最近一直在做一些服务端的设计，经常遇到常量计算的问题，比如获取查找一个类的所有方法，获取有指定注解(Annnotation)的方法并查找注解的上特定的元注解是否有特定的值。比如在服务端方法拦截器上经常执行这样的计算，事实上在运行时，对于一个类(Class)或方法(Method)，它在运行时就是个常量，上述复杂计算返回结果也是一个恒定的值不会改变，称之为常量计算。适用于不需要长期保存的数据。如上的模式大概就是一内一外两个方法，内部方法负责真正的计算由缓存对象调用，外部方法则直接从缓存读取数据提供给调用方。
构建 高效可伸缩的结果缓存
zxadcsdn的博客
11-05 171
通过HashMap实现缓存 Computable接口 public interface Computable&amp;lt;A, V&amp;gt; { V compute(A arg) throws InterruptedException; } **ExpensiveFunction **(表示结果的计算过程) public class ExpensiveFunction implements Compu...
JAVA缓存的实现
Deepblue
12-08 288
缓存可分为二大类: 一、通过文件缓存,顾名思义文件缓存是指把数据存储在磁盘上，不管你是以XML格式，序列化文件DAT格式还是其它文件格式； 二、内存缓存，也就是实现一个类中静态Map,对这个Map进行常规的增删查. 下面为一个简单的缓存代码 [code="java"]package lhm.hcy.guge.frameset.cache; import java.util.*...
java并发--高效缓存
驰骋翱翔
04-11 413
最近阅读《java并发编程实战》第5章中提到的一步步建立高效可伸缩缓存代码，若有所思。 缓存是最容易引起并发问题的场景之一，因为缓存的内容经常为可变状态，而作用域又相对较大。解决并发问题最简单粗暴的方式就是加锁，但这样会降低执行效率，多线程执行到同步代码区，只能等自己活得锁的情况下才能继续执行。我们看下代码： 作者先使用泛型技术提供了一个可伸缩的...
行业分类-设备装置-基于可伸缩性设计的教育平台数据缓存方法及系统.zip
08-27
通过理解并应用以上知识点，教育平台可以构建出一个强大且可扩展的系统，满足不断增长的用户需求，同时确保教学体验的优质和稳定性。"基于可伸缩性设计的教育平台数据缓存方法及系统"的详细文档将深入解析这些概念，...
java建立高效、可伸缩性缓存
windflybird
04-18 5281
缓存 写入前，先排重，同时要防止重复写（两个线程同时写入），或者是重复读（已有线程写入，正在计算，另一个线程可以不必继续访问，直接等待结果就好）。 关键点： 1- ConcurrentHashMap分段锁。 2- Callable启动线程，返回Future对象。 代码： public interface Computable&amp;lt;K,V&amp;gt; { V compute...
在java中构建高效的结果缓存
程序那些事
04-02 9445
文章目录使用HashMap使用ConcurrentHashMapFutureTask 在java中构建高效的结果缓存 缓存是现代应用服务器中非常常用的组件。除了第三方缓存以外，我们通常也需要在java中构建内部使用的缓存。那么怎么才能构建一个高效的缓存呢？ 本文将会一步步的进行揭秘。 使用HashMap 缓存通常的用法就是构建一个内存中使用的Map，在做一个长时间的操作比如计算之前，先在Map中查...
[Java并发编程实战]构建一个高效可复用缓存程序（含代码）
seaicelin的博客
06-08 934
这几天更新了这么多篇文章，其实这些都是并发编程中最基础的知识。现在，我们是时候利用这些知识来写一个小程序了。本篇文章就来介绍如何构建一个用来存储计算结果的高效、可伸缩高速缓存，虽然简单，但也可以说算是对前面知识的一次运用了。 高速缓存，无论是在服务器端还是在前端程序中都有不同形式机制的实现。复用缓存里的结果可以大大缩短程序的等待时间，提高吞吐量。说的通俗一点就是利用空间换时间。在本篇文章中，将一...
java中的Encache一个工具类
11-09
使用Encache进行缓存存取的工具类，java中使用，配置好配置文件就可以使用
Java+redis缓存工具类（SSM）
04-28
直接下载可以运行 就是自己需要创建数据库 很简单 参考实体就行 里面有redis的工具类 可以进行参考
java高效开发26个工具类
11-27
java开发人员必备26个开发工具类，每个方法里面都有注解，通俗易懂。
java并发——构建高效且可伸缩的结果缓存
ly908979139的专栏
04-09 2511
几乎所有的服务器应用都会使用某种形式的缓存。重用之前的计算结果能降低延迟，提高吞吐量，但却要消耗更多内存。看上去简单的缓存，可能会将性能瓶颈转变成伸缩性瓶颈，即使缓存是用来提高单线程性能的。本文将开发一个高效且可伸缩的缓存，用于改进一个高计算开销的计算，我们会从HashMap开始，逐步完善功能，分析它们的并发问题，并讨论如何修改它们。下面基于一个计算任务开始缓存的设计 public interfac
java多线程(十) 之 构建高效且可伸缩的结果缓存
jrymos软件工作室
05-28 548
几乎所有的服务器应用程序都会使用某种形式的缓存,重用之前的计算结果能降低延迟,提高吞吐量,但却需要消耗更多的内存. 本节,我们将开发一个高效且可伸缩的缓存,用于改进一个高计算开销的函数. 我们首先从简单的HashMap开始,然后分析它的并发性缺陷,并讨论如何修复它们.public interface Computable<A, V> { V compute(A arg) throws I
Java缓存工具类
weixin_43863822的博客
07-18 926
Java缓存工具类解决的问题工具类代码 解决的问题 java项目开发时，存在一些情况需要对存入缓存的部分数据进行定时清理，置为失效状态。如登录验证码，存入缓存中设置失效时间，登录时从缓存中获取数据，超时后将缓存中的验证码清空。 关键方法： public synchronized static void put(String key, Object data, long expire) 工具类代码 import java.util.HashMap; import java.util.Map; import
java中的缓存工具类
weixin_45058750的博客
12-16 314
package com.zhizhi.util; import java.util.Map; import java.util.concurrent.ConcurrentHashMap; /** * Map 缓存实现 * Created by winterchen on 2018/4/30. */ public class MapCache { /** * 默认存储1024个缓存 */ private static final int DEFAULT_CACH
Java并发编程：JUC工具类详解
JUC体系主要包括线程池、同步机制、并发容器和并发工具类等。线程池通过`ExecutorService`接口和`ThreadPoolExecutor`类来实现，同步机制包括锁（如`ReentrantLock`）、原子变量（如`AtomicInteger`）和条件变量...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值