• 关于

    java 释放内存

    的搜索结果

回答

java的内存泄漏和C系语言的内存泄露不一样。 c类的内存泄漏指的是有一块内存使用了没有被释放,而且句柄或指针也丢失了(以后也没法释放) java的内存泄漏指的是用完了内存后,这个内存被一些长效对象持有不释放,导致内存占用越来越大的问题,从这个角度来说,java存在内存泄漏的

1296995534731106 2020-03-13 14:19:57 0 浏览量 回答数 0

问题

[@倚贤][¥20]java有没有什么方法可以直接对内存进行操作?垃圾回收机制非常耗内存,有些对象其实用完就可以直接释放了。

黄二刀 2019-12-01 19:27:52 466 浏览量 回答数 2

回答

生活规律告诉我们,在享受便利的同时一般都会付出巨大的代价,如果你在享受了便利的同时,还没有为此付出代价,不是说明没有,只是还没到付出的时候。试问,有哪个Java系统架构师不懂Java虚拟机?纵观Java程序员的发展历程,又有多少人是卡在了Java虚拟机之上。所以如果你还没有感觉到为此付出代价,说明你已经Java虚拟机的糖衣炮弹所击中,且被毒害之深。Java的自动内存管理就是这样,像毒药一样,一旦上瘾就很难戒掉,而且会沉迷于此。而正确的做法就是了解其原理,拿到尚方宝剑,当虚拟机不好好为你提供服务时,拿出宝剑,以便立刻制服他。而此尚方宝剑的锻造需要经历巨大磨难,唯以毅力坚定者方能铸成。Java的内存管理主要两部分,一部分是Java的内存分配,另外一部分是内存的回收。对于这部分内容的了解,首先必须了解清楚Java虚拟机的内存结构。如果对内存结构不熟悉的朋友可以看关于《Java虚拟机的内存结构》这篇文章。我们知道内存可以分为5大块区域,从自动内存管理的角度,线程独占区的内存是比较容易进行管理的,线程创建就要分配这些区域,线程的销毁这些区域也就释放了,因此我们这里主要讨论的主要是关于堆内存和方法区内存的管理。在之前的文章中也提到了虚拟机规范中并没有对方法区这块内存做太多的限制,而且是作为堆内存的一个逻辑部分。下面就分别从内存的分配与内存的回收两个方面来了解Java虚拟机的内存管理。内存分配,内存的分配相比较内存的回收要简单一些,一般有几个原则: 1.对象首先在Eden区域分配。 2.大对象直接进入到老年代。 3.多次存活的对象分配到老年代中。 4.内存分配担保。 5.逃逸分析与栈上分配。 内存回收,这部分涉及的内容就比较多了,首先是内存回收所用到的算法,比如标记对象为垃圾对象的引用计数法以及可达性分析法。在比如垃圾收集算法标记清除算法,复制算法,标记整理算法以及分代收集算法等等。这些理论知识积累了之后就到垃圾收集器,垃圾收集器是执行垃圾回收的具体实现,垃圾收集器有很多,不同的垃圾收集器的适用场景不同,关注点也不同,在不同的环境下选择合适的垃圾收集器并指定合适的参数是一个系统架构师必备的能力。这样对于内存的回收就达到标准了。总结一下主要的内容 0.垃圾对象判断算法 1.垃圾回收算法 2.垃圾收集器 好了,到这里关于java内存管理所需要知识点就都列到这里了,如果你对Java的自动内存管理比较感兴趣,可以观看《深入理解Java虚拟机》这套视频,这里详细的讲解了上面的所有的知识点。

zwt9000 2019-12-02 00:21:45 0 浏览量 回答数 0

阿里云高校特惠,助力学生创业梦!0元体验,快速入门云计算!

学生动手场景应用,快速了解并掌握云服务器的各种新奇玩法!

回答

在函数中定义的一些基本类型的变量和对象的引用变量都是在函数的栈内存中分配,当在一段代码块定义一个变量时,Java 就在栈中为这个变量分配内存空间,当超过变量的作用域后,Java 会自动释放掉为该变量分配的内存空间,该内存空间可以立即被另作它用。从Java的这种分配机制来看,堆栈又可以这样理解:堆栈(Stack)是操作系统在建立某个进程时或者线程(在支持多线程的操作系统中是线程)为这个线程建立的存储区域,该区域具有先进后出的特性。每一个Java应用都唯一对应一个JVM实例,每一个实例唯一对应一个堆。应用程序在运行中所创建的所有类实例或数组都放在这个堆中,并由应用所有的线程 共享.跟C/C++不同,Java中分配堆内存是自动初始化的。Java中所有对象的存储空间都是在堆中分配的,但是这个对象的引用却是在堆栈中分配,也就是说在建立一个对象时从两个地方都分配内存,在堆中分配的内存实际建立这个对象,而在堆栈中分配的内存只是一个指向这个堆对象的指针(引用)而已。

宏卓 2019-12-02 01:48:33 0 浏览量 回答数 0

回答

Java的堆内存是一个运行时数据区,用以保存类的实例(对象),Java虚拟机的堆内存中存储着正在运行的应用程序所建立的所有对象,这些对象不需要程序通过代码来显式地释放。一般来说,堆内存的回收由垃圾回收来负责,所有的JVM实现都有一个由垃圾回收器管理的堆内存。垃圾回收是一种动态存储管理技术,它自动地释放不再被程序引用的对象,按照特定的垃圾回收算法来实现内存资源的自动回收功能。

星尘linger 2020-04-07 09:48:31 0 浏览量 回答数 0

问题

Java关于死循环创建对象释放内存的问题

蛮大人123 2019-12-01 19:32:09 2480 浏览量 回答数 1

回答

Java内存模型定义了一种多线程访问Java内存的规范。Java内存模型要完整讲不是这里几句话能说清楚的,我简单总结一下Java内存模型的几部分内容: (1)Java内存模型将内存分为了主内存和工作内存。类的状态,也就是类之间共享的变量,是存储在主内存中的,每次Java线程用到这些主内存中的变量的时候,会读一次主内存中的变量,并让这些内存在自己的工作内存中有一份拷贝,运行自己线程代码的时候,用到这些变量,操作的都是自己工作内存中的那一份。在线程代码执行完毕之后,会将最新的值更新到主内存中去 (2)定义了几个原子操作,用于操作主内存和工作内存中的变量 (3)定义了volatile变量的使用规则 (4)happens-before,即先行发生原则,定义了操作A必然先行发生于操作B的一些规则,比如在同一个线程内控制流前面的代码一定先行发生于控制流后面的代码、一个释放锁unlock的动作一定先行发生于后面对于同一个锁进行锁定lock的动作等等,只要符合这些规则,则不需要额外做同步措施,如果某段代码不符合所有的happens-before规则,则这段代码一定是线程非安全的

