<role rolename="manager-gui"/>

<user username="admin" password="" roles="manager-gui"/>

有一点必须注意，其中的rolename 必须是“manager-gui” ，更改成admin 或者 admin-gui，都不好用，而下面的username  password是可以任意的，但是后面的roles 必须和上面role 中的rolename相同。

——基于JDK1.5、Linux（Redhat5.5）、Tomcat6

由于项目的原因，需要使用jconsole对tomcat进行远程监控，结合网上的资料对配置方法进行了总结。

第一步、配置tomcat

打开%TOMCAT_HOME%/bin下的文件catalina.sh，搜索“JAVA_OPTS”找到下面这行：

if [ -z "$LOGGING_MANAGER" ]; then

  JAVA_OPTS="$JAVA_OPTS -Djava.util.logging.manager=org.apache.juli.ClassLoaderLogManager"

else

  JAVA_OPTS="$JAVA_OPTS $LOGGING_MANAGER"

fi 

在每个“JAVA_OPTS”后边都添加以下标黄代码段，且在一行显示：

其中-Djava.rmi.server.hostname项必须设置，否则远程连接会因为解析到127.0.0.1失败，该项的值就是你在windows客户端连接linux时的ip地址

-Dcom.sun.management.jmxremote.port="9004"项设置远程连接端口，不要与其他应用冲突

ssl和authenticate设置为false，如果需要安全，请不要false

第二步、重启tomcat

使用root身份登录系统，进入%TOMCAT_HOME%/bin目录下：

第三步、运行jconsole

进入JDK安装目录%JDK_HOME%/bin下，找到“jconsole.exe”，点击运行并选择【远程】选项卡：

在【主机名或ip】输入要远程监控的tomcat服务器地址

在【端口】输入上文设置的端口号：9004

【用户名、口令】为空，点击【连接】进入监控界面。

import java.lang.management.MemoryUsage; 
import java.text.SimpleDateFormat; 
import java.util.Date; 
import java.util.Formatter; 
import java.util.HashMap; 
import java.util.Iterator; 
import java.util.Map; 
import java.util.Set; 
 
import javax.management.MBeanAttributeInfo; 
import javax.management.MBeanInfo; 
import javax.management.MBeanServerConnection; 
import javax.management.ObjectInstance; 
import javax.management.ObjectName; 
import javax.management.openmbean.CompositeDataSupport; 
import javax.management.remote.JMXConnector; 
import javax.management.remote.JMXConnectorFactory; 
import javax.management.remote.JMXServiceURL; 
 
public class test { 
    /** 
     * @param args 
     */ 
    public static void main(String[] args) { 
        try { 
 
            String jmxURL = "service:jmx:rmi:///jndi/rmi://192.168.1.126:10090/jmxrmi";//tomcat jmx url   
            JMXServiceURL serviceURL = new JMXServiceURL(jmxURL); 
 
            Map map = new HashMap(); 
            String[] credentials = new String[] { "monitorRole", "QED" }; 
            map.put("jmx.remote.credentials", credentials); 
            JMXConnector connector = JMXConnectorFactory.connect(serviceURL, map); 
            MBeanServerConnection mbsc = connector.getMBeanServerConnection(); 
 
            //端口最好是动态取得   
            ObjectName threadObjName = new ObjectName("Catalina:type=ThreadPool,name=http-8089"); 
            MBeanInfo mbInfo = mbsc.getMBeanInfo(threadObjName); 
 
            String attrName = "currentThreadCount";//tomcat的线程数对应的属性值   
            MBeanAttributeInfo[] mbAttributes = mbInfo.getAttributes(); 
            System.out.println("currentThreadCount:" + mbsc.getAttribute(threadObjName, attrName)); 
 
            //heap   
            for (int j = 0; j < mbsc.getDomains().length; j++) { 
                System.out.println("###########" + mbsc.getDomains()[j]); 
            } 
            Set MBeanset = mbsc.queryMBeans(null, null); 
            System.out.println("MBeanset.size() : " + MBeanset.size()); 
            Iterator MBeansetIterator = MBeanset.iterator(); 
            while (MBeansetIterator.hasNext()) { 
                ObjectInstance objectInstance = (ObjectInstance) MBeansetIterator.next(); 
                ObjectName objectName = objectInstance.getObjectName(); 
                String canonicalName = objectName.getCanonicalName(); 
                System.out.println("canonicalName : " + canonicalName); 
                if (canonicalName.equals("Catalina:host=localhost,type=Cluster")) { 
                    // Get details of cluster MBeans   
                    System.out.println("Cluster MBeans Details:"); 
                    System.out.println("========================================="); 
                    //getMBeansDetails(canonicalName);   
                    String canonicalKeyPropList = objectName.getCanonicalKeyPropertyListString(); 
                } 
            } 
            //------------------------- system ----------------------   
            ObjectName runtimeObjName = new ObjectName("java.lang:type=Runtime"); 
            System.out.println("厂商:" + (String) mbsc.getAttribute(runtimeObjName, "VmVendor")); 
            System.out.println("程序:" + (String) mbsc.getAttribute(runtimeObjName, "VmName")); 
            System.out.println("版本:" + (String) mbsc.getAttribute(runtimeObjName, "VmVersion")); 
            Date starttime = new Date((Long) mbsc.getAttribute(runtimeObjName, "StartTime")); 
            SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); 
            System.out.println("启动时间:" + df.format(starttime)); 
 
            Long timespan = (Long) mbsc.getAttribute(runtimeObjName, "Uptime"); 
            System.out.println("连续工作时间:" + test.formatTimeSpan(timespan)); 
            //------------------------ JVM -------------------------   
            //堆使用率   
            ObjectName heapObjName = new ObjectName("java.lang:type=Memory"); 
            MemoryUsage heapMemoryUsage = MemoryUsage.from((CompositeDataSupport) mbsc.getAttribute(heapObjName, 
                    "HeapMemoryUsage")); 
            long maxMemory = heapMemoryUsage.getMax();//堆最大   
            long commitMemory = heapMemoryUsage.getCommitted();//堆当前分配   
            long usedMemory = heapMemoryUsage.getUsed(); 
            System.out.println("heap:" + (double) usedMemory * 100 / commitMemory + "%");//堆使用率   
 
            MemoryUsage nonheapMemoryUsage = MemoryUsage.from((CompositeDataSupport) mbsc.getAttribute(heapObjName, 
                    "NonHeapMemoryUsage")); 
            long noncommitMemory = nonheapMemoryUsage.getCommitted(); 
            long nonusedMemory = heapMemoryUsage.getUsed(); 
            System.out.println("nonheap:" + (double) nonusedMemory * 100 / noncommitMemory + "%"); 
 
            ObjectName permObjName = new ObjectName("java.lang:type=MemoryPool,name=Perm Gen"); 
            MemoryUsage permGenUsage = MemoryUsage.from((CompositeDataSupport) mbsc.getAttribute(permObjName, "Usage")); 
            long committed = permGenUsage.getCommitted();//持久堆大小   
            long used = heapMemoryUsage.getUsed();//   
            System.out.println("perm gen:" + (double) used * 100 / committed + "%");//持久堆使用率   
 
            //-------------------- Session ---------------    
            ObjectName managerObjName = new ObjectName("Catalina:type=Manager,*"); 
            Set<ObjectName> s = mbsc.queryNames(managerObjName, null); 
            for (ObjectName obj : s) { 
                System.out.println("应用名:" + obj.getKeyProperty("path")); 
                ObjectName objname = new ObjectName(obj.getCanonicalName()); 
                System.out.println("最大会话数:" + mbsc.getAttribute(objname, "maxActiveSessions")); 
                System.out.println("会话数:" + mbsc.getAttribute(objname, "activeSessions")); 
                System.out.println("活动会话数:" + mbsc.getAttribute(objname, "sessionCounter")); 
            } 
 
            //----------------- Thread Pool ----------------   
            ObjectName threadpoolObjName = new ObjectName("Catalina:type=ThreadPool,*"); 
            Set<ObjectName> s2 = mbsc.queryNames(threadpoolObjName, null); 
            for (ObjectName obj : s2) { 
                System.out.println("端口名:" + obj.getKeyProperty("name")); 
                ObjectName objname = new ObjectName(obj.getCanonicalName()); 
                System.out.println("最大线程数:" + mbsc.getAttribute(objname, "maxThreads")); 
                System.out.println("当前线程数:" + mbsc.getAttribute(objname, "currentThreadCount")); 
                System.out.println("繁忙线程数:" + mbsc.getAttribute(objname, "currentThreadsBusy")); 
            } 
 
        } catch (Exception e) { 
            e.printStackTrace(); 
        } 
    } 
 
    public static String formatTimeSpan(long span) { 
        long minseconds = span % 1000; 
 
        span = span / 1000; 
        long seconds = span % 60; 
 
        span = span / 60; 
        long mins = span % 60; 
 
        span = span / 60; 
        long hours = span % 24; 
 
        span = span / 24; 
        long days = span; 
        return (new Formatter()).format("%1$d天 %2$02d:%3$02d:%4$02d.%5$03d", days, hours, mins, seconds, minseconds) 
                .toString(); 
    } 
 
}  

