大家在进行程序系统维护的时候是否因为java编程的内存管理问题而无法快速解决导致系统出错呢?下面我们就一起来了解和学习一下，关于java编程内存管理都有哪些知识点。

程序计数器(了解)程序计数器，可以看做是当前线程所执行的字节码的行号指示器。

在虚拟机的概念模型里，字节码解释器工作就是通过改变程序计数器的值来选择下一条需要执行的字节码指令，分支、循环、跳转、异常处理、线程恢复等基础功能都要依赖这个计数器来完成。

Java虚拟机栈(了解)Java虚拟机栈也是线程私有的，它的生命周期与线程相同。

虚拟机栈描述的是Java方法执行的内存模型：每个方法在执行的同时都会创建一个栈帧用于存储局部变量表、操作数栈、动态链表、方法出口信息等。

每一个方法从调用直至执行完成的过程，就对应着一个栈帧在虚拟机栈中入栈到出栈的过程。

局部变量表中存放了编译器可知的各种基本数据类型(boolean、byte、char、short、int、float、long、double)、对象引用和returnAddress类型(指向了一条字节码指令的地址)。

如果扩展时无法申请到足够的内存，就会抛出OutOfMemoryError异常。

本地方法栈(了解)本地方法栈与虚拟机的作用相似，不同之处在于虚拟机栈为虚拟机执行的Java方法服务，而本地方法栈则为虚拟机使用到的Native方法服务。

有的虚拟机直接把本地方法栈和虚拟机栈合二为一。

会抛出stackOverflowError和OutOfMemoryError异常。

Java堆堆内存用来存放由new创建的对象实例和数组。

(重点)Java堆是所有线程共享的一块内存区域，在虚拟机启动时创建，此内存区域的目的就是存放对象实例。

Java堆是垃圾收集器管理的主要区域。

java课程培训机构http://www.kmbdqn.cn/发现由于现在收集器基本采用分代回收算法，所以Java堆还可细分为：新生代和老年代。

从内存分配的角度来看，线程共享的Java堆中可能划分出多个线程私有的分配缓冲区(TLAB)。

首先

创建一个Bean用来存贮要得到的信

public class MonitorInfoBean {

/** 可使用内存. */

private long totalMemory

/** 剩余内存. */

private long freeMemory

/** 最大可使用内存. */

private long maxMemory

/** 操作系统. */

private String osName

/** 总的物理内存. */

private long totalMemorySize

/** 剩余的物理内存. */

private long freePhysicalMemorySize

/** 已使用的物理内存. */

private long usedMemory

/** 线程总数. */

private int totalThread

/** cpu使用率. */

private double cpuRatio

public long getFreeMemory() {

return freeMemory

}

public void setFreeMemory(long freeMemory) {

this.freeMemory = freeMemory

}

public long getFreePhysicalMemorySize() {

return freePhysicalMemorySize

}

public void setFreePhysicalMemorySize(long freePhysicalMemorySize) {

this.freePhysicalMemorySize = freePhysicalMemorySize

}

public long getMaxMemory() {

return maxMemory

}

public void setMaxMemory(long maxMemory) {

this.maxMemory = maxMemory

}

public String getOsName() {

return osName

}

public void setOsName(String osName) {

this.osName = osName

}

public long getTotalMemory() {

return totalMemory

}

public void setTotalMemory(long totalMemory) {

this.totalMemory = totalMemory

}

public long getTotalMemorySize() {

return totalMemorySize

}

public void setTotalMemorySize(long totalMemorySize) {

this.totalMemorySize = totalMemorySize

}

public int getTotalThread() {

return totalThread

}

public void setTotalThread(int totalThread) {

this.totalThread = totalThread

}

public long getUsedMemory() {

return usedMemory

}

public void setUsedMemory(long usedMemory) {

this.usedMemory = usedMemory

}

public double getCpuRatio() {

return cpuRatio

}

public void setCpuRatio(double cpuRatio) {

this.cpuRatio = cpuRatio

}

}

之后，建立bean的接口

public interface IMonitorService {

public MonitorInfoBean getMonitorInfoBean() throws Exception

}

然后，就是最关键的，得到cpu的利用率，已用内存，可用内存，最大内存等信息。

import java.io.InputStreamReader

import java.io.LineNumberReader

import sun.management.ManagementFactory

import com.sun.management.OperatingSystemMXBean

import java.io.*

import java.util.StringTokenizer

/**

* 获取系统信息的业务逻辑实现类.

* @author GuoHuang

*/

