……天天向上

TOMCAT獲取信息：JMXServiceURL 、JMXConnector 和MBeanServerConnection

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(); 
 
            //端口最好是動(dòng)態(tài)取得   
            ObjectName threadObjName = new ObjectName("Catalina:type=ThreadPool,name=http-8089"); 
            MBeanInfo mbInfo = mbsc.getMBeanInfo(threadObjName); 
 
            String attrName = "currentThreadCount";//tomcat的線程數(shù)對(duì)應(yīng)的屬性值   
            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("啟動(dòng)時(shí)間:" + df.format(starttime)); 
 
            Long timespan = (Long) mbsc.getAttribute(runtimeObjName, "Uptime"); 
            System.out.println("連續(xù)工作時(shí)間:" + 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();//堆當(dāng)前分配   
            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("應(yīng)用名:" + obj.getKeyProperty("path")); 
                ObjectName objname = new ObjectName(obj.getCanonicalName()); 
                System.out.println("最大會(huì)話數(shù):" + mbsc.getAttribute(objname, "maxActiveSessions")); 
                System.out.println("會(huì)話數(shù):" + mbsc.getAttribute(objname, "activeSessions")); 
                System.out.println("活動(dòng)會(huì)話數(shù):" + 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("最大線程數(shù):" + mbsc.getAttribute(objname, "maxThreads")); 
                System.out.println("當(dāng)前線程數(shù):" + mbsc.getAttribute(objname, "currentThreadCount")); 
                System.out.println("繁忙線程數(shù):" + 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的總數(shù)    
        System.out.println("MBean count = " + mbsc.getMBeanCount());    
        // 對(duì)name屬性的操作（屬性名的第一個(gè)字母要大寫）    
        mbsc.setAttribute(mbeanName, new Attribute("Name", "PANDA"));// 設(shè)值    
        System.out.println("Name = " + mbsc.getAttribute(mbeanName, "Name"));// 取值    
        // 得到proxy代理后直接調(diào)用的方式    
        HelloMBean proxy = (HelloMBean) MBeanServerInvocationHandler.newProxyInstance(mbsc, mbeanName, HelloMBean.class, false);         
        proxy.printHello();         
        proxy.printHello("Raymend");    
        // 遠(yuǎn)程調(diào)用的方式    
        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());         
            }
        // 關(guān)閉MBeanServer連接    
        jmxc.close();      
}    
}    

posted @ 2012-09-05 14:14 japper 閱讀(4994) | 評(píng)論 (0) | 編輯 收藏

LinkedHashMap和HashMap的比較使用

posted @ 2012-09-05 14:12 japper 閱讀(16471) | 評(píng)論 (5) | 編輯 收藏

java synchronized詳解 (轉(zhuǎn))

記下來，很重要。

Java語言的關(guān)鍵字，當(dāng)它用來修飾一個(gè)方法或者一個(gè)代碼塊的時(shí)候，能夠保證在同一時(shí)刻最多只有一個(gè)線程執(zhí)行該段代碼。

     一、當(dāng)兩個(gè)并發(fā)線程訪問同一個(gè)對(duì)象object中的這個(gè)synchronized(this)同步代碼塊時(shí)，一個(gè)時(shí)間內(nèi)只能有一個(gè)線程得到執(zhí)行。另一個(gè)線程必須等待當(dāng)前線程執(zhí)行完這個(gè)代碼塊以后才能執(zhí)行該代碼塊。

     二、然而，當(dāng)一個(gè)線程訪問object的一個(gè)synchronized(this)同步代碼塊時(shí)，另一個(gè)線程仍然可以訪問該object中的非synchronized(this)同步代碼塊。

     三、尤其關(guān)鍵的是，當(dāng)一個(gè)線程訪問object的一個(gè)synchronized(this)同步代碼塊時(shí)，其他線程對(duì)object中所有其它synchronized(this)同步代碼塊的訪問將被阻塞。

     四、第三個(gè)例子同樣適用其它同步代碼塊。也就是說，當(dāng)一個(gè)線程訪問object的一個(gè)synchronized(this)同步代碼塊時(shí)，它就獲得了這個(gè)object的對(duì)象鎖。結(jié)果，其它線程對(duì)該object對(duì)象所有同步代碼部分的訪問都被暫時(shí)阻塞。

     五、以上規(guī)則對(duì)其它對(duì)象鎖同樣適用.