import java.util.Iterator;    
import java.util.Set;    
import javax.management.Attribute;    
import javax.management.MBeanInfo;    
import javax.management.MBeanServerConnection;    
import javax.management.MBeanServerInvocationHandler;    
import javax.management.ObjectInstance;    
import javax.management.ObjectName;    
import javax.management.remote.JMXConnector;    
import javax.management.remote.JMXConnectorFactory;    
import javax.management.remote.JMXServiceURL;    
public class Client {    
    public static void main(String[] args) throws Exception {       
        JMXServiceURL url = new JMXServiceURL("service:jmx:rmi:///jndi/rmi://localhost:9999/server");       
        JMXConnector jmxc = JMXConnectorFactory.connect(url, null);        
        MBeanServerConnection mbsc = jmxc.getMBeanServerConnection();      
        ObjectName mbeanName = new ObjectName("chengang:name=HelloWorld");    
        // 把所有Domain都打印出来    
        System.out.println("Domains:---------------");       
        String domains[] = mbsc.getDomains();        
        for (int i = 0; i < domains.length; i++) {        
            System.out.println("\tDomain[" + i + "] = " + domains[i]);     
        }    
        // MBean的总数    
        System.out.println("MBean count = " + mbsc.getMBeanCount());    
        // 对name属性的操作（属性名的第一个字母要大写）    
        mbsc.setAttribute(mbeanName, new Attribute("Name", "PANDA"));// 设值    
        System.out.println("Name = " + mbsc.getAttribute(mbeanName, "Name"));// 取值    
        // 得到proxy代理后直接调用的方式    
        HelloMBean proxy = (HelloMBean) MBeanServerInvocationHandler.newProxyInstance(mbsc, mbeanName, HelloMBean.class, false);         
        proxy.printHello();         
        proxy.printHello("Raymend");    
        // 远程调用的方式    
        mbsc.invoke(mbeanName, "printHello", null, null);          
        mbsc.invoke(mbeanName, "printHello", new Object[] { "熊猫烧香" }, new String[] { String.class.getName() });    
        // 得mbean的信息    
        MBeanInfo info = mbsc.getMBeanInfo(mbeanName);          
        System.out.println("Hello Class: " + info.getClassName());       
        System.out.println("Hello Attriber：" + info.getAttributes()[0].getName());      
        System.out.println("Hello Operation：" + info.getOperations()[0].getName());    
        // 得到所有的MBean的ObjectName    
        System.out.println("all ObjectName：---------------");         
        Set set = mbsc.queryMBeans(null, null);        
        for (Iterator it = set.iterator(); it.hasNext();) {         
            ObjectInstance oi = (ObjectInstance) it.next();         
            System.out.println("\t" + oi.getObjectName());         
            }
        // 关闭MBeanServer连接    
        jmxc.close();      
}    
}    

Java语言的关键字，当它用来修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码。

     一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。

     二、然而，当一个线程访问object的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该object中的非synchronized(this)同步代码块。

     三、尤其关键的是，当一个线程访问object的一个synchronized(this)同步代码块时，其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞。

     四、第三个例子同样适用其它同步代码块。也就是说，当一个线程访问object的一个synchronized(this)同步代码块时，它就获得了这个object的对象锁。结果，其它线程对该object对象所有同步代码部分的访问都被暂时阻塞。

     五、以上规则对其它对象锁同样适用.

举例说明： 
     一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。

package ths;

public class Thread1 implements Runnable { 
     public void run() { 
          synchronized(this) { 
               for (int i = 0; i < 5; i++) { 
                    System.out.println(Thread.currentThread().getName() + " synchronized loop " + i); 
               } 
          } 
     } 
     public static void main(String[] args) { 
          Thread1 t1 = new Thread1(); 
          Thread ta = new Thread(t1, "A"); 
          Thread tb = new Thread(t1, "B"); 
          ta.start(); 
          tb.start(); 
     }    
}

结果： 
     A synchronized loop 0 
     A synchronized loop 1 
     A synchronized loop 2 
     A synchronized loop 3 
     A synchronized loop 4 
     B synchronized loop 0 
     B synchronized loop 1 
     B synchronized loop 2 
     B synchronized loop 3 
     B synchronized loop 4

     二、然而，当一个线程访问object的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该object中的非synchronized(this)同步代码块。

package ths;