YDYK 2020-04-25 20:09:41 0 浏览量 回答数 0

回答

Java内存模型 按照官方的说法:Java 虚拟机具有一个堆,堆是运行时数据区域,所有类实例和数组的内存均从此处分配。 JVM主要管理两种类型内存:堆和非堆,堆内存(Heap Memory)是在 Java 虚拟机启动时创建,非堆内存(Non-heap Memory)是在JVM堆之外的内存。 堆是Java代码可及的内存,留给开发人员使用的;非堆是JVM留给自己用的,包含方法区、JVM内部处理或优化所需的内存(如 JIT Compiler,Just-in-time Compiler,即时编译后的代码缓存)、每个类结构(如运行时常数池、字段和方法数据)以及方法和构造方法的代码。 JVM 内存包含如下几个部分: 堆内存(Heap Memory): 存放Java对象 非堆内存(Non-Heap Memory): 存放类加载信息和其它meta-data 其它(Other): 存放JVM 自身代码等 Java内存分配 Java的内存管理实际上就是变量和对象的管理,其中包括对象的分配和释放。 JVM内存申请过程如下: JVM 会试图为相关Java对象在Eden中初始化一块内存区域 当Eden空间足够时,内存申请结束;否则到下一步 JVM 试图释放在Eden中所有不活跃的对象(这属于1或更高级的垃圾回收),释放后若Eden空间仍然不足以放入新对象,则试图将部分Eden中活跃对象放入Survivor区 Survivor区被用来作为Eden及OLD的中间交换区域,当OLD区空间足够时,Survivor区的对象会被移到Old区,否则会被保留在Survivor区 当OLD区空间不够时,JVM 会在OLD区进行完全的垃圾收集(0级) 完全垃圾收集后,若Survivor及OLD区仍然无法存放从Eden复制过来的部分对象,导致JVM无法在Eden区为新对象创建内存区域,则出现”out of memory”错误 GC基本原理 GC(Garbage Collection),是JAVA/.NET中的垃圾收集器。 编程人员容易出现问题的地方,忘记或者错误的内存回收会导致程序或系统的不稳定甚至崩溃,Java提供的GC功能可以自动监测对象是否超过作用域从而达到自动回收内存的目的,Java语言没有提供释放已分配内存的显式操作方法。所以,Java的内存管理实际上就是对象的管理,其中包括对象的分配和释放。 对于程序员来说,分配对象使用new关键字;释放对象时,只要将对象所有引用赋值为null,让程序不能够再访问到这个对象,我们称该对象为”不可达的”.GC将负责回收所有”不可达”对象的内存空间。 对于GC来说,当程序员创建对象时,GC就开始监控这个对象的地址、大小以及使用情况。通常,GC采用有向图的方式记录和管理堆(heap)中的所有对象。通过这种方式确定哪些对象是”可达的”,哪些对象是”不可达的”.当GC确定一些对象为”不可达”时,GC就有责任回收这些内存空间。 为了保证 GC能够在不同平台实现的问题,Java规范对GC的很多行为都没有进行严格的规定。例如,对于采用什么类型的回收算法、什么时候进行回收等重要问题都没有明确的规定。 GC分代划分 JVM内存模型中Heap区分两大块,一块是 Young Generation,另一块是Old Generation 在Young Generation中,有一个叫Eden Space的空间,主要是用来存放新生的对象,还有两个Survivor Spaces(from、to),它们的大小总是一样,它们用来存放每次垃圾回收后存活下来的对象。 在Old Generation中,主要存放应用程序中生命周期长的内存对象。 在Young Generation块中,垃圾回收一般用Copying的算法,速度快。每次GC的时候,存活下来的对象首先由Eden拷贝到某个SurvivorSpace,当Survivor Space空间满了后,剩下的live对象就被直接拷贝到OldGeneration中去。因此,每次GC后,Eden内存块会被清空。 在Old Generation块中,垃圾回收一般用mark-compact的算法,速度慢些,但减少内存要求。 垃圾回收分多级,0级为全部(Full)的垃圾回收,会回收OLD段中的垃圾;1级或以上为部分垃圾回收,只会回收Young中的垃圾,内存溢出通常发生于OLD段或Perm段垃圾回收后,仍然无内存空间容纳新的Java对象的情况。增量式GC 增量式GC(Incremental GC),是GC在JVM中通常是由一个或一组进程来实现的,它本身也和用户程序一样占用heap空间,运行时也占用CPU。 当GC进程运行时,应用程序停止运行。当GC运行时间较长时,用户能够感到Java程序的停顿,另外一方面,如果GC运行时间太短,则可能对象回收率太低. 增量式GC就是通过一定的回收算法,把一个长时间的中断,划分为很多个小的中断,通过这种方式减少GC对用户程序的影响。 Sun JDK提供的HotSpot JVM就能支持增量式GC。HotSpot JVM缺省GC方式为不使用增量GC,为了启动增量GC,我们必须在运行Java程序时增加-Xincgc的参数。 HotSpot JVM增量式GC的实现是采用Train GC算法,它的基本想法就是:将堆中的所有对象按照创建和使用情况进行分组(分层),将使用频繁高和具有相关性的对象放在一队中,随着程序的运行,不断对组进行调整。当GC运行时,它总是先回收最老的(最近很少访问的)的对象,如果整组都为可回收对象,GC将整组回收。这样,每次GC运行只回收一定比例的不可达对象,保证程序的顺畅运行。 详解函数finalize 更多内容: https://chenhx.blog.csdn.net/article/details/83957456 https://chenhx.blog.csdn.net/article/details/84294481

谙忆 2019-12-02 03:08:20 0 浏览量 回答数 0

回答

我知道很多人没学过C++,但是面试官就是没事喜欢拿咱们Java和C++比呀!没办法!!!就算没学过C++,也要记下来! 都是面向对象的语言,都支持封装、继承和多态 Java不提供指针来直接访问内存,程序内存更加安全 Java的类是单继承的,C++支持多重继承;虽然Java的类不可以多继承,但是接口可以多继承。 Java有自动内存管理机制,不需要程序员手动释放无用内存

问问小秘 2020-03-27 16:20:13 0 浏览量 回答数 0

回答

