您的位置:

java数据缓存不被回收,java常量会被回收吗

本文目录一览:

java中静态类变量不使用会被回收吗?

静态类变量不会被释放。只有等应用结束才释放。

1、静态类只有在内部类的时候才能被应用

2、静态类在应用初始化时就放在静态方法区中,是公共共享,应用结束才能回收静态方法区。

java 内存回收不了什么原因

垃圾回收(garbagecollection,简称GC)可以自动清空堆中不再使用的对象。垃圾回收机制最早出现于1959年,被用于解决Lisp语言中的问题。垃圾回收是Java的一大特征。并不是所有的语言都有垃圾回收功能。比如在C/C++中,并没有垃圾回收的机制。程序员需要手动释放堆中的内存。由于不需要手动释放内存,程序员在编程中也可以减少犯错的机会。利用垃圾回收,程序员可以避免一些指针和内存泄露相关的bug(这一类bug通常很隐蔽)。但另一方面,垃圾回收需要耗费的计算时间。垃圾回收实际上是将原本属于程序员的责任转移给计算机。使用垃圾回收的程序需要更长的运行时间。在Java中,对象的是通过引用使用的(把对象相像成致命的毒物,引用就像是用于提取毒物的镊子)。如果不再有引用指向对象,那么程序员就再也无从调用或者处理该对象。这样的对象将不可到达(unreachable)。垃圾回收用于释放不可到达对象所占据的内存。这是垃圾回收的基本原则。(不可到达对象是死对象,是垃圾回收所要回收的垃圾)早期的垃圾回收采用引用计数(referencecounting)的机制。每个对象包含一个计数器。当有新的指向该对象的引用时,计数器加1。当引用移除时,计数器减1。当计数器为0时,认为该对象可以进行垃圾回收。然而,一个可能的问题是,如果有两个对象循环引用(cyclicreference),比如两个对象互相引用,而且此时没有其它(指向A或者指向B)的引用,程序员实际上根本无法通过引用到达这两个对象。因此,程序员以栈和static数据为根(root),从根出发,跟随所有的引用,就可以找到所有的可到达对象。也就是说,一个可到达对象,一定被根引用,或者被其他可到达对象引用。

java 怎么把数据存到内存中

这里你采纳与否没关系,给你说说编程与内存的关系。

你定义的任何变量,常量,类,方法等等,其实都在内存中,没有所谓的把数据存内存中,这概念,你可以想一下电脑重启或关机后,内存中的所有数据,都会丢失,除非你保存到磁盘中去。

在内存中的数据有两块,第一、缓冲,一般写数据到磁盘的时候开辟出来的内存空间;第二、缓存,一般是从磁盘读数据到内存中开辟出来的内存空间。会这么使用,原因很简单,磁盘读写数据速度与内存不一致(磁盘的存取效率远远小于内存的存取效率),为了提高数据的存取效率,才会这么干的。

一般而言,java中的所谓数据,大部分都是类,从自动引用计数的概念来分析,你想把对象长久的放在内存中,不会被垃圾回收机制释放,注意制药有一个对象在使用/引用你的数据,这条数据就会存在内存中。所以,想servlet中的全局配置参数,随时可以取到还是唯一一份,你可以参考一下。

另外内存使用分堆与栈,堆在面向对象编程中存储对象的,栈是方法或函数执行的时候临时开辟的存储空间,方法或函数执行完毕就会释放。

希望我的回复能帮助到你,采纳与否没关系。有更好的答案,我就隐藏我的回复。

java集合类中有对对象的引用,使用完后未清空,使得JVM不能回收(求例子)并且附上解决方法

我明白你的意思。

这种情况可能的结果是出现异常类:OutOfMemoryError(内存溢出)。

产生的原因其中之一就是 集合类中对对象的引用,使用完未清空,使得JVM不能回收。

可以这样子清空,代码如下:

Set set = new HashSet();

/*中间这部分是使用set的代码...,最后clear()清空*/

set.clear();

随信附上出现内存溢出异常时常用的解决办法(转自Java面试那些事):

检查代码中是否有死循环或递归调用。

检查是否有大循环重复产生新对象实体。

检查对数据库查询中,是否有一次获得全部数据的查询。一般来说,如果一次取十万条记录到内存,就可能引起内存溢出。这个问题比较隐蔽,在上线前,数据库中数据较少,不容易出问题,上线后,数据库中数据多了,一次查询可能就会引起内存溢出。因此对于数据库查询尽量采用分页的方式查询。

检查List、Map等集合对象是否使用完未清除的问题,List、Map等集合对象会始终存有对对象的引用,使得这些对象不能被GC回收。

检查对大文件的读取是否采用nio的方式。(这块我不懂,你可以百度看看,也欢迎你跟我交流。)

望采纳,谢谢。(●'◡'●)

java google 的内存缓存为什么总调用cacheloader

首先,看一下使用范例:

Java代码