public class Thread2 { 
     public void m4t1() { 
          synchronized(this) { 
               int i = 5; 
               while( i-- > 0) { 
                    System.out.println(Thread.currentThread().getName() + " : " + i); 
                    try { 
                         Thread.sleep(500); 
                    } catch (InterruptedException ie) { 
                    } 
               } 
          } 
     } 
     public void m4t2() { 
          int i = 5; 
          while( i-- > 0) { 
               System.out.println(Thread.currentThread().getName() + " : " + i); 
               try { 
                    Thread.sleep(500); 
               } catch (InterruptedException ie) { 
               } 
          } 
     } 
     public static void main(String[] args) { 
          final Thread2 myt2 = new Thread2(); 
          Thread t1 = new Thread(  new Runnable() {  public void run() {  myt2.m4t1();  }  }, "t1"  ); 
          Thread t2 = new Thread(  new Runnable() {  public void run() { myt2.m4t2();   }  }, "t2"  ); 
          t1.start(); 
          t2.start(); 
     }    
}

结果： 
     t1 : 4 
     t2 : 4 
     t1 : 3 
     t2 : 3 
     t1 : 2 
     t2 : 2 
     t1 : 1 
     t2 : 1 
     t1 : 0 
     t2 : 0

     三、尤其关键的是，当一个线程访问object的一个synchronized(this)同步代码块时，其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞。

     //修改Thread2.m4t2()方法： 
     public void m4t2() { 
          synchronized(this) { 
               int i = 5; 
               while( i-- > 0) { 
                    System.out.println(Thread.currentThread().getName() + " : " + i); 
                    try { 
                         Thread.sleep(500); 
                    } catch (InterruptedException ie) { 
                    } 
               } 
          }

     }

结果：

     t1 : 4 
     t1 : 3 
     t1 : 2 
     t1 : 1 
     t1 : 0 
     t2 : 4 
     t2 : 3 
     t2 : 2 
     t2 : 1 
     t2 : 0

     四、第三个例子同样适用其它同步代码块。也就是说，当一个线程访问object的一个synchronized(this)同步代码块时，它就获得了这个object的对象锁。结果，其它线程对该object对象所有同步代码部分的访问都被暂时阻塞。

     //修改Thread2.m4t2()方法如下：

     public synchronized void m4t2() { 
          int i = 5; 
          while( i-- > 0) { 
               System.out.println(Thread.currentThread().getName() + " : " + i); 
               try { 
                    Thread.sleep(500); 
               } catch (InterruptedException ie) { 
               } 
          } 
     }

结果： 
     t1 : 4 
     t1 : 3 
     t1 : 2 
     t1 : 1 
     t1 : 0 
     t2 : 4 
     t2 : 3 
     t2 : 2 
     t2 : 1 
     t2 : 0

     五、以上规则对其它对象锁同样适用:

package ths;

public class Thread3 {   
     class Inner {    
          private void m4t1() {    
               int i = 5;    
               while(i-- > 0) {    
                    System.out.println(Thread.currentThread().getName() + " : Inner.m4t1()=" + i);    
                    try {    
                         Thread.sleep(500);    
                    } catch(InterruptedException ie) {    
                    }    
               }    
          }    
          private void m4t2() {    
               int i = 5;    
               while(i-- > 0) {    
                    System.out.println(Thread.currentThread().getName() + " : Inner.m4t2()=" + i);    
                    try {    
                         Thread.sleep(500);    
                    } catch(InterruptedException ie) {    
                    }    
               }    
          }    
     }    
     private void m4t1(Inner inner) {    
          synchronized(inner) { //使用对象锁    
          inner.m4t1();    
     }    
     private void m4t2(Inner inner) {    
          inner.m4t2();    
     }    
     public static void main(String[] args) {    
          final Thread3 myt3 = new Thread3();    
          final Inner inner = myt3.new Inner();    
          Thread t1 = new Thread( new Runnable() {public void run() { myt3.m4t1(inner);} }, "t1");    
     Thread t2 = new Thread( new Runnable() {public void run() { myt3.m4t2(inner);} }, "t2");    
     t1.start();    
     t2.start();    
  }    
}

结果：

尽管线程t1获得了对Inner的对象锁，但由于线程t2访问的是同一个Inner中的非同步部分。所以两个线程互不干扰。

     t1 : Inner.m4t1()=4 
     t2 : Inner.m4t2()=4 
     t1 : Inner.m4t1()=3 
     t2 : Inner.m4t2()=3 
     t1 : Inner.m4t1()=2 
     t2 : Inner.m4t2()=2 
     t1 : Inner.m4t1()=1 
     t2 : Inner.m4t2()=1 
     t1 : Inner.m4t1()=0 
     t2 : Inner.m4t2()=0

现在在Inner.m4t2()前面加上synchronized：

     private synchronized void m4t2() { 
          int i = 5; 
          while(i-- > 0) { 
               System.out.println(Thread.currentThread().getName() + " : Inner.m4t2()=" + i); 
               try { 
                    Thread.sleep(500); 
               } catch(InterruptedException ie) { 
               } 
          } 
     }

结果：

尽管线程t1与t2访问了同一个Inner对象中两个毫不相关的部分,但因为t1先获得了对Inner的对象锁，所以t2对Inner.m4t2()的访问也被阻塞，因为m4t2()是Inner中的一个同步方法。