舉例說明： 
     一、當(dāng)兩個(gè)并發(fā)線程訪問同一個(gè)對(duì)象object中的這個(gè)synchronized(this)同步代碼塊時(shí)，一個(gè)時(shí)間內(nèi)只能有一個(gè)線程得到執(zhí)行。另一個(gè)線程必須等待當(dāng)前線程執(zhí)行完這個(gè)代碼塊以后才能執(zhí)行該代碼塊。

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(); 
     }    
}

結(jié)果： 
     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

     二、然而，當(dāng)一個(gè)線程訪問object的一個(gè)synchronized(this)同步代碼塊時(shí)，另一個(gè)線程仍然可以訪問該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(); 
     }    
}

結(jié)果： 
     t1 : 4 
     t2 : 4 
     t1 : 3 
     t2 : 3 
     t1 : 2 
     t2 : 2 
     t1 : 1 
     t2 : 1 
     t1 : 0 
     t2 : 0

     三、尤其關(guān)鍵的是，當(dāng)一個(gè)線程訪問object的一個(gè)synchronized(this)同步代碼塊時(shí)，其他線程對(duì)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) { 
                    } 
               } 
          }

     }

結(jié)果：

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

     四、第三個(gè)例子同樣適用其它同步代碼塊。也就是說，當(dāng)一個(gè)線程訪問object的一個(gè)synchronized(this)同步代碼塊時(shí)，它就獲得了這個(gè)object的對(duì)象鎖。結(jié)果，其它線程對(duì)該object對(duì)象所有同步代碼部分的訪問都被暫時(shí)阻塞。

     //修改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) { 
               } 
          } 
     }

結(jié)果： 
     t1 : 4 
     t1 : 3 
     t1 : 2 
     t1 : 1 
     t1 : 0 
     t2 : 4 
     t2 : 3 
     t2 : 2 
     t2 : 1 
     t2 : 0

     五、以上規(guī)則對(duì)其它對(duì)象鎖同樣適用:

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) { //使用對(duì)象鎖    
          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();    
  }    
}

結(jié)果：

盡管線程t1獲得了對(duì)Inner的對(duì)象鎖，但由于線程t2訪問的是同一個(gè)Inner中的非同步部分。所以兩個(gè)線程互不干擾。

     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

現(xiàn)在在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) { 
               } 
          } 
     }

結(jié)果：

盡管線程t1與t2訪問了同一個(gè)Inner對(duì)象中兩個(gè)毫不相關(guān)的部分,但因?yàn)閠1先獲得了對(duì)Inner的對(duì)象鎖，所以t2對(duì)Inner.m4t2()的訪問也被阻塞，因?yàn)閙4t2()是Inner中的一個(gè)同步方法。

     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 關(guān)鍵字，它包括兩種用法：synchronized 方法和 synchronized 塊。 
1. synchronized 方法：通過在方法聲明中加入 synchronized關(guān)鍵字來聲明 synchronized 方法。如： 
public synchronized void accessVal(int newVal); 
synchronized 方法控制對(duì)類成員變量的訪問：每個(gè)類實(shí)例對(duì)應(yīng)一把鎖，每個(gè) synchronized 方法都必須獲得調(diào)用該方法的類實(shí)例的鎖方能

執(zhí)行，否則所屬線程阻塞，方法一旦執(zhí)行，就獨(dú)占該鎖，直到從該方法返回時(shí)才將鎖釋放，此后被阻塞的線程方能獲得該鎖，重新進(jìn)入可執(zhí)行

狀態(tài)。這種機(jī)制確保了同一時(shí)刻對(duì)于每一個(gè)類實(shí)例，其所有聲明為 synchronized 的成員函數(shù)中至多只有一個(gè)處于可執(zhí)行狀態(tài)（因?yàn)橹炼嘀挥?/p>

