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

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倍,这个决定于循环的次数

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

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

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

  1. java并发编程实战学习(3)--基础构建模块

    转自:java并发编程实战 5.3阻塞队列和生产者-消费者模式 BlockingQueue阻塞队列提供可阻塞的put和take方法,以及支持定时的offer和poll方法.如果队列已经满了,那么put ...

  2. 《java并发编程实战》读书笔记4--基础构建模块,java中的同步容器类&并发容器类&同步工具类,消费者模式

    上一章说道委托是创建线程安全类的一个最有效策略,只需让现有的线程安全的类管理所有的状态即可.那么这章便说的是怎么利用java平台类库的并发基础构建模块呢? 5.1 同步容器类 包括Vector和Has ...

  3. Java并发编程实战 第5章 构建基础模块

    同步容器类 Vector和HashTable和Collections.synchronizedXXX 都是使用监视器模式实现的. 暂且不考虑性能问题,使用同步容器类要注意: 只能保证单个操作的同步. ...

  4. java并发编程实战笔记---(第五章)基础构建模块

    . 5.1同步容器类 1.同步容器类的问题 复合操作,加容器内置锁 2.迭代器与concurrentModificationException 迭代容器用iterator, 迭代过程中,如果有其他线程 ...

  5. 《Java并发编程实战》读书笔记-第5章 基础构建模块

    同步容器类 同步容器类实现线程安全的方式:将所有状态封装起来,对每个公有方法使用同步,使得每一次只有一个线程可以访问.同步容器类包含:Vector.Hashtable.Collections.sync ...

  6. 《Java并发编程实战》/童云兰译【PDF】下载

    <Java并发编程实战>/童云兰译[PDF]下载链接: https://u253469.pipipan.com/fs/253469-230062521 内容简介 本书深入浅出地介绍了Jav ...

  7. Java并发(具体实例)—— 构建高效且可伸缩的结果缓存

    这个例子来自<Java并发编程实战>第五章.本文将开发一个高效且可伸缩的缓存,文章首先从最简单的HashMap开始构建,然后分析它的并发缺陷,并一步一步修复. hashMap版本     ...

  8. Java并发编程实战——读后感

    未完待续. 阅读帮助 本文运用<如何阅读一本书>的学习方法进行学习. P15 表示对于书的第15页. Java并发编程实战简称为并发书或者该书之类的. 熟能生巧,不断地去理解,就像欣赏一部 ...

  9. 【java并发编程实战】-----线程基本概念

    学习Java并发已经有一个多月了,感觉有些东西学习一会儿了就会忘记,做了一些笔记但是不系统,对于Java并发这么大的"系统",需要自己好好总结.整理才能征服它.希望同仁们一起来学习 ...

  10. 《java并发编程实战》笔记

    <java并发编程实战>这本书配合并发编程网中的并发系列文章一起看,效果会好很多. 并发系列的文章链接为:  Java并发性和多线程介绍目录 建议: <java并发编程实战>第 ...

随机推荐

  1. jieba中文分词的.NET版本:jieba.NET

    简介 平时经常用Python写些小程序.在做文本分析相关的事情时免不了进行中文分词,于是就遇到了用Python实现的结巴中文分词.jieba使用起来非常简单,同时分词的结果也令人印象深刻,有兴趣的可以 ...

  2. Senparc.Weixin.MP SDK 微信公众平台开发教程(十七):个性化菜单接口说明

    前不久微信上线了个性化菜单接口,Senparc.Weixin SDK也已经同步更新. 本次更新升级Senparc.Weixin.MP版本到v13.5.2,依赖Senparc.Weixin版本4.5.4 ...

  3. Unity 特殊文件夹 : 位置不能随便放

    有以下几个文件夹: Assets 用来存放资源的文件夹,包括各种材质.模型等 Editor 编辑器类等脚本 Editor Default Resources Editor scripts can ma ...

  4. C标准库-数值字符串转换与内存分配函数

    原文链接:http://www.orlion.ga/977/ 一.数值字符串转换函数 #include <stdlib.h> int atoi(const char *nptr); dou ...

  5. 深入理解DOM节点类型第三篇——注释节点和文档类型节点

    × 目录 [1]注释节点 [2]文档类型 前面的话 把注释节点和文档类型节点放在一起是因为IE8-浏览器的一个bug.IE8-浏览器将标签名为"!"的元素视作注释节点,所以文档声明 ...

  6. Markdown编辑器入门

    欢迎使用博客园的Markdown编辑器 前言 今天早上起来在Ubuntu下操作,所以不能使用Windows Live Writer.所以就直接使用博客园的后台编辑器,开始以为博客园出错了,怎么编辑都没 ...

  7. iOS开发之自定义表情键盘(组件封装与自动布局)

    下面的东西是编写自定义的表情键盘,话不多说,开门见山吧!下面主要用到的知识有MVC, iOS开发中的自动布局,自定义组件的封装与使用,Block回调,CoreData的使用.有的小伙伴可能会问写一个自 ...

  8. C语言 第五章 循环结构练习

    一.计算15+16+17 …98+99的和 for实现 #include "stdio.h" void main() { //15+16+17 …98+99 ; ;i<=;i ...

  9. 搭建SSH详细步骤及相关说明

    因为手里已有相关jar,为方便我搭建的是:Struts2.0+Hibernate3.3+Spring3.0,数据库:MySQL 如果想搭建最新的,在官网上下载最新jar即可. 这里会对比MyEclip ...

  10. 如何使用SOIL在VS2012的 C++环境下显示图片

    先看下效果. 这是一个很无聊的功能....首先说下,我做这个功能的初衷并不是为了实现在控制台中显示图片...(这貌似很无聊) 而是因为自己想做用C做一个游戏:http://q.cnblogs.com/ ...