LoadingCacheKey,Graph graphs =CacheBuilder.newBuilder()

.maximumSize(1000)

.expireAfterWrite(10,TimeUnit.MINUTES)

.removalListener(MY_LISTENER)

.build(

newCacheLoaderKey,Graph(){

publicGraph load(Key key)throwsAnyException{

return createExpensiveGraph(key);

}

});

适用性

缓存在很多情况下都是非常有用的。比如,我们需要多次根据给定的输入获取值,而且该值计算或者获取的开销是非常昂贵的。

缓存和ConcurrentMap是非常相像的,但是它们也不完全一样。最根本的区别就是,ConcurrentMap会持有所有添加的对象,直到被显示的移除。而缓存为了限制其内存的使用,通常都会配置成可以自动的将对象移除。在某些情况下即使不自动移除对象也是非常有用的,如LoadingCache它会自动加载缓存对象。

一般,Guava缓存适用于以下几种情况:

你愿意花费一些内存来换取性能提升;

你预测到某些键会多次进行查询;

你的缓存数据不超过内存(Guava缓存是单个应用中的本地缓存。它不会将数据存储到文件中,或者外部服务器。如果不适合你,可以考虑一下 Memcached)。

如果你的需要符合上面所说的每一条,那么选择Guava缓存绝对没错。

使用CacheBuilder的构建模式可以获取一个Cache,如上面的范例所示。但是如何进行定制才是比较有趣的。

注意:如果你不需要缓存的这些特性,那么使用ConcurrentHashMap会有更好的内存效率,但是如果想基于旧有的ConcurrentMap复制实现Cache的一些特性,那么可能是非常困难或者根本不可能。

加载

对于缓存首先需要明确的是:有没有一个方法可以通过给定的键来计算/加载相应的值?如果有,那么可以使用CacheLoader。如果没有这样的方法,或者你想复写缓存的加载方式,但你仍想保留“get-if-absent-compute”语义,你可以在调用get方法时传入一个Callable实例,来达到目的。缓存的对象可以通过Cache.put直接插入,但是自动加载是首选,因为自动加载可以更加容易的判断所有缓存信息的一致性。

From a CacheLoader

LoadingCache 缓存是通过一个CacheLoader来构建缓存。创建一个CacheLoader仅需要实现V load(K key) throws Exception方法即可。下面的范例就是如何创建一个LoadingCache:

Java代码

LoadingCacheKey,Graph graphs =CacheBuilder.newBuilder()

.maximumSize(1000)

.build(

newCacheLoaderKey,Graph(){

publicGraph load(Key key)throwsAnyException{

return createExpensiveGraph(key);

}

});

...

try{

return graphs.get(key);

}catch(ExecutionException e){

thrownewOtherException(e.getCause());

}

通过方法get(K)可以对LoadingCache进行查询。该方法要不返回已缓存的值,要不通过CacheLoader来自动加载相应的值到缓存中。这里需要注意的是:CacheLoader可能会抛出Exception,LoaderCache.get(K)则可能会抛出ExecutionException。假如你定义的CacheLoader没有声明检查型异常,那么可以通过调用getUnchecked(K)来获取缓存值;但是一旦当CacheLoader中声明了检查型异常,则不可以调用getUnchecked。

Java代码

LoadingCacheKey,Graph graphs =CacheBuilder.newBuilder()

.expireAfterAccess(10,TimeUnit.MINUTES)

.build(

newCacheLoaderKey,Graph(){

publicGraph load(Key key){// no checked exception

return createExpensiveGraph(key);

}

});

...

return graphs.getUnchecked(key);

批量查询可以使用getAll(Iterable? extends K)方法。缺省,getAll方法将循环每一个键调用CacheLoader.load方法获取缓存值。当缓存对象的批量获取比单独获取更有效时,可以通过复写CacheLoader.loadAll方法实现缓存对象的加载。此时当调用getAll(Iterable)方法时性能也会提升。

需要注意的是CacheLoader.loadAll的实现可以为没有明确要求的键加载缓存值。比如,当为某组中的一些键进行计算时,loadAll方法则可能会同时加载组中其余键的值。

From a Callable

所有Guava缓存,不论是否会自动加载,都支持get(K, Callable(V))方法。当给定键的缓存值已存在时则直接返回,否则通过指定的Callable方法进行计算并将值存放到缓存中。直到加载完成时,相应的缓存才会被更改。该方法简单实现了"if cached, return; otherwise create, cache and return"语义。

Java代码

CacheKey,Value cache =CacheBuilder.newBuilder()

.maximumSize(1000)

.build();// look Ma, no CacheLoader

...

try{

// If the key wasn't in the "easy to compute" group, we need to

// do things the hard way.

cache.get(key,newCallableValue(){

@Override

publicValue call()throwsAnyException{

return doThingsTheHardWay(key);

}

});

}catch(ExecutionException e){

thrownewOtherException(e.getCause());

}

直接插入