一個(gè)能夠獲得該類實(shí)例對(duì)應(yīng)的鎖），從而有效避免了類成員變量的訪問沖突（只要所有可能訪問類成員變量的方法均被聲明為 synchronized）

。 
在 Java 中，不光是類實(shí)例，每一個(gè)類也對(duì)應(yīng)一把鎖，這樣我們也可將類的靜態(tài)成員函數(shù)聲明為 synchronized ，以控制其對(duì)類的靜態(tài)成

員變量的訪問。 
synchronized 方法的缺陷：若將一個(gè)大的方法聲明為synchronized 將會(huì)大大影響效率，典型地，若將線程類的方法 run() 聲明為

synchronized ，由于在線程的整個(gè)生命期內(nèi)它一直在運(yùn)行，因此將導(dǎo)致它對(duì)本類任何 synchronized 方法的調(diào)用都永遠(yuǎn)不會(huì)成功。當(dāng)然我們可

以通過將訪問類成員變量的代碼放到專門的方法中，將其聲明為 synchronized ，并在主方法中調(diào)用來解決這一問題，但是 Java 為我們提供

了更好的解決辦法，那就是 synchronized 塊。 
2. synchronized 塊：通過 synchronized關(guān)鍵字來聲明synchronized 塊。語法如下： 
synchronized(syncObject) { 
//允許訪問控制的代碼 
} 
synchronized 塊是這樣一個(gè)代碼塊，其中的代碼必須獲得對(duì)象 syncObject （如前所述，可以是類實(shí)例或類）的鎖方能執(zhí)行，具體機(jī)

制同前所述。由于可以針對(duì)任意代碼塊，且可任意指定上鎖的對(duì)象，故靈活性較高。 
對(duì)synchronized(this)的一些理解    
一、當(dāng)兩個(gè)并發(fā)線程訪問同一個(gè)對(duì)象object中的這個(gè)synchronized(this)同步代碼塊時(shí)，一個(gè)時(shí)間內(nèi)只能有一個(gè)線程得到執(zhí)行。另一個(gè)線

程必須等待當(dāng)前線程執(zhí)行完這個(gè)代碼塊以后才能執(zhí)行該代碼塊。 
二、然而，當(dāng)一個(gè)線程訪問object的一個(gè)synchronized(this)同步代碼塊時(shí)，另一個(gè)線程仍然可以訪問該object中的非synchronized

(this)同步代碼塊。 
三、尤其關(guān)鍵的是，當(dāng)一個(gè)線程訪問object的一個(gè)synchronized(this)同步代碼塊時(shí)，其他線程對(duì)object中所有其它synchronized(this)

同步代碼塊的訪問將被阻塞。 
四、第三個(gè)例子同樣適用其它同步代碼塊。也就是說，當(dāng)一個(gè)線程訪問object的一個(gè)synchronized(this)同步代碼塊時(shí)，它就獲得了這個(gè)

object的對(duì)象鎖。結(jié)果，其它線程對(duì)該object對(duì)象所有同步代碼部分的訪問都被暫時(shí)阻塞。 
五、以上規(guī)則對(duì)其它對(duì)象鎖同樣適用

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

打個(gè)比方：一個(gè)object就像一個(gè)大房子，大門永遠(yuǎn)打開。房子里有 很多房間（也就是方法）。

這些房間有上鎖的（synchronized方法）， 和不上鎖之分（普通方法）。房門口放著一把鑰匙（key），這把鑰匙可以打開所有上鎖的房間。

另外我把所有想調(diào)用該對(duì)象方法的線程比喻成想進(jìn)入這房子某個(gè) 房間的人。所有的東西就這么多了，下面我們看看這些東西之間如何作用的。

在此我們先來明確一下我們的前提條件。該對(duì)象至少有一個(gè)synchronized方法，否則這個(gè)key還有啥意義。當(dāng)然也就不會(huì)有我們的這個(gè)主題了。

一個(gè)人想進(jìn)入某間上了鎖的房間，他來到房子門口，看見鑰匙在那兒（說明暫時(shí)還沒有其他人要使用上鎖的 房間）。于是他走上去拿到了鑰匙