Java内存泄漏就是没有及时清理内存垃圾,导致系统无法再给你提供内存资源(内存资源耗尽); 而Java内存溢出就是你要求分配的内存超出了系统能给你的,系统不能满足需求,于是产生溢出。 内存溢出,这个好理解,说明存储空间不够大。就像倒水倒多了,从杯子上面溢出了来了一样。 内存泄漏,原理是,使用过的内存空间没有被及时释放,长时间占用内存,最终导致内存空间不足,而出现内存溢出。

星尘linger 2020-04-13 09:06:52 0 浏览量 回答数 0

回答

GC 是垃圾收集的意思(Gabage Collection),内存处理是编程人员容易出现问题的地方,忘记或者错误的内存 回收会导致程序或系统的不稳定甚至崩溃,Java 提供的 GC 功能可以自动监测对象是否超过作用域从而达到自动 回收内存的目的,Java 语言没有提供释放已分配内存的显示操作方法。 原文链接:https://thinkwon.blog.csdn.net/article/details/104390752

剑曼红尘 2020-03-11 12:54:28 0 浏览量 回答数 0

回答

编写java程序最为方便的地方就是我们不需要管理内存的分配和释放,一切由jvm来进行处理,当java对象不再被应用时,等到堆内存不够用时,jvm会进行垃圾回收,清除这些对象占用的堆内存空间,如果对象一直被应用,jvm无法对其进行回收,创建新的对象时,无法从Heap中获取足够的内存分配给对象,这时候就会导致内存溢出。而出现内存泄露的地方,一般是不断的往容器中存放对象,而容器没有相应的大小限制或清除机制。容易导致内存溢出。 当服务器应用占用了过多内存的时候,如何快速定位问题呢?现在,Eclipse MAT的出现使这个问题变得非常简单。EclipseMAT是著名的SAP公司贡献的一个工具,可以在Eclipse网站下载到它,完全免费的。 要定位问题,首先你需要获取服务器jvm某刻内存快照。jdk自带的jmap可以获取内存某一时刻的快照,导出为dmp文件后,就可以用Eclipse MAT来分析了,找出是那个对象使用内存过多。

小勿悔 2019-12-02 01:03:07 0 浏览量 回答数 0

回答

最简单来说,你写c/c++,自己在堆上申请的内存需要释放,一旦你忘了,就内存泄漏了;而在java/golang这种语言,申请了可以不用管释放,系统gc会自动扫描堆上的变量,如果没有用就进行释放,降低编程压力。

烛昭 2020-03-12 10:03:24 0 浏览量 回答数 0

问题

服务器内存即将耗尽

落地花开啦 2019-12-01 19:23:34 1180 浏览量 回答数 2

问题

java静态变量所占内存

蛮大人123 2019-12-01 20:00:48 988 浏览量 回答数 1

回答

内存泄漏在java中指,申请使用完的内存没有释放,导致虚拟机不能再次使用该内存,此时这段内存就泄露了,因为申请者不用了,而又不能被虚拟机分配给别人用。 可以使用heapdump分析下

sto_or2 2020-03-22 23:19:51 0 浏览量 回答数 0

回答

堆是堆(heap),栈是栈(stack),堆栈是栈。 栈中分配的是基本类型和自定义对象的引用。 堆中分配的是对象,也就是new出来的东西。被所有线程共享。 方法区/静态区 存放的是类信息和static变量、常量。被所有线程共享。 也可以这么理解:堆是用来存放对象的,栈是用来运行程序的。堆:java的垃圾回收器会自动的回收这些不用的数据。缺点是由于要动态的分配内存,存储效率会比较的慢。栈:栈的优势是存取效率比较快,仅次于寄存器,栈数据可以共享。但缺点是栈中的数据大小和生存期的固定的,缺乏灵活性。一般每个方法的调用都会独立有一个栈来保存对象的引用变量,在方法返回后,栈会清空,当在一段代码块定义一个变量时,Java就在栈中为这个变量分配内存空间,当超过变量的作用域后,Java会自动释放掉为该变量所分配的内存空间,该内存空间可以立即被另作他用。

小川游鱼 2019-12-02 01:49:23 0 浏览量 回答数 0

回答

