JVM specification对JVM内存的描述

首先我们来了解JVM specification中的JVM整体架构。如下图：

中的内存

• 运行时数据组件的详解介绍：

    

Runtime data area 主要包括五个部分：Heap (堆), Method Area(方法区域), Java Stack(java的栈), Program Counter(程序计数器), Native method stack(本地方法栈)。Heap 和Method Area是被所有线程的共享使用的；而Java stack, Program counter 和Native method stack是以线程为粒度的，每个线程独自拥有。

Heap
Java程序在运行时创建的所有类实或数组都放在同一个堆中。而一个Java虚拟实例中只存在一个堆空间，因此所有线程都将共享这个堆。每一个java程序独占一个JVM实例，因而每个java程序都有它自己的堆空间，它们不会彼此干扰。但是同一java程序的多个线程都共享着同一个堆空间，就得考虑多线程访问对象（堆数据）的同步问题。 （这里可能出现的异常java.lang.OutOfMemoryError: Java heap space）

JVM堆一般又可以分为以下三部分：

Ø Perm

Perm代主要保存class,method,filed对象，这部门的空间一般不会溢出，除非一次性加载了很多的类，不过在涉及到热部署的应用服务器的时候，有时候会遇到java.lang.OutOfMemoryError : PermGen space 的错误，造成这个错误的很大原因就有可能是每次都重新部署，但是重新部署后，类的class没有被卸载掉，这样就造成了大量的class对象保存在了perm中，这种情况下，一般重新启动应用服务器可以解决问题。

Ø Tenured

Tenured区主要保存生命周期长的对象，一般是一些老的对象，当一些对象在Young复制转移一定的次数以后，对象就会被转移到Tenured区，一般如果系统中用了application级别的缓存，缓存中的对象往往会被转移到这一区间。

Ø Young

Young区被划分为三部分，Eden区和两个大小严格相同的Survivor区，其中Survivor区间中，某一时刻只有其中一个是被使用的，另外一个留做垃圾收集时复制对象用，在Young区间变满的时候，minor GC就会将存活的对象移到空闲的Survivor区间中，根据JVM的策略，在经过几次垃圾收集后，任然存活于Survivor的对象将被移动到Tenured区间。

Method area
在Java虚拟机中，被装载的class的信息存储在Method area的内存中。

public class TestStackOverFlow {

     public static void main(String[] args) {

            Recursive r = new Recursive();

            r.doit(10000);

            // Exception in thread "main" java.lang.StackOverflowError

     }

}

class Recursive {

     public int doit(int t) {

            if (t <= 1) {

                    return 1;

            }

            return t + doit(t - 1);

     }

}

 

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

Native method stack
对于一个运行中的Java程序而言，它还能会用到一些跟本地方法相关的数据区。当某个线程调用一个本地方法时，它就进入了一个全新的并且不再受虚拟机限制的世界。本地方法可以通过本地方法接口来访问虚拟机的运行时数据区，不止与此，它还可以做任何它想做的事情。比如，可以调用寄存器，或在操作系统中分配内存等。总之，本地方法具有和JVM相同的能力和权限。 (这里出现JVM无法控制的内存溢出问题native heap OutOfMemory )

•     多线程的实现方式和启动
•     多线程是依靠什么方式解决资源竞争
•     多线程的各种状态以及优先级
•     多线程的暂停方式

•       继承Thread和是实现Runnable接口，重写run方法
•       启动只有一种方式：通过start方法，虚拟机会调用run方法

•        锁机制：分为对象锁和类锁，在多个线程调用的情况，每个对象锁都是唯一的，只有获取了锁才能调用synchronized方法
•        synchronize同步：分为同步方法和同步方法块
•        什么时候获取锁：每次调用到synchronize方法，这个时候去获取锁资源，如果线程获取到锁则别的线程只有等到同步方法介绍后，释放锁后，别的线程        才能继续使用

•        主要分为：新状态（还没有调用start方法），可执行状态（调用start方法），阻塞状态，死亡状态

•     sleep:睡眠单位为毫秒
•     wait,waitAll,notify,notifyAll,wait等待，只有通过wait或者waitAll唤醒
•     yield：cpu暂时停用
•     join

