堆栈和堆的内容在定位问题的时候，都是非常重要的信息。线程堆栈 dump 可以了解当时 jvm 中所有线程的运行情况，比如线程的状态和当前正在运行的代码行。堆 dump 可以了解当时堆的使用情况，各个类实例的数量及各个实例所占用的空间大小。

blogjava-凯发k8网页登录

使用 jstack

jstack 是 jdk 自带的工具，用于 dump 指定进程 id(pid)的 jvm 的线程堆栈信息。

# 打印堆栈信息到标准输出 jstack pid  
# 打印堆栈信息到标准输出，会打印关于锁的信息 jstack -l pid  
强制打印堆栈信息到标准输出，如果使用 jstack pid 没有响应的情况下(此时 jvm 进程可能挂起)，
加 -f 参数 jstack -f pid 

使用 jcmd

jcmd 是 jdk 自带的工具，用于向 jvm 进程发送命令，根据命令的不同，可以代替或部分代替 jstack、jmap 等。可以发送命令 thread.print 来打印出 jvm 的线程堆栈信息。

# 下面的命令同等于 jstack pid 
jcmd pid thread.print  

# 同等于 jstack -l pid 
jcmd pid thread.print -l 

使用 kill -3

kill 可以向特定的进程发送信号(signal)，缺省情况是发送终止(term) 的信号 ，即 kill pid 与 kill -15 pid 或 kill -term pid 是等价的。jvm 进程会监听 quit 信号(其值为 3)，当收到这个信号时，会打印出当时的线程堆栈和堆内存使用概要，相比 jstack，此时多了堆内存的使用概要情况。但 jstack 可以指定 -l 参数，打印锁的信息。

kill -3 pid 
# 或 kill -quit pid 

-xx: heapdumponoutofmemoryerror

添加 jvm 参数 -xx: heapdumponoutofmemoryerror 后，当发生 oom(outofmemory)时，自动堆 dump。缺省情况下，jvm 会创建一个名称为 java_pidpid.hprof 的堆 dump 文件在 jvm 的工作目录下。但可以使用参数 -xx:heapdumppath=path 来指定 dump 文件的保存位置。

# jvm 发生 oom 时，会自动在 /var/log/abc 目录下产生堆 dump 文件 java_pidpid.hprof 
java -xx: heapdumponoutofmemoryerror -xx:heapdumppath=/var/log/abc/ 

jmap

jmap 也是 jdk 自带的工具，主要用于获取堆相关的信息。

堆 dump

# 将 jvm 的堆 dump 到指定文件，如果堆中对象较多，需要的时间会较长，子参数 format 只支持 b，
即二进制格式
jmap -dump:format=b,file=file_with_path

# 如果 jvm 进程未响应命令，可以加上参数 -f 尝试
jmap -f -dump:format=b,file=file_with_path

# 可以只 dump 堆中的存活对象，加上 live 子参数，但使用 -f 时不支持 live
jmap -dump:live,format=b,file=file_with_path

获取堆概要信息

# -heap 参数用于查看指定 jvm 进程的堆的信息，包括堆的各个参数的值，堆中新生代、年老代的内存大小、使用率等 
jmap -heap pid  

# 同样，如果 jvm 进程未响应命令，可以加上参数 -f 尝试 
jmap -f -heap pid 

一个实例输出如下：

attaching to process id 68322, please wait
debugger attached successfully.
server compiler detected.
jvm version is 25.112-b16

using thread-local object allocation.
parallel gc with 4 thread(s)

heap configuration:
   minheapfreeratio         = 0
   maxheapfreeratio         = 100
   maxheapsize              = 268435456 (256.0mb)
   newsize                  = 8388608 (8.0mb)
   maxnewsize               = 89128960 (85.0mb)
   oldsize                  = 16777216 (16.0mb)
   newratio                 = 2
   survivorratio            = 8
   metaspacesize            = 21807104 (20.796875mb)
   compressedclassspacesize = 1073741824 (1024.0mb)
   maxmetaspacesize         = 17592186044415 mb
   g1heapregionsize         = 0 (0.0mb)

heap usage:
ps young generation
eden space:
   capacity = 41943040 (40.0mb)
   used     = 1701504 (1.6226806640625mb)
   free     = 40241536 (38.3773193359375mb)
   4.05670166015625% used
from space:
   capacity = 4194304 (4.0mb)
   used     = 0 (0.0mb)
   free     = 4194304 (4.0mb)
   0.0% used
to space:
   capacity = 5242880 (5.0mb)
   used     = 0 (0.0mb)
   free     = 5242880 (5.0mb)
   0.0% used
