http://www.onjava.com/pub/a/onjava/excerpt/javaian5_chap04/index.html

这个是JDK   1.5   的新特性。
举个例子。  
一个列表中加入3个数字，然后从列表中取出作合计的操作。

JDK   1.4   的时候
List   testList   =   new   ArrayList();
testList.add(new   Integer(100));
testList.add(new   Integer(200));
testList.add(new   Integer(300));
int   result   =   0;
for(int   i   =   0;   i   <   testList.size();   i   ++)   {
        //   这里从列表中取数据时，需要强制转换。
        result   +=   (Integer)testList.get(i).intValue();
}
System.out.println(result);

JDK   1.5   的时候
List <Integer>   testList   =   new   ArrayList <Integer> ();
//   注意，JDK1.5的   int   的   100，能够自动的转换成   Integer   类型。不强制要求   new   Integer(100)
testList.add(100);
testList.add(200);
testList.add(300);
int   result   =   0;
for(int   i   =   0;   i   <   testList.size();   i   ++)   {
        //   这里从列表中取数据时，不需要强制转换。
        result   +=   testList.get(i).intValue();
}
System.out.println(result);

cherami

本文来自: 中国自学编程网(www.zxbc.cn) 详细出处参考：http://www.zxbc.cn/html/rjgc/1414044315681.htm

JUnit best practices
JUnit 最佳实践

Techniques for building resilient, relocatable, multithreaded JUnit tests
一项灵活的、可重定位的多线程JUnit测试技术
作者 Andy Schneider

译者 雷云飞 javawebstart Barret gstian [AKA]
校对 gstian [AKA]

本文来自: 中国自学编程网(www.zxbc.cn) 详细出处参考：http://www.zxbc.cn/html/rjgc/1414044383648.htm

老代码：
PrintWriter pw = new PrintWriter(new FileWriter(path));
pw.print(content);
pw.close();

新代码：
FileOutputStream fos = new FileOutputStream(path);
Writer out = new OutputStreamWriter(fos, "UTF-8");
out.write(content);
out.close();
fos.close();

顺便抱怨一句，Java中写文件的方式还真是多阿多……我等一两年经验的小程序员看了都眼晕

   库卡 说：
  读代码也有编码的问题，如果要读取UTF-8的文件，应采用如下方式覆盖默认编码：
  FileInputStream fis = new FileInputStream(s);
  StringBuffer content = new StringBuffer();
  DataInputStream in = new DataInputStream(fis);
  BufferedReader d = new BufferedReader(new InputStreamReader(in, "UTF-8"));
  String line = null;
   while ((line = d.readLine()) != null)
                      content.append(line + "\n");
  d.close();
  in.close();
  fis.close();

假设我们已经有了经过排序的（升序），且满足要求的k个正整数，我们继续：
1、在从1到n-k的区间范围内，产生一个随机的正整数i1；
2、统计在已有序列中比i1小的数，将其个数加到i1上，得到i2；再统计从i1到i2数的个数，得到i3；一直循环，直到i不变为止。然后，把i插入已有的序列。这个过程相当于从头数出i1个空白，以此来保证新的数是随机的。
3、这时得到了k+1个满足要求的数，然后就循环吧。
上面的方法适用于n很大，但是m很小的时候。

如果m和n都很大，并且希望一次性的产生，那么：
1先产生有一定冗余的随机正整数，然后排序，然后去掉相同的数。
如果，产生了超额的数，可以将数列再打乱顺序，然后，取出符合规定的数目的数。

当然，也可以两种方法相结合，就是：
1、先产生超过需求的、有一定冗余的随机正整数，然后排序，然后去掉相同的数，并且保存下来。记录它的数目m1 >m；
2、当要用时，在产生一个从1到m的随机数j，然后取出数据库中第j个数，输出，并且把它从数据库中删除到。
 *
 *
 *
 *
 *
 *
 *
 *
 *数据有点大，用了128m
start_1   ();   是即时输出（因为用boolean数组，所以内存小得多）
start_2   ();   是把数据存进数组，以便再处理（需要内存很大，不赞成使用）
如果要处理数据，可以用   start_1   ();   把数据保存进文件，再从文件中读取数据进行处理。

 */
public class Main{
 
 public final int n = 10000000;
 
 public Main () {
        start_1();
        //start_2 ();
    }
   
    public static void main (String[] args) {
        new Main();
    }
   
    public void start_1() {
        //布朗型默认为 false
        boolean[] barr = new boolean[n];
        //
        java.util.Random r = new java.util.Random ();
        int j = 0, x;
        int m = n;
        while(j < m) {
            x = r.nextInt (n);
            if (! barr[x]) {
                j++;
                barr[x] = true;
                System.out.println (x);
            }
        }
    }
   
    public void start_2() {
        //整型默认为 0
        int[] iarr = new int[n];
        //
        java.util.Random r = new java.util.Random ();
        int j = 0, x;
        int m = n;
        //少循环一次，因为要生成 0
        while(j < m-1) {
            x = r.nextInt (n);
            if (iarr[x] == 0) {
                j++;
                iarr[x] = j;
            }
        }
    }
}
/*
 *上面的算法，没有优化，生成数据耗时间。
下面的算法改进了一下。生成所有数据半分钟左右。
+----------
|   0...999999
|   .
|   .
|   .
|   99

Java code
public class Main {
   
    public Main () {
        start_1 ();
        start_2 ();
    }
   
    public static void main (String[] args) {
        new Main ();
    }
   
    ** void start_1 () {
        for (int i = 0; i < n; i++) {
            byte j = 0;
            while(j < m-1) {
                int x = r.nextInt (m);
                if (barr_1[x] == 0) {
                    j++;
                    barr_1[x] = j;
                }
            }
        }
    }
   
    ** void start_2 () {
        int j = 0;
        while(j < n) {
            int x = r.nextInt (n);
            int y = (int) barr_2[x];
            if (y < m) {
                j++;
                barr_2[x]++;
                int z = ((int) barr_1[x][y]) * n;
                //System.out.println (x + z);
            }
        }
    }
   
    ** final int s = 10000*10000;
    ** final int m = 100;
    ** final int n = s/m;
    ** byte[][] barr_1 = new byte[n][m];
    ** byte[] barr_2 = new byte[n];
    ** java.util.Random r = new java.util.Random ();
   
}
*/

/*
 *和一位仁兄在另一个帖子争论中，受到启发。
终于悟出一种时间复杂度极低的算法。
（可以证明，任意一个数   在   任意位置的概率   都为   1/n）

因为内存不够，所以改成了7个9来算。总时间2秒

Java code
public class Main {
   
    public Main () {
        start ();
    }
   
    public static void main (String args[]) {
        new Main ();
    }
   
    ** void start () {
        java.util.Random r = new java.util.Random ();
        for (int i = 0; i < n; i++) {
            int x = r.nextInt (i+1);
            iarr = iarr[x];
            iarr[x] = i;
        }
        //
        int m = 10;
        for (int i = 0; i < m; i++) {
            System.out.print (iarr + " ");
        }
    }
   
    ** final int n = 1000*10000;
    ** int[] iarr = new int[n];
   
}
*/

public static boolean isPrimeNumber(int number){
     if(number<2)
         return false;
     for(int i=2;i<=Math.sqrt(number);i++){
         if(number%i==0&&number!=2)
             return false;
     }
     return true;
 }

素数算法（二）

上次讨论了简单的素数判定的算法，不过这个算法对于位数较大（一般小于108）的素数判定就显得相当力不从心了。比如在素数目前最广泛的应用领域-公共密钥体系中，一般选择的素数都是相当大的（通常在100位以上），如果采用上次的试除法来判定，那么可能要穷尽你一生的时间都还不够。所以在一般的应用领域，人们采用的是Rabin-Miller检验法。下面是该检验法的算法：

首先选择一个代测的随机数p，计算b，b是2整除p-1的次数。然后计算m，使得n=1+(2^b)m。

（1） 选择一个小于p的随机数a。
（2） 设j=0且z=a^m mod p
（3） 如果z=1或z=p-1，那麽p通过测试，可能使素数
（4） 如果j>0且z=1, 那麽p不是素数
（5） 设j=j+1。如果j<b且z<>p-1,设z=z^2 mod p，然后回到(4)。如果z=p-1，那麽p通过测试，可能为素数。
（6） 如果j=b 且z<>p-1，不是素数

数a被当成证据的概率为75%。这意味着当迭代次数为t时，它产生一个假的素数所花费的时间不超过1/4^t。实际上，对大多数随机数，几乎99.99%肯定a是证据。

实际考虑：

在实际算法，产生素数是很快的。

（1） 产生一个n-位的随机数p
（2） 设高位和低位为1（设高位是为了保证位数，设低位是为了保证位奇数）
（3） 检查以确保p不能被任何小素数整除：如3，5，7，11等等。有效的方法是测试小于2000的素数。使用字轮方法更快
（4） 对某随机数a运行Rabin-Miller检测，如果p通过，则另外产生一个随机数a,在测试。选取较小的a值，以保证速度。做5次 Rabin-Miller测试如果p在其中失败，从新产生p，再测试。

经测试，这个算法在sun的Sparc II工作站上实现：
2 .8秒产生一个256位的素数
24.0秒产生一个512位的素数
2分钟产生一个768位的素数
5.1分钟产生一个1024位的素数

最近在网上看了不少关于素数的问题，也学习到了不少东西，决定整理一下，算是一个学习的总结吧。

首先想说明的是，虽然素数可以进行很深入的研究（如在RSA公共密钥系统的应用），但是由于我对数论的不甚熟悉，所以只能做一些浅尝辄止的探讨，主要就是对一些简单的素数相关算法进行一个讨论。

首先来说说素数的判定算法，如果你是读谭浩强老师的《c程序设计》入门的话，那么一谈到素数的判定算法，你首先应该想到的就是以下的算法：给定一个正整数n，用2到sqrt(n)之间的所有整数去除n，如果可以整除，则n不是素数，如果不可以整除，则n就是素数。这个算法的时间复杂度十分明了，为O（sqrt（n）），算法的描述相当简单，实现也一样不困难。

# include <stdio.h>
# include <math.h>

int isPrime(int n)
{
    int i ;
 
    for(i=2; i <= sqrt(n); i++){
        if(n%i == 0 )
            break ;
    }

    if(i <= sqrt(n))
        printf("%d is not a prime ! ", &n) ;
    else
        printf("%d is a prime ! ", &n) ;
 
    return 0 ;
}

=====================================
public class  SuShu{  
 private int num; 
 SuShu(int n){   
  num=n;
 } 
 public  boolean isSuShu(){
  for(int i=2;i<num;i++){
   if(num%i==0)
    return false;                
  }    
   return true; 
 } 
 public static void main(String[] args){   
  for(int i=1;i<=100;i++){
   SuShu su=new SuShu(i);
   if(su.isSuShu())
    System.out.println(i+"是素数");
   else
    System.out.println(i+"不是素数");   
  }
 }
}

=============================

/**  
* @param n  
* @return if n is a prime return true, else false  
*/ 
public static boolean isPrime(int n) {
 // filte negative, zero, one   
 if (1 >= n) {
       return false;
 }
 // 2 is a prime, stop filter   
 if (2 == n) {
  return true;
 }
 // filter evens
 if (0 == n % 2) {
  return false;
 }
 // go on filting...   
 for (int a = 3; a <= Math.sqrt(n); a += 2) {
  if (0 == n % a) {
   return false;
  }
 }
 // the rest is all prime, stop filting   
 return true;
}
==============================
//目前我认为最好的办法是:(不是lk的观点)
public boolean isPrime(int n){
    for(int i = 2; i * i <= n; i++){
  if(n % i == 0)
   return false;
  }
    return true;
}
===============================
素数是这样的整数，它除了能表示为它自己和1的乘积以外，不能表示为任何其它两个整数的乘积。例如，15＝3＊5，所以15不是素数；又如，12＝6＊2＝4＊3，所以12也不是素数。另一方面，13除了等于13＊1以外，不能表示为其它任何两个整数的乘积，所以13是一个素数。
有的数，如果单凭印象去捉摸，是无法确定它到底是不是素数的。有些数则可以马上说出它不是素数。一个数，不管它有多大，只要它的个位数是2、4、5、6、8或0，就不可能是素数。此外，一个数的各位数字之和要是可以被3整除的话，它也不可能是素数。但如果它的个位数是1、3、7或9，而且它的各位数字之和不能被3整除，那么，它就可能是素数（但也可能不是素数）。没有任何现成的公式可以告诉你一个数到底是不是素数。你只能试试看能不能将这
个数表示为两个比它小的数的乘积。