，并且按照自己 的計(jì)劃使用那些房間。注意一點(diǎn)，他每次使用完一次上鎖的房間后會(huì)馬上把鑰匙還回去。即使他要連續(xù)使用兩間上鎖的房間，

中間他也要把鑰匙還回去，再取回來。

因此，普通情況下鑰匙的使用原則是：“隨用隨借，用完即還。”

這時(shí)其他人可以不受限制的使用那些不上鎖的房間，一個(gè)人用一間可以，兩個(gè)人用一間也可以，沒限制。但是如果當(dāng)某個(gè)人想要進(jìn)入上鎖的房

間，他就要跑到大門口去看看了。有鑰匙當(dāng)然拿了就走，沒有的話，就只能等了。

要是很多人在等這把鑰匙，等鑰匙還回來以后，誰會(huì)優(yōu)先得到鑰匙？Not guaranteed。象前面例子里那個(gè)想連續(xù)使用兩個(gè)上鎖房間的家伙，他

中間還鑰匙的時(shí)候如果還有其他人在等鑰匙，那么沒有任何保證這家伙能再次拿到。 （JAVA規(guī)范在很多地方都明確說明不保證，象

Thread.sleep()休息后多久會(huì)返回運(yùn)行，相同優(yōu)先權(quán)的線程那個(gè)首先被執(zhí)行，當(dāng)要訪問對(duì)象的鎖被 釋放后處于等待池的多個(gè)線程哪個(gè)會(huì)優(yōu)先得

到，等等。我想最終的決定權(quán)是在JVM，之所以不保證，就是因?yàn)镴VM在做出上述決定的時(shí)候，絕不是簡(jiǎn)簡(jiǎn)單單根據(jù) 一個(gè)條件來做出判斷，而是

根據(jù)很多條。而由于判斷條件太多，如果說出來可能會(huì)影響JAVA的推廣，也可能是因?yàn)橹R(shí)產(chǎn)權(quán)保護(hù)的原因吧。SUN給了個(gè)不保證 就混過去了

。無可厚非。但我相信這些不確定，并非完全不確定。因?yàn)橛?jì)算機(jī)這東西本身就是按指令運(yùn)行的。即使看起來很隨機(jī)的現(xiàn)象，其實(shí)都是有規(guī)律

可尋。學(xué)過 計(jì)算機(jī)的都知道，計(jì)算機(jī)里隨機(jī)數(shù)的學(xué)名是偽隨機(jī)數(shù)，是人運(yùn)用一定的方法寫出來的，看上去隨機(jī)罷了。另外，或許是因?yàn)橐肱?/p>

的確定太費(fèi)事，也沒多大意義，所 以不確定就不確定了吧。）

再來看看同步代碼塊。和同步方法有小小的不同。

1.從尺寸上講，同步代碼塊比同步方法小。你可以把同步代碼塊看成是沒上鎖房間里的一塊用帶鎖的屏風(fēng)隔開的空間。

2.同步代碼塊還可以人為的指定獲得某個(gè)其它對(duì)象的key。就像是指定用哪一把鑰匙才能開這個(gè)屏風(fēng)的鎖，你可以用本房的鑰匙；你也可以指定

用另一個(gè)房子的鑰匙才能開，這樣的話，你要跑到另一棟房子那兒把那個(gè)鑰匙拿來，并用那個(gè)房子的鑰匙來打開這個(gè)房子的帶鎖的屏風(fēng)。

         記住你獲得的那另一棟房子的鑰匙，并不影響其他人進(jìn)入那棟房子沒有鎖的房間。

         為什么要使用同步代碼塊呢？我想應(yīng)該是這樣的：首先對(duì)程序來講同步的部分很影響運(yùn)行效率，而一個(gè)方法通常是先創(chuàng)建一些局部變

量，再對(duì)這些變量做一些 操作，如運(yùn)算，顯示等等；而同步所覆蓋的代碼越多，對(duì)效率的影響就越嚴(yán)重。因此我們通常盡量縮小其影響范圍。

如何做？同步代碼塊。我們只把一個(gè)方法中該同 步的地方同步，比如運(yùn)算。

         另外，同步代碼塊可以指定鑰匙這一特點(diǎn)有個(gè)額外的好處，是可以在一定時(shí)期內(nèi)霸占某個(gè)對(duì)象的key。還記得前面說過普通情況下鑰

