2.1-2 先给出书上insertion-sort的C源代码吧，然后再给出按照非升序的代码：

课本中(非降序的)insertion-sort代码：

void insertion_sort(int *A, int n)  
{  
    int i,j;  
    int key; 
 
    for(i = 1; i < n; i++)  
    {  
        j = i - 1;  
        key = A[i]; 
 
        while(j >= 0 && A[j] > key)  
        {  
            A[j+1] = A[j];  
            j = j - 1;  
        } 
 
        A[j+1] = key;  
    }  
} 

在这题中，只要讲非降序改成非升序排序，所以改后代码如下：

void insertion_sort(int *A, int n)  
{  
    int i,j;  
    int key; 
 
    for(i = 1; i < n; i++)  
    {  
        j = i - 1;  
        key = A[i]; 
 
        while(j >= 0 && A[j] < key)  
        {  
            A[j+1] = A[j];  
            j = j - 1;  
        } 
 
        A[j+1] = key;  
    }  
} 

2.1-3这题给出伪代码：

int find(int *A , int n, int v) 
 
{ 
 
    int  i = 0; 
 
    for( ; i < n; i++) 
 
    { 
 
        if(v == A[i]) 
 
            return i; 
 
    } 
 
  
 
    return NIL; 
 
} 

2.1-4直接给出代码：

/*在A[]和B[]中，数组的最低位对应与二进制的高位，即如果一个二进制数是011100，用数组表示就是A[] = {0,1,1,1,0,0}*/ 
 
void add(int *A ,int *B, int *C, int n)  
{  
    int i, a, c = 0;  
    int s;  
    for(i = n - 1; i >= 0 ; i--)  
    {  
        s = A[i] + B[i];  
         
        C[i+1] = (s + c) % 2;  
        c = (s + c) / 2;  
    } 
 
    C[0] = c;  
} 

优化屏障 (Optimization Barrier)

编译器编译源代码时，会将源代码进行优化，将源代码的指令进行重排序，以适合于CPU的并行执行。然而，内核同步必须避免指令重新排序，优化屏障（Optimization barrier）避免编译器的重排序优化操作，保证编译程序时在优化屏障之前的指令不会在优化屏障之后执行。

Linux用宏barrier实现优化屏障，gcc编译器的优化屏障宏定义列出如下（在include/linux/compiler-gcc.h中）： 

#define barrier() __asm__ __volatile__("": : :"memory")

上述定义中，“__asm__”表示插入了汇编语言程序，“__volatile__”表示阻止编译器对该值进行优化，确保变量使用了用户定义的精确地址，而不是装有同一信息的一些别名。“memory”表示指令修改了内存单元。

内存屏障 (Memory Barrier)

软件可通过读写屏障强制内存访问次序。读写屏障像一堵墙，所有在设置读写屏障之前发起的内存访问，必须先于在设置屏障之后发起的内存访问之前完成，确保内存访问按程序的顺序完成。

读写屏障通过处理器构架的特殊指令mfence（内存屏障）、lfence（读屏障）和sfence（写屏障）完成，见《x86-64构架规范》一章。另外，在x86-64处理器中，对硬件进行操作的汇编语言指令是“串行的”，也具有内存屏障的作用，如：对I/O端口进行操作的所有指令、带lock前缀的指令以及写控制寄存器、系统寄存器或调试寄存器的所有指令（如：cli和sti）。

Linux内核提供的内存屏障API函数说明如表2。内存屏障可用于多处理器和单处理器系统，如果仅用于多处理器系统，就使用smp_xxx函数，在单处理器系统上，它们什么都不要。

java nio小结

根据网上的资料做些整理

Java NIO API详解

http://www.blogjava.net/19851985lili/articles/93524.html

这篇文章对nio的api讲解比较全，可以帮助在宏观上把握nio。

BIO 方式使得整个处理过程和连接是绑定的，只要连接建立，无论客户端是否有消息发送，都要进行等待处理，一定程度上浪费了服务器端的硬件资源，因此就有了NIO 方式。Java 对于 NIO 方式的支持是通过 Channel和 Selector 方式来实现，采用的方法为向 Channel注册感兴趣的事件，然后通过 Selector 来获取到发生了事件的 key，如发生了相应的事件，则进行相应的处理，否则则不做任何处理，是典型的Reactor 模式，按照这样的方式，就不用像 BIO 方式一样，即使在没有消息的情况下也需要占据一个线程来阻塞读取消息，从而提升服务器的使用效率， 为实现 TCP/IP+NIO 方式的系统间通讯， Java 提供了 SocketChannel和 ServerSocketChannel两个关键的类，网络 IO 的操作则改为通过ByteBuffer 来实现，具体的基于 java实现TCP/IP+NIO 方式的通讯的方法如下所示。

服务器端：

package com.eric.test.nio;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.util.Iterator;
import java.util.Set;
import java.nio.channels.SocketChannel;

public class NIOServer {
    /*标志数字*/
    private static int flag = 0;
    /*定义缓冲区大小*/
    private static int block = 4096;
    /*接收缓冲区*/
    private static ByteBuffer receiveBuffer = ByteBuffer.allocate(block);
    /*发送缓冲区*/
    private static ByteBuffer sendBuffer = ByteBuffer.allocate(block);
    /*定义Selector*/
    private Selector selector;
    