     t1 : Inner.m4t1()=4 
     t1 : Inner.m4t1()=3 
     t1 : Inner.m4t1()=2 
     t1 : Inner.m4t1()=1 
     t1 : Inner.m4t1()=0 
     t2 : Inner.m4t2()=4 
     t2 : Inner.m4t2()=3 
     t2 : Inner.m4t2()=2 
     t2 : Inner.m4t2()=1 
     t2 : Inner.m4t2()=0

第二篇：

synchronized 关键字，它包括两种用法：synchronized 方法和 synchronized 块。 
1. synchronized 方法：通过在方法声明中加入 synchronized关键字来声明 synchronized 方法。如： 
public synchronized void accessVal(int newVal); 
synchronized 方法控制对类成员变量的访问：每个类实例对应一把锁，每个 synchronized 方法都必须获得调用该方法的类实例的锁方能

执行，否则所属线程阻塞，方法一旦执行，就独占该锁，直到从该方法返回时才将锁释放，此后被阻塞的线程方能获得该锁，重新进入可执行

状态。这种机制确保了同一时刻对于每一个类实例，其所有声明为 synchronized 的成员函数中至多只有一个处于可执行状态（因为至多只有

一个能够获得该类实例对应的锁），从而有效避免了类成员变量的访问冲突（只要所有可能访问类成员变量的方法均被声明为 synchronized）

。 
在 Java 中，不光是类实例，每一个类也对应一把锁，这样我们也可将类的静态成员函数声明为 synchronized ，以控制其对类的静态成

员变量的访问。 
synchronized 方法的缺陷：若将一个大的方法声明为synchronized 将会大大影响效率，典型地，若将线程类的方法 run() 声明为

synchronized ，由于在线程的整个生命期内它一直在运行，因此将导致它对本类任何 synchronized 方法的调用都永远不会成功。当然我们可

以通过将访问类成员变量的代码放到专门的方法中，将其声明为 synchronized ，并在主方法中调用来解决这一问题，但是 Java 为我们提供

了更好的解决办法，那就是 synchronized 块。 
2. synchronized 块：通过 synchronized关键字来声明synchronized 块。语法如下： 
synchronized(syncObject) { 
//允许访问控制的代码 
} 
synchronized 块是这样一个代码块，其中的代码必须获得对象 syncObject （如前所述，可以是类实例或类）的锁方能执行，具体机

制同前所述。由于可以针对任意代码块，且可任意指定上锁的对象，故灵活性较高。 
对synchronized(this)的一些理解    
一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。另一个线

程必须等待当前线程执行完这个代码块以后才能执行该代码块。 
二、然而，当一个线程访问object的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该object中的非synchronized

(this)同步代码块。 
三、尤其关键的是，当一个线程访问object的一个synchronized(this)同步代码块时，其他线程对object中所有其它synchronized(this)

同步代码块的访问将被阻塞。 
四、第三个例子同样适用其它同步代码块。也就是说，当一个线程访问object的一个synchronized(this)同步代码块时，它就获得了这个

object的对象锁。结果，其它线程对该object对象所有同步代码部分的访问都被暂时阻塞。 
五、以上规则对其它对象锁同样适用

http://hi.baidu.com/sunshibing/blog/item/5235b9b731d48ff430add14a.html
java中synchronized用法

打个比方：一个object就像一个大房子，大门永远打开。房子里有 很多房间（也就是方法）。

这些房间有上锁的（synchronized方法）， 和不上锁之分（普通方法）。房门口放着一把钥匙（key），这把钥匙可以打开所有上锁的房间。

另外我把所有想调用该对象方法的线程比喻成想进入这房子某个 房间的人。所有的东西就这么多了，下面我们看看这些东西之间如何作用的。

在此我们先来明确一下我们的前提条件。该对象至少有一个synchronized方法，否则这个key还有啥意义。当然也就不会有我们的这个主题了。

一个人想进入某间上了锁的房间，他来到房子门口，看见钥匙在那儿（说明暂时还没有其他人要使用上锁的 房间）。于是他走上去拿到了钥匙

，并且按照自己 的计划使用那些房间。注意一点，他每次使用完一次上锁的房间后会马上把钥匙还回去。即使他要连续使用两间上锁的房间，

中间他也要把钥匙还回去，再取回来。

因此，普通情况下钥匙的使用原则是：“随用随借，用完即还。”

这时其他人可以不受限制的使用那些不上锁的房间，一个人用一间可以，两个人用一间也可以，没限制。但是如果当某个人想要进入上锁的房

间，他就要跑到大门口去看看了。有钥匙当然拿了就走，没有的话，就只能等了。

要是很多人在等这把钥匙，等钥匙还回来以后，谁会优先得到钥匙？Not guaranteed。象前面例子里那个想连续使用两个上锁房间的家伙，他

中间还钥匙的时候如果还有其他人在等钥匙，那么没有任何保证这家伙能再次拿到。 （JAVA规范在很多地方都明确说明不保证，象

Thread.sleep()休息后多久会返回运行，相同优先权的线程那个首先被执行，当要访问对象的锁被 释放后处于等待池的多个线程哪个会优先得

到，等等。我想最终的决定权是在JVM，之所以不保证，就是因为JVM在做出上述决定的时候，绝不是简简单单根据 一个条件来做出判断，而是

根据很多条。而由于判断条件太多，如果说出来可能会影响JAVA的推广，也可能是因为知识产权保护的原因吧。SUN给了个不保证 就混过去了

。无可厚非。但我相信这些不确定，并非完全不确定。因为计算机这东西本身就是按指令运行的。即使看起来很随机的现象，其实都是有规律

可寻。学过 计算机的都知道，计算机里随机数的学名是伪随机数，是人运用一定的方法写出来的，看上去随机罢了。另外，或许是因为要想弄

的确定太费事，也没多大意义，所 以不确定就不确定了吧。）

再来看看同步代码块。和同步方法有小小的不同。

1.从尺寸上讲，同步代码块比同步方法小。你可以把同步代码块看成是没上锁房间里的一块用带锁的屏风隔开的空间。

2.同步代码块还可以人为的指定获得某个其它对象的key。就像是指定用哪一把钥匙才能开这个屏风的锁，你可以用本房的钥匙；你也可以指定

用另一个房子的钥匙才能开，这样的话，你要跑到另一栋房子那儿把那个钥匙拿来，并用那个房子的钥匙来打开这个房子的带锁的屏风。

         记住你获得的那另一栋房子的钥匙，并不影响其他人进入那栋房子没有锁的房间。

         为什么要使用同步代码块呢？我想应该是这样的：首先对程序来讲同步的部分很影响运行效率，而一个方法通常是先创建一些局部变

量，再对这些变量做一些 操作，如运算，显示等等；而同步所覆盖的代码越多，对效率的影响就越严重。因此我们通常尽量缩小其影响范围。

如何做？同步代码块。我们只把一个方法中该同 步的地方同步，比如运算。

         另外，同步代码块可以指定钥匙这一特点有个额外的好处，是可以在一定时期内霸占某个对象的key。还记得前面说过普通情况下钥

匙的使用原则吗。现在不是普通情况了。你所取得的那把钥匙不是永远不还，而是在退出同步代码块时才还。

          还用前面那个想连续用两个上锁房间的家伙打比方。怎样才能在用完一间以后，继续使用另一间呢。用同步代码块吧。先创建另外

一个线程，做一个同步代码 块，把那个代码块的锁指向这个房子的钥匙。然后启动那个线程。只要你能在进入那个代码块时抓到这房子的钥匙

，你就可以一直保留到退出那个代码块。也就是说 你甚至可以对本房内所有上锁的房间遍历，甚至再sleep(10*60*1000)，而房门口却还有

1000个线程在等这把钥匙呢。很过瘾吧。

          在此对sleep()方法和钥匙的关联性讲一下。一个线程在拿到key后，且没有完成同步的内容时，如果被强制sleep()了，那key还一

直在 它那儿。直到它再次运行，做完所有同步内容，才会归还key。记住，那家伙只是干活干累了，去休息一下，他并没干完他要干的事。为

了避免别人进入那个房间 把里面搞的一团糟，即使在睡觉的时候他也要把那唯一的钥匙戴在身上。