匙的使用原則嗎。現(xiàn)在不是普通情況了。你所取得的那把鑰匙不是永遠(yuǎn)不還，而是在退出同步代碼塊時(shí)才還。

          還用前面那個(gè)想連續(xù)用兩個(gè)上鎖房間的家伙打比方。怎樣才能在用完一間以后，繼續(xù)使用另一間呢。用同步代碼塊吧。先創(chuàng)建另外

一個(gè)線程，做一個(gè)同步代碼 塊，把那個(gè)代碼塊的鎖指向這個(gè)房子的鑰匙。然后啟動(dòng)那個(gè)線程。只要你能在進(jìn)入那個(gè)代碼塊時(shí)抓到這房子的鑰匙

，你就可以一直保留到退出那個(gè)代碼塊。也就是說 你甚至可以對(duì)本房?jī)?nèi)所有上鎖的房間遍歷，甚至再sleep(10*60*1000)，而房門口卻還有

1000個(gè)線程在等這把鑰匙呢。很過癮吧。

          在此對(duì)sleep()方法和鑰匙的關(guān)聯(lián)性講一下。一個(gè)線程在拿到key后，且沒有完成同步的內(nèi)容時(shí)，如果被強(qiáng)制sleep()了，那key還一

直在 它那兒。直到它再次運(yùn)行，做完所有同步內(nèi)容，才會(huì)歸還key。記住，那家伙只是干活干累了，去休息一下，他并沒干完他要干的事。為

了避免別人進(jìn)入那個(gè)房間 把里面搞的一團(tuán)糟，即使在睡覺的時(shí)候他也要把那唯一的鑰匙戴在身上。

          最后，也許有人會(huì)問，為什么要一把鑰匙通開，而不是一個(gè)鑰匙一個(gè)門呢？我想這純粹是因?yàn)閺?fù)雜性問題。一個(gè)鑰匙一個(gè)門當(dāng)然更

安全，但是會(huì)牽扯好多問題。鑰匙 的產(chǎn)生，保管，獲得，歸還等等。其復(fù)雜性有可能隨同步方法的增加呈幾何級(jí)數(shù)增加，嚴(yán)重影響效率。這也

算是一個(gè)權(quán)衡的問題吧。為了增加一點(diǎn)點(diǎn)安全性，導(dǎo)致效 率大大降低，是多么不可取啊。

synchronized的一個(gè)簡(jiǎn)單例子

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--);    
    }    
   }    
}    
}

上面的例子中為了制造一個(gè)時(shí)間差,也就是出錯(cuò)的機(jī)會(huì),使用了Thread.sleep(10)

Java對(duì)多線程的支持與同步機(jī)制深受大家的喜愛，似乎看起來使用了synchronized關(guān)鍵字就可以輕松地解決多線程共享數(shù)據(jù)同步問題。到底如

何？――還得對(duì)synchronized關(guān)鍵字的作用進(jìn)行深入了解才可定論。

總的說來，synchronized關(guān)鍵字可以作為函數(shù)的修飾符，也可作為函數(shù)內(nèi)的語句，也就是平時(shí)說的同步方法和同步語句塊。如果再細(xì)的分類，

synchronized可作用于instance變量、object reference（對(duì)象引用）、static函數(shù)和class literals(類名稱字面常量)身上。

在進(jìn)一步闡述之前，我們需要明確幾點(diǎn)：

A．無論synchronized關(guān)鍵字加在方法上還是對(duì)象上，它取得的鎖都是對(duì)象，而不是把一段代碼或函數(shù)當(dāng)作鎖――而且同步方法很可能還會(huì)被其

他線程的對(duì)象訪問。

B．每個(gè)對(duì)象只有一個(gè)鎖（lock）與之相關(guān)聯(lián)。

C．實(shí)現(xiàn)同步是要很大的系統(tǒng)開銷作為代價(jià)的，甚至可能造成死鎖，所以盡量避免無謂的同步控制。

接著來討論synchronized用到不同地方對(duì)代碼產(chǎn)生的影響：