public class MonitorServiceImpl implements IMonitorService {

private static final int CPUTIME = 30

private static final int PERCENT = 100

private static final int FAULTLENGTH = 10

private static final File versionFile = new File("/proc/version")

private static String linuxVersion = null

/**

* 获得当前的监控对象.

* @return 返回构造好的监控对象

* @throws Exception

* @author GuoHuang

*/

public MonitorInfoBean getMonitorInfoBean() throws Exception {

int kb = 1024

// 可使用内存

long totalMemory = Runtime.getRuntime().totalMemory() / kb

// 剩余内存

long freeMemory = Runtime.getRuntime().freeMemory() / kb

// 最大可使用内存

long maxMemory = Runtime.getRuntime().maxMemory() / kb

OperatingSystemMXBean osmxb = (OperatingSystemMXBean) ManagementFactory

.getOperatingSystemMXBean()

// 操作系统

String osName = System.getProperty("os.name")

// 总的物理内存

long totalMemorySize = osmxb.getTotalPhysicalMemorySize() / kb

// 剩余的物理内存

long freePhysicalMemorySize = osmxb.getFreePhysicalMemorySize() / kb

// 已使用的物理内存

long usedMemory = (osmxb.getTotalPhysicalMemorySize() - osmxb

.getFreePhysicalMemorySize())

/ kb

// 获得线程总数

ThreadGroup parentThread

for (parentThread = Thread.currentThread().getThreadGroup()parentThread

.getParent() != nullparentThread = parentThread.getParent())

int totalThread = parentThread.activeCount()

double cpuRatio = 0

if (osName.toLowerCase().startsWith("windows")) {

cpuRatio = this.getCpuRatioForWindows()

}

else {

cpuRatio = this.getCpuRateForLinux()

}

// 构造返回对象

MonitorInfoBean infoBean = new MonitorInfoBean()

infoBean.setFreeMemory(freeMemory)

infoBean.setFreePhysicalMemorySize(freePhysicalMemorySize)

infoBean.setMaxMemory(maxMemory)

infoBean.setOsName(osName)

infoBean.setTotalMemory(totalMemory)

infoBean.setTotalMemorySize(totalMemorySize)

infoBean.setTotalThread(totalThread)

infoBean.setUsedMemory(usedMemory)

infoBean.setCpuRatio(cpuRatio)

return infoBean

}

private static double getCpuRateForLinux(){

InputStream is = null

InputStreamReader isr = null

BufferedReader brStat = null

StringTokenizer tokenStat = null

try{

System.out.println("Get usage rate of CUP , linux version: "+linuxVersion)

Process process = Runtime.getRuntime().exec("top -b -n 1")

is = process.getInputStream()

isr = new InputStreamReader(is)

brStat = new BufferedReader(isr)

if(linuxVersion.equals("2.4")){

brStat.readLine()

brStat.readLine()

brStat.readLine()

brStat.readLine()

tokenStat = new StringTokenizer(brStat.readLine())

tokenStat.nextToken()

tokenStat.nextToken()

String user = tokenStat.nextToken()

tokenStat.nextToken()

String system = tokenStat.nextToken()

tokenStat.nextToken()

String nice = tokenStat.nextToken()

System.out.println(user+" , "+system+" , "+nice)

user = user.substring(0,user.indexOf("%"))

system = system.substring(0,system.indexOf("%"))

nice = nice.substring(0,nice.indexOf("%"))

float userUsage = new Float(user).floatValue()

float systemUsage = new Float(system).floatValue()

float niceUsage = new Float(nice).floatValue()

return (userUsage+systemUsage+niceUsage)/100

}else{

brStat.readLine()

brStat.readLine()

tokenStat = new StringTokenizer(brStat.readLine())

tokenStat.nextToken()

tokenStat.nextToken()

tokenStat.nextToken()

tokenStat.nextToken()

tokenStat.nextToken()

tokenStat.nextToken()

tokenStat.nextToken()

String cpuUsage = tokenStat.nextToken()

System.out.println("CPU idle : "+cpuUsage)

Float usage = new Float(cpuUsage.substring(0,cpuUsage.indexOf("%")))

return (1-usage.floatValue()/100)

}

} catch(IOException ioe){

System.out.println(ioe.getMessage())

freeResource(is, isr, brStat)

return 1

} finally{

freeResource(is, isr, brStat)

}

}

一 java内存结构

Heap(堆) 实例分配的地方 通过 Xms与 Xmx来设置

MethodArea(方法区域) 类的信息及静态变量 对应是Permanet Generation 通过 XX PermSize来设置

JavaStack(java的栈) 虚拟机只会直接对Javastack执行两种操作 以帧为单位的压栈或出栈 通过 Xss来设置 若不够会抛出StackOverflowError

ProgramCounter(程序计数器) 每一个线程都有它自己的PC寄存器 也是该线程启动时创建的 PC寄存器的内容总是指向下一条将被执行指令的饿地址 这里的地址可以是一个本地指针 也可以是在方法区中相对应于该方法起始指令的偏移量

Nativemethodstack(本地方法栈) 保存native方法进入区域的地址

当中Heap和MethodArea是被所有线程的共享使用的

而Javastack Programcounter和Nativemethodstack是以线程为粒度的 每个线程独自拥有自己的部分

二 内存模型

由以上可以知道java内存分为main memory和线程的Working Memory 就会涉及到这两种内存数据同步以及多个线程操作时数据一致性和可见性的问题 这就不可避免要加锁了 在java中可采用如下的形式

  synchronized关键字或使用ncurrent locks中的锁

  volatile关键字 Volatile表示的是线程每次操作都是在主内存中进行 这只能保证其可见性 而不能保证其的原子性 要有原子性还得加锁

  final变量(基本类型 类类型还是可以改值的)

三 如何保证线程安全

每个线程只操作自有的数据 这个可能性要小

设计的类无数据成员 也就没有共享变量 要有可用是 final或volatile