    public NIOServer(int port) throws IOException{
        //打开服务器套接字通道
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        //服务器配置为非阻塞
        serverSocketChannel.configureBlocking(false);
        //检索与此服务器套接字通道关联的套接字
        ServerSocket serverSocket = serverSocketChannel.socket();
        //进行服务的绑定
        serverSocket.bind(new InetSocketAddress(port));
        //通过open()方法找到Selector
        selector = Selector.open();
        //注册到selector
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
        System.out.println("Server Start -----8888:");
    }
    //监听
    public void listen() throws IOException{
        while(true){
            //监控所有注册的 channel ，当其中有注册的 IO 操作可以进行时，该函数返回，并将对应的 SelectionKey 加入 selected-key set
            selector.select();
            //Selected-key set 代表了所有通过 select() 方法监测到可以进行 IO 操作的 channel ，这个集合可以通过 selectedKeys() 拿到
            Set<SelectionKey> selectionKeys = selector.selectedKeys();
            Iterator<SelectionKey> iterator = selectionKeys.iterator();
            while(iterator.hasNext()){
                SelectionKey selectionKey = iterator.next();
                handleKey(selectionKey);
                iterator.remove();
            }
        }
        
    }
    //处理请求
    public void handleKey(SelectionKey selectionKey) throws IOException{
        //接受请求
        ServerSocketChannel serverSocketChannel = null;
        SocketChannel socketChannel = null;
        String receiveText;
        String sendText;
        int count;
        //测试此键的通道是否准备好接受新的套接字连接
        if(selectionKey.isAcceptable()){
            //返回创建此键的通道
            serverSocketChannel = (ServerSocketChannel)selectionKey.channel();
            //接受客户端建立连接的请求，并返回 SocketChannel 对象
            socketChannel = serverSocketChannel.accept();
            //配置为非阻塞
            socketChannel.configureBlocking(false);
            //注册到selector
            socketChannel.register(selector, SelectionKey.OP_READ);
        }else if(selectionKey.isReadable()){
            //返回为之创建此键的通道
            socketChannel = (SocketChannel)selectionKey.channel();
            //将缓冲区清空，以备下次读取
            receiveBuffer.clear();
            //将发送来的数据读取到缓冲区
            
            count = socketChannel.read(receiveBuffer);
        
            
            if(count>0){
                receiveText = new String(receiveBuffer.array(),0,count);
                System.out.println("服务器端接受到的数据---"+receiveText);
                socketChannel.register(selector, SelectionKey.OP_WRITE);
            }
        }else if (selectionKey.isWritable()) {  
            //将缓冲区清空以备下次写入  
            sendBuffer.clear();  
            // 返回为之创建此键的通道。  
            socketChannel = (SocketChannel) selectionKey.channel();  
            sendText="message from server--" + flag++;  
            //向缓冲区中输入数据  
            sendBuffer.put(sendText.getBytes());  
             //将缓冲区各标志复位,因为向里面put了数据标志被改变要想从中读取数据发向服务器,就要复位  
            sendBuffer.flip();  
            //输出到通道  
            socketChannel.write(sendBuffer);  
            System.out.println("服务器端向客户端发送数据--："+sendText);  
            socketChannel.register(selector, SelectionKey.OP_READ);  
        }  
        
    }
    public static void main(String[] args) throws IOException {
        int port = 8888; 
        NIOServer server = new NIOServer(port);
        server.listen();
    }

}

客户端

package com.eric.test.nio;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
import java.util.Set;

public class NIOClient {
    /*标识数字*/  
    private static int flag = 0;  
    /*缓冲区大小*/  
    private static int BLOCK = 4096;  
    /*接受数据缓冲区*/  
    private static ByteBuffer sendBuffer = ByteBuffer.allocate(BLOCK);  
    /*发送数据缓冲区*/  
    private static ByteBuffer receiveBuffer = ByteBuffer.allocate(BLOCK);  
    /*服务器端地址*/  
    private final static InetSocketAddress SERVER_ADDRESS = new InetSocketAddress(  
            "localhost", 8888);  
  
    public static void main(String[] args) throws IOException {  
        // 打开socket通道  
        SocketChannel clientChannel = SocketChannel.open();  
        // 设置为非阻塞方式  
        clientChannel.configureBlocking(false);  
        // 打开选择器  
        Selector selector = Selector.open();  
        // 注册连接服务端socket动作  
        clientChannel.register(selector, SelectionKey.OP_CONNECT);  
        // 连接  
        clientChannel.connect(SERVER_ADDRESS);  
    
        SocketChannel socketChannel;
        Set<SelectionKey> selectionKeys;    
        String receiveText;  
        String sendText;  
        int count=0;  
  
        while (true) {  
            //选择一组键，其相应的通道已为 I/O 操作准备就绪。  
            //监控所有注册的 channel ，当其中有注册的 IO 操作可以进行时，该函数返回，并将对应的 SelectionKey 加入 selected-key set 
            selector.select();  
            //返回此选择器的已选择键集。  
            selectionKeys = selector.selectedKeys();  
            //System.out.println(selectionKeys.size());  
            for(SelectionKey selectionKey:selectionKeys){ 
                //判断是否为建立连接的事件
                if (selectionKey.isConnectable()) {  
                    System.out.println("client connect");  
                    socketChannel = (SocketChannel) selectionKey.channel();  //
                    // 判断此通道上是否正在进行连接操作。  
                    // 完成套接字通道的连接过程。  
                    if (socketChannel.isConnectionPending()) { 
                        //完成连接的建立（TCP三次握手）
                        socketChannel.finishConnect();  
                        System.out.println("完成连接!");  
                        sendBuffer.clear();  
                        sendBuffer.put("Hello,Server".getBytes());  
                        sendBuffer.flip();  
                        socketChannel.write(sendBuffer);  
                    }  
                    socketChannel.register(selector, SelectionKey.OP_READ);  
                } else if (selectionKey.isReadable()) {  
                    socketChannel = (SocketChannel) selectionKey.channel();  
                    //将缓冲区清空以备下次读取  
                    receiveBuffer.clear();  
                    //读取服务器发送来的数据到缓冲区中  
                    count=socketChannel.read(receiveBuffer);  
                    if(count>0){  
                        receiveText = new String( receiveBuffer.array(),0,count);  
                        System.out.println("客户端接受服务器端数据--:"+receiveText);  
                        socketChannel.register(selector, SelectionKey.OP_WRITE);  
                    }  
  
                } else if (selectionKey.isWritable()) {  
                    sendBuffer.clear();  
                    socketChannel = (SocketChannel) selectionKey.channel();  
                    sendText = "message from client--" + (flag++);  
                    sendBuffer.put(sendText.getBytes());  
                     //将缓冲区各标志复位,因为向里面put了数据标志被改变要想从中读取数据发向服务器,就要复位  
                    sendBuffer.flip();  
                    socketChannel.write(sendBuffer);  
                    System.out.println("客户端向服务器端发送数据--："+sendText);  
                    socketChannel.register(selector, SelectionKey.OP_READ);  
                }  
            }  
            selectionKeys.clear();  
        }  
    }  
}