假設(shè)P1、P2是同一個(gè)類的不同對(duì)象，這個(gè)類中定義了以下幾種情況的同步塊或同步方法，P1、P2就都可以調(diào)用它們。

1． 把synchronized當(dāng)作函數(shù)修飾符時(shí)，示例代碼如下：

Public synchronized void methodAAA()

{

//….

}

這也就是同步方法，那這時(shí)synchronized鎖定的是哪個(gè)對(duì)象呢？它鎖定的是調(diào)用這個(gè)同步方法對(duì)象。也就是說，當(dāng)一個(gè)對(duì)象P1在不同的線程中

執(zhí)行這個(gè)同步方法時(shí)，它們之間會(huì)形成互斥，達(dá)到同步的效果。但是這個(gè)對(duì)象所屬的Class所產(chǎn)生的另一對(duì)象P2卻可以任意調(diào)用這個(gè)被加了

synchronized關(guān)鍵字的方法。

上邊的示例代碼等同于如下代碼：

public void methodAAA()

{

synchronized (this)      // (1)

{

       //…..

}

}

(1)處的this指的是什么呢？它指的就是調(diào)用這個(gè)方法的對(duì)象，如P1。可見同步方法實(shí)質(zhì)是將synchronized作用于object reference。――那個(gè)

拿到了P1對(duì)象鎖的線程，才可以調(diào)用P1的同步方法，而對(duì)P2而言，P1這個(gè)鎖與它毫不相干，程序也可能在這種情形下擺脫同步機(jī)制的控制，造

成數(shù)據(jù)混亂：（

2．同步塊，示例代碼如下：

public void method3(SomeObject so)

{

    synchronized(so)

    {   
       //…..    
    }

}

這時(shí)，鎖就是so這個(gè)對(duì)象，誰拿到這個(gè)鎖誰就可以運(yùn)行它所控制的那段代碼。當(dāng)有一個(gè)明確的對(duì)象作為鎖時(shí)，就可以這樣寫程序，但當(dāng)沒有明

確的對(duì)象作為鎖，只是想讓一段代碼同步時(shí)，可以創(chuàng)建一個(gè)特殊的instance變量（它得是一個(gè)對(duì)象）來充當(dāng)鎖：

class Foo implements Runnable

{

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

        Public void methodA()   
        {

           synchronized(lock) { //… }

        }

        //…..

}

注：零長(zhǎng)度的byte數(shù)組對(duì)象創(chuàng)建起來將比任何對(duì)象都經(jīng)濟(jì)――查看編譯后的字節(jié)碼：生成零長(zhǎng)度的byte[]對(duì)象只需3條操作碼，而Object lock

= new Object()則需要7行操作碼。

3．將synchronized作用于static 函數(shù)，示例代碼如下：

Class Foo   
{

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

    public void methodBBB()   
    {

       synchronized(Foo.class)   // class literal(類名稱字面常量)

    }   
}

   代碼中的methodBBB()方法是把class literal作為鎖的情況，它和同步的static函數(shù)產(chǎn)生的效果是一樣的，取得的鎖很特別，是當(dāng)前調(diào)用這

個(gè)方法的對(duì)象所屬的類（Class，而不再是由這個(gè)Class產(chǎn)生的某個(gè)具體對(duì)象了）。

記得在《Effective Java》一書中看到過將 Foo.class和 P1.getClass()用于作同步鎖還不一樣，不能用P1.getClass()來達(dá)到鎖這個(gè)Class的

目的。P1指的是由Foo類產(chǎn)生的對(duì)象。

可以推斷：如果一個(gè)類中定義了一個(gè)synchronized的static函數(shù)A，也定義了一個(gè)synchronized 的instance函數(shù)B，那么這個(gè)類的同一對(duì)象Obj

在多線程中分別訪問A和B兩個(gè)方法時(shí)，不會(huì)構(gòu)成同步，因?yàn)樗鼈兊逆i都不一樣。A方法的鎖是Obj這個(gè)對(duì)象，而B的鎖是Obj所屬的那個(gè)Class。

小結(jié)如下：

搞清楚synchronized鎖定的是哪個(gè)對(duì)象，就能幫助我們?cè)O(shè)計(jì)更安全的多線程程序。