ps old generation
   capacity = 30408704 (29.0mb)
   used     = 12129856 (11.56793212890625mb)
   free     = 18278848 (17.43206787109375mb)
   39.889421134159484% used

16658 interned strings occupying 1428472 bytes.

获取堆中的类实例统计

# 打印 jvm 堆中的类实例统计信息，以占用内存的大小排序，同样，如果 jvm 未响应命令，也可以使用 -f 参数 
jmap -histo pid  

# 也可以只统计堆中的存活对象，加上 live 子参数，但使用 -f 时不支持 live 
jmap -histo:live pid 

使用 jcmd

# 等同 jmap -dump:live,format=b,file=file_with_path
jcmd pid gc.heap_dump file_with_path

# 等同 jmap -dump:format=b,file=file_with_path
jcmd pid gc.heap_dump -all file_with_path

# 等同 jmap -histo:live pid
jcmd pid gc.class_histogram

# 等同 jmap -histo pid
jcmd pid gc.class_histogram -all

1. pom.xml中加入依赖包
   
           <dependency>
               <groupid>com.google.guavagroupid>
               <artifactid>guavaartifactid>
               <version>18.0version>
           dependency>
   
   
2. 改造cachemanager，myconcurrentmapcachemanager
   
   package com.paul.common.cache;
   /*
    * 凯发天生赢家一触即发官网 copyright 2002-2014 the original author or authors.
    *
    * licensed under the apache license, version 2.0 (the "license");
    * you may not use this file except in compliance with the license.
    * you may obtain a copy of the license at
    *
    *      http://www.apache.org/licenses/license-2.0
    *
    * unless required by applicable law or agreed to in writing, software
    * distributed under the license is distributed on an "as is" basis,
    * without warranties or conditions of any kind, either express or implied.
    * see the license for the specific language governing permissions and
    * limitations under the license.
    */
   
   import java.util.collection;
   import java.util.collections;
   import java.util.map;
   import java.util.concurrent.concurrenthashmap;
   import java.util.concurrent.concurrentmap;
   import java.util.concurrent.timeunit;
   
   import org.springframework.cache.cache;
   import org.springframework.cache.cachemanager;
   import org.springframework.cache.concurrent.concurrentmapcache;
   
   import com.google.common.cache.cachebuilder;
   
   /**
    * {@link cachemanager} implementation that lazily builds {@link concurrentmapcache}
    * instances for each {@link #getcache} request. also supports a 'static' mode where
    * the set of cache names is pre-defined through {@link #setcachenames}, with no
    * dynamic creation of further cache regions at runtime.
    *
    * 

   note: this is by no means a sophisticated cachemanager; it comes with no
    * cache configuration options. however, it may be useful for testing or simple
    * caching scenarios. for advanced local caching needs, consider
    * {@link org.springframework.cache.guava.guavacachemanager} or
    * {@link org.springframework.cache.ehcache.ehcachecachemanager}.
    *
    * @author juergen hoeller
    * @since 3.1
    * @see concurrentmapcache
    */
   public class myconcurrentmapcachemanager implements cachemanager {
   
       private final concurrentmap cachemap = new concurrenthashmap(16);
   
       private boolean dynamic = true;
   
       private boolean allownullvalues = true;
       
       private long expiretime = 30;
       
       private long maximumsize = 100;
   
   
       /**
        * construct a dynamic concurrentmapcachemanager,
        * lazily creating cache instances as they are being requested.
        */
       public myconcurrentmapcachemanager() {
       }
   
       /**
        * construct a static concurrentmapcachemanager,
        * managing caches for the specified cache names only.
        */
       public myconcurrentmapcachemanager(long expiretime, long maximumsize) {
           if(expiretime > 0)
               this.expiretime = expiretime;
           if(maximumsize > 0)
               this.maximumsize = maximumsize;
       }
   
   
       /**
        * specify the set of cache names for this cachemanager's 'static' mode.
        * 

   the number of caches and their names will be fixed after a call to this method,
        * with no creation of further cache regions at runtime.
        * 

   calling this with a {@code null} collection argument resets the
        * mode to 'dynamic', allowing for further creation of caches again.
        */
       public void setcachenames(collection cachenames) {
           if (cachenames != null) {
               for (string name : cachenames) {
                   this.cachemap.put(name, createconcurrentmapcache(name));
               }
               this.dynamic = false;
           }
           else {
               this.dynamic = true;
           }
       }
   
       /**
        * specify whether to accept and convert {@code null} values for all caches
        * in this cache manager.
        * 

   default is "true", despite concurrenthashmap itself not supporting {@code null}
        * values. an internal holder object will be used to store user-level {@code null}s.
        * 

   note: a change of the null-value setting will reset all existing caches,
        * if any, to reconfigure them with the new null-value requirement.
        */
       public void setallownullvalues(boolean allownullvalues) {
           if (allownullvalues != this.allownullvalues) {
               this.allownullvalues = allownullvalues;
               // need to recreate all cache instances with the new null-value configuration
               for (map.entry entry : this.cachemap.entryset()) {
                   entry.setvalue(createconcurrentmapcache(entry.getkey()));
               }
           }
       }
   
       /**
        * return whether this cache manager accepts and converts {@code null} values
        * for all of its caches.
        */
       public boolean isallownullvalues() {
           return this.allownullvalues;
       }
   
   
       @override
       public collection getcachenames() {
           return collections.unmodifiableset(this.cachemap.keyset());
       }
   
       @override
       public cache getcache(string name) {
           cache cache = this.cachemap.get(name);
           if (cache == null && this.dynamic) {
               synchronized (this.cachemap) {
                   cache = this.cachemap.get(name);
                   if (cache == null) {
                       cache = createconcurrentmapcache(name);
                       this.cachemap.put(name, cache);
                   }
               }
           }
           return cache;
       }
   
       /**
        * create a new concurrentmapcache instance for the specified cache name.
        * @param name the name of the cache
        * @return the concurrentmapcache (or a decorator thereof)
        */
       protected cache createconcurrentmapcache(string name) {
           //return new concurrentmapcache(name, isallownullvalues());
           //此处改用google guava的构造manager方式
           return new concurrentmapcache(name,
                                           cachebuilder.newbuilder()
                                                       .expireafterwrite(this.expiretime, timeunit.minutes)
                                                       .maximumsize(this.maximumsize)
                                                       .build()
                                                       .asmap(), 
                                           isallownullvalues());
       }
   
   }

   
   
   