小结：之前对Selector注册事件和SocketChannel有点小困惑。SocketChannel就像一根水管，当监听到写事件时，就往管道写数据；当监听到读事件时，就从管道读出数据。

下面就给出具体代码，与以往一样，我会在代码的适当位置使用注释。但我不会保证在我机器上可以运行的程序会在所有机器上运行（据说这可能是人品问题）。

import javax.microedition.lcdui.*;
import java.io.*;

public class ImageCanvas
    extends Canvas
{
  private Image byteImg;
  private InputStream input;
  public ImageCanvas()
  {
    try
    {
      jbInit();
    }
    catch (Exception e)
    {
      e.printStackTrace();
    }
  }

  /**
   * 三种方法任选一种
   * @throws Exception
   */
  private void jbInit() throws Exception
  {
    byteImg = this.readImage("/res/pic.bin", 11110); // 从一个合成包里读取资源，如*.bin文件
    //byteImg = Image.createImage("/res/caidan.png"); // 直接读取PNG文件
    //byteImg = this.importImage(this.caiDanImage()); // 从byte数组里记取资源，将资源像素保存在byte数组中
    System.out.println("内存情况: " +
                       Runtime.getRuntime().freeMemory() +
                       " / " + Runtime.getRuntime().totalMemory());//这种情况下会简单看下每种方法对内存的影响
    //this.getByte("/res/caidan.png");
  }

  /**
   * Reads a file from the BIN file and return data as an Image
   * @param binfile String 文件名
   * @param pos long 需要跳过的字节长度
   * @return Image 返回一个Image对像
   */
  public Image readImage(String binfile, long pos)
  {
    byte buffer[];
    int len;
    try
    {
      InputStream is = getClass().getResourceAsStream(binfile);
      is.skip(pos);
      len = (is.read() & 0xFF) << 24; // 如果不懂得这几句的意思，请留言给我，或是补习一下基本的编程知识
      len |= (is.read() & 0xFF) << 16;
      len |= (is.read() & 0xFF) << 8;
      len |= (is.read() & 0xFF);
      buffer = new byte[len];
      is.read(buffer, 0, buffer.length);
      is.close();
      is = null;
      System.gc();
    }
    catch (Exception e)
    {
      buffer = null;
      e.printStackTrace();
      System.gc();
      return null;
    }
    return Image.createImage(buffer, 0, buffer.length);
  }

  /**
   * 将资源文件转换为byte数组
   * @param file String 需要转换的文件名
   */
  private void getByte(String file)
  {
    byte[] myData = null;
    input = getClass().getResourceAsStream(file);
    try
    {
      ByteArrayOutputStream byteArray = new ByteArrayOutputStream();
      int ch = 0;
      while ((ch = input.read()) != -1)
      {
        byteArray.write(ch);
      }
      for (int i = 0; i < byteArray.size(); i++)
      {
        myData = byteArray.toByteArray();
      }
      for (int i = 0; i < myData.length; i++)
      {
        System.out.println(myData[i] + ",");
      }
    }
    catch (Exception e)
    {}
    //return myData;
  }

  /**
   * 利用byte数据流生成图片
   * @param byteFile byte[] 图片文件byte数据流
   * @return Image 返回Image对象
   */
  private Image importImage(byte[] byteFile)
  {
    Image img = null;
    img = Image.createImage(byteFile, 0, byteFile.length);
    return img;
  }

  protected void paint(Graphics g)
  {
    /** @todo Add paint codes */
    g.setColor(0xffffff);
    g.fillRect(0, 0, this.getWidth(), this.getHeight());
    g.drawImage(byteImg, 30, 30, g.TOP | g.LEFT);
  }

  private byte[] xiangSuImage()
  {
    byte[] iCaiDanImage =
        { -119, 80, 78, 71, 13, 10, 26, 10, 0, 0, 0,
        13, 73, 72, 68, 82, 0, 0, 0, 65, 0, 0, 0, 56,
        ......//未完的数据
        };
    return iCaiDanImage;
  }

}

总体来

转  JDK5.0垃圾收集优化之--Don't Pause

    ThreadLocal则使用了“拷贝副本”的方式，人人有份，你用你的，我用我的，大家互不影响，是“以空间换时间”。每个线程修改变量时，实际上修改的是变量的副本，不怕影响到其它线程。

    为了加深对ThreadLocal的理解，下面我使用一个例子来演示ThreadLocal如何隔离线程间的变量访问和修改：

【1】SerialNum类

1.创建临时文件

2..先解压目标压缩Jar文件 到临时文件夹

3.拷贝源文件到临时文件夹

4.再压缩临时文件夹

5.再删除临时文件夹

方法可能有些笨，但是我找了好久也没找到现成API实现这个功能。所以和大家分享，共写了三个类

第一个类：