一、内存溢出类型 1、java.lang.OutOfMemoryError: PermGen space JVM管理两种类型的内存,堆和非堆。堆是给开发人员用的上面说的就是,是在JVM启动时创建;非堆是留给JVM自己用的,用来存放类的信息的。它和堆不同,运行期内GC不会释放空间。如果web app用了大量的第三方jar或者应用有太多的class文件而恰好MaxPermSize设置较小,超出了也会导致这块内存的占用过多造成溢出,或者tomcat热部署时侯不会清理前面加载的环境,只会将context更改为新部署的,非堆存的内容就会越来越多。 PermGen space的全称是Permanent Generation space,是指内存的永久保存区域,这块内存主要是被JVM存放Class和Meta信息的,Class在被Loader时就会被放到PermGen space中,它和存放类实例(Instance)的Heap区域不同,GC(Garbage Collection)不会在主程序运行期对PermGen space进行清理,所以如果你的应用中有很CLASS的话,就很可能出现PermGen space错误,这种错误常见在web服务器对JSP进行pre compile的时候。如果你的WEB APP下都用了大量的第三方jar, 其大小超过了jvm默认的大小(4M)那么就会产生此错误信息了。 一个最佳的配置例子:(经过本人验证,自从用此配置之后,再未出现过tomcat死掉的情况) set JAVA_OPTS=-Xms800m -Xmx800m -XX:PermSize=128M -XX:MaxNewSize=256m -XX:MaxPermSize=256m 2、java.lang.OutOfMemoryError: Java heap space 第一种情况是个补充,主要存在问题就是出现在这个情况中。其默认空间(即-Xms)是物理内存的1/64,最大空间(-Xmx)是物理内存的1/4。如果内存剩余不到40%,JVM就会增大堆到Xmx设置的值,内存剩余超过70%,JVM就会减小堆到Xms设置的值。所以服务器的Xmx和Xms设置一般应该设置相同避免每次GC后都要调整虚拟机堆的大小。假设物理内存无限大,那么JVM内存的最大值跟操作系统有关,一般32位机是1.5g到3g之间,而64位的就不会有限制了。 注意:如果Xms超过了Xmx值,或者堆最大值和非堆最大值的总和超过了物理内存或者操作系统的最大限制都会引起服务器启动不起来。 垃圾回收GC的角色 JVM调用GC的频度还是很高的,主要两种情况下进行垃圾回收: 当应用程序线程空闲;另一个是java内存堆不足时,会不断调用GC,若连续回收都解决不了内存堆不足的问题时,就会报out of memory错误。因为这个异常根据系统运行环境决定,所以无法预期它何时出现。 根据GC的机制,程序的运行会引起系统运行环境的变化,增加GC的触发机会。 为了避免这些问题,程序的设计和编写就应避免垃圾对象的内存占用和GC的开销。显示调用System.GC()只能建议JVM需要在内存中对垃圾对象进行回收,但不是必须马上回收, 一个是并不能解决内存资源耗空的局面,另外也会增加GC的消耗。 二、JVM内存区域组成 简单的说java中的堆和栈 java把内存分两种:一种是栈内存,另一种是堆内存 1。在函数中定义的基本类型变量和对象的引用变量都在函数的栈内存中分配; 2。堆内存用来存放由new创建的对象和数组 在函数(代码块)中定义一个变量时,java就在栈中为这个变量分配内存空间,当超过变量的作用域后,java会自动释放掉为该变量所分配的内存空间;在堆中分配的内存由java虚拟机的自动垃圾回收器来管理 堆的优势是可以动态分配内存大小,生存期也不必事先告诉编译器,因为它是在运行时动态分配内存的。缺点就是要在运行时动态分配内存,存取速度较慢; 栈的优势是存取速度比堆要快,缺点是存在栈中的数据大小与生存期必须是确定的无灵活性。 java堆分为三个区:New、Old和Permanent GC有两个线程: 新创建的对象被分配到New区,当该区被填满时会被GC辅助线程移到Old区,当Old区也填满了会触发GC主线程遍历堆内存里的所有对象。Old区的大小等于Xmx减去-Xmn java栈存放 栈调整:参数有+UseDefaultStackSize -Xss256K,表示每个线程可申请256k的栈空间 每个线程都有他自己的Stack 三、JVM如何设置虚拟内存 提示:在JVM中如果98%的时间是用于GC且可用的Heap size 不足2%的时候将抛出此异常信息。 提示:Heap Size 最大不要超过可用物理内存的80%,一般的要将-Xms和-Xmx选项设置为相同,而-Xmn为1/4的-Xmx值。 提示:JVM初始分配的内存由-Xms指定,默认是物理内存的1/64;JVM最大分配的内存由-Xmx指定,默认是物理内存的1/4。 默认空余堆内存小于40%时,JVM就会增大堆直到-Xmx的最大限制;空余堆内存大于70%时,JVM会减少堆直到-Xms的最小限制。因此服务器一般设置-Xms、-Xmx相等以避免在每次GC 后调整堆的大小。 提示:假设物理内存无限大的话,JVM内存的最大值跟操作系统有很大的关系。 简单的说就32位处理器虽然可控内存空间有4GB,但是具体的操作系统会给一个限制, 这个限制一般是2GB-3GB(一般来说Windows系统下为1.5G-2G,Linux系统下为2G-3G),而64bit以上的处理器就不会有限制了 提示:注意:如果Xms超过了Xmx值,或者堆最大值和非堆最大值的总和超过了物理内存或者操作系统的最大限制都会引起服务器启动不起来。 提示:设置NewSize、MaxNewSize相等,"new"的大小最好不要大于"old"的一半,原因是old区如果不够大会频繁的触发"主" GC ,大大降低了性能 JVM使用-XX:PermSize设置非堆内存初始值,默认是物理内存的1/64; 由XX:MaxPermSize设置最大非堆内存的大小,默认是物理内存的1/4。 解决方法:手动设置Heap size 修改TOMCAT_HOME/bin/catalina.bat 在“echo "Using CATALINA_BASE: $CATALINA_BASE"”上面加入以下行: JAVA_OPTS="-server -Xms800m -Xmx800m -XX:MaxNewSize=256m" 四、性能检查工具使用 定位内存泄漏: JProfiler工具主要用于检查和跟踪系统(限于Java开发的)的性能。JProfiler可以通过时时的监控系统的内存使用情况,随时监视垃圾回收,线程运行状况等手段,从而很好的监视JVM运行情况及其性能。 1. 应用服务器内存长期不合理占用,内存经常处于高位占用,很难回收到低位; 2. 应用服务器极为不稳定,几乎每两天重新启动一次,有时甚至每天重新启动一次; 3. 应用服务器经常做Full GC(Garbage Collection),而且时间很长,大约需要30-40秒,应用服务器在做Full GC的时候是不响应客户的交易请求的,非常影响系统性能。 因为开发环境和产品环境会有不同,导致该问题发生有时会在产品环境中发生,通常可以使用工具跟踪系统的内存使用情况,在有些个别情况下或许某个时刻确实是使用了大量内存导致out of memory,这时应继续跟踪看接下来是否会有下降, 如果一直居高不下这肯定就因为程序的原因导致内存泄漏。 五、不健壮代码的特征及解决办法 1、尽早释放无用对象的引用。好的办法是使用临时变量的时候,让引用变量在退出活动域后,自动设置为null,暗示垃圾收集器来收集该对象,防止发生内存泄露。 对于仍然有指针指向的实例,jvm就不会回收该资源,因为垃圾回收会将值为null的对象作为垃圾,提高GC回收机制效率; 2、我们的程序里不可避免大量使用字符串处理,避免使用String,应大量使用StringBuffer,每一个String对象都得独立占用内存一块区域; String str = "aaa"; String str2 = "bbb"; String str3 = str + str2;//假如执行此次之后str ,str2以后再不被调用,那它就会被放在内存中等待Java的gc去回收,程序内过多的出现这样的情况就会报上面的那个错误,建议在使用字符串时能使用StringBuffer就不要用String,这样可以省不少开销; 3、尽量少用静态变量,因为静态变量是全局的,GC不会回收的; 4、避免集中创建对象尤其是大对象,JVM会突然需要大量内存,这时必然会触发GC优化系统内存环境;显示的声明数组空间,而且申请数量还极大。 这是一个案例想定供大家警戒 使用jspsmartUpload作文件上传,运行过程中经常出现java.outofMemoryError的错误, 检查之后发现问题:组件里的代码 m_totalBytes = m_request.getContentLength(); m_binArray = new byte[m_totalBytes]; 问题原因是totalBytes这个变量得到的数极大,导致该数组分配了很多内存空间,而且该数组不能及时释放。解决办法只能换一种更合适的办法,至少是不会引发outofMemoryError的方式解决。 5、尽量运用对象池技术以提高系统性能;生命周期长的对象拥有生命周期短的对象时容易引发内存泄漏,例如大集合对象拥有大数据量的业务对象的时候,可以考虑分块进行处理,然后解决一块释放一块的策略。 6、不要在经常调用的方法中创建对象,尤其是忌讳在循环中创建对象。可以适当的使用hashtable,vector 创建一组对象容器,然后从容器中去取那些对象,而不用每次new之后又丢弃 7、一般都是发生在开启大型文件或跟数据库一次拿了太多的数据,造成 Out Of Memory Error 的状况,这时就大概要计算一下数据量的最大值是多少,并且设定所需最小及最大的内存空间值。 “答案来源于网络,供您参考” 希望以上信息可以帮到您!