•     采用HashMap存储，key直接存取值，value存储一个object
•     存储的key值是唯一的
•      HashSet中元素的顺序是随机的，包括添加(add())和输出都是无序的
  
  代码就不具体详解了，主要就是通过封装HashMap组成。
  
  

•     线程安全
•     不能存储null到key和value
•    HashTable中hash数组默认大小是11，增加的方式是 old*2+1。HashMap中hash数组的默认大小是16，而且一定是2的指数
  
  

  区别	Hashtable	Hashmap
  继承、实现	Hashtable extends Dictionaryimplements Map, Cloneable,Serializable	HashMap extends AbstractMap implements Map, Cloneable,Serializable
  线程同步	已经同步过的可以安全使用	未同步的，可以使用Colletcions进行同步Map Collections.synchronizedMap(Map m)
  对null的处理	Hashtable table = new Hashtable(); table.put(null, "Null"); table.put("Null", null); table.contains(null); table.containsKey(null); table.containsValue(null); 后面的5句话在编译的时候不会有异常，可在运行的时候会报空指针异常具体原因可以查看源代码 public synchronized V put(K key, V value) { // Make sure the value is not null if (value == null) { throw new NullPointerException(); }	HashMap map = new HashMap(); map.put(null, "Null"); map.put("Null", null); map.containsKey(null); map.containsValue(null); 以上这5条语句无论在编译期，还是在运行期都是没有错误的. 在HashMap中，null可以作为键，这样的键只有一个；可以有一个或多个键所对应的值为null。当get()方法返回null值时，即可以表示 HashMap中没有该键，也可以表示该键所对应的值为null。因此，在HashMap中不能由get()方法来判断HashMap中是否存在某个键，而应该用containsKey()方法来判断。
  增长率	protected void rehash() { int oldCapacity = table.length; Entry[] oldMap = table; int newCapacity = oldCapacity * 2 + 1; Entry[] newMap = new Entry[newCapacity]; modCount++; threshold = (int)(newCapacity * loadFactor); table = newMap; for (int i = oldCapacity ; i-- > 0 ;) { for (Entry old = oldMap[i] ; old != null ; ) { Entry e = old; old = old.next; int index = (e.hash & 0x7FFFFFFF) % newCapacity; e.next = newMap[index]; newMap[index] = e; } } }	void addEntry(int hash, K key, V value, int bucketIndex) { Entry e = table[bucketIndex]; table[bucketIndex] = new Entry(hash, key, value, e); if (size++ >= threshold) resize(2 * table.length); }
  哈希值的使用	HashTable直接使用对象的hashCode，代码是这样的： public synchronized booleancontainsKey(Object key) { Entry tab[] = table; int hash = key.hashCode(); int index = (hash & 0x7FFFFFFF) % tab.length; for (Entry e = tab[index] ; e !=null ; e = e.next) { if ((e.hash == hash) && e.key.equals(key)) { return true; } } return false; }	HashMap重新计算hash值，而且用与代替求模 public boolean containsKey(Object key) { Object k = maskNull(key); int hash = hash(k.hashCode()); int i = indexFor(hash, table.length); Entry e = table[i]; while (e != null) { if (e.hash == hash && eq(k, e.key)) return true; e = e.next; } return false; }

• 线程不安全,线程安全请使用Hashtable
• 效率较好
• 提供null作为key或者value

•     默认 初始化
  

• 存入元素：

• 读取元素：

• 总结：

• 默认长度为10

• 底层采用数组存储：protected Object[] elementData;

• 线程安全
• 查询效率比较高，比较适用于查询
• 扩容的长度为初始长度的一半，建议初始化的时候设置已知的长度，免得容器自己去扩容，浪费空间以及效率
  与ArrayList基本一样，除了所有操作资源的方法都加了synchronized，保证线程同步
  这里的源代码就不详解了，具体请参考容器-数组-ArrayList详解。

• 默认长度为10

• 底层采用数组存储：private transient Object[] elementData;

• 线程不安全，在多线程场景会出现问题，可以考虑使用Vector或者Collections.synchronizedList同步该容器
• 查询效率比较高，比较适用于查询
• 扩容的长度为初始长度的一半，建议初始化的时候设置已知的长度，免得容器自己去扩容，浪费空间以及效率

• 增加元素

• 删除元素：

• 获取元素：