package com.jar;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/**
* 文件夹或文件拷贝到指定目录
* 文件夹的删除
* @author zhang
*
*/
public class FolderCopy {

/**
* 测试主程序
*/
public static void main(String args[]) throws IOException {
   String url1 = "D:/wtk/SonyEricsson/JavaME_SDK_CLDC/README.html";
   String url2 = "c:/temp/";
   copyDirectiory(url1, url2);
}
/**
* 文件夹拷贝，将源文件夹下的所有文件及其子文件夹（文件）拷贝到目标文件夹（文件）下
* 
* @param sourceFile
*            源文件夹或文件
* @param desFile
*            目标文件夹
* @return
*/
public static boolean copyDirectiory(String sourceFile, String desFile)
    throws IOException {
   File des = new File(desFile);
   if (!des.exists())
    des.mkdirs();// 不存在目标文件夹就创建
  
   File source = new File(sourceFile);
   if (!source.exists()) {
    System.out.println(source.getAbsolutePath()
      + "========源文件不存在！=======");
    return false;
   }
   FileInputStream input = null;
   FileOutputStream output = null;

   try {
    if (source.isFile()) { // 如果是文件 则读源文件 写入目标文件
     input = new FileInputStream(source);
     File f = new File(desFile + "/"
       + source.getName());
     output = new FileOutputStream(f);
     byte[] b = new byte[1024 * 5];
     int len;
     while ((len = input.read(b)) != -1) { // 读文件
      output.write(b, 0, len); // 向目标文件写文件
     }
     input.close();
     output.flush();
     output.close();
    } else if (source.isDirectory()) { // 如果是文件夹 递归读取子文件或文件夹
    
     File[] file = source.listFiles();
     for (int i = 0; i < file.length; i++) {
      if(file[i].isDirectory())
       copyDirectiory(sourceFile + "/" + file[i].getName(),
        desFile + "/" + file[i].getName());
      else{
       copyDirectiory(sourceFile + "/" + file[i].getName(),
         desFile + "/");
      }
     }
    
    }
    return true;
   } catch (Exception e) {
    e.printStackTrace();
    return false;
   } finally {
    if (input != null)
     input.close();
    if (output != null)
     output.close();
   }
}
/**
* 刪除文件或文件夾
* @param file
*/
public static void deleteFile(File file){ 
     if (file.exists()){ 
      if(file.isFile()){ 
       file.delete(); 
      }else if(file.isDirectory()){ 
       File files[] = file.listFiles(); 
       for(int i=0;i<files.length;i++){ 
        deleteFile(files[i]); 
       } 
      } 
      file.delete(); 
     }else{ 
      System.out.println("所删除的文件不存在！"+'\n'); 
     } 
   }

}

第二个类BatchJar ：

package com.jar;

import java.io.File;
/**
* 批处理：在指定文件夹中的所有Jar文件中添加文件或文件夹
* @author zhang
*
*/

public class BatchJar {

/**
* @param args
*/
public static void main(String[] args) {
   // TODO Auto-generated method stub
   BatchJar jar = new BatchJar();
   jar.batchJar("D:/temp/疯狂农场", "jar", "D:/temp/ashinanren.jar");
}
public void batchJar(String dir, String fileType, String fileName){
   System.out.println(fileName+" 即将被添加到"+dir+"中的"+fileType+"文件中..");
   batchRar(dir,fileType,fileName);
   System.out.println("添加完成！");
}
/**
* 
* @param dir
*            需要遍历的文件夹
* @param fileType
*            压缩文件类型 rar jar zip
* @param fileName
*            要添加的文件或文件夹
* 
*            遍历文件夹 拼写批处理命令
*/
JARDemo jar = new JARDemo();
public void batchRar(String dir, String fileType, String fileName) {

   File file = new File(dir);
   if (file.exists()) {
    if (file.isFile()) { //
     if (isType(file, fileType)) {
      
      jar.fileAddToJar(fileName, file.getAbsolutePath());    
     }

    } else if (file.isDirectory()) {
     File files[] = file.listFiles();
     for (int i = 0; i < files.length; i++) {
      batchRar(files[i].getAbsolutePath(), fileType, fileName);
     }
    }
    // file.delete();
   } else {
    System.out.println("所删除的文件不存在！" + '\n');
   }
  

}
/**
* 判断是否为指定文件类型
*/
private boolean isType(File file, String fileType) {
   if (file == null) {
    return false;
   }
   String fileName = file.getAbsolutePath();
   String suffix = fileName.substring(fileName.lastIndexOf(".") + 1);// 后缀
   // System.out.println("====后缀："+suffix);
   if (fileType.equals(suffix)) {
    return true;
   }
   return false;
}
}

第三个类JARDemo ：
package com.jar;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;

import java.util.Enumeration;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;
import java.util.jar.JarOutputStream;

/**
* 压缩指定文件夹
* 解压指定压缩文件
* 把指定源文件或文件夹添加到指定压缩包中
* @author zhang
*
*/