還有一些技巧可以讓我們對(duì)共享資源的同步訪問更加安全：

1． 定義private 的instance變量+它的 get方法，而不要定義public/protected的instance變量。如果將變量定義為public，對(duì)象在外界可以

繞過同步方法的控制而直接取得它，并改動(dòng)它。這也是JavaBean的標(biāo)準(zhǔn)實(shí)現(xiàn)方式之一。

2． 如果instance變量是一個(gè)對(duì)象，如數(shù)組或ArrayList什么的，那上述方法仍然不安全，因?yàn)楫?dāng)外界對(duì)象通過get方法拿到這個(gè)instance對(duì)象

的引用后，又將其指向另一個(gè)對(duì)象，那么這個(gè)private變量也就變了，豈不是很危險(xiǎn)。 這個(gè)時(shí)候就需要將get方法也加上synchronized同步，并

且，只返回這個(gè)private對(duì)象的clone()――這樣，調(diào)用端得到的就是對(duì)象副本的引用了

posted @ 2012-08-29 17:47 japper 閱讀(346) | 評(píng)論 (0) | 編輯 收藏

MyEclipse的一些配置及優(yōu)化

MyEclipse的基礎(chǔ)配置：


1. 先安裝MyEclipse,安裝MyEclipse7.5需要VPN代理，安裝過程大概持續(xù)10-15分鐘，使用VPN測(cè)試帳號(hào)即可

2. 進(jìn)行MyEclipse的配置，
      從菜單欄中進(jìn)入“Windows --> Preferences”

3. 先要進(jìn)行JDK的配置，
    在左側(cè)欄中選擇“Java --> Installed JREs”，
    按“Add”按鈕進(jìn)行添加

4. 在彈出的“Add JRE”畫面中，選擇JRE的目錄，
    就是選擇你所在的JDK的目錄，我的為：C:\Program Files\Java\jre6
    在JRE名稱一欄中，填下想取的名稱，我這里叫“HiJackson's JRE”，
    然后“OK”確定

5. 返回到設(shè)置框中，將剛剛配置的JRE選中

6. 將Tomcat Server設(shè)為可用，并設(shè)置Tomcat的安裝目錄

7. 在Tomcat的JDK中選擇剛剛配置的JDK

8. 配置完成了，三個(gè)地方可以啟動(dòng)它的服務(wù)，根據(jù)自己的喜好吧~~~

 

優(yōu)化MyEclipse：

經(jīng)過以上的優(yōu)化，myeclipse的啟動(dòng)時(shí)間可以減少2/3，Tomcat的啟動(dòng)速度可以減少1/2(視具體情況而定)，

特別6，7兩項(xiàng)的優(yōu)化效果最明顯，

如果只進(jìn)行前5項(xiàng)，優(yōu)化的效果有限，短期內(nèi)確實(shí)可以提高啟動(dòng)速度，但是大概半個(gè)月后又會(huì)變的很慢（具體原因不明）
另外，使用myeclipse一段時(shí)間后，就會(huì)產(chǎn)生很多項(xiàng)目，即使這些項(xiàng)目是處于關(guān)閉狀態(tài)，myecliose在啟動(dòng)時(shí)也會(huì)加載這些項(xiàng)目，這個(gè)過程會(huì)花費(fèi)很多時(shí)間，所以，建議將不用的項(xiàng)目都delete掉，用的時(shí)候再import

在用[MyEclipse] 寫代碼很容易卡死機(jī)，尤其是在對(duì)JSP文件的﹤%%﹥之間寫代碼的時(shí)候，只要一彈出智能提示就立刻卡死，程序失去響應(yīng)，我以為是MyEclipse版本的問題，結(jié)果換了6.0版-﹥6.5版-﹥7.0版全都一樣，難道是我機(jī)子的問題？可是還原系統(tǒng)后用還是一樣的結(jié)果。