代码如下：

package com.vo;

public class Sushu {

 public static void main(String[] args) {
  int s=0;
  int i;
  for(i=0;i<=100;i++)
  {
 int j;
 for(j=2;j<=i;j++){
  if(i%j==0)
   break;
 }
 if(i==j)
  System.out.println(i);
  }

 }

}

<?xml version="1.0" encoding="UTF-8"?>

<Customers>

    <customer>

            <id>1</id>

            <gender>female</gender>

            <firstname>Jessica</firstname>

            <lastname>Lim</lastname>

            <phoneNumber>1234567</phoneNumber>

            <address>

                <primaryAddress>

                        <postalCode>350106</postalCode>

                        <addressLine1>#25-1</addressLine1>

                        <addressLine2>SHINSAYAMA 2-CHOME</addressLine2>

                </primaryAddress>

                <billingAddress>

                        <receiver>Ms Danielle</receiver>

                        <postalCode>350107</postalCode>

                        <addressLine1>#167</addressLine1>

                        <addressLine2>NORTH TOWER HARBOUR CITY</addressLine2>

                </billingAddress>

            </address>

    </customer>

    <customer>

            <id>2</id>

            <gender>male</gender>

            <firstname>David</firstname>

            <lastname>Bill</lastname>

            <phoneNumber>808182</phoneNumber>

            <address>

                <primaryAddress>

                        <postalCode>319087</postalCode>

                        <addressLine1>1033 WS St.</addressLine1>

                        <addressLine2>Tima Road</addressLine2>

                </primaryAddress>

                <billingAddress>

                        <receiver>Mr William</receiver>

                        <postalCode>672993</postalCode>

                        <addressLine1>1033 WS St.</addressLine1>

                        <addressLine2>Tima Road</addressLine2>

                </billingAddress>

            </address>

    </customer>

</Customers>

<xb:config xmlns:xb="http://xml.apache.org/xmlbeans/2004/02/xbean/config">



  <xb:namespace>

    <xb:package>sample.xmlbean</xb:package>

  </xb:namespace>



</xb:config>

       <?xml version="1.0" encoding="UTF-8"?>

       <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"

                  elementFormDefault="qualified">

         <xs:element name="Customers">

           <xs:complexType>

             <xs:sequence>

               <xs:element maxOccurs="unbounded" name="customer"

                           type="customerType"/>

             </xs:sequence>

           </xs:complexType>

         </xs:element>

       <xs:complexType name="customerType">

             <xs:sequence>

               <xs:element name="id" type="xs:int"/>

               <xs:element name="gender" type="xs:string"/>

               <xs:element name="firstname" type="xs:string"/>

               <xs:element name="lastname" type="xs:string"/>

               <xs:element name="phoneNumber" type="xs:string"/>

               <xs:element name="address" type="addressType"/>

             </xs:sequence>

       </xs:complexType>

         <xs:complexType name="addressType">

             <xs:sequence>

               <xs:element name="primaryAddress" type="primaryAddressType"/>

               <xs:element name="billingAddress" type="billingAddressType"/>

             </xs:sequence>

         </xs:complexType>



         <xs:complexType name="primaryAddressType">

             <xs:sequence>

               <xs:element name="postalCode" type="xs:string"/>

               <xs:element name="addressLine1" type="xs:string"/>

               <xs:element name="addressLine2" type="xs:string"/>

             </xs:sequence>

         </xs:complexType>

         <xs:complexType name="billingAddressType">

             <xs:sequence>

                   <xs:element name="receiver" type="xs:string"/>

               <xs:element name="postalCode" type="xs:string"/>

               <xs:element name="addressLine1" type="xs:string"/>

               <xs:element name="addressLine2" type="xs:string"/>

             </xs:sequence>

         </xs:complexType>

       </xs:schema>

       

       scomp [options] [dirs]* [schemaFile.xsd]* [service.wsdl]* [config.xsdconfig]*

       

       scomp -src build\src  -out build\customerXmlBean.jar schema\customer.xsd

             -compiler C:\jdk142_04\bin\javac customer.xsdconfig

       

          CustomersDocument.java    -- 整个XML文档的Java Class映射

       CustomerType.java              -- 节点sustomer的映射

       AddressType.java                 -- 节点address的映射

       BillingAddressType.java        -- 节点billingAddress的映射

       PrimaryAddressType.java      -- 节点primaryAddress的映射

     

    package com.sample.reader;



    import java.io.File;

    

    import sample.xmlbean.*;

    import org.apache.commons.beanutils.BeanUtils;

    import org.apache.xmlbeans.XmlOptions;

    public class CustomerXMLBean {

    private String filename = null;

    

    public CustomerXMLBean(String filename) {

            super();

            this.filename = filename;

    }



    public void customerReader() {

            try {

              File xmlFile = new File(filename);

              CustomersDocument doc = CustomersDocument.Factory.parse(xmlFile);

              CustomerType[] customers = doc.getCustomers().getCustomerArray();

          

              for (int i = 0; i < customers.length; i++) {

                CustomerType customer = customers[i];

                println("Customer#" + i);

                println("Customer ID:" + customer.getId());

                println("First name:" + customer.getFirstname());

                println("Last name:" + customer.getLastname());

                println("Gender:" + customer.getGender());

                println("PhoneNumber:" + customer.getPhoneNumber());

                // Primary address

                PrimaryAddressType primaryAddress = customer.getAddress().getPrimaryAddress();

                println("PrimaryAddress:");

                println("PostalCode:" + primaryAddress.getPostalCode());

                println("AddressLine1:" + primaryAddress.getAddressLine1());

                println("AddressLine2:" + primaryAddress.getAddressLine2());

                // Billing address

                BillingAddressType billingAddress = customer.getAddress().getBillingAddress();

                println("BillingAddress:");

                println("Receiver:" + billingAddress.getReceiver());

                println("PostalCode:" + billingAddress.getPostalCode());

                println("AddressLine1:" + billingAddress.getAddressLine1());

                println("AddressLine2:" + billingAddress.getAddressLine2());

            

              }

            } catch (Exception ex) {

                    ex.printStackTrace();

            }

    }

    private void println(String str) {

          System.out.println(str);

    }

   public static void main(String[] args) {

      String filename = "F://JavaTest//Eclipse//XMLBean//xml//customers.xml";

                   

     CustomerXMLBean customerXMLBean = new CustomerXMLBean(filename);

                   customerXMLBean.customerReader();

    }



    }

    

       Customer#0

       Customer ID:1

       First name:Jessica

       Last name:Lim

       Gender:female

       PhoneNumber:1234567

       PrimaryAddress:

       PostalCode:350106

       AddressLine1:#25-1

       AddressLine2:SHINSAYAMA 2-CHOME

       BillingAddress:

       Receiver:Ms Danielle

       PostalCode:350107

       AddressLine1:#167

       AddressLine2:NORTH TOWER HARBOUR CITY



       Customer#1

       Customer ID:2

       First name:David

       Last name:Bill

       Gender:male

       PhoneNumber:808182

       PrimaryAddress:

       PostalCode:319087

       AddressLine1:1033 WS St.

       AddressLine2:Tima Road

       BillingAddress:

       Receiver:Mr William

       PostalCode:672993

       AddressLine1:1033 WS St.

       AddressLine2:Tima Road

    

    public void createCustomer() {

    try {

        // Create Document

        CustomersDocument doc = CustomersDocument.Factory.newInstance();

        // Add new customer

        CustomerType customer = doc.addNewCustomers().addNewCustomer();

        // set customer info

        customer.setId(3);

        customer.setFirstname("Jessica");

        customer.setLastname("Lim");

        customer.setGender("female");

        customer.setPhoneNumber("1234567");

        // Add new address

        AddressType address = customer.addNewAddress();

        // Add new PrimaryAddress

        PrimaryAddressType primaryAddress = address.addNewPrimaryAddress();

        primaryAddress.setPostalCode("350106");

        primaryAddress.setAddressLine1("#25-1");

        primaryAddress.setAddressLine2("SHINSAYAMA 2-CHOME");



        // Add new BillingAddress

        BillingAddressType billingAddress = address.addNewBillingAddress();

        billingAddress.setReceiver("Ms Danielle");

        billingAddress.setPostalCode("350107");

        billingAddress.setAddressLine1("#167");

        billingAddress.setAddressLine2("NORTH TOWER HARBOUR CITY");



        File xmlFile = new File(filename);

        doc.save(xmlFile);

        } catch (Exception ex) {

                ex.printStackTrace();

        }



  }

    

    public static void main(String[] args) {

    String filename = "F://JavaTest//Eclipse//XMLBean//xml//customers_new.xml";

        CustomerXMLBean customerXMLBean = new CustomerXMLBean(filename);

        customerXMLBean.createCustomer();

    }

    

    <?xml version="1.0" encoding="UTF-8"?>

    <Customers>

    <customer>

            <id>3</id>

            <gender>female</gender>

            <firstname>Jessica</firstname>

            <lastname>Lim</lastname>

            <phoneNumber>1234567</phoneNumber>

            <address>

                    <primaryAddress>

                         <postalCode>350106</postalCode>

                         <addressLine1>#25-1</addressLine1>

                                       <addressLine2>SHINSAYAMA 2-CHOME</addressLine2>

                    </primaryAddress>

                    <billingAddress>

                        <receiver>Ms Danielle</receiver>

                        <postalCode>350107</postalCode>

                       <addressLine1>#167</addressLine1>

                       <addressLine2>NORTH TOWER HARBOUR CITY</addressLine2>

                    </billingAddress>

                    </address>

            </customer>

    </Customers>

    

      public void updateCustomer(int id,String lastname) {

         try {

        File xmlFile = new File(filename);

        CustomersDocument doc = CustomersDocument.Factory.parse(xmlFile);

        CustomerType[] customers = doc.getCustomers().getCustomerArray();

      

        for (int i = 0; i < customers.length; i++) {

           CustomerType customer = customers[i];

          if(customer.getId()==id){

                customer.setLastname(lastname);

                break;

            }

        }

        doc.save(xmlFile);

         } catch (Exception ex) {

          ex.printStackTrace();

         }

           }

    

    public static void main(String[] args) {

     String filename = "F://JavaTest//Eclipse//XMLBean//xml//customers_new.xml";

                    

    CustomerXMLBean customerXMLBean = new CustomerXMLBean(filename);

                    

    customerXMLBean.updateCustomer(3,"last");

    }

    

    public void deleteCustomer(int id) {

     try {

      File xmlFile = new File(filename);

     CustomersDocument doc = CustomersDocument.Factory.parse(xmlFile);

    CustomerType[] customers = doc.getCustomers().getCustomerArray();



   for (int i = 0; i < customers.length; i++) {

        CustomerType customer = customers[i];

        if(customer.getId()==id){

                        customer.setNil() ;

                        break;

               }

   }

   doc.save(xmlFile);

   } catch (Exception ex) {

        ex.printStackTrace();

        }

   }

    public static void main(String[] args) {

    String filename = "F://JavaTest//Eclipse//XMLBean//xml//customers_new.xml";

                    

    CustomerXMLBean customerXMLBean = new CustomerXMLBean(filename);

                    

    customerXMLBean.deleteCustomer(3);

    }

在Java Swing编程过程中，经常需要处理键盘事件，例如处理快捷键等。这里就介绍如何定义键盘事件，以及如何处理这些事件。

在jdk1.2中，分别针对Jcomponent和Text类的对象定制了不同的处理键盘事件的方法：在Jcomponent中，定义了registerKeyboardAction方法，使用这个方法来将需要处理的键盘事件以及处理事件的行为绑定在一起。Text类中具有keymap对象，同Jcomponent中的处理方法类似，这个对象保存着需要处理的键盘事件和对应的行为。

而在jdk1.3中，使用一种新的方法来处理键盘事件，它将jdk1.2的两种方法整合在一起。不需要区分被处理的是Jcomponent还是Text类型的组件。它定义了两个新的类：InputMap和ActionMap。他们均是简单的表或映射。一个InputMap将一个Keystroke对应到一个对象，ActionMap将一个对象对应到一个行为（Action）。通常InputMap中KeyStroke所对应的对象是一个字符串，通过这个字符串可以在ActionMap中查找到相应的行为。

InputMap和ActionMap中均有put方法。InputMap的put方法可以将Keystroke对应到一个对象，而ActionMap的put方法可以将一个对象对应到一个行为。