public class JARDemo {
public static void main(String[] args) {
   JARDemo t = new JARDemo();

   t.fileAddToJar("d:/com", "d:/temp/shinanren.jar");
}

/**
* 把指定源文件添加到指定压缩包中
* 
* @param sourceFileName
*            要压缩到指定目标压缩文件的源文件或文件夹
* @param destFileName
*            目标压缩文件
* @throws IOException
*/
public void fileAddToJar(String sourceFileName, String jarName) {
//   System.out.println("**=="+sourceFileName);
   // 先解压到临时文件夹，存在先刪除 不存在直接創建
   String tempFileName = "c:/temp";
   File tempDir = new File(tempFileName);
   try {

    if (tempDir.exists()) {
     FolderCopy.deleteFile(tempDir);// 刪除文件夾
    } else {
     tempDir.mkdirs();
    }
   } catch (Exception e) {
    e.printStackTrace();
   }

   try {
    this.unJar(jarName, tempFileName);// 先解压目标压缩Jar文件 到临时文件夹
    File f = new File(sourceFileName);
   
    if(f.isDirectory()){//如果是文件夹
     FolderCopy.copyDirectiory(sourceFileName, tempFileName+"/"+new File(sourceFileName).getName());// 拷贝源文件到临时文件夹
    
    }
    if(f.isFile())
     FolderCopy.copyDirectiory(sourceFileName, tempFileName);// 拷贝源文件到临时文件夹

    this.jar(tempFileName, jarName);// 再压缩临时文件夹

    FolderCopy.deleteFile(tempDir); //再删除临时文件夹

   } catch (IOException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
   }

}

/**
* 压缩指定文件夹
* 
* @param souceFileName
*            源文件
* @param destFileName
*            目标文件
*/
private void jar(String souceFileName, String destFileName) {
   destName = destFileName;
   File file = new File(souceFileName);
   try {
    jar(file, destFileName);
   } catch (Exception e) {
    e.printStackTrace();
   }
}

private void jar(File souceFile, String destFileName) throws IOException {
   FileOutputStream fileOut = null;
   try {
    fileOut = new FileOutputStream(destFileName);
   } catch (FileNotFoundException e) {
    e.printStackTrace();
   }
   JarOutputStream out = new JarOutputStream(fileOut);
   jar(souceFile, out, "");
   out.close();
}

String destName = "";

private void jar(File souceFile, JarOutputStream out, String base)
    throws IOException {

   if (souceFile.isDirectory()) {
    File[] files = souceFile.listFiles();
    out.putNextEntry(new JarEntry(base + "/"));
    base = base.length() == 0 ? "" : base + "/";
    for (File file : files) {
     jar(file, out, base + file.getName());
    }
   } else {
    if (base.length() > 0) {
     out.putNextEntry(new JarEntry(base));
    } else {
     out.putNextEntry(new JarEntry(souceFile.getName()));
    }

    FileInputStream in = new FileInputStream(souceFile);

    int b;
    byte[] by = new byte[1024];
    while ((b = in.read(by)) != -1) {
     out.write(by, 0, b);
    }
    in.close();
   }
}

/**
* 解压缩文件
* 
* @param zipFilename
* @param outputDirectory
* @throws IOException
*/
public synchronized void unJar(String jarFilename, String outputDirectory)
    throws IOException {
   File outFile = new File(outputDirectory);
   if (!outFile.exists()) {
    outFile.mkdirs();
   }

   JarFile jarFile = new JarFile(jarFilename);
   Enumeration en = jarFile.entries();
   JarEntry jarEntry = null;
   while (en.hasMoreElements()) {
    jarEntry = (JarEntry) en.nextElement();
    if (jarEntry.isDirectory()) {
     // mkdir directory
     String dirName = jarEntry.getName();
     dirName = dirName.substring(0, dirName.length() - 1);

     File f = new File(outFile.getPath() + File.separator + dirName);
//    

    } else {
     // unjar file
     File f = new File(outFile.getPath() + File.separator
       + jarEntry.getName());
    
     this.createFile(f);

     InputStream in = jarFile.getInputStream(jarEntry);
     FileOutputStream out = new FileOutputStream(f);
     try {
      int c;
      byte[] by = new byte[1024];
      while ((c = in.read(by)) != -1) {
       out.write(by, 0, c);
      }
      // out.flush();
     } catch (IOException e) {
      e.printStackTrace();
     } finally {
      out.close();
      in.close();
     }
    }
   }
}

/**
* 创建文件 包含不存在的文件夹
*/
public boolean createFile(File file) {
//   System.out.println("=="+file.getAbsolutePath());
   if (file == null)
    return false;
   try {
    if (file.isDirectory()&&!file.exists()) {
     file.mkdirs();// 创建目录
    } else { 
    
     File fileP = new File(file.getParent());
     if(!fileP.exists()){
      fileP.mkdirs();
     }
    
    }
    file.createNewFile();//先确保创建文件夹目录后创建文件
    return true;
   } catch (Exception e) {
    e.printStackTrace();
    return false;
   }
}

/**
* 把指定文件打包 只能是文件不能文件夹
*/
public void fileJar() {
   String[] filenames = new String[] { "d:/d.jar", "d:/a.txt" };
   byte[] buf = new byte[1024];
   try {
    // Create the Jar file
    String outFilename = "d:/d.jar";
    JarOutputStream out = new JarOutputStream(new FileOutputStream(
      outFilename));

    for (int i = 0; i < filenames.length; i++) {
     FileInputStream in = new FileInputStream(filenames[i]);

     // Add Jar entry to output stream.
     System.out.println("==" + filenames[i]);
     out.putNextEntry(new JarEntry(filenames[i]));

     // Transfer bytes from the file to the Jar file
     int len;
     while ((len = in.read(buf)) > 0) {
      out.write(buf, 0, len);
     }

     // Complete the entry

     out.closeEntry();
     in.close();
    }

    // Complete the Jar file
    out.close();
   } catch (Exception e) {
    e.printStackTrace();
   }
}
}

下面是有关参数的几个说明
-verbose:gc在虚拟机发生内存回收时在输出设备显示信息，该参数用来监视虚拟机内存回收的情况。
-Xnoclassgc
关闭虚拟机对class的垃圾回收功能。
-Xincgc
启动增量垃圾收集器，缺省是关闭的。增量垃圾收集器能减少偶然发生的长时间的垃圾回收造成的暂停时间。但增量垃圾收集器和应用程序并发执行，因此会占用部分CPU在应用程序上的功能。
-Xloggc:<file>
将虚拟机每次垃圾回收的信息写到日志文件中，文件名由file指定，文件格式是平文件，内容和-verbose:gc输出内容相同。

JVM管理的内存，通常叫做堆(heap)，如果 JVM 不能在 java 堆中获得更多内存来分配更多 java 对象，将会抛出 java 内存不足错误。如果 java 堆充满了活动对象，并且 JVM 无法再扩展 java 堆，那么它将不能分配更多 java 对象。
在这种情况下，JVM就出现 java.lang.OutOfMemoryError 。

JVM启动后，保留一段地址空间，这个空间的大小由-Xmx指定。这块空间的大小就是heap可能的最大值，但一开始不一定全都分配了物理内存，初始分配的heap大小由-Xms指定，一般的jdk都有最小值，如果-Xms小于-Xmx，需要的时候，向OS申请
当JVM进行GC的时候，是要消耗CPU资源和需要一定时间的，这会影响到程序的正常运行，因此需要尽可能减少GC消耗的时间。

Java程序运行过程中，对象的生命周期有长有短，所以Java Heap分为3个区，Young，Old和Permanent。当Young被填满时，GC会将对象移到Old区。Permanent是一个永久区域，分配给JVM，可以通过 命令行参数 -XX:MaxPermSize=64m 来设置，permanent generation添满后导致Full GC。