牧明 2019-12-02 02:16:21 0 浏览量 回答数 0

回答

Java一直被评选为最好的语言,在语言榜上一直排第一,主要就是在性能和易用性上找到了一个平衡点,GC解决了程序员释放内存的问题,大大的方便了业务开发,除了做业务开发以外,Java语言还是可以做很多工作的,例如,一个著名的UML画图工具Visual Paramdigm就是用java开发的,用起来也特别的好用,Java不适合的就是系统软件,偏底层的,这是这些软件趋于稳定,需求量没有业务开发大,国内大部分的IT行业都是从事应用层次开发的,所以,我认为Java可以在IT行业再坚持10年没有任何问题。

智扬 2019-12-02 01:50:01 0 浏览量 回答数 0

回答

1、Java语言是一门面向对象语言,且语法足够简单; 2、Java避免了C/C++之中复杂的指针关系,而使用了更为简单的引用方式来进行内存传递; 3、Java是为数不多的支持多线程开发的编程语言; 4、Java提供了自动的垃圾收集机制,可以定期释放出无用的垃圾空间; 5、Java语言的安全性较高; 6、Java最大的特点是具备可移植性,即:同一个程序在不同的操作系统上都可以运行。

游客pklijor6gytpx 2019-12-02 03:17:59 0 浏览量 回答数 0

回答