          最后，也许有人会问，为什么要一把钥匙通开，而不是一个钥匙一个门呢？我想这纯粹是因为复杂性问题。一个钥匙一个门当然更

安全，但是会牵扯好多问题。钥匙 的产生，保管，获得，归还等等。其复杂性有可能随同步方法的增加呈几何级数增加，严重影响效率。这也

算是一个权衡的问题吧。为了增加一点点安全性，导致效 率大大降低，是多么不可取啊。

synchronized的一个简单例子

public class TextThread {

public static void main(String[] args) {   
   TxtThread tt = new TxtThread();    
   new Thread(tt).start();    
   new Thread(tt).start();    
   new Thread(tt).start();    
   new Thread(tt).start();    
}    
}

class TxtThread implements Runnable {   
int num = 100;    
String str = new String();

public void run() {   
   synchronized (str) {    
    while (num > 0) {

     try {   
      Thread.sleep(1);    
     } catch (Exception e) {    
      e.getMessage();    
     }    
     System.out.println(Thread.currentThread().getName()    
       + "this is " + num--);    
    }    
   }    
}    
}

上面的例子中为了制造一个时间差,也就是出错的机会,使用了Thread.sleep(10)

Java对多线程的支持与同步机制深受大家的喜爱，似乎看起来使用了synchronized关键字就可以轻松地解决多线程共享数据同步问题。到底如

何？――还得对synchronized关键字的作用进行深入了解才可定论。

总的说来，synchronized关键字可以作为函数的修饰符，也可作为函数内的语句，也就是平时说的同步方法和同步语句块。如果再细的分类，

synchronized可作用于instance变量、object reference（对象引用）、static函数和class literals(类名称字面常量)身上。

在进一步阐述之前，我们需要明确几点：

A．无论synchronized关键字加在方法上还是对象上，它取得的锁都是对象，而不是把一段代码或函数当作锁――而且同步方法很可能还会被其

他线程的对象访问。

B．每个对象只有一个锁（lock）与之相关联。

C．实现同步是要很大的系统开销作为代价的，甚至可能造成死锁，所以尽量避免无谓的同步控制。

接着来讨论synchronized用到不同地方对代码产生的影响：

假设P1、P2是同一个类的不同对象，这个类中定义了以下几种情况的同步块或同步方法，P1、P2就都可以调用它们。

1． 把synchronized当作函数修饰符时，示例代码如下：

Public synchronized void methodAAA()

{

//….

}

这也就是同步方法，那这时synchronized锁定的是哪个对象呢？它锁定的是调用这个同步方法对象。也就是说，当一个对象P1在不同的线程中

执行这个同步方法时，它们之间会形成互斥，达到同步的效果。但是这个对象所属的Class所产生的另一对象P2却可以任意调用这个被加了

synchronized关键字的方法。

上边的示例代码等同于如下代码：

public void methodAAA()

{

synchronized (this)      // (1)

{

       //…..

}

}

(1)处的this指的是什么呢？它指的就是调用这个方法的对象，如P1。可见同步方法实质是将synchronized作用于object reference。――那个

拿到了P1对象锁的线程，才可以调用P1的同步方法，而对P2而言，P1这个锁与它毫不相干，程序也可能在这种情形下摆脱同步机制的控制，造

成数据混乱：（

2．同步块，示例代码如下：

public void method3(SomeObject so)

{

    synchronized(so)

    {   
       //…..    
    }

}

这时，锁就是so这个对象，谁拿到这个锁谁就可以运行它所控制的那段代码。当有一个明确的对象作为锁时，就可以这样写程序，但当没有明

确的对象作为锁，只是想让一段代码同步时，可以创建一个特殊的instance变量（它得是一个对象）来充当锁：

class Foo implements Runnable

{

        private byte[] lock = new byte[0]; // 特殊的instance变量

        Public void methodA()   
        {

           synchronized(lock) { //… }

        }

        //…..

}

注：零长度的byte数组对象创建起来将比任何对象都经济――查看编译后的字节码：生成零长度的byte[]对象只需3条操作码，而Object lock

= new Object()则需要7行操作码。

3．将synchronized作用于static 函数，示例代码如下：

Class Foo   
{

    public synchronized static void methodAAA()   // 同步的static 函数   
    {    
        //….    
    }

    public void methodBBB()   
    {

       synchronized(Foo.class)   // class literal(类名称字面常量)

    }   
}