young generation由一块Eden和两块Survivor Space构成。新创建的对象的内存都分配自eden。一块Survivor Space是空闲的，用作copying collection的目标空间。Minor collection的过程就是将eden和在用survivor space中的活对象copy到空闲survivor space中。对象在survivor spaces 里经历了数次copied后，就会被移到tenured generation或tenured掉。
GC用较高的频率对young generation进行扫描和回收，这种叫做minor collection，而对old generation的检查回收频率要低很多，称为major collection。这样就不需要每次GC都将内存中所有对象都检查一遍。

老版本的JVM是分代垃圾收集（generational garbage collection），有两种收集方式：
第一个是scavenge，将所有活的对象搬到另外一块内存后，整块内存回收。这种方法有效率，但需要有一定的空闲内存，拷贝也有开销，用于minor collection。
第二个是mark-compact，将活的对象标记出来，然后搬迁到一起连成大块的内存，其他内存就可以回收了。这种方法不需要额外的空间，速度会慢一些，方法用于major collection。
注意这两种GC机制都不是并行的，是单线程的，GC运行时，所有的用户线程将暂停，Java应用程序不做任何工作，web应用停止响应。

JDK 1.4.1 中新的收集器都是为解决多处理器系统中垃圾收集器的问题而设计的。因为大多数垃圾收集算法会在一段时间里使系统停止，单线程的收集器很快会成为伸缩性瓶颈，因为在垃圾收集器将用户程序线程挂起时，除了一个处理器之外，其他的处理器都是空闲的。新收集器中的两个――并行复制收集器和并发标记-清除收集器――设计为减少收集暂停时间。另一个是并行清除收集器，它是为在大堆上的更高吞吐能力而设计的。

并行复制收集器用 JVM 选项 -XX:+UseParNewGC 启用，是一个年轻代复制收集器，它将垃圾收集的工作分为与 CPU 数量一样多的线程。并发标记-清除收集器由 -XX:+UseConcMarkSweepGC 选项启用，它是一个老代标记-清除收集器，它在初始标记阶段（及在以后暂短重新标记阶段）暂短地停止整个系统，然后恢复用户程序，同时垃圾收集器线程与用户程序并发地执行。并行复制收集器和并发标记-清除收集器基本上是默认的复制收集器和标记-整理收集器的并发版本。由 -XX:+UseParallelGC 启用的并行清除收集器是年轻代收集器，针对多处理器系统上非常大(吉字节以及更大的)堆进行了优化。

JDK 1.4.1 还包括大量的微调垃圾收集的选项。调整这些选项并衡量它们的效果可能会花费您大量时间，因此在试图微调垃圾收集器之前先对您的应用程序进行彻底的配置（profile）和优化，这样您的微调工作可能会得到更好的结果。
微调垃圾收集首先要做的是检查冗长的 GC 输出。这会使您得到垃圾收集操作的频率、定时和持续时间等信息。最简单的垃圾收集微调就是扩大最大堆的大小（ -Xmx ）。随着堆的增大，复制收集会变得更有效，所以在增大堆时，您就减少了每个对象的收集成本。除了增加最大堆的大小，还可以用选项 -XX:NewRatio 增加分配给年轻代的空间份额。也可以用 -Xmn 选项显式指定年轻代的大小。

注意：大的收集（major collection）既会收集年轻的代，也会收集老的代。 System.gc() 方法总是触发一个大的收集，这就是应该尽量少用（如果不能完全不用的话） System.gc() 的原因之一，因为大的收集要比小的收集花费长得多的时间。没有办法以编程方式触发小的收集，最好使用-XX:+DisableExplicitGC禁止ExplicitGC。

JVM的很多参数会影响里面各部分空间的分配。-XX:MinHeapFreeRatio与-XX:MaxHeapFreeRatio设定空闲内存占总内存的比例范围，这两个参数会影响GC的频率和单次GC的耗时。-XX:NewRatio决定young与old generation的比例，设置-XX:NewRatio=3意味着old和 young generation是1:3。Young generation空间越大，minor collection频率越低，但是old generation空间小了，又可能导致major collection频率增加。一般来说，eden大小在maximum heap大小的1/4到1/3之间，old generation的大小一定要大于young generation。
-XX:NewSize和-XX:MaxNewSize直接指定了young generation的最小值和最大值。

如果是Server-Side应用，请加 -server 参数。这样，缺省的NewRatio 是2，SurvivorRatio 是 25 ，适合大部分应用。也可以用NewSize、MaxNewSize来设置。 设置- Xms 和 -Xmx 的大小相等，可以避免在每次 GC 后调整堆内存的大小。同样道理设置NewSize、MaxNewSize相等。
对于web应用还要注意，由于经常生成和加载类，permanent generation对GC的影响较大，应设置的大些。如果应用程序中有长期活对象，尽可能减少这些对象的存在期。例如，调整 HTTP 会话超时值将有助于更快地回收空闲会话对象。存泄漏的一个例子是在应用服务器中使用数据库连接池。当使用连接池时，必须在 finally 块中显式关闭 JDBC 语句和结果集对象。这是因为，当从池中调用连接对象上的 close() 时，只是简单地把连接返回池中以供重用，并没有实际关闭连接和关联的语句/结果集对象。如果使用全局缓存，最好使用 Week Reference，例如用 WeakHashMap 代替 HashMap 。

/*
 * $Id: ClassLoaderUtil.java, Dec 22, 2009, 8:22:21 PM, liama. Exp$
 *
 */

import java.io.File;
import java.io.PrintStream;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.List;

import sun.misc.Launcher;

/**
 * Class/Interface description
 *
 * @author liama</a>
 * @since JDK 1.5
 */
public class ClassLoaderUtil {
    /**
     * The value is used for get parent loader.
     */
    private static Field classes;

