找到my.ini文件

添加一句max_allowed_packet=16M，如果不行将16M再加大

加大wait_timeout也可起一定作用

eg:

wait_timeout=2880000
interactive_timeout = 2880000
max_allowed_packet = 100M

应用时记住重启数据库哦～～

一 class的热替换
ClassLoader中重要的方法
loadClass
      ClassLoader.loadClass(...) 是ClassLoader的入口点。当一个类没有指明用什么加载器加载的时候，JVM默认采用AppClassLoader加载器加载没有加载过的class，调用的方法的入口就是loadClass(...)。如果一个class被自定义的ClassLoader加载，那么JVM也会调用这个自定义的ClassLoader.loadClass(...)方法来加载class内部引用的一些别的class文件。重载这个方法，能实现自定义加载class的方式，抛弃双亲委托机制，但是即使不采用双亲委托机制，比如java.lang包中的相关类还是不能自定义一个同名的类来代替，主要因为JVM解析、验证class的时候，会进行相关判断。
 
defineClass
      系统自带的ClassLoader，默认加载程序的是AppClassLoader，ClassLoader加载一个class，最终调用的是defineClass(...)方法，这时候就在想是否可以重复调用defineClass(...)方法加载同一个类(或者修改过)，最后发现调用多次的话会有相关错误:
...
java.lang.LinkageError
attempted duplicate class definition
...
所以一个class被一个ClassLoader实例加载过的话，就不能再被这个ClassLoader实例再次加载(这里的加载指的是，调用了defileClass(...)放方法，重新加载字节码、解析、验证。)。而系统默认的AppClassLoader加载器，他们内部会缓存加载过的class，重新加载的话，就直接取缓存。所与对于热加载的话，只能重新创建一个ClassLoader，然后再去加载已经被加载过的class文件。www.2cto.com

下面看一个class热加载的例子：
代码：HotSwapURLClassLoader自定义classloader，实现热替换的关键
  1 package testjvm.testclassloader;
  2
  3 import java.io.File;
  4 import java.io.FileNotFoundException;
  5 import java.net.MalformedURLException;
  6 import java.net.URL;
  7 import java.net.URLClassLoader;
  8 import java.util.HashMap;
  9 import java.util.Map;
 10
 11 /**
 12  * 只要功能是重新加载更改过的.class文件，达到热替换的作用
 13  * @author banana
 14  */
 15 public class HotSwapURLClassLoader extends URLClassLoader {
 16     //缓存加载class文件的最后最新修改时间
 17     public static Map<String,Long> cacheLastModifyTimeMap = new HashMap<String,Long>();
 18     //工程class类所在的路径
 19     public static String projectClassPath = "D:/Ecpworkspace/ZJob-Note/bin/";
 20     //所有的测试的类都在同一个包下
 21     public static String packagePath = "testjvm/testclassloader/";
 22    
 23     private static HotSwapURLClassLoader hcl = new HotSwapURLClassLoader();
 24    
 25     public HotSwapURLClassLoader() {
 26         //设置ClassLoader加载的路径
 27         super(getMyURLs());
 28     }
 29    
 30     public static HotSwapURLClassLoader  getClassLoader(){
 31         return hcl;
 32     }
 33
 34     private static  URL[] getMyURLs(){
 35         URL url = null;
 36         try {
 37             url = new File(projectClassPath).toURI().toURL();
 38         } catch (MalformedURLException e) {
 39             e.printStackTrace();
 40         }
 41         return new URL[] { url };
 42     }
 43    
 44     /**
 45      * 重写loadClass，不采用双亲委托机制("java."开头的类还是会由系统默认ClassLoader加载)
 46      */
 47     @Override
 48     public Class<?> loadClass(String name,boolean resolve) throws ClassNotFoundException {
 49         Class clazz = null;
 50         //查看HotSwapURLClassLoader实例缓存下，是否已经加载过class
 51         //不同的HotSwapURLClassLoader实例是不共享缓存的
 52         clazz = findLoadedClass(name);
 53         if (clazz != null ) {
 54             if (resolve){
 55                 resolveClass(clazz);
 56             }
 57             //如果class类被修改过，则重新加载
 58             if (isModify(name)) {
 59                 hcl = new HotSwapURLClassLoader();
 60                 clazz = customLoad(name, hcl);
 61             }
 62             return (clazz);
 63         }
 64
 65         //如果类的包名为"java."开始，则有系统默认加载器AppClassLoader加载
 66         if(name.startsWith("java.")){
 67             try {
 68                 //得到系统默认的加载cl，即AppClassLoader
 69                 ClassLoader system = ClassLoader.getSystemClassLoader();
 70                 clazz = system.loadClass(name);
 71                 if (clazz != null) {
 72                     if (resolve)
 73                         resolveClass(clazz);
 74                     return (clazz);
 75                 }
 76             } catch (ClassNotFoundException e) {
 77                 // Ignore
 78             }
 79         }
 80        
 81         return customLoad(name,this);
 82     }
 83
 84     public Class load(String name) throws Exception{
 85         return loadClass(name);
 86     }
 87
 88     /**
 89      * 自定义加载
 90      * @param name
 91      * @param cl
 92      * @return
 93      * @throws ClassNotFoundException
 94      */
 95     public Class customLoad(String name,ClassLoader cl) throws ClassNotFoundException {
 96         return customLoad(name, false,cl);
 97     }
 98
 99     /**
100      * 自定义加载
101      * @param name
102      * @param resolve
103      * @return
104      * @throws ClassNotFoundException
105      */
106     public Class customLoad(String name, boolean resolve,ClassLoader cl)
107             throws ClassNotFoundException {
108         //findClass()调用的是URLClassLoader里面重载了ClassLoader的findClass()方法
109         Class clazz = ((HotSwapURLClassLoader)cl).findClass(name);
110         if (resolve)
111             ((HotSwapURLClassLoader)cl).resolveClass(clazz);
112         //缓存加载class文件的最后修改时间
113         long lastModifyTime = getClassLastModifyTime(name);
114         cacheLastModifyTimeMap.put(name,lastModifyTime);
115         return clazz;
116     }
117    
118     public Class<?> loadClass(String name) throws ClassNotFoundException {
119         return loadClass(name,false);
120     }
121    
122     @Override
123     protected Class<?> findClass(String name) throws ClassNotFoundException {
124         // TODO Auto-generated method stub
125         return super.findClass(name);
126     }
127    
128     /**
129      * @param name
130      * @return .class文件最新的修改时间
131      */
132     private long getClassLastModifyTime(String name){
133         String path = getClassCompletePath(name);
134         File file = new File(path);
135         if(!file.exists()){
136             throw new RuntimeException(new FileNotFoundException(name));
137         }
138         return file.lastModified();
139     }
140    
141     /**
142      * 判断这个文件跟上次比是否修改过
143      * @param name
144      * @return
145      */
146     private boolean isModify(String name){
147         long lastmodify = getClassLastModifyTime(name);
148         long previousModifyTime = cacheLastModifyTimeMap.get(name);
149         if(lastmodify>previousModifyTime){
150             return true;
151         }
152         return false;
153     }
154    
155     /**
156      * @param name
157      * @return .class文件的完整路径 (e.g. E:/A.class)
158      */
159     private String getClassCompletePath(String name){
160         String simpleName = name.substring(name.lastIndexOf(".")+1);
161         return projectClassPath+packagePath+simpleName+".class";
162     }
163    
164 }
165