一、Java内存分配     Java虚拟机在执行Java程序的过程中会把它所管理的内存划分为若干个不同的数据区域。这些区域存储不同类型的数据,这些区域的内存分配和销毁的时间也不同,有的区域随着虚拟机进程的启动而存在,有些区域则是依赖用户线程的启动和结束而建立和销毁。根据《Java虚拟机规范(第2版)》的规定,Java虚拟机管理的内存包括五个运行时数据区域,如下图所示:      1、方法区     方法区(Method Area)是各个线程共享的内存区域,它用于存储已被虚拟机加载的类信息(包括类的名称、方法信息、成员变量信息)、常量、静态变量、以及编译器编译后的代码等数据。当方法区无法满足内存分配需求时,将抛出OutOfMemeryError异常。     运行时常量池(Runtime Constant Pool)是方法区的一部分,此区域会在两种情况下存储数据。     (1)class文件的常量池中的数据     class文件中的常量池用于存放编译期生成的各种字面值和常量,这部分内容在类被加载后存放到方法区的运行时常量池中。     字面值:private String name="zhangSan";private int age = 23+3;     常量:private final String TAG = "MainActivity";private final int age = 26;     (2)运行期间生成的常量     运行时常量池相对于class文件常量池的另外一个重要特征是具备动态性,Java语言并不要求常量一定只能在编译期产生,也就是并非预置入class文件中常量池的内容才能进入方法区运行时常量池,运行期间也可能将新的常量放入池中,这种特性被开发人员利用得比较多的便是String类的intern()方法。String str = "abc".intern();当运行时常量池中存在字符串"abc时,将该字符串的引用返回,赋值给str,否则创建字符串"abc",加入运行时常量池中,并返回引用赋值给str。既然运行时常量池是方法区的一部分,自然会受到方法区内存的限制,当常量池无法再申请到内存时会抛出OutOfMemoryError异常。 2、虚拟机栈     虚拟机栈是线程私有的内存空间,每个线程都有一个线程栈,每个方法被执行时都会创建一个栈帧,方法执行完成,栈帧弹出,线程运行结束,线程栈被回收。虚拟机栈就是Java中的方法执行的内存模型,每个方法在执行的同时都会创建一个栈帧,这个栈帧用于存储局部变量表、操作数栈、指向当前方法所属的类的运行时常量池的引用、方法返回地址等信息,每个方法从调用直至执行完成的过程,就对应着一个栈帧在虚拟机栈中入栈到出栈的过程。局部变量表用来存储方法中的局部变量,包括方法中声明的变量以及函数形参。对于基本数据类型的变量,则直接存储它的值,对于引用类型的变量,则存的是指向对象的引用。局部变量表的大小在编译器就可以确定其大小,并且在程序执行期间局部变量表的大小是不会改变的。程序中的所有计算过程都是在借助于操作数栈来完成的。指向运行时常量池的引用,因为在方法执行的过程中有可能需要用到类中的常量,所以必须要有一个引用指向当前方法所属的类的运行时常量池。方法返回地址,当一个方法执行完毕之后,要返回之前调用它的地方,因此在栈帧中必须保存一个方法返回地址。     在Java虚拟机规范中,对这个区域规定了两种异常状况:如果线程请求的栈深度大于虚拟机所允许的深度,将抛出StackOverflowError异常;如果虚拟机栈可以动态扩展(当前大部分的Java虚拟机都可动态扩展,只不过Java虚拟机规范中也允许固定长度的虚拟机栈),当扩展时无法申请到足够的内存时会抛出OutOfMemoryError异常。 3、本地方法栈     本地方法栈也是线程私有的内存空间,本地方法栈与Java栈所发挥的作用是非常相似的,它们之间的区别不过是Java栈执行Java方法,本地方法栈执行的是本地方法,有的虚拟机直接把本地方法栈和虚拟机栈合二为一。 4、堆     Java堆是Java虚拟机所管理的内存中最大的一块,在虚拟机启动时创建,此内存区域的目的就是存放对象实例,几乎所有的对象实例都在这里分配内存。从内存分配的角度来看,线程共享的Java堆中可能划分出多个线程私有的分配缓冲区(TLAB)。Java堆可以处于物理上不连续的内存空间,只要逻辑上连续即可,在实现上,既可以实现固定大小的,也可以是扩展的。如果堆中没有足够的内存分配给实例,并且堆也无法再拓展时,将会抛出OutOfMemeryError异常。     堆是运行时动态分配内存,对象在没有引用变量指向它的时候,才变成垃圾,但是仍然占着内存,在程序空闲的时候(没有工作线程运行,GC线程优先级最低)或者堆内存不足的时候(GC线程被触发),被垃圾回收器释放掉,由于要在运行时动态分配内存,存取速度较慢。 5、程序计数器     程序计数器的作用可以看做是当前线程所执行的字节码的行号指示。字节码解释器工作时就是通过改变这个计数器的值来选取下一条需要执行的字节码指令,分支、循环、跳转、异常处理、线程恢复等基础功能都需要依赖这个计数器来完成。由于Java虚拟机的多线程是通过线程轮流切换并分配处理器执行时间的方式来实现的,在任何一个确定的时刻,一个处理器(对于多核处理器来说是一个内核)只会执行一条线程中的指令。因此,为了线程切换后能恢复到正确的执行位置,每条线程都需要有一个独立的程序计数器,各条线程之间的计数器互不影响,独立存储,我们称这类内存区域为线程私有的内存。如果线程正在执行的是一个Java方法,这个计数器记录的是正在执行的虚拟机字节码指令的地址;如果正在执行的是Natvie方法,这个计数器值则为空。 二、Java内存回收     对于虚拟机栈空间,当方法调用结束后,基本类型变量、引用类型变量、形参占据的空间会被自动释放,但引用类型指向的对象在堆中,堆中的无用内存由垃圾回收线程回收,GC线程优先级最低,只有当没有工作线程存在时GC线程才会执行,或者堆空间不足时会自动触发GC线程工作。除了回收内存,GC线程还负责整理堆中的碎片。 1、四种引用类型     Java中的对象引用分为四种,强引用类型、软引用类型、弱引用类型、虚引用类型。Java中提供这四种引用类型主要有两个目的:第一是可以让程序员通过代码的方式决定某些对象的生命周期;第二是有利于JVM进行垃圾回收。使用软引用和弱引用可以有效的避免oom。软引用关联的对象,只有软引用关联时,才可回收,如果有强引用同时关联,不会回收对象占用的内存,弱引用也如此。 (1)强引用     强引用是使用最普遍的引用,类似Object obj = new Object()、String str = "hello"。如果一个对象具有强引用,那垃圾回收器绝不会回收它。当内存空间不足,Java虚拟机宁愿抛出OutOfMemoryError错误,使程序异常终止,也不会靠随意回收具有强引用的对象来解决内存不足的问题。 (2)软引用(SoftReference)     软引用是用来描述一些有用但并不是必需的对象,在Java中用java.lang.ref.SoftReference类来表示,如果内存空间足够,垃圾回收器就不会回收它;如果内存空间不足了,就会回收这些对象的内存。只要垃圾回收器没有回收它,该对象就可以被程序使用。软引用通常用于网页缓存、图片缓存,防止内存溢出,在内存充足的时候,缓存对象会一直存在,在内存不足的时候,缓存对象占用的内存会被垃圾收集器回收。使用示例: public void testSoftReference() { Map<String,SoftReference<Bitmap>> imagesCache = new HashMap<String,SoftReference<Bitmap>>(); Bitmap bitmap = getBitmap(); SoftReference<Bitmap> image1 = new SoftReference<Bitmap>(bitmap); imagesCache.put("image1",image1); SoftReference<Bitmap> result_SoftReference = imagesCache.get("image1"); Bitmap result_Bitmap = result_SoftReference .get(); } import java.lang.ref.SoftReference; public class Main { public static void main(String[] args) { SoftReference<String> sr = new SoftReference<String>(new String("hello")); System.out.println(sr.get()); } } (3)弱引用(WeakReference)     弱引用也是用来描述非必需对象的,但是它的强度比软引用更弱一些,在java中用java.lang.ref.WeakReference类来表示。当垃圾收集器工作时,无论当前内存是否足够,都会回收掉只被弱引用关联的对象,不过由于垃圾回收器是一个优先级很低的线程,因此不一定会很快发现那些只具有弱引用的对象。弱引用可以用于:单例类持有一个activity引用时,会造成内存泄露,把activity声明为弱引用,在activity销毁后,垃圾收集器扫描到activity对象时,会回收activity对象的内存。使用示例: public class SingleTon1 { private static final SingleTon1 mInstance = null; private WeakReference<Context> mContext; private SingleTon1(WeakReference<Context> context) { mContext = context; } public static SingleTon1 getInstance(WeakReference<Context> context) { if (mInstance == null) { synchronized (SingleTon1.class) { if (mInstance == null) { mInstance = new SingleTon1(context); } } } return mInstance; } } public class MyActivity extents Activity { public void onCreate (Bundle savedInstanceState){ super.onCreate(savedInstanceState); setContentView(R.layout.main); SingleTon1 singleTon1 = SingleTon1.getInstance(new WeakReference<Context>(this)); } }import java.lang.ref.WeakReference; public class Main { public static void main(String[] args) { WeakReference<String> sr = new WeakReference<String>(new String("hello")); System.out.println(sr.get()); System.gc(); //通知JVM的gc进行垃圾回收 System.out.println(sr.get()); } } 输出结果: hellonull     第二个输出结果是null,这说明只要JVM进行垃圾回收,被弱引用关联的对象必定会被回收掉。不过要注意的是,这里所说的被弱引用关联的对象是指只有弱引用与之关联,如果存在强引用同时与之关联,则进行垃圾回收时也不会回收该对象(软引用也是如此)。 (4)虚引用     虚引用和软引用、弱引用不同,它并不影响对象的生命周期,也无法通过虚引用来取得一个对象实例,在java中用java.lang.ref.PhantomReference类表示。如果一个对象与虚引用关联,则跟没有引用与之关联一样,在任何时候都可能被垃圾回收器回收。虚引用必须和引用队列(ReferenceQueue)联合使用,如下: import java.lang.ref.PhantomReference;import java.lang.ref.ReferenceQueue; public class Main { public static void main(String[] args) { ReferenceQueue<String> queue = new ReferenceQueue<String>(); PhantomReference<String> pr = new PhantomReference<String>(new String("hello"), queue); System.out.println(pr.get()); } } 2、垃圾回收算法 (1)标记-清除(Mark-Sweep)    标记-清除(Mark-Sweep)算法,分为标记和清除两个阶段:首先标记出所有需要回收的对象,在标记完成后统一回收掉所有被标记的对象。 标记-清除算法主要问题是:1、效率问题,标记和清除过程的效率很低2、空间问题,标记清除之后会产生大量不连续的内存碎片,空间碎片太多可能会导致,当程序在以后的运行过程中需要分配较大对象时无法找到足够的连续内存而不得不提前触发另一次垃圾收集 (2)复制(Copying)算法     复制算法,它将可用内存按容量划分为大小相等的两块,每次只使用其中的一块。当这一块的内存用完了,就将还存活着的对象复制到另外一块上面,然后再把已使用过的内存空间一次清理掉。这样使得每次都是对其中的一块进行内存回收,内存分配时也就不用考虑内存碎片等复杂情况,只要移动堆顶指针,按顺序分配内存即可,实现简单,运行高效。 复制算法的主要问题是:1、复制算法将内存缩小为原来的一半,过于浪费2、对象存活率较高时就要执行较多的复制操作,造成频繁GC,效率将会变低 (3)标记-整理(Mark-Compact)     标记-整理算法的标记过程仍然与标记-清除算法一样,但后续步骤不是直接对可回收对象进行清理,而是让所有存活的对象都向一端移动,然后直接清理掉端边界以外的内存,这样连续的内存空间就比较多了。     如上图所示,所有存活的对象依次向左上角移动,(0,4)移动到(0,2),(1,0)移动到(0,3),依次类推,当所有的存活对象移动完成后,把剩余的所有空间清空,也就是清空(1,1)后的所有空间。 (4)分代回收(generational collection) 程序创建的大部分对象的生命周期都很短,只有一小部分对象的生命周期比较长,根据这样的规律,一般把Java堆分为Young Generation(新生代),Old Generation(老年代)和Permanent Generation(持久代),上面几种算法是通过分代回收混合在一起的,这样就可以根据各个年代的特点采用最适当的回收算法。 (1)新生代     在新生代中,有一个叫Eden Space的空间,主要是用来存放新生的对象,还有两个Survivor Spaces(from、to), 这两个区域大小相等,相当于copying算法中的两个区域,它们用来存放每次垃圾回收后存活下来的对象。在新生代中,垃圾回收一般用Copying的算法,速度快。     当新建对象无法放入eden区时,将触发minor collection(minorGC 是清理新生代的GC线程,eden的清理,from、to的清理都由MinorGC完成),将eden区与from区的存活对象复制到to区,经过一次垃圾回收,eden区和from区清空,to区中则紧密的存放着存活对象;当eden区再次满时,minor collection将eden区和to区的存活对象复制到from区,eden区和to区被清空,from区存放eden区和to区的存活对象,就这样from区和to区来回切换。如果进行minor collection的时候,发现to区放不下,则将eden区和from区的部分对象放入成熟代。另一方面,即使to区没有满,JVM依然会移动世代足够久远的对象到成熟代。 (2)成熟代     在成熟代中主要存放应用程序中生命周期长的内存对象,垃圾回收一般用mark-compact的算法,速度慢些,但减少内存要求。如果成熟代放满对象,无法从新生代移入新的对象,那么将触发major collection(major GC清理整合OldGen的内存空间)。 (3)永久代    在永久代中,主要用来放JVM自己的反射对象,比如类对象、方法对象、成员变量对象、构造方法对象等。     此外,垃圾回收一般是在程序空闲的时候(没有工作线程,GC线程优先级较低)或者堆内存不足的时候自动触发,也可以调用System.gc()主动的通知Java虚拟机进行垃圾回收,但这只是个建议,Java虚拟机不一定马上执行,启动时机的选择由JVM决定,并且取决于堆内存中Eden区是否可用 作者:喜六六 来源:CSDN 原文:https://blog.csdn.net/qq_29078329/article/details/78929457 版权声明:本文为博主原创文章,转载请附上博文链接!