    /**
     * The add url method loader.
     */
    private static Method addURL;
    static {
        try {
             classes = ClassLoader.class.getDeclaredField("parent");
             addURL = URLClassLoader.class.getDeclaredMethod("addURL",new Class[] { URL.class });
         } catch (Exception e) {
             e.printStackTrace();
         }
         classes.setAccessible(true);
         addURL.setAccessible(true);
     }

    /**
     * The value is used for system loader
     */
    private static URLClassLoader system = (URLClassLoader) getSystemClassLoader();

    /**
     * The value is used for external loader
     */
    private static URLClassLoader ext = (URLClassLoader) getExtClassLoader();

    /**
     * Get system loader
     *
     * @return {@link ClassLoader}
     */
    public static ClassLoader getSystemClassLoader() {
        return ClassLoader.getSystemClassLoader();
     }

    /**
     * Get external loader
     *
     * @return {@link ClassLoader}
     */
    public static ClassLoader getExtClassLoader() {
        return getSystemClassLoader().getParent();
     }

    /**
     * Get sub class loader from system class loader
     *
     * @return {@link List}
     */
    public static List getClassesLoadedBySystemClassLoader() {
        return getClassesLoadedByClassLoader(getSystemClassLoader());
     }

    /**
     * Get sub class loader from external class loader
     *
     * @return {@link List}
     */
    public static List getClassesLoadedByExtClassLoader() {
        return getClassesLoadedByClassLoader(getExtClassLoader());
     }

    /**
     * Get sub class loader from  class loader
     *
     * @param cl {@link ClassLoader}
     * @return {@link List}
     */
    public static List getClassesLoadedByClassLoader(ClassLoader cl) {
        try {
            return (List) classes.get(cl);
         } catch (Exception e) {
            //throw new RootException(e);
             e.printStackTrace();
            return null;
        }
     }

    /**
     * Get bootstrap urls
     *
     * @return {@link URL}
     */
    public static URL[] getBootstrapURLs() {
        return Launcher.getBootstrapClassPath().getURLs();
     }

    /**
     * Get system urls
     *
     * @return {@link URL}
     */
    public static URL[] getSystemURLs() {
        return system.getURLs();
     }

    /**
     * Get external urls
     *
     * @return {@link URL}
     */
    public static URL[] getExtURLs() {
        return ext.getURLs();
     }

    /**
     * Print class path to specify stream
     *
     * @param ps {@link PrintStream}
     * @param classPath {@link URL}
     */
    private static void list(PrintStream ps, URL[] classPath) {
        for (int i = 0; i < classPath.length; i++) {
             ps.println(classPath[i]);
         }
     }

    /**
     * List boot strap class path
     */
    public static void listBootstrapClassPath() {
         listBootstrapClassPath(System.out);
     }

    /**
     * Print boot strap class path
     *
     * @param ps {@link PrintStream}
     */
    public static void listBootstrapClassPath(PrintStream ps) {
         ps.println("BootstrapClassPath:");
         list(ps, getBootstrapClassPath());
     }

    /**
     * list system class path
     */
    public static void listSystemClassPath() {
         listSystemClassPath(System.out);
     }

    /**
     * Print system class path
     *
     * @param ps {@link PrintStream}
     */
    public static void listSystemClassPath(PrintStream ps) {
         ps.println("SystemClassPath:");
         list(ps, getSystemClassPath());
     }

    /**
     * List external class path
     */
    public static void listExtClassPath() {
         listExtClassPath(System.out);
     }

    /**
     * Print external class path
     *
     * @param ps {@link PrintStream}
     */
    public static void listExtClassPath(PrintStream ps) {
         ps.println("ExtClassPath:");
         list(ps, getExtClassPath());
     }

    /**
     * Get boot strap class path
     *
     * @return {@link URL}
     */
    public static URL[] getBootstrapClassPath() {
        return getBootstrapURLs();
     }

    /**
     * Get system class path
     *
     * @return {@link URL}
     */
    public static URL[] getSystemClassPath() {
        return getSystemURLs();
     }

    /**
     * Get external class path
     *
     * @return {@link URL}
     */
    public static URL[] getExtClassPath() {
        return getExtURLs();
     }

    /**
     * Add user specify URL to system class loader
     *
     * @param url {@link URL}
     */
    public static void addURL2SystemClassLoader(URL url) {
        try {
             addURL.invoke(system, new Object[] { url });
         } catch (Exception e) {
             e.printStackTrace();
         }
     }

    /**
     * Add user specify URL to external class loader
     *
     * @param url {@link URL}
     */
    public static void addURL2ExtClassLoader(URL url) {
        try {
             addURL.invoke(ext, new Object[] { url });
         } catch (Exception e) {
             e.printStackTrace();
         }
     }

    /**
     * Add user specify String to class loader
     *
     * @param path {@link String}
     */
    public static void addClassPath(String path) {
         addClassPath(new File(path));
     }

    /**
     * Add user specify String to external class loader
     *
     * @param path {@link String}
     */
    public static void addExtClassPath(String path) {
         addExtClassPath(new File(path));
     }

    /**
     * Add user specify File to  class loader
     *
     * @param dirOrJar {@link File}
     */
    public static void addClassPath(File dirOrJar) {
        try {
             addURL2SystemClassLoader(dirOrJar.toURL());
         } catch (MalformedURLException e) {
            //throw new RootException(e);
             e.printStackTrace();
         }
     }

    /**
     * Add user specify File to external class loader
     *
     * @param dirOrJar {@link File}
     */
    public static void addExtClassPath(File dirOrJar) {
        try {
             addURL2ExtClassLoader(dirOrJar.toURL());
         } catch (MalformedURLException e) {
             e.printStackTrace();
         }
     }
   