   代码中的methodBBB()方法是把class literal作为锁的情况，它和同步的static函数产生的效果是一样的，取得的锁很特别，是当前调用这

个方法的对象所属的类（Class，而不再是由这个Class产生的某个具体对象了）。

记得在《Effective Java》一书中看到过将 Foo.class和 P1.getClass()用于作同步锁还不一样，不能用P1.getClass()来达到锁这个Class的

目的。P1指的是由Foo类产生的对象。

可以推断：如果一个类中定义了一个synchronized的static函数A，也定义了一个synchronized 的instance函数B，那么这个类的同一对象Obj

在多线程中分别访问A和B两个方法时，不会构成同步，因为它们的锁都不一样。A方法的锁是Obj这个对象，而B的锁是Obj所属的那个Class。

小结如下：

搞清楚synchronized锁定的是哪个对象，就能帮助我们设计更安全的多线程程序。

还有一些技巧可以让我们对共享资源的同步访问更加安全：

1． 定义private 的instance变量+它的 get方法，而不要定义public/protected的instance变量。如果将变量定义为public，对象在外界可以

绕过同步方法的控制而直接取得它，并改动它。这也是JavaBean的标准实现方式之一。

2． 如果instance变量是一个对象，如数组或ArrayList什么的，那上述方法仍然不安全，因为当外界对象通过get方法拿到这个instance对象

的引用后，又将其指向另一个对象，那么这个private变量也就变了，岂不是很危险。 这个时候就需要将get方法也加上synchronized同步，并

且，只返回这个private对象的clone()――这样，调用端得到的就是对象副本的引用了

优化MyEclipse：

经过以上的优化，myeclipse的启动时间可以减少2/3，Tomcat的启动速度可以减少1/2(视具体情况而定)，

特别6，7两项的优化效果最明显，

如果只进行前5项，优化的效果有限，短期内确实可以提高启动速度，但是大概半个月后又会变的很慢（具体原因不明）
另外，使用myeclipse一段时间后，就会产生很多项目，即使这些项目是处于关闭状态，myecliose在启动时也会加载这些项目，这个过程会花费很多时间，所以，建议将不用的项目都delete掉，用的时候再import

在用[MyEclipse] 写代码很容易卡死机，尤其是在对JSP文件的﹤%%﹥之间写代码的时候，只要一弹出智能提示就立刻卡死，程序失去响应，我以为是MyEclipse版本的问题，结果换了6.0版-﹥6.5版-﹥7.0版全都一样，难道是我机子的问题？可是还原系统后用还是一样的结果。

百度一下你就知道，但是百度了N下才找到了一些门路，搜索也讲究技巧，换了N个[关键字] 组合才搜出来。说是MyEclipse在智能提示的时候自动访问网络上sun公司的最新API文档，只要关闭掉网络连接就可以了。我试了试断开网络然后在用MyEclipse写代码，结果还真的搞定了。可是，我总不能因为个这就不上网了吧，继续接着百度，找到了两全其美的解决方法。

在自己创建的工程名上右键，选择Properties--﹥在打开的窗口中点击Java Build Path--﹥单击Libraries选项卡，找到如图中标记2所示的地方--﹥选择右边的Remove更改成如标记1所示的样子--﹥点击OK。

举个简单的例子，一个让用户输入姓名的HTML表单(Form)。示例代码如下：

<form action="http://www.blabla.cn/asdocs/html_tutorials/yourname.asp" method="get">

请输入你的姓名：

<input type="text" name="yourname">

<input type="submit" value="提交">

</form>

学习HTML表单(Form)最关键要掌握的有三个要点：

表单控件(Form Controls)
Action
Method
先说表单控件(Form Controls)，通过HTML表单的各种控件，用户可以输入文字信息，或者从选项中选择，以及做提交的操作。比如上面的例句里，input type= "text"就是一个表单控件，表示一个单行输入框。

用户填入表单的信息总是需要程序来进行处理，表单里的action就指明了处理表单信息的文件。比如上面例句里的http://www.linkzj.cn/asdocs/html_tutorials/yourname.asp。

至于method，表示了发送表单信息的方式。method有两个值：get和post。get的方式是将表单控件的name/value信息经过编码之后，通过URL发送(你可以在地址栏里看到)。而post则将表单的内容通过http发送，你在地址栏看不到表单的提交信息。那什么时候用get，什么时候用post呢？一般是这样来判断的，如果只是为取得和显示数据，用get；一旦涉及数据的保存和更新，那么建议用post。

HTML表单(Form)常用控件(Controls)
HTML表单(Form)常用控件有：

input type="text" 单行文本输入框
input type="submit" 将表单(Form)里的信息提交给表单里action所指向的文件
input type="checkbox" 复选框
input type="radio" 单选框
select 下拉框
textArea 多行文本输入框
input type="password" 密码输入框(输入的文字用*表示)
表单控件(Form Control)：单行文本输入框(input type="text")
单行文本输入框允许用户输入一些简短的单行信息，比如用户姓名。例句如下：

<input type="text" name="yourname">

表单控件(Form Control)：
复选框(input type="checkbox")
复选框允许用户在一组选项里，选择多个。示例代码：

<input type="checkbox" name="fruit" value ="apple">苹果<br>

<input type="checkbox" name="fruit" value ="orange">桔子<br>

<input type="checkbox" name="fruit" value ="mango">芒果<br>

用checked表示缺省已选的选项。

<input type="checkbox" name="fruit" value ="orange" checked>桔子<br>

表单控件(Form Control)：单选框(input type="radio")
使用单选框，让用户在一组选项里只能选择一个。示例代码：

<input type="radio" name="fruit" value = "Apple">苹果<br>

<input type="radio" name="fruit" value = "Orange">桔子<br>

<input type="radio" name="fruit" value = "Mango">芒果<br>

用checked表示缺省已选的选项。

<input type="radio" name="fruit" value = "Orange" checked>桔子<br>

表单控件(Form Control)：下拉框(select)
下拉框(Select)既可以用做单选，也可以用做复选。单选例句如下：

<select name="fruit" >

<option value="apple">苹果

<option value="orange">桔子

<option value="mango">芒果

</select>

如果要变成复选，加muiltiple即可。用户用Ctrl来实现多选。例句：

<select name="fruit" multiple>

用户还可以用size属性来改变下拉框(Select)的大小。

表单控件(Form Control)：多行输入框(textarea)
多行输入框(textarea)主要用于输入较长的文本信息。例句如下：

<textarea name="yoursuggest" cols ="50" rows = "3"></textarea>

其中cols表示textarea的宽度，rows表示textarea的高度。

表单控件(Form Control)：密码输入框(input type="password")
密码输入框(input type="password")主要用于一些保密信息的输入，比如密码。因为用户输入的时候，显示的不是输入的内容，而是黑点符号。。例句如下：

<input type="password" name="yourpw">

表单控件(Form Control)：提交(input type="submit")
通过提交(input type=submit)可以将表单(Form)里的信息提交给表单里action所指向的文件。例句如下：

<input type="submit" value="提交">

表单控件(Form Control)：图片提交(input type="image")
input type=image 相当于 input type=submit，不同的是，input type=image 以一个图片作为表单的提交按钮，其中 src 属性表示图片的路径。

<input type="image" src ="http://www.blabla.cn/images/icons/go.gif"  alt = "提交" NAME="imgsubmit">

这个url中，a、b和c是url参数，具体的说是参数名，与之用“=”隔开的是对应的参数值。也就是说参数a的值为3、参数b的值为5、参数c的值为7。get.do是请求地址，紧跟这个地址的参数a需要用“?”作为分隔符，其余参数用“&”做分隔符。

这种get请求发起后，服务器端可以通过request.getParameter()方法来获得参数值。如要获得参数a的值可以通过request.getParameter("a");

2.Post方式
相比get方式，post方式更为隐蔽。例如：http://www.javaweb.cc/post.do
在这个url中，你看不到任何参数，真正的参数隐藏在Http请求的数据体中。如果了解网络监听的话，就会对这一点深有体会。
我们举一个简单的例子：通过表单做登录操作。
我们简化一个登录表单：

<form action="login.do" method="post">
<ul>
<li><label for="username">用户名</label><input id="username" name="username" type="text" /></li>
<li><label for="password">密码</label><input id="password" type="password" /></li>
<li><label><input type="submit" value="登录" /> <input
type="reset" value="重置" /></label></li>
</ul>
</form>
表单中有2个字段，用户名（username）和密码（password）
注意form标签中的method参数值是post！

即便是表单，在服务器端仍然可以通过request.getParameter()方法来获得参数值。
Post方式，其实是将表单字段和经过编码的字段值经过组合以数据体的方式做了参数传递。

经过一番阐述，相信大家对两种网络参数传递方式都有所了解了。
Get方式比较简单，通过构建一个简单HttpURLConnection就可以获得，我们暂且不说。
我们主要来描述一下如何通过java代码构建一个表单提交。
仔细研究表单提交时所对应的http数据体，发现其表单字段是以如下方式构建的：

arg0=urlencode(value0)&arg1=urlencode(value1)
当然，尤其要注意字段名，参数名只不能使用中文这类字符。
3、通过httpclient来模拟POST提交表单：

import java.util.Random;
import java.util.ArrayList;
import java.util.List;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.cookie.Cookie;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.protocol.HTTP;
import org.apache.http.util.EntityUtils;

/** *//**
 * Example how to use multipart/form encoded POST request.
 */
public class ClientMultipartFormPost {