使用cache.put(key, value)方法可以将值直接插入到缓存中,但这将会覆盖缓存中已存在的值。通过使用Cache.asMap()所导出的ConcurrentMap对象中的方法也可以对缓存进行修改。但是,请注意asMap中的任何方法都不能自动的将数据加载到缓存中。也就是说,asMap中的各方法是在缓存自动加载范围之外来运作。所以,当你使用CacheLoader或Callable来加载缓存时,应该优先使用Cache.get(K, CallableV),而不是Cache.asMap().putIfAbsent。

缓存回收

残酷的现实是我们可以肯定的说我们没有足够的内存来缓存一切。你必须来决定:什么时候缓存值不再值得保留?Guava提供了三种基本的缓存回收策略:基于容量回收策略,基于时间回收策略,基于引用回收策略。

基于容量回收策略

使用CacheBuilder.maximumSize(long)可以设置缓存的最大容量。缓存将会尝试回收最近没有使用,或者没有经常使用的缓存项。警告:缓存可能会在容量达到限制之前执行回收,通常是在缓存大小逼近限制大小时。

另外,如果不同的缓存项有不同的“权重”, 如,缓存项有不同的内存占用,此时你需要使用CacheBuilder.weigher(Weigher)指定一个权重计算函数,并使用CacheBuilder.maxmumWeight(long)设定总权重。和maximumSize同样需要注意的是缓存也是在逼近总权重的时候进行回收处理。此外,缓存项的权重是在创建时进行计算,此后不再改变。

Java代码

LoadingCacheKey,Graph graphs =CacheBuilder.newBuilder()

.maximumWeight(100000)

.weigher(

newWeigherKey,Graph(){

publicint weigh(Key k,Graph g){

return g.vertices().size();

}

})

.build(

newCacheLoaderKey,Graph(){

publicGraph load(Key key){// no checked exception

return createExpensiveGraph(key);

}

});

基于时间回收策略

CacheBuilder为基于时间的回收提供了两种方式:

expireAfterAccess(long, TimeUnit) 当缓存项在指定的时间段内没有被读或写就会被回收。这种回收策略类似于基于容量回收策略;

expireAfterWrite(long, TimeUnit) 当缓存项在指定的时间段内没有更新就会被回收。如果我们认为缓存数据在一段时间后数据不再可用,那么可以使用该种策略。

就如下面的讨论,定时过期回收会在写的过程中周期执行,偶尔也会读的过程中执行。

测试定时回收

测试定时回收其实不需要那么痛苦的,我们不必非得花费2秒来测试一个2秒的过期。在构建缓存时使用Ticker接口,并通过CacheBuilder.ticker(Ticker)方法指定时间源,这样我们就不用傻乎乎等系统时钟慢慢的走了。

基于引用回收策略

通过键或缓存值的弱引用(weak references),或者缓存值的软引用(soft references),Guava可以将缓存设置为允许垃圾回收。

CacheBuilder.weakKeys() 使用弱引用存储键。当没有(强或软)引用到该键时,相应的缓存项将可以被垃圾回收。由于垃圾回收是依赖==进行判断,因此这样会导致整个缓存也会使用==来比较键的相等性,而不是使用equals();

CacheBuilder.weakValues() 使用弱引用存储缓存值。当没有(强或软)引用到该缓存项时,将可以被垃圾回收。由于垃圾回收是依赖==进行判断,因此这样会导致整个缓存也会使用==来比较缓存值的相等性,而不是使用equals();

CacheBuilder.softValues() 使用软引用存储缓存值。当响应需要时,软引用才会被垃圾回收通过最少使用原则回收掉。由于使用软引用造成性能上的影响,我们强烈建议使用可被预言的maximum cache size的策略来代替。同样使用softValues()缓存值的比较也是使用==,而不是equals()。

显示移除

在任何时候,你都可以可以通过下面的方法显式将无效的缓存移除,而不是被动等待被回收:

使用Cache.invalidate(key)单个移除;

使用Cache.invalidteAll(keys)批量移除;

使用Cache.invalidateAll()移除全部。

Java中数据库连接池是如何做到,将Connection作为对象放入内存中不被回收机回收?

纠正下你的说法.一个类是不会无缘无故运行的,所以谈不上占用内存,更没有回收.你问的应该是使用一个类创建了一个对象,如何回收该对象所占的内存空间?

例如有一个Person类,我们创建他的一个对象,一般是如下:

Person mPerson = new Person();

这个时候情况是,在栈内存中标记了一个名字叫mPerson的空间,它存储了一个关于某块内存区域位置的信息,说白了,就是你使用new Person();创建出来的对象的位置,我们称mPerson为Person对象的一个引用。这个对象位于堆内存,它是有默认值的,必须占内存一部分空间,想使用的时候,可以通过mPerson找到它。当你把mPerson赋值为null后,你那个对象就没有引用了,这个时候,你的JVM会在适当的时候自动去回收掉Person的对象。