在每一个Jcomponent组件中，会有三个缺省的InputMap和一个缺省的ActionMap。他们可以通过调用getInputMap(int condition)和getActionMap()得到。三个InputMap分别是当组件本身拥有焦点时的InputMap（WHEN_FOCUSED），当组件的祖先拥有焦点时的InputMap（WHEN_ANCESTOR_OF_FOCUSED_COMPONENT）和组件所在的窗体具有焦点时的InputMap（WHEN_IN_FOCUSED_WINDOW）（括号内表示为了得到这些InputMap，应该在getInputMap中设置的参数）。以下分别说明这三种InputMap：

1. 组件本身拥有焦点时的InputMap：当组件拥有焦点时，键盘按键按下，则java在这个InputMap中查找键盘事件所对应的KeyStroke对象。

2. 组件的祖先拥有焦点时的InputMap：当组件的祖先拥有焦点时，键盘按键按下，则java查找这个InputMap。

3. 组件所在的窗口拥有焦点时的InputMap：当组件所在的窗口具有焦点时，键盘按键按下，则java查找这个InputMap。

当一个键被按下，这个事件被转化成一个KeyStroke对象，java会查找这个Jcomponent的相应InputMap（例如，当组件的祖先具有焦点时，java就查找这个Jcomponent的祖先拥有焦点的InputMap）中是否有这个KeyStroke，如果有，取出它所对应的对象（通常是字符串），利用这个对象在这个Jcomponent的ActionMap中查找，如果找到对应的行为（Action），则java执行这个行为的actionPerformed方法（随后介绍这个方法）。从而达到处理键盘事件的目的。

每一个InputMap可以具有parent属性，这个属性的值是一个InputMap。当在一个InputMap中查找不到键盘事件的KeyStroke时，java会自动在它的parent属性指定的InputMap中查找，依次向上查找，直至找到。使用parent的好处是：当有一些固定的，不希望用户进行改动的键盘映射可以存放在parent属性所指定的InputMap中，从而避免被意外修改；另外可以将多个Jcomponent的缺省InputMap设置具有相同的parent，使得可以共享一些键盘绑定的设置。可以通过InputMap类的setparent()方法设置它的parent属性。ActionMap也具有相同的parent属性，使用方法也相同。

以上是如何将一个键盘事件对应到一个行为，以下就简单介绍行为（Action）。

行为是一个实现了Action接口的类。在Action接口中定义了7个方法。其中最关键的是actionPerformed()方法。这个方法描述了这个行为的具体操作过程。其他几个方法包括setEnabled，isEnabled，putValue，getValue，addPropertyChangeListener，和removePropertyChangeListener方法。他们分别用来设置行为是否可用、判断行为可用的状态、设置和取得行为的一些属性，最后两个方法用来允许其他对象在行动对象的属性发生变化后得到通知。

通常我们使用一个实现了Action接口的大部分方法的抽象类AbstractAction类作为基类，重载actionPerformed方法以实现我们的行为。

我们用一个例子来具体说明如何进行实际的操作。

首先编写一个具体的行为，对指定的键盘事件进行处理：

public class TextAction extends AbstractAction
            {
            　private String a;
            　public TextAction(String a)
            　{ this.a = a; }
            　　public void actionPerformed(ActionEvent parm1)
            　　{
            　　　String b = parm1.getActionCommand(); //得到行为的命令字符串
            　　　System.out.println("command="+b);
            　　　System.out.println("prompt="+this.a);
            　　}
            　}

建立四个TextAction对象：

TextAction whenFocusSon = new TextAction("focus son");

TextAction whenFocusFather = new TextAction("focus father");

TextAction window = new TextAction("window");

TextAction ancestor = new TextAction("ancestor");

随后，在一个窗体中加入两个面板，名为sonPanel和parentPanel，使得parentPanel是sonPanel的祖先。并在sonPanel中加入一个名为son的button，在parentPanel中加入名为parent的button。在fatherPanel外加入几个button。

得到son组件的三个InputMap，并创建一个名为focusFatherIm的InputMap，使得这个InputMap成为focusIm的parent：

//get default inputMap (when focus inputmap) and set a parent InputMap
            focusIm = son.getInputMap();
            focusFatherIm = new InputMap();
            focusIm.setParent(focusFatherIm);
            //get WHEN_ANCESTOR_OF_FOCUSED_COMPONENT inputMap
            ancestorIm = son.getInputMap(WHEN_ANCESTOR_OF_FOCUSED_COMPONENT);
            //get WHEN_IN_FOCUSED_WINDOW inputMap
            windowIm = son.getInputMap(WHEN_IN_FOCUSED_WINDOW);
            //在这些InputMap中分别加入键盘绑定：
            focusIm.put(KeyStroke.getKeyStroke('f'),"actionFocusSon");
            focusFatherIm.put(KeyStroke.getKeyStroke('F'),"actionFocusFather");
            ancestorIm.put(KeyStroke.getKeyStroke('a'),"actionAncestor");
            windowIm.put(KeyStroke.getKeyStroke('w'),"actionWindow");
            //得到son组件的缺省的ActionMap，并将已经建立的行为与特定的对象（字符串）进行绑定：
            am = son.getActionMap();
            am.put("actionFocusSon",whenFocusSon);
            am.put("actionFocusFather",whenFocusFather);
            am.put("actionAncestor",ancestor);
            am.put("actionWindow",window);

运行程序及其相应结果：

1. 单击son按钮，这时如果按下'f'，'F'，'a'，'w'，程序均会有相应的输出。这是因为，此时的焦点在son按钮上，而son按钮组件的三个InputMap都是有效的。所以他们对应的事件都会发生。

2. 单击parent按钮，这时按下'w'，程序会有相应的输出。而按下'f'，'F'，'a'，程序没有反应。这是因为parent按钮具有焦点，这个按钮不是son按钮的祖先，而son所在的窗口具有焦点，所以只有组件所在窗口具有焦点的InputMap是有效的。

3. 单击其他的按钮（parentPanel外的按钮），这时按下'w'，程序会有相应的输出。而按下'f'，'F'，'a'，程序没有反应。这是因为这些按钮具有焦点，他们不是son按钮的祖先，而son所在的窗口具有焦点，所以只有组件所在窗口具有焦点的InputMap是有效的。

附：主要程序代码：

import java.awt.*;
            import javax.swing.*;
            import com.borland.jbcl.layout.*;
            import java.awt.event.ActionEvent;
            import java.awt.event.ActionListener;
            import com.sun.java.swing.plaf.motif.*;
            public class EventPanel extends JPanel implements ActionListener
            {
            　JButton btnYellow = new JButton();
            　JButton btnBlue = new JButton();
            　JButton btnRed = new JButton();
            　JPanel parentPanel = new JPanel();
            　JPanel sonPanel = new JPanel();
            　XYLayout xYLayout1 = new XYLayout();
            　JButton son = new JButton();
            　JButton parent = new JButton();
            　public EventPanel()
            　{
            　　try{
            　　　jbInit();
            　　}catch(Exception ex)
            　　{ ex.printStackTrace(); }
            　　}
            　void jbInit() throws Exception
            　{
            　　btnYellow.setText("Yellow");
            　　btnYellow.setBounds(new Rectangle(35, 23, 97, 29));
            　　this.setLayout(null);
            　　btnBlue.setBounds(new Rectangle(154, 21, 97, 29));
            　　btnBlue.setText("Blue");
            　　btnRed.setBounds(new Rectangle(272, 24, 97, 29));
            　　btnRed.setText("Red");
            　　parentPanel.setBorder(BorderFactory.createRaisedBevelBorder());
            　　parentPanel.setBounds(new Rectangle(27, 68, 358, 227));
            　　parentPanel.setLayout(xYLayout1);
            　　sonPanel.setBorder(BorderFactory.createLoweredBevelBorder());
            　　son.setText("son");
            　　parent.setText("parent");
            　　this.add(btnYellow, null);
            　　this.add(btnBlue, null);
            　　this.add(btnRed, null);
            　　this.add(parentPanel, null);
            　　parentPanel.add(sonPanel, new XYConstraints(58, 22, 229, 125));
            　　sonPanel.add(son, null);
            　　parentPanel.add(parent, new XYConstraints(150, 167, -1, -1));
            　　btnYellow.addActionListener(this);
            　　btnRed.addActionListener(this);
            　　btnBlue.addActionListener(this);
            　　InputMap focusIm,focusFatherIm,ancestorIm,windowIm;
            　　ActionMap am;
            　　//create four TextAction for diff purpose
            　　TextAction whenFocusSon = new TextAction("focus son");
            　　TextAction whenFocusFather = new TextAction("focus father");
            　　TextAction window = new TextAction("window");
            　　TextAction ancestor = new TextAction("ancestor");
            　　//get default inputMap (when focus inputmap) and set a parent InputMap
            　　focusIm = son.getInputMap();
            　　focusFatherIm = new InputMap();
            　　focusIm.setParent(focusFatherIm);
            　　//get WHEN_ANCESTOR_OF_FOCUSED_COMPONENT inputMap
            　　ancestorIm = son.getInputMap(WHEN_ANCESTOR_OF_FOCUSED_COMPONENT);
            　　//get WHEN_IN_FOCUSED_WINDOW inputMap
            　　windowIm = son.getInputMap(WHEN_IN_FOCUSED_WINDOW);
            　　//put the keyStroke to the InputMap
            　　focusIm.put(KeyStroke.getKeyStroke('f'),"actionFocusSon");
            　　focusFatherIm.put(KeyStroke.getKeyStroke('F'),"actionFocusFather");
            　　ancestorIm.put(KeyStroke.getKeyStroke('a'),"actionAncestor");
            　　windowIm.put(KeyStroke.getKeyStroke('w'),"actionWindow");
            　　//get the actionMap
            　　am = son.getActionMap();
            　　am.put("actionFocusSon",whenFocusSon);
            　　am.put("actionFocusFather",whenFocusFather);
            　　am.put("actionAncestor",ancestor);
            　　am.put("actionWindow",window);
            　}
            　public void actionPerformed(ActionEvent e)
            　{
            　　//this code is used to change the backgracolor
            　　Object source=e.getSource();
            　　Color color=null;//=getBackground();
            　　if (source==btnYellow) color=Color.yellow;
            　　else if (source==btnRed) color = Color.red;
            　　else if (source == btnBlue) color = Color.blue;
            　　setBackground(color);
            　　repaint();
            　}
            }

　　[安全性]是多线程编程的首要原则，如果两个以上的线程访问同一对象时，一个线程会损坏另一个线程的数据，这就是违反了安全性原则，这样的程序是不能进入实际应用的。

　　安全性的保证可以通过设计安全的类和程序员的手工控制。如果多个线程对同一对象访问不会危及安全性，这样的类就是线程安全的类，在JAVA中比如String类就被设计为线程安全的类。而如果不是线程安全的类，那么就需要程序员在访问这些类的实例时手工控制它的安全性。

　　[可行性]是多线程编程的另一个重要原则，如果仅仅实现了安全性，程序却在某一点后不能继续执行或者多个线程发生死锁，那么这样的程序也不能作为真正的多线程程序来应用。

　　相对而言安全性和可行性是相互抵触的，安全性越高的程序，可性行会越低。要综合平衡。

　　[高性能] 多线程的目的本来就是为了增加程序运行的性能，如果一个多线程完成的工作还不如单线程完成得快。那就不要应用多线程了。

　　高性能程序主要有以下几个方面的因素：

　　数据吞吐率，在一定的时间内所能完成的处理能力。

　　响应速度，从发出请求到收到响应的时间。

　　容量，指同时处理雅致同任务的数量。

　　安全性和可行性是必要条件，如果达到不这两个原则那就不能称为真正的多线程程序。而高性是多线程编程的目的，也可以说是充要条件。否则，为什么采用多线程编程呢？

[生产者与消费者模式]

　　首先以一个生产者和消费者模式来进入实战篇的第一节。

　　生产者和消费者模式中保护的是谁？

　　多线程编程都在保护着某些对象，这些个对象是"紧俏资源"，要被最大限度地利用，这也是采用多线程方式的理由。在生产者消费者模式中，我们要保护的是"仓库"，在我下面的这个例子中，

就是桌子(table)。

　　我这个例子的模式完全是生产者-消费者模式，但我换了个名字。厨师-食客模式，这个食堂中只有1张桌子，同时最多放10个盘子，现在有4个厨师做菜，每做好一盘就往桌子上放(生产者将产品往仓库中放)，而有6个食客不停地吃(消费者消费产品，为了说明问题，他们的食量是无限的)。