代码：Hot被用来修改的类
1 package testjvm.testclassloader;
2
3 public class Hot {
4     public void hot(){
5         System.out.println(" version 1 : "+this.getClass().getClassLoader());
6     }
7 }
8

代码：TestHotSwap测试类
 1 package testjvm.testclassloader;
 2
 3 import java.lang.reflect.Method;
 4
 5 public class TestHotSwap {
 6
 7     public static void main(String[] args) throws Exception {
 8         //开启线程，如果class文件有修改，就热替换
 9         Thread t = new Thread(new MonitorHotSwap());
10         t.start();
11     }
12 }
13
14 class MonitorHotSwap implements Runnable {
15     // Hot就是用于修改，用来测试热加载
16     private String className = "testjvm.testclassloader.Hot";
17     private Class hotClazz = null;
18     private HotSwapURLClassLoader hotSwapCL = null;
19
20     @Override
21     public void run() {
22         try {
23             while (true) {
24                 initLoad();
25                 Object hot = hotClazz.newInstance();
26                 Method m = hotClazz.getMethod("hot");
27                 m.invoke(hot, null); //打印出相关信息
28                 // 每隔10秒重新加载一次
29                 Thread.sleep(10000);
30             }
31         } catch (Exception e) {
32             e.printStackTrace();
33         }
34     }
35
36     /**
37      * 加载class
38      */
39     void initLoad() throws Exception {
40         hotSwapCL = HotSwapURLClassLoader.getClassLoader();
41         // 如果Hot类被修改了，那么会重新加载，hotClass也会返回新的
42         hotClazz = hotSwapCL.loadClass(className);
43     }
44 }

     在测试类运行的时候，修改Hot.class文件
Hot.class
原来第五行:System.out.println(" version 1 : "+this.getClass().getClassLoader());
改后第五行:System.out.println(" version 2 : "+this.getClass().getClassLoader());
  