百度一下你就知道，但是百度了N下才找到了一些門路，搜索也講究技巧，換了N個(gè)[關(guān)鍵字] 組合才搜出來。說是MyEclipse在智能提示的時(shí)候自動(dòng)訪問網(wǎng)絡(luò)上sun公司的最新API文檔，只要關(guān)閉掉網(wǎng)絡(luò)連接就可以了。我試了試斷開網(wǎng)絡(luò)然后在用MyEclipse寫代碼，結(jié)果還真的搞定了。可是，我總不能因?yàn)閭€(gè)這就不上網(wǎng)了吧，繼續(xù)接著百度，找到了兩全其美的解決方法。

在自己創(chuàng)建的工程名上右鍵，選擇Properties--﹥?cè)诖蜷_的窗口中點(diǎn)擊Java Build Path--﹥單擊Libraries選項(xiàng)卡，找到如圖中標(biāo)記2所示的地方--﹥選擇右邊的Remove更改成如標(biāo)記1所示的樣子--﹥點(diǎn)擊OK。

posted @ 2012-07-20 10:25 japper 閱讀(1013) | 評(píng)論 (0) | 編輯 收藏

jquery筆記0717

1、不常用的切換函數(shù)$("p").toggle();當(dāng)點(diǎn)擊切換按鈕時(shí)，隱藏元素為P行和顯示P行；


2、append() 函數(shù)向所匹配的 HTML 元素內(nèi)部追加內(nèi)容$(selector).append(content);
類似的還有：
$(selector).html(content) 改變被選元素的（內(nèi)部）HTML
$(selector).append(content) 向被選元素的（內(nèi)部）HTML 追加內(nèi)容
$(selector).prepend(content) 向被選元素的（內(nèi)部）HTML “預(yù)置”（Prepend）內(nèi)容
$(selector).after(content) 在被選元素之后添加 HTML
$(selector).before(content) 在被選元素之前添加 HTML

3、css操作：函數(shù) css({properties}) 同時(shí)為所有匹配元素的一系列 CSS 屬性設(shè)置值：
$(selector).css({properties})
$("p").css({"background-color":"red","font-size":"200%"});

jQuery 擁有兩種用于尺寸操作的重要函數(shù)：

• $(selector).height(value)
• $(selector).width(value)

總結(jié)如：
$(selector).css(name,value) 為匹配元素設(shè)置樣式屬性的值
$(selector).css({properties}) 為匹配元素設(shè)置多個(gè)樣式屬性
$(selector).css(name) 獲得第一個(gè)匹配元素的樣式屬性值
$(selector).height(value) 設(shè)置匹配元素的高度
$(selector).width(value) 設(shè)置匹配元素的寬度

4、AJAX：

jQuery AJAX 請(qǐng)求
$(selector).load(url,data,callback) 把遠(yuǎn)程數(shù)據(jù)加載到被選的元素中
$.ajax(options) 把遠(yuǎn)程數(shù)據(jù)加載到 XMLHttpRequest 對(duì)象中
$.get(url,data,callback,type) 使用 HTTP GET 來加載遠(yuǎn)程數(shù)據(jù)
$.post(url,data,callback,type) 使用 HTTP POST 來加載遠(yuǎn)程數(shù)據(jù)
$.getJSON(url,data,callback) 使用 HTTP GET 來加載遠(yuǎn)程 JSON 數(shù)據(jù)
$.getScript(url,callback) 加載并執(zhí)行遠(yuǎn)程的 JavaScript 文件

(url) 被加載的數(shù)據(jù)的 URL（地址）

(data) 發(fā)送到服務(wù)器的數(shù)據(jù)的鍵/值對(duì)象

(callback) 當(dāng)數(shù)據(jù)被加載時(shí)，所執(zhí)行的函數(shù)

(type) 被返回的數(shù)據(jù)的類型 (html,xml,json,jasonp,script,text)

(options) 完整 AJAX 請(qǐng)求的所有鍵/值對(duì)選項(xiàng)

略。。。

posted @ 2012-07-17 11:21 japper 閱讀(384) | 評(píng)論 (0) | 編輯 收藏

使用jxl導(dǎo)出大數(shù)據(jù)量EXCEL時(shí)內(nèi)存溢出的解決辦法

posted @ 2012-07-16 11:48 japper 閱讀(8908) | 評(píng)論 (1) | 編輯 收藏