你的数据非常大，那你写入内存会不会比较占资源，为什么不用异步刷新，让它显示不部分再慢慢加载
Ⅱ java如何实现一千万条数据的计算而内存不会溢出
这跟大数据查询优化的方法差不多，毕竟数据量在那里，不可能单靠一种方式就能解决。
1）、硬件要求不用说了，表空间，内存等分配最大；
2）、如果大表已经做过分表最好，其次就是常用查询用的字段加索引(有时候效果很明显)；
3）、SQL语句方面，用exist代替in，查询大表前小表后，过滤条件方最后，大条件方最后，
尽量用表关联查询减少子查询，避免在索引上试用计算；
4）、程序方面；尽量减少在同一循环内做复杂计算，多条件计算等。
5）、采用缓存技术，避免大数据的重复查询。
Ⅲ 使用java实现以个简单的缓存机制
你这个分数太少了吧，程序到是有，不过给你有点可惜
CacheMgr.java
import java.util.*;
import cn.javass.framework.cache.vo.CacheConfModel;
public class CacheMgr {
private static Map cacheMap = new HashMap();
private static Map cacheConfMap = new HashMap();
private CacheMgr(){
}
private static CacheMgr cm = null;
public static CacheMgr getInstance(){
if(cm==null){
cm = new CacheMgr();
Thread t = new ClearCache();
t.start();
}
return cm;
}
/**
* 增加缓存
* @param key
* @param value
* @param ccm 缓存对象
* @return
*/
public boolean addCache(Object key,Object value,CacheConfModel ccm){
boolean flag = false;
cacheMap.put(key, value);
cacheConfMap.put(key, ccm);
System.out.println("now addcache=="+cacheMap.size());
return true;
}
/**
* 删除缓存
* @param key
* @return
*/
public boolean removeCache(Object key){
cacheMap.remove(key);
cacheConfMap.remove(key);
System.out.println("now removeCache=="+cacheMap.size());
return true;
}
/**
* 清除缓存的类
* @author wanglj
* 继承Thread线程类
*/
private static class ClearCache extends Thread{
public void run(){
while(true){
Set tempSet = new HashSet();
Set set = cacheConfMap.keySet();
Iterator it = set.iterator();
while(it.hasNext()){
Object key = it.next();
CacheConfModel ccm = (CacheConfModel)cacheConfMap.get(key);
//比较是否需要清除
if(!ccm.isForever()){
if((new Date().getTime()-ccm.getBeginTime())>= ccm.getDurableTime()*60*1000){
//可以清除，先记录下来
tempSet.add(key);
}
}
}
//真正清除
Iterator tempIt = tempSet.iterator();
while(tempIt.hasNext()){
Object key = tempIt.next();
cacheMap.remove(key);
cacheConfMap.remove(key);
}
System.out.println("now thread================>"+cacheMap.size());
//休息
try {
Thread.sleep(60*1000L);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
}
CacheConfModel.java
public class CacheConfModel implements java.io.Serializable{
private long beginTime;
private boolean isForever = false;
private int rableTime;
public long getBeginTime() {
return beginTime;
}
public void setBeginTime(long beginTime) {
this.beginTime = beginTime;
}
public boolean isForever() {
return isForever;
}
public void setForever(boolean isForever) {
this.isForever = isForever;
}
public int getDurableTime() {
return rableTime;
}
public void setDurableTime(int rableTime) {
this.rableTime = rableTime;
}
}
顺便说一句，缓存的管理不是靠时间久来计算的，是靠最大不活动间隔计算的，你的设计思想有问题
Ⅳ Java的缓存机制，不解
缓存也是内存，静态map只是分配一个固定内存空间而已，后面的缓存机制还得自己去弄的
Ⅳ java缓存框架的使用步骤是怎么样的
用ehcache或者redis。ehcache就是本地能用，redis是分布式缓存。用法你找下看看就知道了。缓存存的就是key value。找个例子看下就知道怎么用了
Ⅵ 请教java中怎么缓存大量的数据，比如100w条记录
小子，解决问题的思路首先就不对，什么叫JAVA中……JVM虚拟内存一般只有几百M，为何别人那么多大型系统都能跑起来？
第一，大量的数据是不会考虑放在JVM内存中；
第二，如果需要缓存大量的dto，动态数据（又称过程数据）一般用的是redis；如果是静态，系统启动时就加载的大量配置，一般考虑放ehcache。
第三，由于redis用的是物理内存，不是JVM内存，一般情况下往redis里丢千万级别的记录数基本不影响性能，小小100w条算什么呢。
Ⅶ java内存或者是缓存管理怎么实现
我不太清楚你为什么用map来存放数据？你用什么作为key呢？如果是我做的话我会自定义一个对象，里面大体上有如下属性：发言人、发言时间、发言内容等。然后用list存放这些对象，list是由顺序的。如果长度到达一定值可以把最先放进去的对象清除掉或移动到其他地方。
Ⅷ java怎样将数据保存到缓存中，之后再保存
Java中可以使用队列来保存数据，当使用的时候，加上锁，防止其他进程访问，当不用的时候保存到数据库里面，示例如下：
packagecom.henry;
importjava.util.HashMap;
importjava.util.Map;
importjava.util.Random;
importjava.util.concurrent.locks.ReadWriteLock;
importjava.util.concurrent.locks.ReentrantReadWriteLock;
publicclassCacheDataTest{
staticMap<Integer,Object>dataMap=newHashMap<Integer,Object>();
staticReadWriteLocklock=newReentrantReadWriteLock();//创建读写锁的实例
staticObjectgetData(Integerkey){
lock.readLock().lock();//读取前先上锁
Objectval=null;
try{
val=dataMap.get(key);
if(val==null){
//
lock.readLock().unlock();
lock.writeLock().lock();
try{
//可能已经由其他线程写入数据
if(val==null){
//dataMap.put(key,"");//queryfromdb
val=queryDataFromDB(key);
}
}finally{
//
lock.readLock().lock();
//Unlockwrite,stillholdread
lock.writeLock().unlock();
}
}
}finally{
lock.readLock().unlock();//最后一定不要忘记释放锁
}
System.out.println("getdatakey="+key+">val="+val);
returnval;
}
staticObjectqueryDataFromDB(Integerkey){
Objectval=newRandom().nextInt(1000);
dataMap.put(key,val);
System.out.println("writeintodatakey="+key+">val="+val);
returnval;
}
publicstaticvoidmain(String[]args){
for(inti=0;i<10;i++){
newThread(newRunnable(){publicvoidrun(){
getData(newRandom().nextInt(5));
}}).start();
}
}
}
Ⅸ java中map可否限制key的数量
在JDK中提供了一个相当用价值的主要用于缓存的Map实现—— LinkedHashMap 。
LinkedHashMap的迭代顺序就是最后访问其条目的顺序，从近期访问最少到近期访问最多的顺序。
详情可参考JKD中关于LinkedHashMap的API文档。
你需要做的就是继承LinkedHashMap 并重写removeEldestEntry方法。
示例如下：
privatestaticfinalintMAX_ENTRIES=100;
(Map.Entry<K,V>eldest){
//当前记录数大于设置的最大的记录数，删除最旧记录（即最近访问最少的记录）
returnsize()>MAX_ENTRIES;
}
Ⅹ java面试问到java缓存有多少种实现方式
我知道的有两种
缓存数据放内存里，key-value键值对，存取都快。redis、ehcache
放数据库，让数据库的定时策略自动删除。mongodb
还有些是直接存文件的.OSCache(不太熟悉)