auto_answer 2019-12-02 01:50:42 0 浏览量 回答数 0

回答

浅谈java的垃圾回收机制的特点: 1.垃圾回收机制的目标是回收无用对象的内存空间(记住:不是对象),这些内存空间是JVM堆内存的内存空间。垃圾回收只回收内存资源,对于那些物理资源,如数据库连接,Socket,I/O流等资源无能无能为力,我们要自己关闭回收。 2.为了加快垃圾回收机制回收那些无用对象所占的内存空间,我们可以讲对象的引用变量置于null(记住:置于null后,垃圾回收机制不会立即执行的)。 3.垃圾回收机制的潜在缺点它的开销会影响性能。Java虚拟机必须跟踪程序中有用的对象才可以确定哪些对象时无用的,并释放那些无用对象所占的内存空间。这个过程要处花费处理器时间的。 4.垃圾回收的不可预知性。我们可以通过Runtime对象的gc()方法或者System.gc()的方法来建议系统进行垃圾回收,但我们不能精确控制垃圾回收机制的运行

景凌凯 2020-04-07 21:23:37 0 浏览量 回答数 0

回答

1、按照Java编程规范,是每次使用的数据库连接对象,都要关闭,释放资源,即时释放内存2、使用连接池,重用连接,减少对象的创建和销毁。3、比较著名的是阿里的Druid连接池,你可以结合ORM框架一起使用

徐雷frank 2019-12-02 01:47:20 0 浏览量 回答数 0

回答

Java服务OOM,最常见的原因为:(1)有可能是内存分配确实过小,而正常业务使用了大量内存;(2)某一个对象被频繁申请,却没有释放,内存不断泄漏,导致内存耗尽;(3)某一个资源被频繁申请,系统资源耗尽,例如:不断创建线程,不断发起网络连接。然后使用以下的命令或工具逐一排查:(一)确认是不是内存本身就分配过小 方法:jmap -heap 10765 可以查看新生代,老生代堆内存的分配大小以及使用情况,看是否本身分配过小。 (二)找到最耗内存的对象 方法:jmap -histo:live 10765 | more 使用该命令后,会以表格的形式显示存活对象的信息,并按照所占内存大小排序,找到最耗内存的对象。 (三)确认是否是资源耗尽 工具:pstree netstat 查看进程创建的线程数,以及网络连接数,如果资源耗尽,也可能出现OOM。

小川游鱼 2019-12-02 01:45:54 0 浏览量 回答数 0

回答

Java服务OOM,最常见的原因为:(1)有可能是内存分配确实过小,而正常业务使用了大量内存;(2)某一个对象被频繁申请,却没有释放,内存不断泄漏,导致内存耗尽;(3)某一个资源被频繁申请,系统资源耗尽,例如:不断创建线程,不断发起网络连接。然后使用以下的命令或工具逐一排查:(一)确认是不是内存本身就分配过小 方法:jmap -heap 10765 可以查看新生代,老生代堆内存的分配大小以及使用情况,看是否本身分配过小。(二)找到最耗内存的对象 方法:jmap -histo:live 10765 | more 使用该命令后,会以表格的形式显示存活对象的信息,并按照所占内存大小排序,找到最耗内存的对象。(三)确认是否是资源耗尽工具:pstree netstat 查看进程创建的线程数,以及网络连接数,如果资源耗尽,也可能出现OOM。