    public static void ExecuClient(String userName, String wlanuserip2,
            String wlanacip2) throws Exception {
        DefaultHttpClient httpclient = new DefaultHttpClient();
        String a1="http://172.21.16.38:8080/bpss/jsp/do_login.jsp";
        try {
            HttpGet httpget = new HttpGet(a1);
            HttpResponse response = httpclient.execute(httpget);
            HttpEntity entity = response.getEntity();
            System.out.println("Login form get: " + response.getStatusLine());
            EntityUtils.consume(entity);
            //这里需要生成并传递一个COOKIE过去
            System.out.println("Initial set of cookies:");
            List<Cookie> cookies = httpclient.getCookieStore().getCookies();
            if (cookies.isEmpty()) {
                System.out.println("None");
            } else {
                for (int i = 0; i < cookies.size(); i++) {
                    System.out.println("- " + cookies.get(i).toString());
                }
            }
            HttpPost httppost = new HttpPost(a1);

            List<NameValuePair> nvps = new ArrayList<NameValuePair>();
            nvps.add(new BasicNameValuePair("local", "zh_CN"));
            nvps.add(new BasicNameValuePair("USER", userName));
            nvps.add(new BasicNameValuePair("PWD", "123456"));
            nvps.add(new BasicNameValuePair("pwdtype", "1"));
            nvps.add(new BasicNameValuePair("actiontype", "LOGIN"));
            nvps.add(new BasicNameValuePair("logonsessid", ""));

            httppost.setEntity(new UrlEncodedFormEntity(nvps, HTTP.UTF_8));

            response = httpclient.execute(httppost);
            entity = response.getEntity();
            System.out.println("测试地址: " + a1);
            System.out.println("Login form get: " + response.getStatusLine());
            EntityUtils.consume(entity);
            
            //读出COOKIE信息
            System.out.println("Post logon cookies:");
            cookies = httpclient.getCookieStore().getCookies();
            if (cookies.isEmpty()) {
                System.out.println("None");
            } else {
                for (int i = 0; i < cookies.size(); i++) {
                    System.out.println("- " + cookies.get(i).toString());
                }
            }

        } finally {
            try {
                httpclient.getConnectionManager().shutdown();// 总是关闭连接
            } catch (Exception ignore) {
                System.out.println(ignore.getMessage());
            }
        }
    }

只要在表单中存在上面列出的任何一种按钮，那么相应表单控件拥有焦点的情况下，按回车键就可以提交表单。如果表单里没有提交按钮，按回车键不会提交表单。

　　以这种方式提交表单时，浏览器会在将请求发送给服务器之前触发submit事件。这样，我们就有机会验证表单数据，并据以决定是否允许表单提交。阻止这个事件的默认行为就可以取消表单提交。例如，下面代码会阻止表单提交：

var EventUtil = {
    addHandler: function (element, type, handler) {
        if (element.addEventListener) {
            element.addEventListener(type, handler, false);
        } else if (element.attachEvent) {
            element.attachEvent("on" + type, handler);
        } else {
            element["on" + type] = handler;
        }
    },
    getEvent: function (event) {
        return event ? event : window.event;
    },
    preventDefault: function (event) {
        if (event.preventDefault) {
            event.preventDefault();
        } else {
            event.returnValue = false;
        }
    }

}；

var form = document.getElementById("myForm");
EventUtil.addHandler(form, "submit", function () {
    //取得事件对象
    event = EventUtil.getEvent(event);
    //阻止默认事件
    EventUtil.preventDefault(event);
});　　
调用preventDefault()方法阻止了表单提交。一般来说，在表单数据无效而不能发送给服务器时，可以使用这一技术。

5、在JavaScript中，以编程方式调用submit()方法也可以提交表单。
     这种方式无需表单包含提交按钮，任何时候都可以正常提交表单。来看一个例子：

　　var form = document.getElementById("myForm");
　　//提交表单
　　form.submit();　　
     在以调用submit()方法的形式提交表单时，不会触发submit事件，因此要记得在调用此方法之前先验证表单数字据。

　　提交表单时可能出现的最大问题，就是重复提交表单。在第一次提交表单后，如果长时间没有反映，用户可能会变得不耐烦。这时候，他们也许会反复单击提交按钮。结果往往很麻烦（因为服务器要处理重复请求），或者造成错误（如果是下了订单，那么可能会多定好几份）。
解决这一问题的办法有两个：
     在第一次提交表单后就禁用提交按钮；
     利用onsubmit事件处理程序取消后续的表单提交操作。

java.version

Java 运行时环境版本

java.vendor

Java 运行时环境供应商

java.vendor.url

Java 供应商的 URL

java.home

Java 安装目录

java.vm.specification.version

Java 虚拟机规范版本

java.vm.specification.vendor

Java 虚拟机规范供应商

java.vm.specification.name

Java 虚拟机规范名称

java.vm.version

Java 虚拟机实现版本

java.vm.vendor

Java 虚拟机实现供应商

java.vm.name

Java 虚拟机实现名称

java.specification.version

Java 运行时环境规范版本

java.specification.vendor

Java 运行时环境规范供应商

java.specification.name

Java 运行时环境规范名称

java.class.version

Java 类格式版本号

java.class.path

Java 类路径

java.library.path

加载库时搜索的路径列表

java.io.tmpdir

默认的临时文件路径

java.compiler

要使用的 JIT 编译器的名称

java.ext.dirs

一个或多个扩展目录的路径

os.name

操作系统的名称

os.arch

操作系统的架构

os.version

操作系统的版本

file.separator

文件分隔符（在 UNIX 系统中是“/”）

path.separator

路径分隔符（在 UNIX 系统中是“:”）

line.separator

行分隔符（在 UNIX 系统中是“/n”）

user.name

用户的账户名称

user.home

用户的主目录

user.dir

用户的当前工作目录

org.apache.commons.lang.StringUtils中提供许多有用的字符串操作方法，了解这些方法，我们可以避免许多不必要的重复工作。下面介绍其中比较有用的几个方法：

检查空字符串：

01.StringUtils.isBlank(String str);  
02.StringUtils.isNotBlank(String str);  

缩写字符串：

String test  =   " This is a test of the abbreviation. "   
02.System.out.println( StringUtils.abbreviate( test,  10  ) );  
03.  
04.[Console输出]  
05.This is   

查找嵌套字符串：

01. String htmlContent  =   " <html>/n "   +   
02.                      "   <head>/n "   +   
03.                      "     <title>Test Page</title>/n "   +   
04.                      "   </head>/n "   +   
05.                      "   <body>/n "   +   
06.                      "     <p>This is a TEST!</p>/n "   +   
07.                      "   </body>/n "   +   
08.                      " </html> " ;  
09.  
10. //  Extract the title from this XHTML content     
11. String title  =  StringUtils.substringBetween(htmlContent,  " <title> " ,  " </title> " );  
12.System.out.println(  " Title:  "   +  title );  
13.  
14.[Console输出]  
15.Title: Test Page   

01. String test1  =   " ORANGE " ;  
02.  
03.String test2  =   " ICE9 " ;  
04.  
05.String test3  =   " ICE CREAM " ;  
06.  
07.String test4  =   " 820B Judson Avenue " ;  
08.  
09.//判断字母   
10. boolean  t1val  =  StringUtils.isAlpha( test1 );  //  returns true    
11. //判断是不是字母数字   
12. boolean  t2val  =  StringUtils.isAlphanumeric( test2 );  //  returns true    
13. //字母空格   
14. boolean  t3val  =  StringUtils.isAlphaSpace( test3 );  //  returns true    
15. //字母数字空格   
16. boolean  t4val  =    
17.  
18.    StringUtils.isAlphanumericSpace( test4 );  //  returns true   

01. File manuscriptFile  =   new  File( " manuscript.txt " );  
02.  
03.Reader reader  =   new  FileReader( manuscriptFile );  
04.  
05.StringWriter stringWriter  =   new  StringWriter( );  
06.  
07. while ( reader.ready( ) )   { writer.write( reader.read( ) ); }   
08.   
09.String manuscript  =  stringWriter.toString( );  
10.  
11. //  Convert string to lowercase    
12.   
13.manuscript  =  StringUtils.lowerCase(manuscript);  
14.  
15. //  count the occurrences of "futility"    
16.   
17. int  numFutility  =  StringUtils.countMatches( manuscript,  " futility "  );   

比较不同字符串：

01. int  dist  =  StringUtils.getLevenshteinDistance(  " Word " ,  " World "  );  
02.  
03.String diff  =  StringUtils.difference(  " Word " ,  " World "  );  
04.  
05. int  index  =  StringUtils.indexOfDifference(  " Word " ,  " World "  );  
06.  
07.System.out.println(  " Edit Distance:  "   +  dist );  
08.  
09.System.out.println(  " Difference:  "   +  diff );  
10.  
11.System.out.println(  " Diff Index:  "   +  index );  
12.  
13.[Console输出]  
14.Edit Distance:  2   
15.   
16.Difference: ld  
17.  
18.Diff Index:  3   