　　一般而言，厨师200-400ms做出一盘菜，而食客要400-600ms吃完一盘。当桌子上放满了10个盘子后，所有厨师都不能再往桌子上放，而当桌子是没有盘子时，所有的食客都只好等待。

　　下面我们来设计这个程序：

　　因为我们不知道具体是什么菜，所以叫它food：

 class Food{}

　　然后是桌子，因为它要有序地放而且要有序地取(不能两个食客同时争取第三盘菜)，所以我们扩展LinkedList，或者你用聚合把一个LinkedList作为属性也能达到同样的目的，例子中我是用

继承，从构造方法中传入一个可以放置的最大值。

class Table extends java.util.LinkedList{
int maxSize;
public Table(int maxSize){
this.maxSize = maxSize;
}
}

现在我们要为它加两个方法，一是厨师往上面放菜的方法，一是食客从桌子上拿菜的方法。

放菜：因为一张桌子由多个厨师放菜，所以厨师放菜的要被同步，如果桌子上已经有十盘菜了。所有厨师就要等待：

 public synchronized void putFood(Food f){
while(this.size() >= this.maxSize){
try{
this.wait();
}catch(Exception e){}
}
this.add(f);
notifyAll();
}

拿菜：同上面，如果桌子上一盘菜也没有，所有食客都要等待：

 public synchronized Food getFood(){
while(this.size() <= 0){
try{
this.wait();
}catch(Exception e){}
}
Food f = (Food)this.removeFirst();
notifyAll();
return f;
}

厨师类：

　　由于多个厨师要往一张桌子上放菜，所以他们要操作的桌子应该是同一个对象，我们从构造方法中将桌子对象传进去以便控制在主线程中只产生一张桌子。

厨师做菜要用一定的时候，我用在make方法中用sleep表示他要消耗和时候，用200加上200的随机数保证时间有200-400ms中。做好后就要往桌子上放。

这里有一个非常重要的问题一定要注意，就是对什么范围同步的问题，因为产生竞争的是桌子，所以所有putFood是同步的，而我们不能把厨师自己做菜的时间也放在同步中，因为做菜是各自做的。同样食客吃菜的时候也不应该同步，只有从桌子中取菜的时候是竞争的，而具体吃的时候是各自在吃。所以厨师类的代码如下：

 class Chef extends Thread{
Table t;
Random r = new Random(12345);
public Chef(Table t){
this.t = t;
}
public void run(){
while(true){
Food f = make();
t.putFood(f);
}
}
private Food make(){
try{
Thread.sleep(200+r.nextInt(200));
}catch(Exception e){}
return new Food();
}
}

同理我们产生食客类的代码如下：

class Eater extends Thread{
Table t;
Random r = new Random(54321);
public Eater(Table t){
this.t = t;
}
public void run(){
while(true){
Food f = t.getFood();
eat(f);
}
}
private void eat(Food f){
try{
Thread.sleep(400+r.nextInt(200));
}catch(Exception e){}
}
}

完整的程序在这儿：

package debug;
import java.util.regex.*;
import java.util.*;
class Food{}
class Table extends LinkedList{
int maxSize;
public Table(int maxSize){
this.maxSize = maxSize;
}
public synchronized void putFood(Food f){
while(this.size() >= this.maxSize){
try{
this.wait();
}catch(Exception e){}
}
this.add(f);
notifyAll();
}
public synchronized Food getFood(){
while(this.size() <= 0){
try{
this.wait();
}catch(Exception e){}
}
Food f = (Food)this.removeFirst();
notifyAll();
return f;
}
}
class Chef extends Thread{
Table t;
String name;
Random r = new Random(12345);
public Chef(String name,Table t){
this.t = t;
this.name = name;
}
public void run(){
while(true){
Food f = make();
System.out.println(name+" put a Food:"+f);
t.putFood(f);
}
}
private Food make(){
try{
Thread.sleep(200+r.nextInt(200));
}catch(Exception e){}
return new Food();
}
}
class Eater extends Thread{
Table t;
String name;
Random r = new Random(54321);
public Eater(String name,Table t){
this.t = t;
this.name = name;
}
public void run(){
while(true){
Food f = t.getFood();
System.out.println(name+" get a Food:"+f);
eat(f);
}
}
private void eat(Food f){
try{
Thread.sleep(400+r.nextInt(200));
}catch(Exception e){}
}
}
public class Test {
public static void main(String[] args) throws Exception{
Table t = new Table(10);
new Chef("Chef1",t).start();
new Chef("Chef2",t).start();
new Chef("Chef3",t).start();
new Chef("Chef4",t).start();
new Eater("Eater1",t).start();
new Eater("Eater2",t).start();
new Eater("Eater3",t).start();
new Eater("Eater4",t).start();
new Eater("Eater5",t).start();
new Eater("Eater6",t).start();
}
}

这一个例子中，我们主要关注以下几个方面：

　　1.同步方法要保护的对象，本例中是保护桌子，不能同时往上放菜或同时取菜。

　　假如我们把putFood方法和getFood方法在厨师类和食客类中实现，那么我们应该如此：

(以putFood为例)

class Chef extends Thread{
Table t;
String name;
public Chef(String name,Table t){
this.t = t;
this.name = name;
}
public void run(){
while(true){
Food f = make();
System.out.println(name+" put a Food:"+f);
putFood(f);
}
}
private Food make(){
Random r = new Random(200);
try{
Thread.sleep(200+r.nextInt());
}catch(Exception e){}
return new Food();
}
public void putFood(Food f){//方法本身不能同步,因为它同步的是this.即Chef的实例
synchronized (t) {//要保护的是t
while (t.size() >= t.maxSize) {
try {
t.wait();
}
catch (Exception e) {}
}
t.add(f);
t.notifyAll();
}
}
}

　　2.同步的范围，在本例中是放和取两个方法，不能把做菜和吃菜这种各自不相干的工作放在受保护的范围中。

　　3.参与者与容积比

　　 对于生产者和消费者的比例，以及桌子所能放置最多菜的数量三者之间的关系是影响性能的重要因素，如果是过多的生产者在等待，则要增加消费者或减少生产者的数据，反之则增加生产者或减少消费者的数量。

　　另外如果桌子有足够的容量可以很大程序提升性能，这种情况下可以同时提高生产者和消费者的数量，但足够大的容时往往你要有足够大的物理内存。

　　[一个线程在进入对象的休息室(调用该对象的wait()方法)后会释放对该对象的锁]，基于这个原因。在同步中，除非必要，否则你不应用使用Thread.sleep(long l)方法，因为sleep方法并不释放对象的锁。

　　这是一个极其恶劣的品德，你自己什么事也不干，进入sleep状态，却抓住竞争对象的监视锁不让其它需要该对象监视锁的线程运行，简单说是极端自私的一种行为。但我看到过很多程序员仍然有在同步方法中调用sleep的代码。

　　看下面的例子：

package debug;
class SleepTest{
public synchronized void wantSleep(){
try{
Thread.sleep(1000*60);
}catch(Exception e){}
System.out.println("111");
}
public synchronized void say(){
System.out.println("123");
}
}
class T1 extends Thread{
SleepTest st;
public T1(SleepTest st){
this.st = st;
}
public void run(){
st.wantSleep();
}
}
class T2 extends Thread{
SleepTest st;
public T2(SleepTest st){
this.st = st;
}
public void run(){
st.say();
}
}
public class Test {
public static void main(String[] args) throws Exception{
SleepTest st = new SleepTest();
new T1(st).start();
new T2(st).start();
}
}

　　我们看到，线程T1的实例运行后，当前线程抓住了st实例的锁，然后进入了sleep。直到它睡满60秒后才运行到System.out.println("111");然后run方法运行完成释放了对st的监视锁，线程T2的实例才得到运行的机会。

　　而如果我们把wantSleep方法改成：

  public synchronized void wantSleep(){
try{
//Thread.sleep(1000*60);
this.wait(1000*60);
}catch(Exception e){}
System.out.println("111");
}

　　我们看到，T2的实例所在的线程立即就得到了运行机会，首先打印了123，而T1的实例所在的线程仍然等待，直到等待60秒后运行到System.out.println("111");方法。

　　所以，调用wait(long l)方法不仅达到了阻塞当前线程规定时间内不运行，而且让其它有竞争需求的线程有了运行机会，这种利人不损己的方法，何乐而不为？这也是一个有良心的程序员应该遵循的原则。

　　当一个线程调用wait(long l)方法后，线程如果继续运行，你无法知道它是等待时间完成了还是在wait时被其它线程唤醒了，如果你非常在意它一定要等待足够的时间才执行某任务，而不希望是中途被唤醒，这里有一个不是非常准确的方法：

 long l = System.System.currentTimeMillis();
wait(1000);//准备让当前线程等待1秒
while((System.System.currentTimeMillis() - l) < 1000)//执行到这里说明它还没有等待到1秒
//是让其它线程给闹醒了
wait(1000-(System.System.currentTimeMillis()-l));//继续等待余下的时间.

　　这种方法不是很准确，但基本上能达到目的。

　　所以在同步方法中，除非你明确知道自己在干什么，非要这么做的话，你没有理由使用sleep，wait方法足够达到你想要的目的。而如果你是一个很保守的人，看到上面这段话后，你对sleep方法深恶痛绝，坚决不用sleep了，那么在非同步的方法中(没有和其它线程竞争的对象)，你想让当前线程阻塞一定时间后再运行，应该如何做呢？(这完全是一种卖弄，在非同步的方法中你就应该合理地应用sleep嘛，但如果你坚决不用sleep，那就这样来做吧)

    public static mySleep(long l){
Object o = new Object();
synchronized(o){
try{
o.wait(l);
}catch(Exception e){}
}
}

　　放心吧，没有人能在这个方法外调用o.notify[All]，所以o.wait(l)会一直等到设定的时间才会运行完成。

[虚拟锁的使用]

　　虚拟锁简单说就是不要调用synchronized方法(它等同于synchronized(this))和不要调用synchronized(this)，这样所有调用在这个实例上的所有同步方法的线程只能有一个线程可以运行。也就是说：

　　如果一个类有两个同步方法 m1，m2，那么不仅是两个以上线调用m1方法的线程只有一个能运行，就是两个分别调用m1，m2的线程也只有一个能运行。当然非同步方法不存在任何竞争，在一个线程获取该对象的监视锁后这个对象的非同步方法可以被任何线程调用。

　　而大多数时候，我们可能会出现这种情况，多个线程调用m1时需要保护一种资源，而多个线程调用M2时要保护的是另一种资源，如果我们把m1,m2都设成同步方法。两个分别调用这两个方法的线程其实并不产生冲突，但它们都要获取这个实例的锁(同步方法是同步this)而产生了不必要竞争。

　　所以这里应该采用虚拟锁。

　　即将m1和m2方法中各自保护的对象作为属性a1,a2传进来，然后将同步方法改为方法的同步块分别以a1,a2为参数，这样到少是不同线程调用这两个不同方法时不会产生竞争，当然如果m1,m2方法都操作同一受保护对象则两个方法还是应该作为同步方法。这也是应该将方法同步还是采用同步块的理由之一。

package debug;
class SleepTest{
public synchronized void m1(){
System.out.println("111");
try{
Thread.sleep(10000);
}catch(Exception e){}
}
public synchronized void m2(){
System.out.println("123");
}
}
class T1 extends Thread{
SleepTest st;
public T1(SleepTest st){
this.st = st;
}
public void run(){
st.m1();
}
}
class T2 extends Thread{
SleepTest st;
public T2(SleepTest st){
this.st = st;
}
public void run(){
st.m2();
}
}
public class Test {
public static void main(String[] args) throws Exception{
SleepTest st = new SleepTest();
new T1(st).start();
new T2(st).start();
}
}

　　这个例子可以看到两个线程分别调用st实例的m1和m2方法却因为都要获取st的监视锁而产生了竞争。T2实例要在T1运行完成后才能运行(间隔了10秒)。而假设m1方法要操作操作一个文件 f1，m2方法要操作一个文件f2，当然我们可以在方法中分别同步f1,f2，但现在还不知道f2,f2是否存在，如果不存在我们就同步了一个null对象，那么我们可以使用虚拟锁：