3. 配置想着bean, cache-concurrentmap-applicationcontext.xml
   
   xml version="1.0" encoding="utf-8"?>
   <beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/xmlschema-instance" xmlns:context="http://www.springframework.org/schema/context"
       xmlns:cache="http://www.springframework.org/schema/cache"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:c="http://www.springframework.org/schema/c"
       xmlns:jee="http://www.springframework.org/schema/jee"
       xmlns:util="http://www.springframework.org/schema/util"
       xsi:schemalocation="http://www.springframework.org/schema/context
             http://www.springframework.org/schema/context/spring-context-3.0.xsd
             http://www.springframework.org/schema/beans
             http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
             http://www.springframework.org/schema/cache
             http://www.springframework.org/schema/cache/spring-cache.xsd
             http://www.springframework.org/schema/jee 
             http://www.springframework.org/schema/jee/spring-jee.xsd
             http://www.springframework.org/schema/util
             http://www.springframework.org/schema/util/spring-util.xsd">
   
       <cache:annotation-driven />
   
       
       
       <bean id="cachemanager"
           class="com.paul.common.cache.myconcurrentmapcachemanager">
           <constructor-arg index="0" value="1" />
           <constructor-arg index="1" value="5000" />
       bean>    
       
   beans>
   
   
   
4. 通过注释进行使用
   
   /*
    * jboss, home of professional open source
    * 凯发天生赢家一触即发官网 copyright 2014, red hat, inc. and/or its affiliates, and individual
    * contributors by the @authors tag. see the 凯发天生赢家一触即发官网 copyright.txt in the
    * distribution for a full listing of individual contributors.
    *
    * licensed under the apache license, version 2.0 (the "license");
    * you may not use this file except in compliance with the license.
    * you may obtain a copy of the license at
    * http://www.apache.org/licenses/license-2.0
    * unless required by applicable law or agreed to in writing, software
    * distributed under the license is distributed on an "as is" basis,
    * without warranties or conditions of any kind, either express or implied.
    * see the license for the specific language governing permissions and
    * limitations under the license.
    */
   package com.paul.springmvc.data;
   
   import java.util.list;
   
   import javax.persistence.entitymanager;
   import javax.persistence.criteria.criteriabuilder;
   import javax.persistence.criteria.criteriaquery;
   import javax.persistence.criteria.root;
   
   import org.springframework.beans.factory.annotation.autowired;
   import org.springframework.cache.annotation.cacheevict;
   import org.springframework.cache.annotation.cacheable;
   import org.springframework.stereotype.repository;
   import org.springframework.transaction.annotation.transactional;
   
   import com.paul.springmvc.model.member;
   
   @repository
   @transactional
   public class memberdaoimpl implements memberdao {
       @autowired
       private entitymanager em;
   
       @cacheable(value = "my-local-cache", key = "#id")
       public member findbyid(long id) {
           system.out.println("memberdaoimpl no cache");
           return em.find(member.class, id);
       }
   
       public member findbyemail(string email) {
           criteriabuilder cb = em.getcriteriabuilder();
           criteriaquery criteria = cb.createquery(member.class);
           root member = criteria.from(member.class);
   
           /*
            * swap criteria statements if you would like to try out type-safe criteria queries, a new
            * feature in jpa 2.0 criteria.select(member).orderby(cb.asc(member.get(member_.name)));
            */
   
           criteria.select(member).where(cb.equal(member.get("email"), email));
           return em.createquery(criteria).getsingleresult();
       }
   
       public list findallorderedbyname() {
           criteriabuilder cb = em.getcriteriabuilder();
           criteriaquery criteria = cb.createquery(member.class);
           root member = criteria.from(member.class);
   
           /*
            * swap criteria statements if you would like to try out type-safe criteria queries, a new
            * feature in jpa 2.0 criteria.select(member).orderby(cb.asc(member.get(member_.name)));
            */
   
           criteria.select(member).orderby(cb.asc(member.get("name")));
           return em.createquery(criteria).getresultlist();
       }
   
       @cacheevict(value="my-local-cache",allentries=true,beforeinvocation=true)//清空所有缓存
       public void register(member member) {
           em.persist(member);
           return;
       }
   }