输出
 version 1 : testjvm.testclassloader.HotSwapURLClassLoader@610f7612
 version 1 : testjvm.testclassloader.HotSwapURLClassLoader@610f7612
 version 2 : testjvm.testclassloader.HotSwapURLClassLoader@45e4d960
 version 2 : testjvm.testclassloader.HotSwapURLClassLoader@45e4d960
     所以HotSwapURLClassLoader是重加载了Hot类 。注意上面，其实当加载修改后的Hot时，HotSwapURLClassLoader实例跟加载没修改Hot的HotSwapURLClassLoader不是同一个。
图：HotSwapURLClassLoader加载情况

     总结：上述类热加载，需要自定义ClassLoader，并且只能重新实例化ClassLoader实例，利用新的ClassLoader实例才能重新加载之前被加载过的class。并且程序需要模块化，才能利用这种热加载方式。

二 class卸载
      在Java中class也是可以unload。JVM中class和Meta信息存放在PermGen space区域。如果加载的class文件很多，那么可能导致PermGen space区域空间溢出。引起：java.lang.OutOfMemoryErrorPermGen space.  对于有些Class我们可能只需要使用一次，就不再需要了，也可能我们修改了class文件，我们需要重新加载 newclass，那么oldclass就不再需要了。那么JVM怎么样才能卸载Class呢。

      JVM中的Class只有满足以下三个条件，才能被GC回收，也就是该Class被卸载（unload）：
   - 该类所有的实例都已经被GC。
   - 加载该类的ClassLoader实例已经被GC。
   - 该类的java.lang.Class对象没有在任何地方被引用。

     GC的时机我们是不可控的，那么同样的我们对于Class的卸载也是不可控的。

例子：
代码：SimpleURLClassLoader，一个简单的自定义classloader
  1 package testjvm.testclassloader;
  2
  3 import java.io.File;
  4 import java.net.MalformedURLException;
  5 import java.net.URL;
  6 import java.net.URLClassLoader;
  7
  8 public class SimpleURLClassLoader extends URLClassLoader {
  9     //工程class类所在的路径
 10     public static String projectClassPath = "E:/IDE/work_place/ZJob-Note/bin/";
 11     //所有的测试的类都在同一个包下
 12     public static String packagePath = "testjvm/testclassloader/";
 13    
 14     public SimpleURLClassLoader() {
 15         //设置ClassLoader加载的路径
 16         super(getMyURLs());
 17     }
 18    
 19     private static  URL[] getMyURLs(){
 20         URL url = null;
 21         try {
 22             url = new File(projectClassPath).toURI().toURL();
 23         } catch (MalformedURLException e) {
 24             e.printStackTrace();
 25         }
 26         return new URL[] { url };
 27     }
 28    
 29     public Class load(String name) throws Exception{
 30         return loadClass(name);
 31     }
 32
 33     public Class<?> loadClass(String name) throws ClassNotFoundException {
 34         return loadClass(name,false);
 35     }
 36    
 37     /**
 38      * 重写loadClass，不采用双亲委托机制("java."开头的类还是会由系统默认ClassLoader加载)
 39      */
 40     @Override
 41     public Class<?> loadClass(String name,boolean resolve) throws ClassNotFoundException {
 42         Class clazz = null;
 43         //查看HotSwapURLClassLoader实例缓存下，是否已经加载过class
 44         clazz = findLoadedClass(name);
 45         if (clazz != null ) {
 46             if (resolve){
 47                 resolveClass(clazz);
 48             }
 49             return (clazz);
 50         }
 51
 52         //如果类的包名为"java."开始，则有系统默认加载器AppClassLoader加载
 53         if(name.startsWith("java.")){
 54             try {
 55                 //得到系统默认的加载cl，即AppClassLoader
 56                 ClassLoader system = ClassLoader.getSystemClassLoader();
 57                 clazz = system.loadClass(name);
 58                 if (clazz != null) {
 59                     if (resolve)
 60                         resolveClass(clazz);
 61                     return (clazz);
 62                 }
 63             } catch (ClassNotFoundException e) {
 64                 // Ignore
 65             }
 66         }
 67        
 68         return customLoad(name,this);
 69     }
 70
 71     /**
 72      * 自定义加载
 73      * @param name
 74      * @param cl
 75      * @return
 76      * @throws ClassNotFoundException
 77      */
 78     public Class customLoad(String name,ClassLoader cl) throws ClassNotFoundException {
 79         return customLoad(name, false,cl);
 80     }
 81
 82     /**
 83      * 自定义加载
 84      * @param name
 85      * @param resolve
 86      * @return
 87      * @throws ClassNotFoundException
 88      */
 89     public Class customLoad(String name, boolean resolve,ClassLoader cl)
 90             throws ClassNotFoundException {
 91         //findClass()调用的是URLClassLoader里面重载了ClassLoader的findClass()方法
 92         Class clazz = ((SimpleURLClassLoader)cl).findClass(name);
 93         if (resolve)
 94             ((SimpleURLClassLoader)cl).resolveClass(clazz);
 95         return clazz;
 96     }
 97    
 98     @Override
 99     protected Class<?> findClass(String name) throws ClassNotFoundException {
100         return super.findClass(name);
101     }
102 }
103