package debug;
class SleepTest{
String vLock1 = "vLock1";
String vLock2 = "vLock2";
public void m1(){
synchronized(vLock1){
System.out.println("111");
try {
Thread.sleep(10000);
}
catch (Exception e) {}
//操作f1
}
}
public void m2(){
synchronized(vLock2){
System.out.println("123");
//操作f2
}
}
}
class T1 extends Thread{
SleepTest st;
public T1(SleepTest st){
this.st = st;
}
public void run(){
st.m1();
}
}
class T2 extends Thread{
SleepTest st;
public T2(SleepTest st){
this.st = st;
}
public void run(){
st.m2();
}
}
public class Test {
public static void main(String[] args) throws Exception{
SleepTest st = new SleepTest();
new T1(st).start();
new T2(st).start();
}
}

　　我们看到两个分别调用m1和m2的线程由于它们获取不同对象的监视锁，它们没有任何竞争就正常运行，只有这两个线程同时调用m1或m2才会产生阻塞。

[深入了解线程对象与线程,线程与运行环境]

　　在基础篇中的第一节，我就强调过，要了解多线程编程，首要的两个概念就是线程对象和线程。现在我们来深入理解线程对象，线程，运行环境之间的关系，弄清Runnable与Thread的作用。

　　在JAVA平台中，序列化机制是一个非常重要的机制，如果不能理解并熟练应用序列化机制，你就不能称得上一个java程序员。

　　在JAVA平台中，为什么有些对象中可序列化的，而有些对象就不能序列化？

　　能序列化的对象，简单说是一种可以复制(意味着可以按一定机制进行重构它)的对象，这种对象说到底就是内存中一些数据的组合。只要按一定位置和顺序组合就能完整反映这个对象。

　　而有些对象，是和当前环境相关的，它反映了当前运行的环境和时序，所以不能被序列，否则在另外的环境和时序中就无法“还原”。

　　比如，一个Socket对象：

Socket sc = new Socket("111.111.111.111",80);

　　这个sc对象表示当前正在运行这段代码的主机和IP为"111.111.111.111"的80端口之间建立的一个物理连结，如果它被序列化，那么在另一个时刻在另一个主机上它如何能被还原？Socket连结一旦断开，就已经不存在，它不可能在另一个时间被另一个主机所重现。重现的已经不是原来那个sc对象了。

　　线程对象也是这种不可序列化对象，当我们new Thread时，已经初始化了当前这个线程对象所在有主机的运行环境相关的信息，线程调度机制，安全机制等只特定于当前运行环境的信息，假如它被序列化，在另一个环境中运行的时候原来初始化的运行环境的信息就不可能在新的环境中运行。而假如要重新初始化，那它已经不是原来那个线程对象了。

　　正如Socket封装了两个主机之间的连结，但它们并不是已经连结关传送数据了。要想传送数据，你还要getInputStream和getOutputStream，并read和write，两台主机之间才开始真正的“数据连结”。

　　一个Thread对象并建立后，只是有了可以"运行"的令牌，仅仅只是一个"线程对象"。只有当它调用start()后，当前环境才会分配给它一个运行的"空间"，让这段代码开始运行。这个运行的"空间"，才叫真正的"线程"。也就是说，真正的线程是指当前正在执行的那一个"事件"。是那个线程对象所在的运行环境。

　　明白了上面的概念，我们再来看看JAVA中为什么要有Runnable对象和Thread对象。

　　一、从设计技巧上说，JAVA中为了实现回调，无法调用方法指针，那么利用接口来约束实现者强制提供匹配的方法，并将实现该接口的类的实例作为参数来提供给调用者，这是JAVA平台实现回调的重要手段。

　　二、但是从实际的操作来看，对于算法和数据，是不依赖于任何环境的。所以把想要实现的操作中的算法和数据封装到一个run方法中(由于算法本身是数据的一个部分，所以我把它们合并称为数据)，可以将离数据和环境的逻辑分离开来。使程序员只关心如何实现我想做的操作，而不要关心它所在的环境。当真正的需要运行的时候再将这段"操作"传给一个具体当前环境的Thread对象。

　　三、这是最最重要的原因：实现数据共享