在cdi bean中使用cache

package com.paul.myejb;

import javax.annotation.resource;
import javax.cache.annotation.cacheresult;
import javax.ejb.remote;
import javax.ejb.stateless;
import javax.interceptor.interceptors;

import org.infinispan.cache;
import org.infinispan.manager.embeddedcachemanager;
//import org.springframework.cache.annotation.cacheable;
import org.springframework.ejb.interceptor.springbeanautowiringinterceptor;

/**
 * session bean implementation class helloworldbean
 */
@stateless
//@local(helloworld.class)
@remote(helloworld.class)
@interceptors(springbeanautowiringinterceptor.class)
//@rolesallowed({roles.admin})
public class helloworldbean implements helloworld {
    
    @resource(lookup = "java:jboss/infinispan/tickets")
    private embeddedcachemanager container;
    
    
    /**
     * default constructor. 
     */
    public helloworldbean() {
    }

//    @transactional
//    @cacheable(value = "books", key = "#name")
    @cacheresult
    public string sayhello(string name) {
        system.out.println("no cache");
        string result = "hello "   name   ", i am helloworldbean.";
        cache cache = this.container.getcache();
        cache.put(name, result);
        return result;
    }

}

1. 添加依赖的spring bean
   
   xml version="1.0" encoding="utf-8"?>
   <beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/xmlschema-instance" xmlns:context="http://www.springframework.org/schema/context"
       xmlns:cache="http://www.springframework.org/schema/cache"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:jee="http://www.springframework.org/schema/jee"
       xsi:schemalocation="http://www.springframework.org/schema/context
             http://www.springframework.org/schema/context/spring-context-3.0.xsd
             http://www.springframework.org/schema/beans
             http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
             http://www.springframework.org/schema/cache
             http://www.springframework.org/schema/cache/spring-cache.xsd
             http://www.springframework.org/schema/jee 
             http://www.springframework.org/schema/jee/spring-jee.xsd">
   
       <cache:annotation-driven />
       
       <bean id="cachemanager"
             class="org.infinispan.spring.provider.containercachemanagerfactorybean">
             <constructor-arg ref="cachecontainer"  />
       bean>
       
       <jee:jndi-lookup id="cachecontainer" jndi-name="java:jboss/infinispan/tickets" > 
       jee:jndi-lookup>
       
       
       
   beans>
   
   
2. 使用cache
   
   package com.paul.myejb.spring;
   
   import org.springframework.beans.factory.annotation.autowired;
   import org.springframework.cache.cachemanager;
   import org.springframework.cache.annotation.cacheable;
   import org.springframework.stereotype.component;
   
   @component
   public class myspringbean {
       
       @autowired
       private cachemanager cachemanager;
       
       @cacheable(value = "my-local-cache", key = "#name")
       public string sayhello(string name)
       {
           system.out.println("myspringbean no cache");
           string result = "hi "   name   ", i am spring!";
           org.springframework.cache.cache springcache = this.cachemanager.getcache("my-local-cache");
           system.out.println(springcache.get(name) == null ? "null" : springcache.get(name).get());
           springcache.put(name, result);
           return result;
       }
   
   }
   
   
3.