    /**
     * Add specify path to specify loader
     *
     * @param cl {@link ClassLoader}
     * @param path String
     */
    public static void addClassPath2ClassLoader(ClassLoader cl, String path){
        try {
            addURL.invoke(cl, new File(path).toURL());
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        } catch (MalformedURLException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
    }
   
    /**
     * Add specify path to specify loader
     *
     * @param cl {@link ClassLoader}
     * @param path String
     */
    public static void addClassPath2ClassLoader(ClassLoader cl, URL path){
        try {
            addURL.invoke(cl, path);
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
    }
}

1、synchronized关键字的作用域有二种：

1）是某个对象实例内，synchronized aMethod(){}可以防止多个线程同时访问这个对象的synchronized方法（如果一个对象有多个synchronized方法，只要一个线程访问了其中的一个synchronized方法，其它线程不能同时访问这个对象中任何一个synchronized方法）。这时，不同的对象实例的synchronized方法是不相干扰的。也就是说，其它线程照样可以同时访问相同类的另一个对象实例中的synchronized方法；

2）是某个类的范围，synchronized static aStaticMethod{}防止多个线程同时访问这个类中的synchronized static 方法。它可以对类的所有对象实例起作用。2、除了方法前用synchronized关键字，synchronized关键字还可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。用法是: synchronized(this){/*区块*/}，它的作用域是当前对象；

3、synchronized关键字是不能继承的，也就是说，基类的方法synchronized f(){} 在继承类中并不自动是synchronized f(){}，而是变成了f(){}。继承类需要你显式的指定它的某个方法为synchronized方法；

堆区:
1.存储的全部是对象，每个对象都包含一个与之对应的class的信息。(class的目的是得到操作指令)
2.jvm只有一个堆区(heap)被所有线程共享，堆中不存放基本类型和对象引用，只存放对象本身
栈区:
1.每个线程包含一个栈区，栈中只保存基础数据类型的对象和自定义对象的引用(不是对象)，对象都存放在堆区中
2.每个栈中的数据(原始类型和对象引用)都是私有的，其他栈不能访问。
3.栈分为3个部分：基本类型变量区、执行环境上下文、操作指令区(存放操作指令)。
方法区:
1.又叫静态区，跟堆一样，被所有的线程共享。方法区包含所有的class和static变量。
2.方法区中包含的都是在整个程序中永远唯一的元素，如class，static变量。


为了更清楚地搞明白发生在运行时数据区里的黑幕，我们来准备2个小道具（2个非常简单的小程序）。

AppMain.java

 public   class  AppMain                //运行时, jvm 把appmain的信息都放入方法区

{

public   static   void  main(String[] args)  //main 方法本身放入方法区。

{

Sample test1 = new  Sample( " 测试1 " );   //test1是引用，所以放到栈区里， Sample是自定义对象应该放到堆里面

Sample test2 = new  Sample( " 测试2 " );



test1.printName();

test2.printName();

} 

} 

Sample.java

 public   class  Sample        //运行时, jvm 把appmain的信息都放入方法区

{

/** 范例名称 */ 

private  name;      //new Sample实例后， name 引用放入栈区里，  name 对象放入堆里



/** 构造方法 */ 

public  Sample(String name)

{

this .name = name;

} 



/** 输出 */ 

public   void  printName()   //print方法本身放入 方法区里。

{

System.out.println(name);

} 

} 

OK，让我们开始行动吧，出发指令就是：“java AppMain”，包包里带好我们的行动向导图，Let’s GO！



系统收到了我们发出的指令，启动了一个Java虚拟机进程，这个进程首先从classpath中找到AppMain.class文件，读取这个文件中的二进制数据，然后把Appmain类的类信息存放到运行时数据区的方法区中。这一过程称为AppMain类的加载过程。
接着，Java虚拟机定位到方法区中AppMain类的Main()方法的字节码，开始执行它的指令。这个main()方法的第一条语句就是：
Sample test1=new Sample("测试1");
语句很简单啦，就是让java虚拟机创建一个Sample实例，并且呢，使引用变量test1引用这个实例。貌似小case一桩哦，就让我们来跟踪一下Java虚拟机，看看它究竟是怎么来执行这个任务的：

1、 Java虚拟机一看，不就是建立一个Sample实例吗，简单，于是就直奔方法区而去，先找到Sample类的类型信息再说。结果呢，嘿嘿，没找到@@，这会儿的方法区里还没有Sample类呢。可Java虚拟机也不是一根筋的笨蛋，于是，它发扬“自己动手，丰衣足食”的作风，立马加载了Sample类，把Sample类的类型信息存放在方法区里。

2、 好啦，资料找到了，下面就开始干活啦。Java虚拟机做的第一件事情就是在堆区中为一个新的Sample实例分配内存, 这个Sample实例持有着指向方法区的Sample类的类型信息的引用。这里所说的引用，实际上指的是Sample类的类型信息在方法区中的内存地址，其实，就是有点类似于C语言里的指针啦~~，而这个地址呢，就存放了在Sample实例的数据区里。

3、 在JAVA虚拟机进程中，每个线程都会拥有一个方法调用栈，用来跟踪线程运行中一系列的方法调用过程，栈中的每一个元素就被称为栈帧，每当线程调用一个方法的时候就会向方法栈压入一个新帧。这里的帧用来存储方法的参数、局部变量和运算过程中的临时数据。OK，原理讲完了，就让我们来继续我们的跟踪行动！位于“=”前的Test1是一个在main()方法中定义的变量，可见，它是一个局部变量，因此，它被会添加到了执行main()方法的主线程的JAVA方法调用栈中。而“=”将把这个test1变量指向堆区中的Sample实例，也就是说，它持有指向Sample实例的引用。

OK，到这里为止呢，JAVA虚拟机就完成了这个简单语句的执行任务。参考我们的行动向导图，我们终于初步摸清了JAVA虚拟机的一点点底细了，COOL！

接下来，JAVA虚拟机将继续执行后续指令，在堆区里继续创建另一个Sample实例，然后依次执行它们的printName()方法。当JAVA虚拟机执行test1.printName()方法时，JAVA虚拟机根据局部变量test1持有的引用，定位到堆区中的Sample实例，再根据Sample实例持有的引用，定位到方法去中Sample类的类型信息，从而获得printName()方法的字节码，接着执行printName()方法包含的指令。