　　因为一个线程对象不对多次运行。所以把数据放在Thread对象中，不会被多个线程同时访问。简单说：

    class T extends Thread{
Object x;
public void run(){//......;}
}
T t = new T();

　　当T的实例t运行后，t所包含的数据x只能被一个t.start();对象共享，除非声明成    static Object x;

　　一个t的实例数据只能被一个线程访问。意思是"一个数据实例对应一个线程"。

　　而假如我们从外部传入数据，比如

  class T extends Thread{
private Object x;
public T(Object x){
this.x = x;
}
public void run(){//......;}
}

　　这样我们就可以先生成一个x对象传给多个Thread对象，多个线程共同操作一个数据。也就是"一个数据实例对应多个线程"。

　　现在我们把数据更好地组织一下，把要操作的数据Object x和要进行的操作一个封装到Runnable的run()方法中，把Runnable实例从外部传给多个Thread对象。这样，我们就有了：

　　[一个对象的多个线程]

　　这是以后我们要介绍的线程池的重要概念。

　　在java中，线程的中断(interrupt)只是改变了线程的中断状态，至于这个中断状态改变后带来的结果，那是无法确定的，有时它更是让停止中的线程继续执行的唯一手段。不但不是让线程停止运行，反而是继续执行线程的手段。

　　对于执行一般逻辑的线程，如果调用它的interrupt()方法，那么对这个线程没有任何影响，比如线程a正在执行：while(条件) x ++;这样的语句，如果其它线程调用a.interrupt();那么并不会影响a对象上运行的线程，如果在其它线程里测试a的中断状态它已经改变，但并不会停止这个线程的运行。在一个线程对象上调用interrupt()方法，真正有影响的是wait,join,sleep方法，当然这三个方法包括它们的重载方法。

　　请注意：[上面这三个方法都会抛出InterruptedException]，记住这句话，下面我会重复。一个线程在调用interrupt()后，自己不会抛出InterruptedException异常，所以你看到interrupt()并没有抛出这个异常，所以我上面说如果线程a正在执行while(条件) x ++;你调用a.interrupt();后线程会继续正常地执行下去。

　　但是，如果一个线程被调用了interrupt()后，它的状态是已中断的。这个状态对于正在执行wait,join,sleep的线程，却改变了线程的运行结果。

　　一、对于wait中等待notify/notifyAll唤醒的线程，其实这个线程已经“暂停”执行，因为它正在某一对象的休息室中，这时如果它的中断状态被改变，那么它就会抛出异常。这个InterruptedException异常不是线程抛出的，而是wait方法，也就是对象的wait方法内部会不断检查在此对象上休息的线程的状态，如果发现哪个线程的状态被置为已中断，则会抛出InterruptedException，意思就是这个线程不能再等待了，其意义就等同于唤醒它了。

　　这里唯一的区别是，被notify/All唤醒的线程会继续执行wait下面的语句，而在wait中被中断的线程则将控制权交给了catch语句。一些正常的逻辑要被放到catch中来运行。但有时这是唯一手段，比如一个线程a在某一对象b的wait中等待唤醒，其它线程必须获取到对象b的监视锁才能调用b.notify()[All]，否则你就无法唤醒线程a，但在任何线程中可以无条件地调用a.interrupt();来达到这个目的。只是唤醒后的逻辑你要放在catch中，当然同notify/All一样，继续执行a线程的条件还是要等拿到b对象的监视锁。

　　二、对于sleep中的线程，如果你调用了Thread.sleep(一年);现在你后悔了，想让它早些醒过来，调用interrupt()方法就是唯一手段，只有改变它的中断状态，让它从sleep中将控制权转到处理异常的catch语句中，然后再由catch中的处理转换到正常的逻辑。同样地，于join中的线程你也可以这样处理。

　　对于一般介绍多线程模式的书上，他们会这样来介绍：当一个线程被中断后，在进入wait,sleep,join方法时会抛出异常。是的，这一点也没有错，但是这有什么意义呢？如果你知道那个线程的状态已经处于中断状态，为什么还要让它进入这三个方法呢？当然有时是必须这么做的，但大多数时候没有这么做的理由，所以我上面主要介绍了在已经调用这三个方法的线程上调用interrupt()方法让它从"暂停"状态中恢复过来。这个恢复过来就可以包含两个目的：

　　一、[可以使线程继续执行]，那就是在catch语句中招待醒来后的逻辑，或由catch语句转回正常的逻辑。总之它是从wait,sleep,join的暂停状态活过来了。

　　二、[可以直接停止线程的运行]，当然在catch中什么也不处理，或return，那么就完成了当前线程的使命，可以使在上面“暂停”的状态中立即真正的“停止”。

　　中断线程

　　有了上一节[线程的中断]，我们就好进行如何[中断线程]了。这绝对不是玩一个文字游戏。是因为“线程的中断”并不能保证“中断线程”，所以我要特别地分为两节来说明。这里说的“中断线程”意思是“停止线程”，而为什么不用“停止线程”这个说法呢？因为线程有一个明确的stop方法，但它是反对使用的，所以请大家记住，在java中以后不要提停止线程这个说法，忘记它！但是，作为介绍线程知识的我，我仍然要告诉你为什么不用“停止线程”的理由。

　　[停止线程]

　　当在一个线程对象上调用stop()方法时，这个线程对象所运行的线程就会立即停止，并抛出特殊的ThreadDeath()异常。这里的“立即”因为太“立即”了，就象一个正在摆弄自己的玩具的孩子，听到大人说快去睡觉去，就放着满地的玩具立即睡觉去了。这样的孩子是不乖的。

　　假如一个线程正在执行：

synchronized void {
x = 3;
y = 4;
}

　　由于方法是同步的，多个线程访问时总能保证x,y被同时赋值，而如果一个线程正在执行到x = 3;时，被调用了 stop()方法，即使在同步块中，它也干脆地stop了，这样就产生了不完整的残废数据。而多线程编程中最最基础的条件要保证数据的完整性，所以请忘记线程的stop方法，以后我们再也不要说“停止线程”了。

　　 如何才能“结束”一个线程？

　　[中断线程]

　　结束一个线程，我们要分析线程的运行情况。也就是线程正在干什么。如果那个孩子什么事也没干，那就让他立即去睡觉。而如果那个孩子正在摆弄他的玩具，我们就要让它把玩具收拾好再睡觉。

　　所以一个线程从运行到真正的结束，应该有三个阶段：

1. 正常运行.
2. 处理结束前的工作,也就是准备结束.
3. 结束退出.

　　在我的JDBC专栏中我N次提醒在一个SQL逻辑结束后，无论如何要保证关闭Connnection那就是在finally从句中进行。同样，线程在结束前的工作应该在finally中来保证线程退出前一定执行：

 try{
正在逻辑
}catch(){}
finally{
清理工作
}

　　那么如何让一个线程结束呢？既然不能调用stop，可用的只的interrupt()方法。但interrupt()方法只是改变了线程的运行状态，如何让它退出运行？对于一般逻辑，只要线程状态已经中断，我们就可以让它退出，所以这样的语句可以保证线程在中断后就能结束运行：

 while(!isInterrupted()){
正常逻辑
}

　　这样如果这个线程被调用interrupt()方法，isInterrupted()为true，就会退出运行。但是如果线程正在执行wait,sleep,join方法，你调用interrupt()方法，这个逻辑就不完全了。

　　如果一个有经验的程序员来处理线程的运行的结束：

 public void run(){
try{
while(!isInterrupted()){
正常工作
}
}
catch(Exception e){
return;
}
finally{
清理工作
}
}

　　我们看到，如果线程执行一般逻辑在调用innterrupt后，isInterrupted()为true，退出循环后执行清理工作后结束，即使线程正在wait,sleep,join,也会抛出异常执行清理工作后退出。

　　这看起来非常好，线程完全按最我们设定的思路在工作。但是，并不是每个程序员都有这种认识，如果他聪明的自己处理异常会如何？事实上很多或大多数程序员会这样处理：

 public void run(){
while(!isInterrupted()){
try{
正常工作
}catch(Exception e){
//nothing
}
finally{
}
}
}
}

　　想一想，如果一个正在sleep的线程，在调用interrupt后，会如何？wait方法检查到isInterrupted()为true，抛出异常，而你又没有处理。而一个抛出了InterruptedException的线程的状态马上就会被置为非中断状态，如果catch语句没有处理异常，则下一次循环中isInterrupted()为false，线程会继续执行，可能你N次抛出异常，也无法让线程停止。

　　那么如何能确保线程真正停止？在线程同步的时候我们有一个叫“二次惰性检测”(double check)，能在提高效率的基础上又确保线程真正中同步控制中。那么我把线程正确退出的方法称为“双重安全退出”，即不以isInterrupted()为循环条件。而以一个标记作为循环条件：

class MyThread extend Thread{
private boolean isInterrupted = false;//这一句以后要修改
public void interrupt(){
isInterrupted = true;
super.interrupt();
}
public void run(){
while(!isInterrupted){
try{
正常工作
}catch(Exception e){
//nothing
}
finally{
}
}
}
}

　　试试这段程序,可以正确工作吗?

　　对于这段程序仍然还有很多可说的地方，先到这里吧。

　　随着计算机技术的发展，编程模型也越来越复杂多样化。但多线程编程模型是目前计算机系统架构的最终模型。随着CPU主频的不断攀升，X86架构的硬件已经成为瓶，在这种架构的CPU主频最高为4G。事实上目前3.6G主频的CPU已经接近了顶峰。

　　如果不能从根本上更新当前CPU的架构(在很长一段时间内还不太可能)，那么继续提高CPU性能的方法就是超线程CPU模式。那么，作业系统、应用程序要发挥CPU的最大性能，就是要改变到以多线程编程模型为主的并行处理系统和并发式应用程序。

　　所以，掌握多线程编程模型，不仅是目前提高应用性能的手段，更是下一代编程模型的核心思想。多线程编程的目的，就是"最大限度地利用CPU资源"，当某一线程的处理不需要占用CPU而只和I/O,OEMBIOS等资源打交道时，让需要占用CPU资源的其它线程有机会获得CPU资源。从根本上说，这就是多线程编程的最终目的。

　　[第一需要弄清的问题]

　　如同程序和进程的区别，要掌握多线程编程，第一要弄清的问题是：线程对象和线程的区别。

　　线程对象是可以产生线程的对象。比如在java平台中Thread对象，Runnable对象。线程，是指正在执行的一个指点令序列。在java平台上是指从一个线程对象的start()开始，运行run方法体中的那一段相对独立的过程。

　　鉴于作者的水平，无法用更确切的词汇来描述它们的定义。但这两个有本质区别的概念请初学者细细体会，随着介绍的深入和例程分析的增加，就会慢慢明白它们所代表的真实含义。

　　天下难事必始于易，天下大事必始于细。

　　让我们先从最简单的"单线程"来入手：(1)带引号说明只是相对而言的单线程，(2)基于java。

    class BeginClass{
public static void main(String[] args){
for(int i=0;i<100;i++)
System.out.println("Hello,World!");
}
}

　　如果我们成功编译了该java文件，然后在命令行上敲入：

　　java BeginClass

　　现在发生了什么呢？每一个java程序员，从他开始学习java的第一分钟里都会接触到这个问

　　题，但是，你知道它到底发生发什么？

　　JVM进程被启动，在同一个JVM进程中，有且只有一个进程，就是它自己。然后在这个JVM环境中，所有程序的运行都是以线程来运行。JVM最先会产生一个主线程，由它来运行指定程序的入口点。在这个程序中，就是主线程从main方法开始运行。当main方法结束后，主线程运行完成。JVM进程也随之退出。

　　我们看到的是一个主线程在运行main方法，这样的只有一个线程执行程序逻辑的流程我们称

　　之为单线程。这是JVM提供给我们的单线程环境，事实上，JVM底层还至少有垃圾回收这样的后台线程以及其它非java线程，但这些线程对我们而言不可访问，我们只认为它是单线程的。

　　主线程是JVM自己启动的，在这里它不是从线程对象产生的。在这个线程中，它运行了main方法这个指令序列。理解它，但它没有更多可以研究的内容。

　　[接触多线程]

    class MyThread extends Thread{
public void run(){
System.out.println("Thread say:Hello,World!");
}
}
public class MoreThreads{
public static void main(String[] args){
new MyThread();
new MyThread().start();
System.out.println("Main say:Hello,World");
}
}

　　执行这个程序，main方法第一行产生了一个线程对象，但并没有线程启动。

　　main方法第二行产生了一个线程对象，并启动了一个线程。

　　main方法第三行，产生并启动一个线程后，主线程自己也继续执行其它语句。

　　我们先不研究Thread对象的具体内容，稍微来回想一下上面的两个概念，线程对象和线程。在JAVA中，线程对象是JVM产生的一个普通的Object子类。而线程是CPU分配给这个对象的一个运行过程。我们说的这个线程在干什么，不是说一个线程对象在干什么，而是这个运行过程在干什么。如果一时想不明白，不要急，但你要记得它们不是一回事就行了。

　　累了吧？为不么不继续了？

　　基于这种风格来介绍多线程，并不是每个人都喜欢和接受的，如果你不喜欢，正好不浪费你的时间了，而如果你接受的话，那就看下一节吧。

[线程的并发与并行]

　　在单CPU系统中，系统调度在某一时刻只能让一个线程运行，虽然这种调试机制有多种形式(大多数是时间片轮巡为主)，但无论如何，要通过不断切换需要运行的线程让其运行的方式就叫并发(concurrent)。而在多CPU系统中，可以让两个以上的线程同时运行，这种可以同时让两个以上线程同时运行的方式叫做并行(parallel)。

　　在上面包括以后的所有论述中，请各位朋友谅解，我无法用最准确的词语来定义储如并发和并行这类术语，但我以我的经验能通俗地告诉大家它是怎么一回事，如果您看到我说的一些"标准"文档上说的不一样，只要意思一致，那您就不要挑刺了。

[JAVA线程对象]

　　现在我们来开始考察JAVA中线程对象。

　　在JAVA中，要开始一个线程，有两种方式。一是直接调用Thread实例的start()方法，二是
将Runable实例传给一个Thread实例然后调用它的start()方法。

　　在前面已经说过，线程对象和线程是两个完全不同的概念。这里我们再次深入一下，生成一个线程的实例，并不代表启动了线程。而启动线程是说在某个线程对象上启动了该实例对应的线程，当该线程结束后，并不会就立即消失。

　　对于从很多书籍上可以看到的基础知识我就不用多说了。既然是基础知识，我也着重于从普通文档上读不到的内容。所以本节我重点要说的是两种线程对象产生线程方式的区别。

class MyThread extends Thread{
public int x = 0;
public void run(){
for(int i=0;i<100;i++){
try{
Thread.sleep(10);
}catch(Exception e){}
System.out.println(x++);
}
}
}

　　如果我们生成MyThread的一个实例，然后调用它的start()方法，那么就产生了这个实例对应的线程：

public class Test {
public static void main(String[] args) throws Exception{
MyThread mt = new MyThread();
mt.start();
}
}

　　不用说，最终会打印出0到99，现在我们稍微玩一点花样：

public class Test {
public static void main(String[] args) throws Exception{
MyThread mt = new MyThread();
mt.start();
System.out.println(101);
}
}

　　也不用说，在基础篇（一）中我们知道由于单CPU的原因，一般会先打印101，然后打印0到99。不过我们可以控制线程让它按我们的意思来运行：

public class Test {
public static void main(String[] args) throws Exception{
MyThread mt = new MyThread();
mt.start();
mt.join();
System.out.println(101);
}
}

　　好了，我们终于看到，mt实例对应的线程(假如我有时说mt线程请你不要怪我，不过我尽量不这么说)。在运行完成后，主线程才打印101。因为我们让当前线程(这里是主线程)等待mt线程的运行结束。"在线程对象a上调用join()方法，就是让当前正在执行的线程等待线程对象a对应的线程运行完成后才继续运行。" 请大家一定要深刻理解并熟记这句话，而我这里引出这个知识点的目的是为了让你继续看下面的例子：

public class Test {
public static void main(String[] args) throws Exception{
MyThread mt = new MyThread();
mt.start();
mt.join();
Thread.sleep(3000);
mt.start();
}
}

　　当线程对象mt运行完成后，我们让主线程休息一下，然后我们再次在这个线程对象上启动线程。结果我们看到：

　　Exception in thread "main" java.lang.IllegalThreadStateException

　　也就是这种线程对象一时运行一次完成后，它就再也不能运行第二次了。我们可以看一下它有具体实现:

    public synchronized void start() {
if (started)
throw new IllegalThreadStateException();
started = true;
group.add(this);
start0();
}

　　一个Thread的实例一旦调用start()方法，这个实例的started标记就标记为true，事实中不管这个线程后来有没有执行到底，只要调用了一次start()就再也没有机会运行了，这意味着：

[通过Thread实例的start()，一个Thread的实例只能产生一个线程]

　　那么如果要在一个实例上产生多个线程(也就是我们常说的线程池)，我们应该如何做呢？这就是Runnable接口给我们带来的伟大的功能。

class R implements Runnable{
private int x = 0;
public void run(){
for(int i=0;i<100;i++){
try{
Thread.sleep(10);
}catch(Exception e){}
System.out.println(x++);
}
}
}

　　
正如它的名字一样，Runnable的实例是可运行的，但它自己并不能直接运行，它需要被Thread对象来包装才行运行：

public class Test {
public static void main(String[] args) throws Exception{
new Thread(new R()).start();
}
}

　　当然这个结果和mt.start()没有什么区别。但如果我们把一个Runnable实例给Thread对象多次包装，我们就可以看到它们实际是在同一实例上启动线程：

public class Test {
public static void main(String[] args) throws Exception{
R r = new R();
for(int i=0;i<10;i++)
new Thread(r).start();
}
}

　　x是实例对象，但结果是x被加到了999，说明这10个线程是在同一个r对象上运行的。请大家注意，因为这个例子是在单CPU上运行的，所以没有对多个线程同时操作共同的对象进行同步。这里是为了说明的方便而简化了同步，而真正的环境中你无法预知程序会在什么环境下运行，所以一定要考虑同步。

　　到这里我们做一个完整的例子来说明线程产生的方式不同而生成的线程的区别：

package debug;
import java.io.*;
import java.lang.Thread;
class MyThread extends Thread{
public int x = 0;
public void run(){
System.out.println(++x);
}
}
class R implements Runnable{
private int x = 0;
public void run(){
System.out.println(++x);
}
}
public class Test {
public static void main(String[] args) throws Exception{
for(int i=0;i<10;i++){
Thread t = new MyThread();
t.start();
}
Thread.sleep(10000);//让上面的线程运行完成
R r = new R();
for(int i=0;i<10;i++){
Thread t = new Thread(r);
t.start();
}
}
}

　　上面10个线程对象产生的10个线程运行时打印了10次1。下面10个线程对象产生的10个线程运行时打印了1到10。我们把下面的10个线程称为同一实例(Runnable实例)的多个线程。

　　下节我们将研究线程对象方法，还是那句话，一般文档中可以读到的内容我不会介绍太多
请大家自己了解。

　　尽管线程对象的常用方法可以通过API文档来了解,但是有很多方法仅仅从API说明是无法详细了解的。

　　本来打算用一节的篇幅来把线程方法中一些重要的知识说完,但这样下来估计要很常的篇幅,可能要用好几节才能说把和线程方法相关的一些重要的知识说完。

　　首先我们接基础篇(二)来说明start()方法。

　　一个线程对象生成后,如果要产生一个执行的线程,就一定要调用它的start()方法.在介绍这个方法时不得不同时说明run方法.其实线程对象的run方法完全是一个接口回调方法,它是你这个线程对象要完成的具体逻辑.简单说你要做什么就你在run中完成,而如何做,什么时候做就不需要你控制了,你只要调用start()方法,JVM就会管理这个线程对象让它产生一个线程并注册到线程处理系统中。

　　从表面上看,start()方法调用了run()方法,事实上,start()方法并没有直接调用run方法.在JDK1.5以前start()方法是本地方法,它如何最终调用run方法已经不是JAVA程序员所能了解的.而在JDK1.5中,原来的那个本地start()方法被start0()代替,另个一个纯JAVA的start()中调用本地方法start0(),而在start()方法中做了一个验证,就是对一个全局变量(对象变量)started做检验,如果为true,则start()抛出异常,不会调用本地方法start0(),否则,先将该变量设有true,然后调用start0()。

　　从中我们可以看到这个为了控制一个线程对象只能运行成功一次start()方法.这是因为线程的运行要获取当前环境,包括安全,父线程的权限,优先级等条件,如果一个线程对象可以运行多次,那么定义一个static 的线程在一个环境中获取相应权限和优先级,运行完成后它在另一个环境中利用原来的权限和优先级等属性在当前环境中运行,这样就造成无法预知的结果.简单说来,让一个线程对象只能成功运行一次,是基于对线程管理的需要。

start()方法最本质的功能是从CPU中申请另一个线程空间来执行run()方法中的代码,它和当前的线程是两条线,在相对独立的线程空间运行,也就是说,如果你直接调用线程对象的run()方法,当然也会执行,但那是在当前线程中执行,run()方法执行完成后继续执行下面的代码.而调用start()方法后,run()方法的代码会和当前线程并发(单CPU)或并行(多CPU)执行。

　　所以请记住一句话[调用线程对象的run方法不会产生一个新的线程],虽然可以达到相同的执行结果,但执行过程和执行效率不同。

　　[线程的interrupt()方法,interrupted()和isInterrupted()]

　　这三个方法是关系非常密切而且又比较复杂的,虽然它们各自的功能很清楚,但它们之间的关系有大多数人不是真正的了解。

　　先说interrupt()方法,它是实例方法,而它也是最奇怪的方法,在java语言中,线程最初被设计为"隐晦难懂"的东西,直到现在它的语义不没有象它的名字那样准确。大多数人以为,一个线程象调用了interrupt()方法,那它对应的线程就应该被中断而抛出异常,事实中,当一个线程对象调用interrupt()方法,它对应的线程并没有被中断,只是改变了它的中断状态。

　　使当前线程的状态变以中断状态,如果没有其它影响,线程还会自己继续执行。

　　只有当线程执行到sleep,wait,join等方法时,或者自己检查中断状态而抛出异常的情况下,线程才会抛出异常。

如果线程对象调用interrupt()后它对应的线程就立即中断,那么interrupted()方法就不可能执行。

　　 因为interrupted()方法是一个static方法,就是说只能在当前线程上调用,而如果一个线程interrupt()后它已经中断了,那它又如何让自己interrupted()?

　　正因为一个线程调用interrupt()后只是改变了中断状态,它可以继续执行下去,在没有调用sleep,wait,join等法或自己抛出异常之前,它就可以调用interrupted()来清除中断状态(还会原状)interrupted()方法会检查当前线程的中断状态,如果为 "被中断状态"则改变当前线程为"非中断状态"并返回true,如果为"非中断状态"则返回false,它不仅检查当前线程是否为中断状态,而且在保证当前线程回来非中断状态,所以它叫"interrupted",是说中断的状态已经结束(到非中断状态了)isInterrupted()方法则仅仅检查线程对象对应的线程是否是中断状态,并不改变它的状态。

　　目前大家只能先记住这三个方法的功能,只有真正深入到多线程编程实践中,才会体会到它们为什么是对象方法,为什么是类方法。

　　线程到底什么时候才被中断抛出InterruptedException异常,我们将在提高篇中详细讨论。

　　[sleep(),join(),yield()方法]

　　在现在的环节中,我只能先说明这些方法的作用和调用原则,至于为什么,在基础篇中无法深入,只能在提高篇中详细说明。

　　sleep()方法中是类方法,也就是对当前线程而言的,程序员不能指定某个线程去sleep,只能是当前线程执行到sleep()方法时,睡眠指定的时间(让其它线程运行).事实上也只能是类方法,在当前线程上调用.试想如果你调用一个线程对象的sleep()方法,那么这个对象对应的线程如果不是正在运行,它如何sleep()?所以只有当前线程,因为它正在执行,你才能保证它可以调用sleep()方法。

　　原则:[在同步方法中尽量不要调用线程的sleep()方法],或者简单说,对于一般水平的程序员你基本不应该调用sleep()方法。

　　join()方法,正如第一节所言,在一个线程对象上调用join方法,是当前线程等待这个线程对象对应的线程结束,比如有两个工作,工作A要耗时10秒钟,工作B要耗时10秒或更多。我们在程序中先生成一个线程去做工作B,然后做工作A。

　　new?B().start();//做工作B

　　A();//做工作A

　　工作A完成后,下面要等待工作B的结果来进行处理.如果工作B还没有完成我就不能进行下面的工作C,所以

　　B?b?=?new?B();

　　b.start();//做工作B

　　A();//做工作A

　　b.join();//等工作B完成。

　　C();//继续工作C。

　　原则:[join是测试其它工作状态的唯一正确方法],我见过很多人,甚至有的是博士生,在处理一项工作时如果另一项工作没有完成,说让当前工作线程sleep(x),我问他,你这个x是如何指定的,你怎么知道是100毫秒而不是99毫秒或是101毫秒?其实这就是OnXXX事件的实质,我们不是要等多长时间才去做什么事,而是当等待的工作正好完成的时候去做。

　　yield()方法也是类方法,只在当前线程上调用,理由同上,它主是让当前线程放弃本次分配到的时间片原则:[不是非常必要的情况下,没有理由调用它].调用这个方法不会提高任何效率,只是降低了CPU的总周期上面介绍的线程一些方法,基于(基础篇)而言只能简单提及.以后具体应用中我会结合实例详细论述。

　　线程本身的其它方法请参看API文档.下一节介绍非线程的方法,但和线程密切相关的两[三]个对象方法:

　　[wait(),notify()/notifyAll()]

　　这是在多线程中非常重要的方法。

[wait(),notify()/notityAll()方法]

　　关于这两个方法,有很多的内容需要说明.在下面的说明中可能会有很多地方不能一下子明白,但在看完本节后,即使不能完全明白,你也一定要回过头来记住下面的两句话:

　　[wait(),notify()/notityAll()方法是普通对象的方法(Object超类中实现),而不是线程对象的方法]

　　[wait(),notify()/notityAll()方法只能在同步方法中调用]

[线程的互斥控制]

　　多个线程同时操作某一对象时,一个线程对该对象的操作可能会改变其状态,而该状态会影响另一线程对该对象的真正结果.

　　这个例子我们在太多的文档中可以看到,就象两个操售票员同时售出同一张票一样.

　　所以需要一种机制来管理这类问题的发生,当某个线程正在执行一个不可分割的部分时,其它线程不能不能同时执行这一部分.

　　象这种控制某一时刻只能有一个线程执行某个执行单元的机制就叫互斥控制或共享互斥(mutual exclusion)

　　在JAVA中,用synchornized关键字来实现互斥控制(暂时这样认为,JDK1.5已经发展了新的机制)

[synchornized关键字]

　　把一个单元声明为synchornized,就可以让在同一时间只有一个线程操作该方法.

　　有人说synchornized就是一把锁,事实上它确实存在锁,但是是谁的锁,锁谁,这是一个非常复杂的问题.

　　每个对象只有一把监视锁(monitor lock),一次只能被一个线程获取.当一个线程获取了这一个锁后,其它线程就只能等待这个线程释放锁才能再获取.

那么synchornized关键字到底锁什么?得到了谁的锁?

对于同步块,synchornized获取的是参数中的对象锁:

synchornized(obj){
//...............
}

　　线程执行到这里时,首先要获取obj这个实例的锁,如果没有获取到线程只能等待.如果多个线程执行到这里,只能有一个线程获取obj的锁,然后执行{}中的语句,所以,obj对象的作用范围不同,控制程序不同.

　　假如:

public void test(){
Object o = new Object();
synchornized(obj){
//...............
}
}

　　这段程序控制不了任何,多个线程之间执行到Object o = new Object();时会各自产生一个对象然后获取这个对象有监视锁,各自皆大欢喜地执行.

　　而如果是类的属性:

class Test{
Object o = new Object();
public void test(){
synchornized(o){
//...............
}
}
}

　　所有执行到Test实例的synchornized(o)的线程,只有一个线程可以获取到监视锁.

　　有时我们会这样:

public void test(){
synchornized(this){
//...............
}
}

　　那么所有执行Test实例的线程只能有一个线程执行.而synchornized(o)和synchornized(this)的范围是不同的,因为执行到Test实例的synchornized(o)的线程等待时,其它线程可以执行Test实例的synchornized(o1)部分,但多个线程同时只有一个可以执行Test实例的synchornized(this).]