代码：A
1 public class A { 
2 //  public static final Level CUSTOMLEVEL = new Level("test", 550) {}; // 内部类
3 }
代码：TestClassUnload，测试类
 1 package testjvm.testclassloader;
 2
 3 public class TestClassUnLoad {
 4
 5     public static void main(String[] args) throws Exception {
 6         SimpleURLClassLoader loader = new SimpleURLClassLoader();
 7         // 用自定义的加载器加载A
 8         Class clazzA = loader.load("testjvm.testclassloader.A");
 9         Object a = clazzA.newInstance();
10         // 清除相关引用
11         a = null;
12         clazzA = null;
13         loader = null;
14         // 执行一次gc垃圾回收
15         System.gc();
16         System.out.println("GC over");
17     }
18 }
19

      运行的时候配置VM参数: -verbose:class；用于查看class的加载与卸载情况。如果用的是Eclipse，在Run Configurations中配置此参数即可。
图:Run Configurations配置   

输出结果
.....
[Loaded java.net.URI$Parser from E:\java\jdk1.7.0_03\jre\lib\rt.jar]
[Loaded testjvm.testclassloader.A from file:/E:/IDE/work_place/ZJob-Note/bin/]
[Unloading class testjvm.testclassloader.A]
GC over
[Loaded sun.misc.Cleaner from E:\java\jdk1.7.0_03\jre\lib\rt.jar]
[Loaded java.lang.Shutdown from E:\java\jdk1.7.0_03\jre\lib\rt.jar]
......

配置spring

com.alibaba.druid.support.spring.stat.DruidStatInterceptor是一个标准的Spring MethodInterceptor。可以灵活进行AOP配置。

Spring AOP的配置文档： http://static.springsource.org/spring/docs/current/spring-framework-reference/html/aop-api.html

按类型拦截配置

				  <bean id="druid-stat-interceptor"
    class="com.alibaba.druid.support.spring.stat.DruidStatInterceptor">
  </bean>

  <bean id="druid-type-proxyCreator" class="com.alibaba.druid.support.spring.stat.BeanTypeAutoProxyCreator">
    <!-- 所有ABCInterface的派生类被拦截监控  -->
    <property name="targetBeanType" value="xxxx.ABCInterface" />
    <property name="interceptorNames">
        <list>
            <value>druid-stat-interceptor</value>
        </list>
    </property>
  </bean>

		

方法名正则匹配拦截配置

				  <bean id="druid-stat-interceptor"
    class="com.alibaba.druid.support.spring.stat.DruidStatInterceptor">
  </bean>

<bean id="druid-stat-pointcut" class="org.springframework.aop.support.JdkRegexpMethodPointcut"
    scope="prototype">
    <property name="patterns">
        <list>
            <value>com.mycompany.service.*</value>
            <value>com.mycompany.dao.*</value>
        </list>
    </property>
</bean>

<aop:config>
    <aop:advisor advice-ref="druid-stat-interceptor"
        pointcut-ref="druid-stat-pointcut" />
</aop:config>

		

有些情况下，可能你需要配置proxy-target-class，例如：

				<aop:config proxy-target-class="true">
    <aop:advisor advice-ref="druid-stat-interceptor"
        pointcut-ref="druid-stat-pointcut" />
</aop:config>

		

按照BeanId来拦截配置

				  <bean id="druid-stat-interceptor"
    class="com.alibaba.druid.support.spring.stat.DruidStatInterceptor">
  </bean>

<bean
    class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
    <property name="proxyTargetClass" value="true" />
    <property name="beanNames">
        <list>
            <!-- 这里配置需要拦截的bean id列表 -->
            <value>xxx-dao</value>
            <value>xxx-service</value>
        </list>
    </property>
    <property name="interceptorNames">
        <list>
            <value>druid-stat-interceptor</value>
        </list>
    </property>
</bean>
		

来看AtomicInteger提供的接口。

//获取当前的值

public final int get()

//取当前的值，并设置新的值

 public final int getAndSet(int newValue)

//获取当前的值，并自增

 public final int getAndIncrement()

//获取当前的值，并自减

public final int getAndDecrement()

//获取当前的值，并加上预期的值

public final int getAndAdd(int delta)

... ...

下面是一个对比测试，我们写一个synchronized的方法和一个AtomicInteger的方法来进行测试，直观的感受下性能上的差异

结果

time elapse:31
time elapse:16
由此不难看出，通过JNI本地的CAS性能远超synchronized关键字

Reference

http://stackoverflow.com/questions/2443239/java-atomicinteger-what-are-the-differences-between-compareandset-and-weakcompar