 2、 获取该目录下的文件名 

3、这里顺便记录一个获取日期的方法：

4、通过正则表达式判断文件名格式是否正确

5、一个移动文本的方法

 6、案例：需要每小时生成一个文本记录，以小时为单位，超过一小时生成另外一个文本

            SimpleDateFormat format=new SimpleDateFormat(rsb.getString("BRASAUTH.DATAFORMAT"));
            //SimpleDateFormat format2=new SimpleDateFormat("hhmm");
            String filename=rsb.getString("BRASAUTH.FILENAME");
            String path=rsb.getString("BRASAUTH.TXTPATH");
            
            File dir = new File(path);
            if(!dir.exists())
            {
                //如果目录不存在
                dir.mkdir();
            }
            /**//*判断文本，如已经经过一个小时，则另新建一个文本
             * 
             */            
            String fullPath=path+filename+format.format(new Date())+".txt";            
            FileOutputStream outStr = new FileOutputStream(new File(fullPath),true);             
            BufferedOutputStream buff = new BufferedOutputStream(outStr); 
            buff.write(authInfo.getBytes());
            

今天忙了一下午，终于把这个读取方法写到了，当然引用网络上的一个方法；其实同事也写了一个读取方法，但是感觉过于复杂。
总结一个：主要分几个步骤
1、因为是读取外部目录的配置文件，因此不适用该方式：
ResourceBundle rsb1 = ResourceBundle.getBundle("D:/WORK/XXXX/XXXXCount.properties");默认读取与该类同路径的配置文件；
private static String proFileFoLog4j=Logger.getLogger(XXXXAuth.class)；默认读取jar包中的log4j日志配置文件；

2、解决方法1：
1）、重新加载Properties文件：
  Properties pro = new Properties();
  String path=getConf(proFileName);//获取当前类所在的路径，该方法请看下面。
        try {
         pro.load(new FileInputStream(path));
  } catch (FileNotFoundException e) {
   e.printStackTrace();
  } catch (IOException e) {
   e.printStackTrace();
  }
2）、编写一个获取当前类路径的方法，这里直接使用了网友已经写好的代码，直接运行，不用修改，省事！当然还有其它的获取路径的方法：
 // 其他方法的定义 //
 /**
  * *getAppPath需要一个当前程序使用的Java类的class属性参数，它可以 返回打包过的
  * *Java可执行文件（jar，war）所处的系统目录名或非打包Java程 序所处的目录
  *
  * @param cls为Class类型
  *@return 返回值为该类所在的 Java程序运行的目录
  */
 public static String getAppPath(Class cls) {
  ClassLoader loader = cls.getClassLoader();
  String clsName = cls.getName() + ".class";
  Package pack = cls.getPackage();
  String path = "";
  if (pack != null)
  {
   String packName = pack.getName();
   clsName = clsName.substring(packName.length() + 1);
   if (packName.indexOf(".") < 0)
    path = packName + "/";
   else {
    int start = 0, end = 0;
    end = packName.indexOf(".");
    while (end != -1) {
     path = path + packName.substring(start, end) + "/";
     start = end + 1;
     end = packName.indexOf(".", start);
    }
    path = path + packName.substring(start) + "/";
   }
  }
  java.net.URL url = loader.getResource(path + clsName);
  String realPath = url.getPath();
  int pos = realPath.indexOf("file:");
  if (pos > -1)
   realPath = realPath.substring(pos + 5);
  pos = realPath.indexOf(path + clsName);
  realPath = realPath.substring(0, pos - 5);
  if (realPath.endsWith("!"))
   realPath = realPath.substring(0, realPath.lastIndexOf("/"));
  return realPath;
 }// getAppPath定义 结束

3）获取完整的配置文件路径名称： String path=getConf.getAppPath(XXXXAuth.class)+proFileName;被第一步pro.load(new FileInputStream(path));调用即可获取配置文件。
4）通过getProperties(proFileFoRead).get("XXXXAUTH.ISENABLE").toString();获取配置文件信息即可。

2、解决方法2：
关于log4j引用外部文件夹的log4j.properties文件，有一种最简单的方法：直接在main函数中加入如下一句：
PropertyConfigurator.configure(getConf(proFileFoLog4j)); //设置log4j配置文件的路径
其中getConf()方法调用了上面的获取完整路径的方法，即可。