　　而对于

synchornized(Test.class){
//...............
}

　　这样的同步块而言,所有调用Test多个实例的线程赐教只能有一个线程可以执行.

[synchornized方法]

　　如果一个方法声明为synchornized的,则等同于把在为个方法上调用synchornized(this).

　　如果一个静态方法被声明为synchornized,则等同于把在为个方法上调用synchornized(类.class).

　　现在进入wait方法和notify/notifyAll方法.这两个(或叫三个)方法都是Object对象的方法,而不是线程对象的方法.如同锁一样,它们是在线程中调用某一对象上执行的.

class Test{
public synchornized void test(){
//获取条件,int x 要求大于100;
if(x < 100)
wait();
}
}

　　这里为了说明方法没有加在try{}catch(){}中,如果没有明确在哪个对象上调用wait()方法,则为this.wait();

　　假如:

　　Test t = new Test();

　　现在有两个线程都执行到t.test();方法.其中线程A获取了t的对象锁,进入test()方法内.

　　这时x小于100,所以线程A进入等待.

　　当一个线程调用了wait方法后,这个线程就进入了这个对象的休息室(waitset),这是一个虚拟的对象,但JVM中一定存在这样的一个数据结构用来记录当前对象中有哪些程线程在等待.

　　当一个线程进入等待时,它就会释放锁,让其它线程来获取这个锁.

　　所以线程B有机会获得了线程A释放的锁,进入test()方法,如果这时x还是小于100,线程B也进入了t的休息室.

　　这两个线程只能等待其它线程调用notity[All]来唤醒.

　　但是如果调用的是有参数的wait(time)方法,则线程A,B都会在休息室中等待这个时间后自动唤醒.

[为什么真正的应用都是用while(条件)而不用if(条件)]

　　在实际的编程中我们看到大量的例子都是用?

　　while(x < 100)

　　wait();go();而不是用if,为什么呢?

　　在多个线程同时执行时,if(x <100)是不安全的.因为如果线程A和线程B都在t的休息室中等待,这时另一个线程使x==100了,并调用notifyAll方法,线程A继续执行下面的go().而它执行完成后,x有可能又小于100,比如下面的程序中调用了--x,这时切换到线程B,线程B没有继续判断,直接执行go();就产生一个错误的条件,只有while才能保证线程B又继续检查一次.

[notify/notifyAll方法]

　　这两个方法都是把某个对象上休息区内的线程唤醒,notify只能唤醒一个,但究竟是哪一个不能确定,而notifyAll则唤醒这个对象上的休息室中所有的线程.

　　一般有为了安全性,我们在绝对多数时候应该使用notifiAll(),除非你明确知道只唤醒其中的一个线程.

　　那么是否是只要调用一个对象的wait()方法,当前线程就进入了这个对象的休息室呢?事实中,要调用一个对象的wait()方法,只有当前线程获取了这个对象的锁,换句话说一定要在这个对象的同步方法或以这个对象为参数的同步块中.

class MyThread extends Thread{
Test t = new Test();
public void run(){
t.test();
System.out.println("Thread say:Hello,World!");
}
}
public class Test {
int x = 0;
public  void test(){
if(x==0)
try{
wait();
}catch(Exception e){}
}
public static void main(String[] args) throws Exception{
new MyThread().start();
}
}

　　这个线程就不会进入t的wait方法而直接打印出Thread say:Hello,World!.

　　而如果改成:

public class Test {
int x = 0;
public synchornized void test(){
if(x==0)
try{
wait();
}catch(Exception e){}
}
public static void main(String[] args) throws Exception{
new MyThread().start();
}
}

　　我们就可以看到线程一直等待,注意这个线程进入等待后没有其它线程唤醒,除非强行退出JVM环境,否则它一直等待.

　　所以请记住:

　　[线程要想调用一个对象的wait()方法就要先获得该对象的监视锁,而一旦调用wait()后又立即释放该锁]

　　以上是对线程基础知识的简单介绍,不进入实例,我们无法真正了解它的真实意义.下节我们就会以实例来进入多线程编程的 实战篇

转载自dev2dev网友axman的go deep into java专栏。

Volatile修饰的成员变量在每次被线程访问时，都强迫从共享内存中重读该成员变量的值。而且，当成员变量发生变化时，强迫线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。

Java语言规范中指出：为了获得最佳速度，允许线程保存共享成员变量的私有拷贝，而且只当线程进入或者离开同步代码块时才与共享成员变量的原始值对比。

这样当多个线程同时与某个对象交互时，就必须要注意到要让线程及时的得到共享成员变量的变化。

而volatile关键字就是提示VM：对于这个成员变量不能保存它的私有拷贝，而应直接与共享成员变量交互。

使用建议：在两个或者更多的线程访问的成员变量上使用volatile。当要访问的变量已在synchronized代码块中，或者为常量时，不必使用。

由于使用volatile屏蔽掉了VM中必要的代码优化，所以在效率上比较低，因此一定在必要时才使用此关键字。