小川游鱼 2019-12-02 01:49:38 0 浏览量 回答数 0

问题

Java 如何让一个线程运行特定的时间终止?

蛮大人123 2019-12-01 20:02:36 1335 浏览量 回答数 2

回答

这个我遇到过,但记不太清了,应该在 DataSender 里做文章。我看看再说######@站在巨人的肩膀上奋斗 AsyncMessage msg提升为类变量######回复 @站在巨人的肩膀上奋斗 : 这个类是第三方提供的######回复 @站在巨人的肩膀上奋斗 : AsyncMessage msg = new AsyncMessage();这个弄成单例的试试######帅哥,我这个问题有结果了吗?期待您的回复######谢谢,麻烦您了######看那个对象多,然后一层一层找######PrecautionPlanModel 这个对象多,但就是前台打开页面的时候才会生成该对象的集合,当下次打开的时候会不会释放呢? AsyncMessage也多,但很少发事件,它怎么也多呢?######new  DataSender().javaToFlex(result);这个为啥是new的######也可以不new的,使用注入,不是这的问题吧?###### @红薯 帮帮忙呀,没人回复呀 伤心呀 ######不会,帮顶######既然是java做后台,可以使用java的一些监测工具 ######自测就用的监控,我已经给出结果了呀######代码看起来没多大问题,看你的样子,JVM的内存设置比较大,只有到达一定比例,JVM才会回收内存。你的报错信息也是可以贴出来的。######是的,设置了3g,跑起来就用了1g,据说是按比例分配的。你说的达到一定的比例才会释放,什么意思?快3g的时候,手动释放都不行。最后看到有两个map和一个message相当占内存######吧所有new出来的局部变量改为全局的一个个的试。 AsyncMessage  NotificationResult我记得就是那个对象没释放,具体的记不得了######大哥,帮我再回忆下,怎么释放呢?######java里面的对象没释放?试试在操作后把对象设置为null。######java虚拟机没有那么脆弱吧######这是什么通信?######我负责后台,通信的方式见图片,相信flex的朋友会知道的

爱吃鱼的程序员 2020-06-03 16:43:40 0 浏览量 回答数 0

回答

何时会内存泄漏:一.资源释放问题:程序代码的问题,长期保持某些资源,如Context,Cursor,IO流的引用,资源得不到释放造成内存泄漏.二.对象内存过大:保存了多个耗用内存过大的对象,如 Bitmap,XML文件,造成内存超出限制。三.static关键字的使用问题:static是java中的一个关键字,当用它修饰成员变量时,那么该变量就属于该类,而不是该类的实例。所以用static修饰的变量,它的生命周期是很长的,如果他用来引用一下资源耗费过多的实例(Context的情况最多),这时就要谨慎对待。-------针对static的解决方案:1)应该尽量避免static成员变量引用资源耗费过多的实例。如Context。2)Context尽量使用ApplicationContext,因为Application的Context的生命周期比较长,引用它不会出现内训泄漏的问题。3)使用WeakReference代替引用,比如可以使用WeakReference mContextRef.四.线程导致内存溢出:线程产生内存泄漏的主要原因是在于线程的生命周期不可控。-------针对这种线程的内存泄漏问题的解决方案:1)将线程的内部类(因为非静态内部类拥有外部类对象的强引用,而静态类则不拥有)。2)在线程内部采用弱引用保存Context的引用。五.查询数据库没有关闭cursor:程序中经常用到会进行查询数据库的操作,但是经常会使用完毕Cursor后没有关闭的情况,如果我们的查询结果集比较小,对内存的消耗不容易被发现,只有在长时间大量操作的情况下才会出现内存问题,这样就会给以后的测试和问题排查带来困难和风险。六.构造Adapter没有复用ConvertView:在使用listview的时候通常使用Adapter,那么 我们应该尽可能的使用ConvertView。为什么要复用ConvertView?当ContertView为空时,用setTag()方法为每一个View绑定一个存放控件的ViewHolder对象,当convertVIew不为空,重复利用已经创建的view的时候,使用getTag()方法获取绑定的ViewHolder对象,这样就避免了findViewById对控件的层层查询,而是快速定位到控件。七.Bitmap不在使用时没有调用recycle()释放内存:有时我们会手动的操作Bitmap对象比较占内存,当它不在被使用的时候,可以调用Bitmap.recycle()方法回收此对象的像素所占的内存,但这不是必须的,视情况而定。内存泄漏会抛哪些异常: OutOfMemoryError异常

小川游鱼 2019-12-02 01:49:36 0 浏览量 回答数 0

回答

不用假设自己管理内存会比虚拟机更智能,大部分小对象和临时创建对象本身就没有很长的生存周期,纠结这一点内存释放的性能没有意义,需要的是更多的关注java整体垃圾回收算法的原理和参数调整对垃圾回收的影响。建议去学习一下现代jvm的垃圾回收机制,看一下分代垃圾回收的原理

yu_hc200 2019-12-02 01:50:07 0 浏览量 回答数 0

回答

了解引用的区别首先要明白GC的机制虽然Java程序员不需要关注内存,但是运行在手机上的内存远远不能和PC比new出一个对象,则在栈区得到了一份引用,如果没有指向任何一个对象,则GC机制会将之放入待回收区等待回收(不可达算法) 普通的声明对象方法都属于强引用,如果没有释放系统会一直保存,当达到系统分配给apk的内存阈值后则产生oom异常如果想系统强制回收一部分内存则引出了弱引用,常见的使用场景有图片浏览,使用WeakReference来引用,则会在内存吃紧的时候强制回收 深入了解的话需要看看JVM相关的书籍,对于Android程序员来说不必太深入,平时积累好良好的编码习惯,多多练习

青楼艾小生 2019-12-02 01:40:10 0 浏览量 回答数 0
阿里云大学 云服务器ECS com域名 网站域名whois查询 开发者平台 小程序定制 小程序开发 国内短信套餐包 开发者技术与产品 云数据库 图像识别 开发者问答 阿里云建站 阿里云备案 云市场 万网 阿里云帮助文档 免费套餐 开发者工具 企业信息查询 小程序开发制作 视频内容分析 企业网站制作 视频集锦 代理记账服务 2020阿里巴巴研发效能峰会 企业建站模板 云效成长地图 高端建站