package myprojects.jmemorydemo;
import javax.swing.UIManager;
import java.awt.*;
public class JMemoryDemo {
private boolean packFrame = false;
public JMemoryDemo() {
MainFrame frame = new MainFrame();
if (packFrame) {
frame.pack();
}
else {
frame.validate();
}
Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
Dimension frameSize = frame.getSize();
if (frameSize.height > screenSize.height) {
frameSize.height = screenSize.height;
}
if (frameSize.width > screenSize.width) {
frameSize.width = screenSize.width;
}
frame.setLocation((screenSize.width - frameSize.width) / 2, (screenSize.height - frameSize.height)
/ 2);
frame.setVisible(true);
}
public static void main(String[] args)
{
new JMemoryDemo();
}
}
===================================================
package myprojects.jmemorydemo;
import javax.swing.*;
public class ProgressThread extends Thread {
JProgressBar pbar;
JLabel label;
public ProgressThread(JProgressBar pbar,JLabel label) {
this.pbar=pbar;
this.label=label;
}
public void run() {
int min=0;
int max=100;
int free=0;
int totle=0;
int status=0;
pbar.setMinimum(min);
pbar.setMaximum(max);
pbar.setValue(status);
while(true){
try{
totle=(int)(Runtime.getRuntime().totalMemory()/1024);
free=(int)(Runtime.getRuntime().freeMemory()/1024);
}catch(Exception e){
e.printStackTrace();
}
label.setText("Free Memory :"+(int)(Runtime.getRuntime().freeMemory()/1024)+"K"+" Totle Memory Allo
cated :"
+(int)(Runtime.getRuntime().totalMemory()/1024)+"K");
status=(int)(free*100/totle);
pbar.setValue(status);
pbar.setString("Free Momery "+ status+"%");
try{
this.sleep(1000);
}catch(InterruptedException err){}
}
}
}
===============================================
package myprojects.jmemorydemo;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class MainFrame extends JFrame {
private JPanel contentPane;
private BorderLayout borderLayout1 = new BorderLayout();
private JProgressBar jProgressBar1 = new JProgressBar();
private JLabel jLabel1 = new JLabel();
private JLabel jLabel2 = new JLabel();
public MainFrame() {
enableEvents(AWTEvent.WINDOW_EVENT_MASK);
try {
jbInit();
}
catch(Exception e) {
e.printStackTrace();
}
}
private void jbInit() throws Exception {
(MainFrame.class.getResource("[Your Icon]")));
contentPane = (JPanel) this.getContentPane();
contentPane.setLayout(borderLayout1);
this.setSize(new Dimension(304, 215));
this.setTitle("JMemoryDemo");
jLabel1.setFont(new java.awt.Font("Dialog", 0, 14));
jLabel1.setHorizontalAlignment(SwingConstants.CENTER);
jLabel1.setText("Memory Monitor");
jProgressBar1.setOrientation(JProgressBar.VERTICAL);
jProgressBar1.setFont(new java.awt.Font("Dialog", 0, 14));
jProgressBar1.setToolTipText("");
jProgressBar1.setStringPainted(true);
jLabel2.setFont(new java.awt.Font("Dialog", 0, 14));
jLabel2.setText("");
contentPane.add(jProgressBar1, BorderLayout.CENTER);
contentPane.add(jLabel1, BorderLayout.NORTH);
contentPane.add(jLabel2, BorderLayout.SOUTH);
ProgressThread pThread = new ProgressThread(this.jProgressBar1,this.jLabel2);
pThread.start();
}
protected void processWindowEvent(WindowEvent e) {
super.processWindowEvent(e);
if (e.getID() == WindowEvent.WINDOW_CLOSING) {
System.exit(0);
}
}
}

　　totle=(int)(Runtime.getRuntime().totalMemory()/1024);

　　free=(int)(Runtime.getRuntime().freeMemory()/1024);

Merlin 的魔力: 不确定的进度条

JProgressBar 的一个细微但是重要的更新

级别： 初级
John Zukowski (jaz@zukowski.net), 总裁, JZ Ventures, Inc
2003 年 12 月 01 日

开发人员用 JProgressBar 组件向用户显示一项任务的进度。针对非常长的任务或者难于精确确定完成进度的任务，Merlin版本对 JProgressBar 增加了一个不确定模式。本月，专栏作者 John Zukowski 对 JProgressBar 的使用作了重新介绍，并讨论了它的新的不确定模式。您可以在本文的 讨论论坛中与作者以及其他读者共享您的想法（您也可以单击文章顶部或者底部的 讨论进入论坛）。

在 Java 2 SDK, Standard Edition，版本 1.4 中，有了一些大的变化，如增加了像 JSpinner 这样的新组件、像 SpringLayout 这样的新布局管理器、或者像 Java Logging API 这样的新 API。而另一些变化则没有这么显著，如小的改进或者对现有 API 的优化。本月关于 SpringLayout 组件的技巧就属于后一种情况。它是细微的，但是很重要。

进度条的基本用法

JProgressBar 是原来的 Swing 组件集中的一个。它提供了一种以图形方式显示进程完成进度的简单方式。当进程进行时，一个长条就会在该组件上逐渐延伸，直到任务完成并且长条全部填满。长条的移动通常是某个多线程任务的一部分，这有助于避免阻塞应用程序其余部分的进度，如常规的屏幕更新。虽然没有哪一条特定的规则说进度条必须进行线性移动，但是如果看到进程从 10% 移动到 35%，然后又回到 27%，然后再增加到 80%，最后以 0% 结束，作为用户我会觉得多少有些古怪。

用五个构造函数中的一个来构造 JProgressBar ，如清单 1 所示：

  public JProgressBar()
            public JProgressBar(int orientation)
            public JProgressBar(int minimum, int maximum)
            public JProgressBar(int orientation, int minimum, int maximum)
            public JProgressBar(BoundedRangeModel model)
            

JProgressBar 需要初始化方向和值范围。方向是通过 JProgressBar 的 VERTICAL 或者 HORIZONTAL 常量确定的。默认为 HORIZONTAL 。

在创建了这个组件并在屏幕上显示它后，启动第二个线程以执行需要测量其进度的任务。然后定期用 setValue() 方法更新进度条的值以显示任务的当前进展。清单 2 显示了 setValue() 的一个简单例子：

import javax.swing.*;
            import java.awt.*;
            import java.awt.event.*;
            import java.lang.reflect.*;
            public class ProgressSample {
            static class BarThread extends Thread {
            private static int DELAY = 500;
            JProgressBar progressBar;
            public BarThread(JProgressBar bar) {
            progressBar = bar;
            }
            public void run() {
            int minimum = progressBar.getMinimum();
            int maximum = progressBar.getMaximum();
            Runnable runner = new Runnable() {
            public void run() {
            int value = progressBar.getValue();
            progressBar.setValue(value+1);
            }
            };
            for (int i=minimum; i<maximum; i++) {
            try {
            SwingUtilities.invokeAndWait(runner);
            // Our task for each step is to just sleep
            Thread.sleep(DELAY);
            } catch (InterruptedException ignoredException) {
            } catch (InvocationTargetException ignoredException) {
            }
            }
            }
            }
            public static void main(String args[]) {
            // Initialize
            final JProgressBar aJProgressBar = new JProgressBar(0, 100);
            final JButton aJButton = new JButton("Start");
            ActionListener actionListener = new ActionListener() {
            public void actionPerformed(ActionEvent e) {
            aJButton.setEnabled(false);
            Thread stepper = new BarThread(aJProgressBar);
            stepper.start();
            }
            };
            aJButton.addActionListener(actionListener);
            JFrame theFrame = new JFrame("Progress Bars");
            theFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            Container contentPane = theFrame.getContentPane();
            contentPane.add(aJProgressBar, BorderLayout.NORTH);
            contentPane.add(aJButton, BorderLayout.SOUTH);
            theFrame.setSize(300, 100);
            theFrame.show();
            }
            }
            

第一次运行这段代码时，您会看到类似于图 1 的屏幕。

单击这个按钮，启动第二个任务，并在它运行时更新进度条。图 2 显示了运行到一半时的进度条。

这里没什么特别的。主要代码创建带有一个按钮和进度条的 GUI。当您选择按钮时，它就引发操作以更新进度条。进度条用来对某些任务进行测量。在示例程序中，这个任务就是休眠半秒 100 次。

在默认情况下，除了进度条外，没有其他关于进度的图形指示。添加如下的一行代码，您就可以在任务完成过程中，让进度条显示任务完成的百分比：

  aJProgressBar.setStringPainted(true);
            

图 3 显示了我们增加了新代码的屏幕：

回页首

使用不确定模式

从 Merlin 版本开始， JProgressBar 还支持另一种模式 ―― 确定。对于非固定步数的长任务，可以使用这种模式。它显示固定的动画以表明有些事情正在发生，但是它不表明完成的百分比。如果您确定了任务所要花费的时间，就可以切换回确定模式。在不确定模式下， JProgressBar 显示一个长条，在显示区域中来回移动。

清单 3 显示了这种模式的一个例子。这个新方法就是 setIndeterminate() 。值为 true 意味着不确定，而值为 false 则意味着普通或者确定。

import javax.swing.*;
            import java.awt.*;
            import java.awt.event.*;
            public class ProgressSample2 {
            public static void main(String args[]) {
            final JProgressBar aJProgressBar = new JProgressBar(0, 100);
            aJProgressBar.setIndeterminate(true);
            JButton aJButton = new JButton("Toggle");
            ActionListener actionListener = new ActionListener() {
            public void actionPerformed(ActionEvent e) {
            boolean indeterminate = aJProgressBar.isIndeterminate();
            aJProgressBar.setIndeterminate(!indeterminate);
            }
            };
            aJButton.addActionListener(actionListener);
            JFrame theFrame = new JFrame("Indeterminate");
            theFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            Container contentPane = theFrame.getContentPane();
            contentPane.add(aJProgressBar, BorderLayout.NORTH);
            contentPane.add(aJButton, BorderLayout.SOUTH);
            theFrame.setSize(300, 100);
            theFrame.show();
            }
            }
            

图 4显示相关的屏幕（您需要想像这个长条是来回移动的）。按钮用于在进度条的不确定和确定模式之间进行切换。

有两种新的 UI 默认值用于改变重绘时间间隔和循环时间： ProgressBar.repaintInterval 和 ProgressBar.cycleTime 。改变这些设置 ―― 如下所示 ―― 会改变显示速度。循环时间必须是重绘时间间隔的偶数倍，所以如果间隔为 100，那么循环时间应该是 200、500 或者 1000 ―― 但不能是 750。

  UIManager.put("ProgressBar.repaintInterval", new Integer(150));
            UIManager.put("ProgressBar.cycleTime", new Integer(1050));
            

注意您需要在创建进度条 之前设置这些值。

结束语

ProgressBar 还有很多内容，但是其他特性在 1.4 版中都没有改变。我们简单回顾了这个组件的原有使用方式，并介绍了在 Merlin 版本中它的新特性。您也可以考虑用 ProgressMonitor 或者 ProgressMonitorInputStream 监视这些长任务的进度。它们都在内部利用了 JProgressBar 的优点。

public class Test{
    public static void main(String[] args){
        System.out.println("*******--TEST  JAVA!--*********");
    }
}

如果使用了第三方jar包 : 要写入.mf文件中

Manifest-Version: 1.0
Main-Class: lk.Test
Class-Path: lib/jxl.jar

用法: jar {ctxui}[vfm0Me] [jar-file] [manifest-file] [entry-point] [-C dir] files ...
选项包括：
    -c  创建新的归档文件
    -t  列出归档目录
    -x  解压缩已归档的指定（或所有）文件
    -u  更新现有的归档文件
    -v  在标准输出中生成详细输出
    -f  指定归档文件名
    -m  包含指定清单文件中的清单信息
    -e  为捆绑到可执行 jar 文件的独立应用程序指定应用程序入口点

    -0  仅存储；不使用任何 ZIP 压缩
    -M  不创建条目的清单文件
    -i  为指定的 jar 文件生成索引信息
    -C  更改为指定的目录并包含其中的文件

如果有任何目录文件，则对其进行递归处理。
清单文件名、归档文件名和入口点名的指定顺序与 "m"、"f" 和 "e" 标志的指定顺序相同。

示例 1：将两个类文件归档到一个名为 classes.jar 的归档文件中：
       jar cvf classes.jar Foo.class Bar.class
示例 2：使用现有的清单文件 "mymanifest" 并
           将 foo/ 目录中的所有文件归档到 "classes.jar" 中：
       jar cvfm classes.jar mymanifest -C foo/ .