BlogJava-Java天空任我翱翔-随笔分类-Java Language

1970年1月1日开始计时

persister — Mon, 22 Feb 2010 03:07:00 GMT

编程语言和数据库里面经常可以看到，定义的时间是从1970年1月1日开始，但不知道为啥，于是到网上找找答案。

比如java中：

Date date = new Date(0);
System.out.println(date);

打印出来的结果:

Thu Jan 01 08:00:00 CST 1970

也是1970年1月1日，实际上时分秒是8点0分0秒(北京时间+8的缘故)。

最初计算机操作系统是32位，而时间也是用32位表示。

System.out.println(Integer.MAX_VALUE);
2147483647

Integer在JAVA内用32位表示，因此32位能表示的最大值是2147483647。另外1年365天的总秒数是31536000，

2147483647/31536000 = 68.1

因为用32位来表示时间的最大间隔是68年，而最早出现的UNIX操作系统考虑到计算
机产生的年代和应用的时限综合取了1970年1月1日作为UNIX TIME的纪元时间(开始
时间)，而java自然也遵循了这一约束。

至于时间回归的现象相信随着64为操作系统的产生逐渐得到解决，因为用64位操作
系统可以表示到292,277,026,596年12月4日15时30分08秒，这个怎么说都够用了，不够的话变成128，256位？这个时候地球还存在吗？哈哈。

persister 2010-02-22 11:07 发表评论

多线程设计模式总结

persister — Sun, 31 Jan 2010 07:26:00 GMT

Java多线程设计模式，帮助多线程功能提高质量，降低学习成本。主要的Pattern如下：
1.Single Threaded Execution Pattern 多个线程共享一个实例，这样的话，多个线程都
擅自改动实例的状态，实例会丧失安全性。这种情况可以通过Java的关键词synchronized来解决。如多个人
通过一个gate时，只能一个个通过，那么可以如下的方式：
public synchronized void pass(String name){
   this.name = name;
}
synchronized方法的性能比普通的方法低，所以降低减少使用。
JDK中很多方法是synchronized，可以安全使用，很多为了性能是没有同步。为了提高性能可以考虑使用 Immutable Pattern
2.Immutable Pattern 多个线程共享一个实例，但是实例的状态不会改变，可以提供throughput，但必须保证
不变形（实例的状态不会改变）。需要使用private，final等来支持。
3.Guarded Suspension Pattern 多个线程共享一个实例，这样的话，多个线程都
擅自改动实例的状态，实例会丧失安全性。当实例的状态不恰当时，就要求线程等待到合适的状态，以“警戒条   件”来表示实例的“适当的状态”。如果警戒条件一直不成立，线程会永远等待下去，会使程序丧失生命性。Java   中用while循环来测试警戒条件，使用wait方法让线程等待，并使用notify/notifyAll通知警戒条件的改变。
检   验、修改警戒条件是，会使用Single Threaded Execution Pattern。Pattern的例子如下：
public class RequestQueue{

      private final LinkedList queue = new LinkedList();
      public synchronized Request getRequest(){
   while(queue.size() <= 0){   //警戒条件
         try{
       wait();
          }catch(InterruptedException e){}
   }
   return (Request)queue.removeFirst();
      }
      public synchronized void putRequest(Request request){
       queue.addLast(request);
       notifyAll();

      }

}

以上使用Queue的客户端和服务器代码里面非常干净，没有多线程的东西，代码复用性很好。
当警戒条件不成立时想要马上退出，就使用Balking Pattern
4.Balking Pattern 一直等待安全的时机，会使程序的响应性降低。Java语言中，检验警戒条件时要使用if语句
，当要balk时，可使用return退出方法，或者throw抛出异常。
public class Data {
    private String filename;    //修改是的名字
    private String content;     // 资料的内容
    private boolean changed;    //修改后的内容还没存储的话，值为true

    public Data(String filename, String content) {
        this.filename = filename;
        this.content = content;
        this.changed = true;
    }

    // 修改资料内容
    public synchronized void change(String newContent) {
        content = newContent;
        changed = true;
    }

    // 若有资料修改，就存储到挡安里
    public synchronized void save() throws IOException {
        if (!changed) {
            System.out.println(Thread.currentThread().getName() + " balks");
            return; //没有就退出
        }
        doSave();
        changed = false;
    }

    // 实际资料储存到挡案里用的方法
    private void doSave() throws IOException {
        System.out.println(Thread.currentThread().getName() + " calls doSave, content = " + content);
        Writer writer = new FileWriter(filename);
        writer.write(content);
        writer.close();
    }
}

5.Producer-Consumer Pattern 当Producer参与者与Consumer参与者处理的速度不同时，速度慢的会扯速度快的
后腿，而降低程序的throughput。解决的办法就是在两者之间，加上中继用的Channel参与者。并让Channel
参与者存放多条数据，这样就可以缓冲Producer和Consumer之间处理速度的差异。这个模式使用了Guarded
Suspension Pattern。

public class Table {
    private final String[] buffer;
    private int tail; /下一个放put的地方
    private int head; //下一个放的take地方
    private int count; // buffer内的蛋糕数
    public Table(int count) {
        this.buffer = new String[count];
        this.head = 0;
        this.tail = 0;
        this.count = 0;
    }
    // 放置蛋糕
    public synchronized void put(String cake) throws InterruptedException {
        System.out.println(Thread.currentThread().getName() + " puts " + cake);
        while (count >= buffer.length) {
            wait();
        }
        buffer[tail] = cake;
        tail = (tail + 1) % buffer.length;
        count++;
        notifyAll();
    }
    // 取得蛋糕
    public synchronized String take() throws InterruptedException {
        while (count <= 0) {
            wait();
        }
        String cake = buffer[head];
        head = (head + 1) % buffer.length;
        count--;
        notifyAll();
        System.out.println(Thread.currentThread().getName() + " takes " + cake);
        return cake;
    }
}

6.Read-Write Lock Pattern 多个线程共享一个实例，如进程之间不进行共享胡扯，会丧失安全性。
但使用Single Threaded Execution Pattern会使程序throughput降低。解决的方法就是将控制reader参与者的    锁定与控制writer参与者的锁定分开，加入ReadWriteLock参与者，以提供两种不同的锁定。

public final class ReadWriteLock {
    private int readingReaders = 0; // (A)...实际正在读取的执行绪数量
    private int waitingWriters = 0; // (B)...正在等待写入的执行绪数量
    private int writingWriters = 0; // (C)...实际正在写入的执行绪数量
    private boolean preferWriter = true; // 写入优先的话，值为true

    public synchronized void readLock() throws InterruptedException {
        while (writingWriters > 0 || (preferWriter && waitingWriters > 0)) {
            wait();
        }
        readingReaders++;                       // (A)实际正在读取的线程数量加1
    }

    public synchronized void readUnlock() {
        readingReaders--;                       // (A)实际正在读取的线程数量减1
        preferWriter = true;
        notifyAll();
    }

    public synchronized void writeLock() throws InterruptedException {
        waitingWriters++;                       // (B)正在等待写入的线程数量加1
        try {
            while (readingReaders > 0 || writingWriters > 0) {
                wait();
            }
        } finally {1
          waitingWriters--;                   // (B)正在等待写入的线程数量减1
        }
        writingWriters++;                       // (C)实际正在写入的线程数量加1
    }

    public synchronized void writeUnlock() {
        writingWriters--;                       // (C)实际正在写入的线程数量减
        preferWriter = false;
        notifyAll();
    }
}

public class Data {
    private final char[] buffer;
    private final ReadWriteLock lock = new ReadWriteLock();
    public Data(int size) {
        this.buffer = new char[size];
        for (int i = 0; i < buffer.length; i++) {
            buffer[i] = '*';
        }
    }
    public char[] read() throws InterruptedException {
        lock.readLock();
        try {
            return doRead();
        } finally {
            lock.readUnlock();
        }
    }
    public void write(char c) throws InterruptedException {
        lock.writeLock();
        try {
            doWrite(c);
        } finally {
            lock.writeUnlock();
        }
    }
    private char[] doRead() {
        char[] newbuf = new char[buffer.length];
        for (int i = 0; i < buffer.length; i++) {
            newbuf[i] = buffer[i];
        }
        slowly();
        return newbuf;
    }
    private void doWrite(char c) {
        for (int i = 0; i < buffer.length; i++) {
            buffer[i] = c;
            slowly();
        }
    }
    private void slowly() {
        try {
            Thread.sleep(50);
        } catch (InterruptedException e) {
        }
    }
}

7.Thread-Per-Message Pattern 在方法的属性处理完成之前，控制权不会从Host参与者退出。如果方法的处理
属性很话费时间，程序的响应性能会降低。解决的方式就在Host的参与者里，启动新的线程，并且将该方法应    该进行的工作交给这个心的线程，这样Client参与者的线程可以继续执行下一个操作，这样做，不用更改    Client参与者的程序代码，并能提高程序的响应性。想节省启动线程所花费的时间，可以使用Worker Thread    Pattern。
public class Host {
    private final Helper helper = new Helper();
    public void request(final int count, final char c) {
        System.out.println("    request(" + count + ", " + c + ") BEGIN");
        new Thread() {
            public void run() {
                helper.handle(count, c);
            }
        }.start();
        System.out.println("    request(" + count + ", " + c + ") END");
    }
}

8.Worker Thread Pattern 如果方法的处理属性很花时间，程序的响应性会降低。为了提供响应性，而启动新
的线程来处理方法时，启动线程所花的时间又会降低throughput。另外当送出的请求太多时，会启动
过多的线程，这会使承载量变差。
public class Channel {
    private static final int MAX_REQUEST = 100;
    private final Request[] requestQueue;
    private int tail; // 下一个putRequest的地方
    private int head; // 下一个takeRequest的地方
    private int count; // Request的数量

    private final WorkerThread[] threadPool;

    public Channel(int threads) {
        this.requestQueue = new Request[MAX_REQUEST];
        this.head = 0;
        this.tail = 0;
        this.count = 0;

        threadPool = new WorkerThread[threads];
        for (int i = 0; i < threadPool.length; i++) {
            threadPool[i] = new WorkerThread("Worker-" + i, this);
        }
    }
    public void startWorkers() {
        for (int i = 0; i < threadPool.length; i++) {
            threadPool[i].start();
        }
    }
    public synchronized void putRequest(Request request) {
        while (count >= requestQueue.length) {
            try {
                wait();
            } catch (InterruptedException e) {
            }
        }
        requestQueue[tail] = request;
        tail = (tail + 1) % requestQueue.length;
        count++;
        notifyAll();
    }
    public synchronized Request takeRequest() {
        while (count <= 0) {
            try {
                wait();
            } catch (InterruptedException e) {
            }
        }
        Request request = requestQueue[head];
        head = (head + 1) % requestQueue.length;
        count--;
        notifyAll();
        return request;
    }
}

9.Future Pattern 当Client会将工作委托给其他线程，而Client参与者希望得到处理的结果。将工作委托给
别人时，如果又等待执行结果，会使响应性降低。
public class FutureData implements Data {
    private RealData realdata = null;
    private boolean ready = false;
    public synchronized void setRealData(RealData realdata) {
        if (ready) {
            return;     // balk
        }
        this.realdata = realdata;
        this.ready = true;
        notifyAll();
    }
    public synchronized String getContent() {
        while (!ready) {
            try {
                wait();
            } catch (InterruptedException e) {
            }
        }
        return realdata.getContent();
    }
}

附多线程程序的评价标准
1、安全性——不损坏对象对象损坏是指对象的状态不符合设计师的原意，通常是获取对象的状态值并非预期值。
2、生存性——进行必要的处理也许不是现在，但是一定会进行必要的处理，如果程序安全了，但是有些必要的处理得不到操作，那么这个多线程程序也是不合格的。
3、复用性——可再利用类写多线程程序，如果能够将多线程的共享和互斥结构隐藏在类里面，这就是一个高度可复印的程序。
4、性能——能快速大量处理主要表现在吞吐量（Throughput）即一定时间内能完成的处理量，能完成的处理量越多，表示数据吞吐量越大；容量（Capacity）指可同时处理的数量；响应性（Responsiveness）指从发出请求到收到响应的时间，时间越短，响应性越高。
5、伸缩性（Scalability）等

前两个是必要条件，后面几个是程序质量的描述

persister 2010-01-31 15:26 发表评论

Java NIO学习笔记二

persister — Tue, 19 Jan 2010 07:44:00 GMT

Java NIO最吸引人的地方是提供了非阻塞的IO，可以方便的编写出高性能的服务器。NIO里面包括Buffer，Channel和Nonblocking IO。如下几篇文章可以参考：
http://www.diybl.com/course/3_program/java/javashl/20081123/152302.html
http://www.javaeye.com/topic/40489
http://dengminhui.javaeye.com/blog/500876
http://blog.csdn.net/lcllcl987/archive/2007/04/16/1566114.aspx

具体可以看O'Reilly.Java.I.O.2nd.Edition.chm，写得非常的详细。

Apahce提供了Java NIO封装的框架Mina。现在发展到2.0，可以用来学习高性能网络编程。

persister 2010-01-19 15:44 发表评论

多线程访问数据库导致内存泄露的优化过程

persister — Thu, 14 Jan 2010 13:11:00 GMT

1、这家公司有一个数据库代理程序，用于数据库服务器的代理，游戏服务器执行sql指令，DBAgent接受此指令，执行一些组织后，调用JDBC执行数据库操作，然后将结果返回。

2、发生的问题：内存一直升高，处理客户端请求的线程并不多（高峰期大概300左右吧），数据库上的连接数也不多（100的样子）。运行5-6天，基本上内存就用完了，而且得不到数据库的连接。他们非常急，我就试着接下这个项目。

3、接到这个优化项目，查看了他们的部分代码。发现连接池写得有些问题，得不到数据库连接后wait，但是不会接到任何有效的notify，也就是说只要一等待就会超时。还有其他的问题，一开始我以为是这个问题，修改后让他们去跑，结果还是一样，内存上去后一直下不来，最后崩溃。

4、通过这个发现就是内存泄露了。一开始用jprofiler测试，发现内存上去后就Out of memory了，而且hashmap和long[]的对象非常多一直下不去。但是找不到这些对象是怎么产生的。折磨了我好几天，还请教了很多人，都得不到答案。后来发现是java启动参数中内存参数设置的太低了，本来需要100多M的内存，你就设置给16M，不崩溃才怪呢。于是改成了128M。结果内存上去之后，到达一个峰值就下来了，然后震荡，但一直就没有上去。那程序没有泄露？可是生产上怎么泄露了呢？

5、就在我基本上要放弃的时候，我想到了测试环境可能真实环境不同，有必要看一下他们生产服务器上虚拟机的运行情况。记得Java有自带的工具查询java虚拟机运行情况的。jmap这个工具可以查看jvm中运行实例的个数以及实例的类名。让他们的人用了下这个工具，将结果发给我了，我一看，吓了一大跳。排在第一位的是int[]，竟然达到了1G。最有问题的是com.mysql.jdbc.PreparedStatement对象，达到了6万多。com.mysql.jdbc.ResultSetImpl和java.util.HashMap$Entry[]也达到了6万多。不用说，肯定是PreparedStatement没有关闭。

6、查看源代码，发现PreparedStatement对象都在finally块中关闭了，怎么会泄露呢？找了1个小时没有找到，就去洗澡了。在洗澡的时候突然想到，里面有一个for循环，PreparedStatement对象可能被赋值N次，那前面的N-1次不就没有关闭啊，对，找到答案了。赶紧擦干身子出来找到那段代码：

1  String[] valuesArray = value.split(";");
2  for (int i = 0 ;i < valuesArray.length;i++){
3
4 String[] valueArray = valuesArray[i].split(",");
10                     ps = conn.prepareStatement(sqlbean.getSql());
11                     for(int k = 0;k 12                         if("s".equalsIgnoreCase(paraTypeArray[k])){
13                             ps.setString(k+1,valueArray[k]);
14                         }else if("i".equalsIgnoreCase(paraTypeArray[k])){
15                             ps.setInt(k+1,Integer.parseInt(valueArray[k]));
16                         }
17                     }
18
19                     rsString = "" + ps.executeUpdate();
20
21 }

确实如此，循环的N-1个PreparedStatement对象没有关闭，导致了泄漏。解决办法就是将
ps = conn.prepareStatement(sqlbean.getSql());

移到for循环的外面，这样就没有问题了。不过从这段代码也可以看出，写得也是在是烂，这个干吗放到
循环的里面呢，本身从语言上来说就有问题。管它呢，解决问题就行了，呵呵。
几乎兴奋了一个晚上。第二天找他们的人一说，他们说是循环N次的，不只是一个值。问题不就解决了？Great。

7、让他们去测试运行吧。运行第一天的晚上九点（这是高峰期）以后，内存非常平稳。问题彻底解决了。

总结这次的优化项目：
对Java虚拟机的认识提高了。对java性能测试工具（JProfiler）更加熟练了，可以和eclipse集成呢，非常方便。

persister 2010-01-14 21:11 发表评论

java多线程设计模式:wait/notify机制

persister — Thu, 03 Dec 2009 06:45:00 GMT

通常，多线程之间需要协调工作。例如，浏览器的一个显示图片的线程displayThread想要执行显示图片的任务，必须等待下载线程 downloadThread将该图片下载完毕。
如果图片还没有下载完，displayThread能暂停，当downloadThread完成了任务后，再通知displayThread“图片准备完毕，能显示了”，这时，displayThread继续执行。　　
以上逻辑简单的说就是：如果条件不满足，则等待。
当条件满足时，等待该条件的线程将被唤醒。
在Java中，这个机制的实现依赖于wait/notify。等待机制和锁机制是密切关联的。
例如：　　

1 synchronized(obj)
2 {　　
3 while(!condition)
4 {
5 　　obj.wait();　　
6
7 }　　
8 obj.doSomething();　　
9 }　

当线程A获得了obj锁后，发现条件condition不满足，无法继续下一处理，于是线程A就wait()。　　在另一线程B中，如果B更改了某些条件，使得线程A的condition条件满足了，就能唤醒线程A：

1 synchronized(obj)
2 {　　
3 condition = true;　　
4 obj.notify();　　
5 }　

需要注意的概念是：　　
# 调用obj的wait(), notify()方法前，必须获得obj锁，也就是必须写在synchronized(obj) {...} 代码段内。　　

# 调用obj.wait()后，线程A就释放了obj的锁，否则线程B无法获得obj锁，也就无法在synchronized(obj) {...} 代码段内唤醒A。　　

# 当obj.wait()方法返回后，线程A需要再次获得obj锁，才能继续执行。　　
# 如果A1,A2,A3都在obj.wait()，则B调用obj.notify()只能唤醒A1,A2,A3中的一个（具体哪一个由JVM决定）。　　
# obj.notifyAll()则能全部唤醒A1,A2,A3，不过要继续执行obj.wait()的下一条语句，必须获得obj锁，因此，A1,A2,A3只有一个有机会获得锁继续执行，例如A1，其余的需要等待A1释放obj锁之后才能继续执行。　　
# 当B调用obj.notify/notifyAll的时候，B正持有obj锁，因此，A1,A2,A3虽被唤醒，不过仍无法获得obj锁。直到B退出synchronized块，释放obj锁后，A1,A2,A3中的一个才有机会获得锁继续执行。

persister 2009-12-03 14:45 发表评论

James配置邮箱服务器

persister — Sun, 15 Nov 2009 07:32:00 GMT

按照网上说的配置好了，具体参考http://blog.csdn.net/ejbcreate/archive/2009/10/22/4712681.aspx 。可是用公司的outlook总是不成功，只能收邮件，不能往其他邮箱发送邮件
后来改成foxmail6，结果就可以了。尝试一下不是用smtp authentication，结果也能发送，吓了一跳
岂不是邮箱服务器变成open relay了，到网上一查，说foxmail4以后的版本默认就加上认证了
也即是说你没选认证的话也会帮你加上，所以不用担心了。
对James邮箱服务器学的还不深，有时候可以研究一下，学学pop和smtp等协议。

persister 2009-11-15 15:32 发表评论

在jsp中怎么实现登录后，自动跳转到登录前正浏览的页面

persister — Mon, 19 Oct 2009 05:58:00 GMT

在jsp中怎么实现登录后，自动跳转到登录前正浏览的页面？就像csdn的一样，

不管你从哪能个页面登录，成功登录后会自动跳转回那个页面。

解决方法一：

登录处理后，返回如下内容：

2 PrintWriter out = response.getWriter();
3
4 out.println("""-//W3C//DTD HTML 4.01 Transitional//EN"">");
7
8 out.println("");
9
11
12 out.println(" ");
13
16 out.println("");
19
20 out.println(" ");
21
22 out.println("");
23
24 out.flush();
25
26 out.close();
27
28 return null;
29

解决方法二：    



1 String referer = req.getHeader("Referer");

2 resp.sendRedirect(referer);
3 return;
4
5

上面两种方法不可取是因为，如果用户登录失败，再次登录的话就会出现登录后返回到登录的错误。



第三种：把你要在跳转时需要保存的信息存放在session变量中，登录后清除这个session。可行。

需要登录操作的页面上面添加：

1 <%
2     if(session.getAttribute("party")== null){
3         if(null != request.getQueryString())
4             session.setAttribute("redirectUrl", request.getRequestURL().append("?").append(request.getQueryString()).toString());
5         else
6             session.setAttribute("redirectUrl", request.getRequestURL().toString());
7         response.sendRedirect(request.getContextPath() +  "/loginto");
8     }
9 %>

在登录处理页面：

1 String redirectUrl = (String)req.getSession().getAttribute("redirectUrl");
2         if(StringUtils.isValid(redirectUrl)){
3             req.getSession().removeAttribute("redirectUrl");
4             resp.sendRedirect(redirectUrl);
5         }

第四种方法：写一个servlet会话判断类，如果在线就继续执行，不在线则提示登录。所有的需要在线操作的
servlet都集成此类，这样就不需要上面那么在每个页面写上这些代码了，可以集中控制。这种方式比较完整。

HttpSession session = request.getSession();

if (session.getAttribute("person") == null)
{
     if (null != request.getQueryString())
                session.setAttribute("redirectUrl", request.getRequestURL().append("?").append(request.getQueryString()).toString());
     else
                session.setAttribute("redirectUrl", request.getRequestURL()
                        .toString());
     response.sendRedirect(request.getContextPath() + "/login.jsp");
     return null;
}

return process(config, request, response);

persister 2009-10-19 13:58 发表评论

java乱码问题网上总结，非常不错

persister — Fri, 16 Oct 2009 02:29:00 GMT

Java开发中经常会遇到乱码问题，下面是几个在开发中应该注意的问题：

1.尽量使用统一的编码，如果你是重头开发一个系统，特别是Java开发的，所有的文件包括js和css，数据库连接都是用UTF-8进行编码。

2.添加Filter进行编码设定，这个是我们经常用的。

3.尽早统一开发环境，早点模拟真实环境测试，平台可能造成乱码问题。

二、乱码发生的情况和应对措施
1.开发环境乱码
      由于Java默认使用UTF-8编码，而且网上很多人都建议Struts开发的时候应尽量选用UTF-8做为默认编码，而非GBK。IDE使用Eclipse，在第一次使用Eclipse的时候应将default text editor改为UTF-8编码。

2.POST请求的过滤
      这个是最基本的了，每个Servlet系统基本都会用到这个东西。不过只对POST请求有效，这个挺关键的。使用SetCharacterEncodingFilter，这个很基础的一套过滤器，将所有来自页面的POST请求全部过滤为UTF-8编码。

3. JSP ,HTML页面乱码
     将JSP页面全部改为charset=UTF-8，这样可以保证与后台交互的时候都是UTF-8编码，一般应用做了以上工作。

就基本可以应付了。

4.资源文件中汉字转化UTF-8字符问题
      国际化问题，在使用资源文件的时候，由于中文在properties文件中无法被程序所识别，需要将其进行转码，我在资源文件下面制作了一个很简单的 bat文件，每次修改资源文件的时候都是在一个临时文件中修改，然后执行这个bat文件，
set path=%path%;%JAVA_HOME%/bin/,native2ascii -encoding UTF-8 ApplicationResources_bk.txt >

ApplicationResources_zh.properties

5. GET请求乱码
      如果在本项目中采用了get方式提交请求并附加参数，结果导致编码乱码，原因是Tomcat默认请求编码是ISO8859，需要在Tomcat的配置文件 server.xml添加一个参数，URIEncoding=”UTF-8”,这样请求中附件的参数就会以UTF-8来进行编码。这个方法不错，将ajax中get方式请求中的中文全处理了。

6.Ajax请求乱码
    使用Ajax，JS 也是默认使用ISO8859编码，所以在进行请求时遇到中文参数需要进行编码，如：var url =

"GetSelectListAction.do?queryData=subTrade" + "&queryId=" + encodeURI(obj.value) + "&r=" +

Math.random();
    这里有两个地方需要注意：第一个地方是encodeURI()，方法，可以将参数进行转码，默认是转化为UTF-8，如果需要转为其他码制，需要在方法中添加第二个参数。
     第二个地方是Math.random()，由于Ajax有缓存机制，在接受请求的时候第一时间先判断该请求的地址是否被访问过，如果被访问过则直接使用缓存中的内容返回，这个东西很讨厌，客户在访问过一次出错后以后每次出现的都是这个错误，所以在请求中给其增加一个时间戳，只要可以随机生成一个不同的字串就可以，保证Ajax每次都去访问服务器。

7. GET方法的另一个乱码问题
      在项目即将交工的时候突然又出现乱码问题，发现对于超长的汉字做为参数传递仍然会出现乱码问题，解决方法是采用java.net.URLEncoder的 Encode方法强制转码，缺点是会使JSP页面代码相当的长，但是目前还没有其他好的解决办法，我想最好的办法就是不用中文做为参数传递：

persister 2009-10-16 10:29 发表评论

apache+tomcat 负载均衡安装配置

persister — Wed, 14 Oct 2009 12:28:00 GMT

1.        操作系统
RedHat Linux
2.        所需软件
Apache 2.2.14 下载地址
http://apache.freelamp.com/httpd/httpd-2.2.14.tar.gz
Tomcat5.5.28    下载地址
http://tomcat.apache.org/download-55.cgi
JK 下载地址
http://apache.etoak.com/tomcat/tomcat-connectors
文件：tomcat-connectors-1.2.28-src.tar.gz

Jdk 1_5_0_04   下载地址
    http://java.sun.com/j2se/1.5.0/download.jsp

备注：下载时将所需软件包文件保存在/opt目录下
3.        安装步骤

A 安装JDK
# cd /opt/
# chmod +x jdk-1_5_0_04-linux-i586-rpm.bin
# ./jdk-1.5.0_04-linux-i586-rpm.bin
# cd /usr/java/
# ln -s /usr/java/jdk-1_5_0_04 /opt/java
# vi /etc/profile

           #添加如下内容

export JAVA_HOME=/opt/java/
export CLASSPATH=.:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
export PATH=.:$JAVA_HOME/bin:$PATH

B 安装Apache

# cd /opt/
# tar xvfz httpd-2.0.54.tar.gz
# cd httpd-2.0.54
#./configure --prefix=/opt/apache --enable-module=so
# make
# make install
# cd /opt/apache/conf
# vi ./httpd.conf

将Listen 80 修改为Listen :80 IP到时候就是自己机器的IP地址，否则
其他机器没法访问你。

将ServerName 修改为ServerName ，这个地方直接127.0.0.1即可。集群的时候会读httpd-vhost.conf

下面是一个配置有关的问题：

修改serverName，重装apache后问题依旧，最后发现host配置不正确，

httpd.conf 中serverName 为www.zudar.com

host 中 127.0.0.1 www.zudar.com

改为 192.168.100.38 www.zudar.com

后正确启动

问题是由于 ip 地址与域名没有正确匹配引起

也就是说host中一点要配置好ip与serverName

hostname与/etc/hosts的关系

很过人一提到更改hostname首先就想到修改/etc/hosts文件，认为hostname的配置文件就是/etc/hosts。其实不是的。

hosts文件的作用相当如DNS，提供IP地址到hostname的对应。早期的互联网计算机少，单机hosts文件里足够存放所有联网计算机。不过随着互联网的发展，这就远远不够了。于是就出现了分布式的DNS系统。由DNS服务器来提供类似的IP地址到域名的对应。具体可以man hosts。

Linux系统在向DNS服务器发出域名解析请求之前会查询/etc/hosts文件，如果里面有相应的记录，就会使用hosts里面的记录。/etc/hosts文件通常里面包含这一条记录
127.0.0.1    localhost.localdomain   localhost

hosts文件格式是一行一条记录，分别是IP地址 hostname aliases，三者用空白字符分隔，aliases可选。

127.0.0.1到localhost这一条建议不要修改，因为很多应用程序会用到这个，比如sendmail，修改之后这些程序可能就无法正常运行。

修改hostname后，如果想要在本机上用newhostname来访问，就必须在/etc/hosts文件里添加一条newhostname的记录。比如我的eth0的IP是192.168.1.61，我将hosts文件修改如下：
#hostname blog.infernor.net
# cat /etc/hosts
127.0.0.1 localhost.localdomain localhost
192.168.1.61    blog.infernor.net       blog

这样，我就可以通过blog或者blog.infernor.net来访问本机。

在DirectoryIndex中添加 index.jsp

         # cd /opt/apache/bin/

# ./apachectl configtest

若显示Syntax ok则表明安装成功

#./apachectl start

启动apache服务，访问本机80端口，查看端口是否正常

# ./apachectl stop

关闭服务

备注：prefix定义apache的安装路径

C 安装Tomcat

         # cd /opt/
         # tar xvfz jakarta-tomcat-5.5.9.tar.gz
         # ln –s /opt/jakarta-tomcat-5.5.9　/opt/tomcat
         # vi /opt/tomcat/bin/catalina.sh

      JAVA_HOME=/opt/java

        启动服务后，访问本机8080端口，查看端口是否正常

# /opt/tomcat/bin/startup.sh /startup.bat

         关闭服务

# /opt/tomcat/bin/shutdown.sh /shutdown.bat

修改各个tomcat的端口（如果两台机器是在不同的主机上，端口可以不动，显然）
tomcat1/conf/server.xml
改为

               maxThreads="150" minSpareThreads="25" maxSpareThreads="75"
               enableLookups="false" redirectPort="8443" acceptCount="100"
               debug="0" connectionTimeout="20000"
               disableUploadTimeout="true" URIEncoding="UTF-8"/>改为
......

作loadbalance的话，上面connector可以注释掉。

               enableLookups="false" redirectPort="8443" debug="0"
               protocol="AJP/1.3" />改为
......


tomcat2/conf/server.xml
改为

               maxThreads="150" minSpareThreads="25" maxSpareThreads="75"
               enableLookups="false" redirectPort="8443" acceptCount="100"
               debug="0" connectionTimeout="20000"
               disableUploadTimeout="true" URIEncoding="UTF-8"/>改为
......
上面这个connector同样也注释掉。

               enableLookups="false" redirectPort="8443" debug="0"
               protocol="AJP/1.3" />改为

D 安装JK

#cd /usr/local/
# tar xzvf jakarta-tomcat-connectors-1.2.14-src.tar.gz
#cd jakarta-tomcat-connectors-1.2.14-src/native
#./buildconf.sh
#./configure --with-apxs=/usr/local/apache/bin/apxs
#make
#make install
#cd /opt/jakarta-tomcat-connectors- jk1.2.14-src/jk/native/apache-2.0/
#cp mod_jk.so /opt/apache/modules/

E 系统整合

#vi /opt/apache/conf/httpd.conf

           在文件最末尾加上如下语句

include conf/mod_jk.conf

# Configure mod_jk.conf

在conf目录下创建mod_jk.conf文件，内容如下：

--------------------------mod_jk.conf--------------------------
# Load mod_jk module
LoadModule jk_module modules/mod_jk.so

# Where to find workers.properties
JkWorkersFile conf/workers.properties

# Where to put jk logs
JkLogFile logs/mod_jk.log

# Set the jk log level [debug/error/info]
JkLogLevel info

# Select the log format
JkLogStampFormat "[%a %b %d %H:%M:%S %Y] "

# JkRequestLogFormat set the request format
JkRequestLogFormat "%w %V %T"

#指定那些请求交给tomcat处理,"controller"为在workers.propertise里指定的负载分配控制器
JkMount /*.jsp loadbalancer（这个loadbalancer是下面worker.list最后一个值）

如果还要指定*.do也进行分流就再加一行
JkMount /*.do loadbalancer

如果你想对所有的请求进行分流只需要写成
JkMount /* loadbalancer

--------------------------mod_jk.conf--------------------------

编辑workers.properties
#vi /opt/apache/conf/workers.properties

#
# workers.properties
#

# list the workers by name

worker.list=tomcat1, tomcat2, loadbalancer

# ------------------------

# First tomcat server

# ------------------------

worker.tomcat1.port=11003
worker.tomcat1.host=127.0.0.1
worker.tomcat1.type=ajp13

# Specify the size of the open connection cache.

#worker.tomcat1.cachesize
#
# Specifies the load balance factor when used with

# a load balancing worker.

# Note:

# ----> lbfactor must be > 0

# ----> Low lbfactor means less work done by the worker.

worker.tomcat1.lbfactor=100

# ------------------------
# Second tomcat server
# ------------------------

worker.tomcat2.port=12003
worker.tomcat2.host=127.0.0.1
worker.tomcat2.type=ajp13

# Specify the size of the open connection cache.
#worker.tomcat2.cachesize
#

# Specifies the load balance factor when used with
# a load balancing worker.
# Note:

# ----> lbfactor must be > 0
# ----> Low lbfactor means less work done by the worker.
worker.tomcat2.lbfactor=100

# ------------------------

# Load Balancer worker

# ------------------------

# The loadbalancer (type lb) worker performs weighted round-robin

# load balancing with sticky sessions.

# Note:

# ----> If a worker dies, the load balancer will check its state

# once in a while. Until then all work is redirected to peer

# worker.
worker.loadbalancer.type=lb
worker.loadbalancer.balanced_workers=tomcat1, tomcat2

#
# END workers.properties
#

cluster配置，如果不配置cluster只是做loadbalance不需要
修改server.xml中的engine
#vi /opt/tomcat/conf/server.xml

在120行左右修改原来的, 添加jvmRoute="tomcat1"

若第二台tomcat，添加jvmRoute的修改为tomcat2

至此，系统已经整个完毕启动apache和tomcat服务如果不放心可以编写一个测试

在其中一个tomcat的webapps中建立一个目录TestCluster，里面新建一个test.jsp,内容为

<%
System.out.println("===========================");
%>

把TestCluster放到tomcat1,tomcat2的webapps下

启动apache,tomcat1,tomcat2,进行测试
通过 http://localhost/TestCluster/test.jsp 访问，多刷新几次页面，查看Tomcat1和Tomcat2 logs目录下面的catalina.out
文件，你将可以看到打印了一行行"==========================="，并且从统计上来说，
大约在tomcat2打印的数量和在Tomcat1中一样，
如果lbfactor不一样的话，可以看到请求会被tomcat1,tomcat2按照不同的权重分流处理,实现了负载均衡。

自动重启

    将如下内容添加至/etc/rc.d/rc.local文件末尾，以便系统启动后开启apache,tomcat服务

/usr/local/tomcat1/bin/startup.sh
/usr/local/tomcat2/bin/startup.sh
/opt/apache/bin/apachectl start

这样做是不是够呢，比如说一个浏览器访问的时候开始被分发给A sever，然后又分发给B server，那么
session里面的数据就不一致了或不正确了。两个问题，一个是apahce已经实现了，对于同一个浏览器通过来的请求会绑定到同一个server，那就没有问题。但是通过下面的测试发现不是的。

  <%@ page contentType="text/html; charset=GBK" %>
<%@ page import="java.util.*" %>
<html><head><title>Cluster App Testtitle>head>
<body>
Server Info:
<%
out.println(request.getLocalAddr() + " : " + request.getLocalPort()+"
");%>
<%
  out.println("
ID " + session.getId()+"
");
  // 如果有新的 Session 属性设置
  String dataName = request.getParameter("dataName");
  if (dataName != null && dataName.length() > 0) {
     String dataValue = request.getParameter("dataValue");
     session.setAttribute(dataName, dataValue);
  }
  out.print("Session 列表");
  Enumeration e = session.getAttributeNames();
  while (e.hasMoreElements()) {
     String name = (String)e.nextElement();
     String value = session.getAttribute(name).toString();
     out.println( name + " = " + value+"
");
         System.out.println( name + " = " + value);
   }
%>
  <form action="index.jsp" method="POST">
    名称:<input type=text size=20 name="dataName">
     <br>
    值:<input type=text size=20 name="dataValue">
     <br>
    <input type=submit>
   form>
body>
html>

是需要其他配置还是？另一个方法就是session的复制，及集群功能。
配置集群的方法参考“链接”中的一篇文章就可以了。

apache和tomcat虚拟机设置：
1，在apache中注销DocumentRoot，ServerName，Directory 等行（Directory包括的也

是）。
2，把conf文件中的Include conf/extra/httpd-vhosts.conf的注销去掉，这个文件专

门用于配置虚拟主机。
3，设置conf文件的listen 为你的ip
4，假设apache的项目在usr/webapps下，项目的域名为www.mydomain.com,并在isp做好

了域名解析指向当前服务器的IP
5，打开conf/extra/httpd-vhosts.conf ,添加如下内容
NameVirtualHost *:80

ServerAdmin admin@yazhouly.cn
ServerName www.mydomain.com
DocumentRoot "/usr/webapps/test"

    Options FollowSymLinks
    AllowOverride None
    Order deny,allow
    Deny from all

    Options Indexes FollowSymLinks
    AllowOverride None
    Order allow,deny
    Allow from all

JkMount /* loadbalancer

其中最后四行表示关于jsp的内容都转交给tomcat处理，虽然我们在配置连接器的时候

，已经配置了，但是在虚拟机设置后，还是要单独加上这几句，其中work就是

mod_jk.conf中配置的代理名。
打开tomcat目录conf下面的server.xml
添加主机信息
            unpackWARs="true" autoDeploy="true"
            xmlValidation="false" xmlNamespaceAware="false">

crossContext="true"/>

保存重新启动apache
在地址栏中输入
www.mydomain.com
就会出现你的首页

遇到的问题
1）启动时产生 Error receiving mcast package
经测试发现，我用的ADSL,如果我联网，则会报这个异常，如果断网则不会产生。看来那个
tcpListenAddress="192.168.0.1"
需要使用外网的IP地址才可以。
2）启动异常，一般是端口被占用
请仔细看各个server.xml配置文件，各个端口不能相同

3)如果不能做cluster只做load balance那么jvm="tomcat1"和jvm="tomcat2"这两部分内容必须保留，
cluster保持注释状态，不需要。

persister 2009-10-14 20:28 发表评论

JspSmart之upload组件源码

persister — Tue, 13 Oct 2009 09:08:00 GMT

摘要: Code highlighting produced by Actipro CodeHighlighter (freeware) http://www.CodeHighlighter.com/ --> 1 File.java 2 3 import&n... 阅读全文

persister 2009-10-13 17:08 发表评论

html中的Image标签及Servlet获取图片

persister — Fri, 02 Oct 2009 06:12:00 GMT

Image属性src是可以设置servlet的路径的，即从servlet获取图片
如在web.xml配置：

GenerateImageServlet

org.bruce.util.GenerateImageServlet

GenerateImageServlet

/getImage

然后在jsp文件中：

这样就可以得到图片了。这里就给动态获取图片提供了一种途径。
比如可以通过src="getImage?id=1000"就可以得到1000号图片。

还可以采用JavaScript onclick方法刷新图片，网上参考资料采用如下方法：

尝试后，发现这种方法无效，由于路径没变，浏览器不会重新发起请求。这里我采用另外一种技巧：

这样由于路径发生了变化，就重新发起请求，轻松实现点击更新图片内容。
在生成验证码的时候这个方法很管用，因为当页面显示的验证码看不清时，应该提供方法重新获取一张。

persister 2009-10-02 14:12 发表评论

hibernate二级缓存

persister — Wed, 30 Sep 2009 11:02:00 GMT

Hibernate二级缓存

在一个数据库系统中，如果缓存设置的合适，那么可以极大的提高系统的效率，Hibernate作为一个ORM工具
提供了缓存的机制，包括一级（Session级）缓存和二级（SessionFactory级）缓存。这里主要总结一下二级缓存。

1.首先需要在hibernate.cfg.xml中配置，当然需要导入缓存的jar包

<property name="hibernate.cache.use_query_cache">trueproperty>
<property name="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProviderproperty>

   hibernate.cache.use_query_cache必须配置，如果想缓存使用findall()、list()、Iterator()、createCriteria()、
   createQuery()等方法获得的数据结果集。

2.在每个实体的hbm文件中配置cache元素，usage可以是read-only或者是read-write等。

<hibernate-mapping>
        <class name="com.xxx.db.base.City" table="city" catalog="haosou">
            <cache usage="nonstrict-read-write"/>
            <id name="citycode" type="string">
                <column name="citycode" />
                <generator class="assigned" />
            id>
            <property name="city" type="string">
                <column name="city" not-null="true" />
            property>
            <set name="districts" table="district" cascade="all" inverse="true">
                <key column="citycode" />
                <one-to-many class="com.haosou.db.base.District"/>
            set>
        class>
    hibernate-mapping>

如果相对具体某个类的缓存进行特定的配置，需要在ehcache.xml进行配置：

3.Query或Criteria()时设置其setCacheable(true);

    Session session = HibernateSessionFactory.getCurrentSession();
    Query q = session.createQuery("from City");
    q.setCacheable(true);
    return q.list();

    Session session = HibernateSessionFactory.getCurrentSession();
    Query q = session.createQuery("from District d where d.city.citycode='" + cityId + "'");
    q.setCacheable(true);
    return q.list();

执行以上代码时，第一次会查询数据库，但是后面就直接从缓存中查询，而不会使用数据库的连接，提高了性能。
以上任一环节都不能少，比如cache元素没有配置，那么就会导致查询district的时候发起N个数据库的连接，这样会极大的降低性能。

persister 2009-09-30 19:02 发表评论

OFBiz的中文乱码解决方案

persister — Mon, 10 Aug 2009 08:58:00 GMT

OFBiz开发时遇到乱码的问题，MySQL数据库插入中文数据时出现了一个问题，报告中文错误：incorrect string value ．．．．．

1.这时由于字符编码不一致导致的，应该将数据库对应的表或coloum改成uft-8，所以如果在CustomerExtra这表中存储中文的话，需要将
此表另外还有operationlog表的charset改成utf-8

2.Servlet中字符显示为证券的中文，而且表也设置为utf-8，但是数据库和页面还是乱码，怎么回事？
这里需要修改jdbc url的参数，如将jdbc:mysql://localhost/ccbportal?zeroDateTimeBehavior=convertToNull
改成：jdbc:mysql://localhost/ccbportal?zeroDateTimeBehavior=convertToNull&useUnicode=true&characterEncoding=UTF-8

3.前台输入的是中文，到后台就变成了乱码，怎么回事？
无论何种表单提交都可以在后台的java文件中通过String des = new String(s.getBytes("iso8859-1"),"UTF-8");
来转换成你想要的UTF－8编码方式。但如果每处都加词句太麻烦，故分post和get两种方式区分提交。
写一个Filter即可解决问题：

1
2  import java.io.IOException;
3  import javax.servlet.ServletException;
4  import javax.servlet.Filter;
5  import javax.servlet.FilterChain;
6  import javax.servlet.FilterConfig;
7
8  import javax.servlet.ServletRequest;
9  import javax.servlet.ServletResponse;
10
11  public class SetCharacterEncodingFilter implements Filter {
12
13   protected String encoding = "GBK";
14
15   protected FilterConfig filterConfig = null;
16
17   protected boolean ignore = true;
18
19   public void init(FilterConfig filterConfig) throws ServletException {
20    this.filterConfig = filterConfig;
21    this.encoding = filterConfig.getInitParameter("encoding");
22    String value = filterConfig.getInitParameter("ignore");
23    if (value == null)
24     this.ignore = true;
25    else if (value.equalsIgnoreCase("true"))
26     this.ignore = true;
27    else if (value.equalsIgnoreCase("yes"))
28     this.ignore = true;
29    else
30     this.ignore = false;
31   }
32
33   public void doFilter(ServletRequest request, ServletResponse response,
34     FilterChain chain) throws IOException, ServletException {
35    // Conditionally select and set the character encoding to be used
36    if (ignore || (request.getCharacterEncoding() == null)) {
37     String encoding = selectEncoding(request);
38     if (encoding != null) {
39      request.setCharacterEncoding(encoding);
40     }
41
42    }
43    // Pass control on to the next filter
44    chain.doFilter(request, response);
45   }
46
47   protected String selectEncoding(ServletRequest request) {
48    return (this.encoding);
49   }
50
51   public void destroy() {
52    this.encoding = null;
53    this.filterConfig = null;
54   }
55  }
56

web.xml添加此Filter：

1  <filter>
2   <filter-name>encodeFilterfilter-name>
3   <filter-class> com.aicent.ccb.filter.SetCharacterEncodingFilterfilter-class>
4   <init-param>
5    <param-name>encodingparam-name>
6    <param-value>GBKparam-value>
7   init-param>
8   <init-param>
9    <param-name>ignoreparam-name>
10    <param-value>trueparam-value>
11   init-param>
12  filter>
13  <filter-mapping>
14   <filter-name>encodeFilterfilter-name>
15   <url-pattern>/control/*url-pattern>
16  filter-mapping>

persister 2009-08-10 16:58 发表评论

Java里面中文排序问题

persister — Sun, 12 Jul 2009 13:07:00 GMT

package com.liuby.test;

import java.text.Collator;
import java.util.Arrays;
import java.util.Locale;

public class SortingChinese {
public static void main(String[] args) {
  String[] names = { "张山", "李四", "王五", "爱情", "幸福", "English", "EngTi", "EngMi", "王六", "郑森", "郑"};
  Arrays.sort(names, Collator.getInstance(Locale.CHINA));
  for (int i = 0; i < names.length; i++)
   System.out.println(names[i]);
//  English
//  EngMi
//  EngTi
//  爱情
//  李四
//  王六
//  王五
//  幸福
//  张山
//  郑
//  郑森
}
}

persister 2009-07-12 21:07 发表评论

JDBM学习八（Record）

persister — Tue, 19 May 2009 02:47:00 GMT

1.record概念

Record是从使用者角度来说的，如使用PhysicalRowIdManager插入一个10000byte的Record

byte[] data = TestUtil.makeRecord(10000, (byte) 1);

Location loc = physMgr.insert( data, 0, data.length );

每一个记录都会被DataPage和RecordHeader进行封装：

    curBlock = file.get( start );
    curPage = DataPage.getDataPageView( curBlock );
    curPage.setFirst( DataPage.O_DATA );
    RecordHeader hdr = new RecordHeader( curBlock, DataPage.O_DATA );
    hdr.setAvailableSize( 0 );
    hdr.setCurrentSize( 0 );

一个BlockIo最多只能存储8164（RecordFile.BLOCK_SIZE - DataPage.O_DATA - RecordHeader.SIZE）个bytes
如果不需要RecordHeader（这个BlockIo全都是data，不需要RecordHeader），那么可以存储8172（RecordFile.BLOCK_SIZE - DataPage.O_DATA）个bytes。两者相差RecordHeader.SIZE（8）个bytes。

    curBlock = file.get( start );
    curPage = DataPage.getDataPageView( curBlock );
    curPage.setFirst( (short) 0 ); // no rowids, just data

上面最后一行代码curPage.setFirst( (short) 0 )并不是说从0的位置开始可以存储数据，而是从DataPage.O_DATA（20）开始存储数据：

       if ( leftToWrite > 0 ) {
                block = file.get( curs.next() );
                dataOffset = DataPage.O_DATA;
        }

2.JDBM效率

顺序插入记录的时候，BlockIo能够非常紧凑的使用，不会出现多余的空间遗漏，比如上面插入10000个bytes，那么第二次插入10000时，那么从第一次结束的地方开始（第二个BlockIo的offset为10000-8164+20=1856）安排第一个记录。但是如果一旦出现update的情况则不一样了，比如10000个bytes的记录被update成20000个bytes，JDBM会释放这个10000bytes的空间，在FREEPHYSIDS_PAGE中就多一个10000bytes的slot待使用。这个时候如果插入一个20bytes的记录，那么就独占这个10000bytes的空间，这就造成空间浪费。这种策略只适合查询较多的情况，不适合频繁的更新，当然可以优化，只从这个slot中取20+28个bytes空间，其他的依然放在这个slot中待使用。如果有时间，我想试试。

persister 2009-05-19 10:47 发表评论

JDBM学习七（部分总结）

persister — Mon, 18 May 2009 07:35:00 GMT

1.RecordFile
从RecordFile的commit方法部分代码：
if (transactionsDisabled) {
                long offset = node.getBlockId() * BLOCK_SIZE;
                file.seek(offset);
                file.write(node.getData());
                node.setClean();
                free.add(node);
            }
可以断定，File被均匀（大小都为BLOCK_SIZE=8192）的分成N个BlockIo。每一个
BlockIo都有一个BlockId,BlockId是从0开始顺序递增的，这样只要知道这个BlockId
也就可以知道BlockIo的在RecordFile的位置了。
-----------------------------------------------------------------
|0   BlockIo                                                                               |8192
-----------------------------------------------------------------
|1   BlockIo                                                                               |8192
-----------------------------------------------------------------
|2   BlockIo                                                                               |8192
-----------------------------------------------------------------
.
.
.
-----------------------------------------------------------------
|n   BlockIo                                                                               |8192
-----------------------------------------------------------------

从getNewNode方法可以知道，BlockIo不是从RecordFile里面生成出来的，而是
直接new一个出来。因为RecordFile持有的是RandomAccessFile，即如果你要往里面
写数据你就直接写好了。先New一个BlockIo，往BlockIo里面填值以后，你要close或者
commit，那么就把BlockIo里面的数据写到这个RandomAccessFile里面就是了。
    private BlockIo getNewNode(long blockid)
    throws IOException
    {

        BlockIo retval = null;
        if (!free.isEmpty()) {
            retval = (BlockIo) free.removeFirst();
        }
        if (retval == null)
            retval = new BlockIo(0, new byte[BLOCK_SIZE]);

        retval.setBlockId(blockid);
        retval.setView(null);
        return retval;
    }

2.PageHeader
Pageheader对每一个（应该是除了第0个，第0个被FileHeader封装）BlockIo封装，PageHeader还维护
着前一个和后一个BlockIo，即通过PageHeader可以将所有的BlockIo串起来。被PageHeader封装的BlockIo
也就被称为一个Page

3.PageManager
PageManager实现了对Page的管理，包括对Page的allocate和free，获取第一个和最后一个Page，一个特定Page的前后Page，
以及RecordFile的commit和rollback。

4.PhysicalRow
PhysicalRowId，FreePhysicalRowId，FreePhysicalRowIdPage和FreePhysicalRowIdPageManager对BLockIo进行更细粒度的管理。每一个BlockIo被分成一个个PhysicalRowId（Id这个取名有歧义，其实就是BlockIo的一部分），
当然一个FreePhysicalRowId也可能跨越几个BlockIo。PhysicalRowId包含一个
Block Number和一个Offset，FreePhysicalRowId还有一个size来表示这块PhysicalRowId的size是多少。

FreePhysicalRowIdPage继承PageHeader，持有ELEMS_PER_PAGE(583)个FreePhysicalRowId供分配或者释放管理：

// slots we returned.
FreePhysicalRowId[] slots = new FreePhysicalRowId[ELEMS_PER_PAGE];

为了记录分配的个数，有一个setCount方法。和PageHeader将BlockIo封装起来并且维护前后的BlockIo不同，
FreePhysicalRowIdPage维护free的PhysicalRowId，这些Id是以一个数组组织起来的。相同的是都对BlockIo
进行封装：
BlockIo curBlock = _file.get(freePage);
FreePhysicalRowIdPage fp = FreePhysicalRowIdPage
   .getFreePhysicalRowIdPageView(curBlock);
int slot = fp.getFirstFree();
if (slot != -1) {
  free = fp.alloc(slot); //这里调用了FreePhysicalRowIdPage的setCount操作，
           //这个count会写到BlockIo里面进行记录

  break;
}

_file.release(curBlock);

从这里可以看到：BlockIo除了被PageHeader封装外，还会被FreePhysicalRowIdPage封装，只是FreePhysicalRowIdPage
可能不会封装每一个BlockIo，只是free的这块而已。

这些FreePhysicalRowId拥有同样的BlockIo，offset具有一定规律：

    /** Returns the value of the indicated slot */
    FreePhysicalRowId get(int slot) {
if (slots[slot] == null)
slots[slot] = new FreePhysicalRowId(block, slotToOffset(slot)); //这时的offset只是区分，没有实际意思
return slots[slot];
    }

    /** Converts slot to offset */
    short slotToOffset(int slot) {
return (short) (O_FREE +
(slot * FreePhysicalRowId.SIZE)); //即相差FreePhysicalRowId.SIZE，14个byte
    }

FreePhysicalRowId的使用大致是这样的：

byte[] data = TestUtil.makeRecord(10000, (byte) 1);

Location loc = physMgr.insert( data, 0, data.length );

data = TestUtil.makeRecord(20000, (byte) 2);

Location loc2 = physMgr.update(loc, data, 0, data.length );

当更新的时候，数据量变大了，那么前面的10000byte容量放不下20000个，那么就释放掉10000这块容量：

free( loc )具体代码如下：

free( Location id )
        throws IOException
    {
        // get the rowid, and write a zero current size into it.
        BlockIo curBlock = file.get( id.getBlock() );
        DataPage curPage = DataPage.getDataPageView( curBlock );
        RecordHeader hdr = new RecordHeader( curBlock, id.getOffset() );
        hdr.setCurrentSize( 0 );
        file.release( id.getBlock(), true );

        // write the rowid to the free list
        freeman.put( id, hdr.getAvailableSize() );
    }
最后调用的是FreePhysicalRowIdPageManager的put方法：

        /**
* Puts the indicated rowid on the free list
*/
void put(Location rowid, int size) throws IOException {

  FreePhysicalRowId free = null;
  PageCursor curs = new PageCursor(_pageman, Magic.FREEPHYSIDS_PAGE);
  long freePage = 0;
  while (curs.next() != 0) {
   freePage = curs.getCurrent();
   BlockIo curBlock = _file.get(freePage);
   FreePhysicalRowIdPage fp = FreePhysicalRowIdPage
     .getFreePhysicalRowIdPageView(curBlock);
   int slot = fp.getFirstFree();
   if (slot != -1) {
    free = fp.alloc(slot);
    break;
   }

   _file.release(curBlock);
  }
  if (free == null) {
   // No more space on the free list, add a page.
   freePage = _pageman.allocate(Magic.FREEPHYSIDS_PAGE);
   BlockIo curBlock = _file.get(freePage);
   FreePhysicalRowIdPage fp = FreePhysicalRowIdPage
     .getFreePhysicalRowIdPageView(curBlock);
   free = fp.alloc(0);
  }

  free.setBlock(rowid.getBlock());
  free.setOffset(rowid.getOffset());
  free.setSize(size);
  _file.release(freePage, true);
}

    最后几行代码就是对FreePhysicalRowId对象进行了设置，以供后面使用，见PhysicalRowIdManager的alloc方法：

    alloc( int size )
        throws IOException
    {
        Location retval = freeman.get( size );
        if ( retval == null ) {
            retval = allocNew( size, pageman.getLast( Magic.USED_PAGE ) );
        }
        return retval;
    }

    FreePhysicalRowIdPageManager的get( size )方法有如下代码：
    int slot = fp.getFirstLargerThan(size)
    retval = new Location(fp.get(slot)); //fp.get(slot)返回一个FreePhysicalRowId，Location根据FreePhysicalRowId进行设置
    return retval;

    FreePhysicalRowIdPage的getFirstLargerThan(size):
        /**
* Returns first slot with available size >= indicated size, or -1 if no
* slots are available.
**/
int getFirstLargerThan(int size) {
  for (int i = 0; i < ELEMS_PER_PAGE; i++) {
   if (isAllocated(i) && get(i).getSize() >= size) //getSize会取到前面的setSize的值
    return i;
  }
  return -1;
}

    Location的构造方法如下：
     /**
     * Creates a location based on the data of the physical rowid.
     */
    Location(PhysicalRowId src) {
        block = src.getBlock();
        offset = src.getOffset();
    }

FreePhysicalRowIdPageManager只有两个方法，是对FreePhysicalRowIdPage进行管理的。类似于
/**
* Returns a free physical rowid of the indicated size, or null if nothing
* was found.
*/
Location get(int size)

/**
* Puts the indicated rowid on the free list
*/
void put(Location rowid, int size)

persister 2009-05-18 15:35 发表评论

JDBM学习六（Physical Row）

persister — Wed, 13 May 2009 05:26:00 GMT

PhysicalRowId:A physical rowid is nothing else than a pointer to a physical location
in a file - a (block, offset) tuple.
里面有方法：
/** Returns the block number */
    long getBlock() {
        return block.readLong(pos + O_BLOCK);
    }

    /** Sets the block number */
    void setBlock(long value) {
        block.writeLong(pos + O_BLOCK, value);
    }
    还不是很明白这个block number和rowid是什么关系，好像这个number的设置是很自由的，奇怪
FreePhysicalRowId:This class extends the physical rowid with a size value to indicated
the size of a free rowid on the free rowid list.
这个类就是比PhysicalRowId多了一个size的设置，这个size是a free rowid的，不是很明白这句话,rowid需要这个size干吗？

FreePhysicalRowId id = ......
id.setBlock(1);
id.setOffset((short) 2);
id.setSize(3);

FreePhysicalRowIdPage:describe a page that holds physical rowids that were freed.
这个类管理rowid，其主要方法如下：

    // slots we returned.
    FreePhysicalRowId[] slots = new FreePhysicalRowId[ELEMS_PER_PAGE];

    /** Returns the number of free rowids */
    short getCount() {
return block.readShort(O_COUNT);
    }

    /** Sets the number of free rowids */
    private void setCount(short i) {
block.writeShort(O_COUNT, i);
    }

    /** Frees a slot */
    void free(int slot) {
get(slot).setSize(0);
setCount((short) (getCount() - 1));
    }

    /** Allocates a slot */
    FreePhysicalRowId alloc(int slot) {
setCount((short) (getCount() + 1));
return get(slot);
    }

    /** Returns true if a slot is allocated */
    boolean isAllocated(int slot) {
return get(slot).getSize() != 0;
    }

    /** Returns true if a slot is free */
    boolean isFree(int slot) {
return !isAllocated(slot);
    }


    /** Returns the value of the indicated slot */
    FreePhysicalRowId get(int slot) {
if (slots[slot] == null)
      slots[slot] = new FreePhysicalRowId(block, slotToOffset(slot));;
return slots[slot];
    }

    /** Converts slot to offset */
    short slotToOffset(int slot) {
return (short) (O_FREE +
      (slot * FreePhysicalRowId.SIZE));
    }

    /**
     * Returns first free slot, -1 if no slots are available
     */
    int getFirstFree() {
for (int i = 0; i < ELEMS_PER_PAGE; i++) {
      if (isFree(i))
    return i;
}
return -1;
    }

    /**
     * Returns first slot with available size >= indicated size,
     * or -1 if no slots are available.
     **/
    int getFirstLargerThan(int size) {
for (int i = 0; i < ELEMS_PER_PAGE; i++) {
      if (isAllocated(i) && get(i).getSize() >= size)
    return i;
}
return -1;
    }

以上主要是进行分配和释放工作，最后两个方法用于查找第一个free的slot和根据size查找slot，很有用，要记住。
在db中，一个库包含多个table，一个table包含多个记录。一个RecordFile应该就是一个db吧。

FreePhysicalRowIdPageManager：manages free physical rowid pages and provides methods
to free and allocate physical rowids on a high level.
它有两个成员变量：
    // our record file
    protected RecordFile _file;

// our page manager
protected PageManager _pageman;

RecordFile和PageManager这两个类前面都有研究，应该不是问题。FreePhysicalRowIdPageManager
只有两个方法：

    /**
     * Returns a free physical rowid of the indicated size, or
     * null if nothing was found.
     */
    Location get( int size )

    /**
     * Puts the indicated rowid on the free list
     */
    void put(Location rowid, int size)

这里的get方法很重要，从这个方法里面可以看出数据文件的组织方式：

    /**
     * Returns a free physical rowid of the indicated size, or
     * null if nothing was found.
     */
    Location get( int size )
        throws IOException
    {
        // Loop through the free physical rowid list until we find
        // a rowid that's large enough.
        Location retval = null;
        PageCursor curs = new PageCursor( _pageman, Magic.FREEPHYSIDS_PAGE );

        while (curs.next() != 0) {
            FreePhysicalRowIdPage fp = FreePhysicalRowIdPage
                .getFreePhysicalRowIdPageView( _file.get( curs.getCurrent() ) );
            int slot = fp.getFirstLargerThan( size );
            if ( slot != -1 ) {
                // got one!
                retval = new Location( fp.get( slot ) );

                int slotsize = fp.get( slot ).getSize();
                fp.free( slot );
                if ( fp.getCount() == 0 ) {
                    // page became empty - free it
                    _file.release( curs.getCurrent(), false );
                    _pageman.free( Magic.FREEPHYSIDS_PAGE, curs.getCurrent() );
                } else {
                    _file.release( curs.getCurrent(), true );
                }

                return retval;
            } else {
                // no luck, go to next page
                _file.release( curs.getCurrent(), false );
            }

        }
        return null;
    }
当保存数据时，先得到FreePhysicalRowIdPage里面去查有没有合适大小的slot可用。得到合适的slot后，就得到了
FreePhysicalRowId。FreePhysicalRowId持有size信息，这个size前面没有搞清楚，到这里就清楚了，其实是可存放
数据文件的size。FreePhysicalRowId还持有BlockIo和offset信息，这个被Location使用，get方法最后也是返回Location对象。

PhysicalRowIdManager：manages physical row ids, and their data.

persister 2009-05-13 13:26 发表评论

JDBM学习五（PageManager）

persister — Tue, 12 May 2009 07:30:00 GMT

1.PageHeader
PageManager有一个成员变量FileHeader，FileHeader represents a file header. It is a 1:1 representation of the data
that appears in block 0 of a file.FileHeader主要是存储了一些数值：offset和blockid。这些数值是用一个也是RecordFile的第一个BLockIo对象进行存储的，所以它有一个BlockIo的引用。
先看其成员变量：
    // offsets
    private static final short O_MAGIC = 0; // short magic
    private static final short O_LISTS = Magic.SZ_SHORT; // long[2*NLISTS]
    private static final int O_ROOTS =
        O_LISTS + (Magic.NLISTS * 2 * Magic.SZ_LONG);

// my block
private BlockIo block;

O_MAGIC表示FileHeader标示的位置：block.writeShort(O_MAGIC, Magic.FILE_HEADER)向0的位置写入
FileHeader的文件头。

O_LISTS标示LISTS的offset的位置，显然前面是short类型的变量，所以O_LISTS = Magic.SZ_SHORT
O_ROOTS = O_LISTS + (Magic.NLISTS * 2 * Magic.SZ_LONG) Magic.NLISTS等于5，即五个List：
short FREE_PAGE = 0;
short USED_PAGE = 1;
short TRANSLATION_PAGE = 2;
short FREELOGIDS_PAGE = 3;
short FREEPHYSIDS_PAGE = 4;
乘2则表示每隔List需要使用2个Magic.SZ_LONG长度，FIleHeader使用2个Magic.SZ_LONG长度的来记录当前list
中第一个和最后一个block的offset：
     /**
     * Returns the first block of the indicated list
     */
    long getFirstOf(int list) {
        return block.readLong(offsetOfFirst(list));
    }

    /**
     * Sets the first block of the indicated list
     */
    void setFirstOf(int list, long value) {
        block.writeLong(offsetOfFirst(list), value);
    }
    上面的getFirstOf和setFirstOf中输入的参数int list是0~4的值，即上面的5中list的类型值
    即getFirstOf和setFirstOf式获取和设置相应list第一个block顺序号的大小
    而下面是设置最后一个block顺序号的大小。

     /**
     * Returns the last block of the indicated list
     */
    long getLastOf(int list) {
        return block.readLong(offsetOfLast(list));
    }

    /**
     * Sets the last block of the indicated list
     */
    void setLastOf(int list, long value) {
        block.writeLong(offsetOfLast(list), value);
    }

    /** Returns the offset of the "first" block of the indicated list */
    private short offsetOfFirst(int list) {
        return (short) (O_LISTS + (2 * Magic.SZ_LONG * list));
    }

    /** Returns the offset of the "last" block of the indicated list */
    private short offsetOfLast(int list) {
        return (short) (offsetOfFirst(list) + Magic.SZ_LONG);
    }

2.PageManager
PageManager管理5个LinkedList，每一个type有一个LinkedList，LinkedList里面的元素就是BlockIo对象。这些LinkedList构成了
RecordFile对象。一个PageManager只有一个FileHeader。

    // our record file
    private RecordFile file;
    // header data
    private FileHeader header;
    private BlockIo headerBuf;

    /**
     * Creates a new page manager using the indicated record file.
     */
    PageManager(RecordFile file) throws IOException {
        this.file = file;

        // check the file header. If the magic is 0, we assume a new
        // file. Note that we hold on to the file header node.
        headerBuf = file.get(0);
        if (headerBuf.readShort(0) == 0)
            header = new FileHeader(headerBuf, true);
        else
            header = new FileHeader(headerBuf, false);
    }

PageHeader对BlockIo进行了封装，也就是说LinkedList里面元素实际上市PageHeader对象。但是这是为什么呢？
这个PageHeader主要是做什么的？而且这写是怎么关联起来的呢？下面在PageManager的allocate方法有几行代码
可能帮助理解：
buf = file.get(oldLast);
pageHdr = PageHeader.getView(buf);
pageHdr.setNext(retval);
file.release(oldLast, true);
每一个BlockIo都需要一个PageHeader，这点我真是不大理解，PageHeader，这个Page到底是什么？难道
每一个BlockIo都是一个Page？PageHeader的主要方法就是设置next和previous：

    /** Returns the next block. */
    long getNext() {
        paranoiaMagicOk();
        return block.readLong(O_NEXT);
    }

    /** Sets the next block. */
    void setNext(long next) {
        paranoiaMagicOk();
        block.writeLong(O_NEXT, next);
    }

    /** Returns the previous block. */
    long getPrev() {
        paranoiaMagicOk();
        return block.readLong(O_PREV);
    }

    /** Sets the previous block. */
    void setPrev(long prev) {
        paranoiaMagicOk();
        block.writeLong(O_PREV, prev);
    }

next和previous的id放在O_NEXT和O_PREV的位置。

3.PageHeader的作用

PageHeader类构造函数有一个参数BlockIo block，注释应为@param block The block that contains the page header
而不是@param block The block that contains the file header。

这基本可以确定，每一个BLockIo都有一个PageHeader，这些PageHeader构成一个LinkedList。
那么怎么得到这些LinkedList里面的对象呢？看一下PageManager这些方法就知道了：
    /**
     * Returns the page following the indicated block
     */
    long getNext(long block) throws IOException {
        try {
            return PageHeader.getView(file.get(block)).getNext();
        } finally {
            file.release(block, false);
        }
    }

    /**
     * Returns the page before the indicated block
     */
    long getPrev(long block) throws IOException {
        try {
            return PageHeader.getView(file.get(block)).getPrev();
        } finally {
            file.release(block, false);
        }
    }

    /**
     * Returns the first page on the indicated list.
     */
    long getFirst(short type) throws IOException {
        return header.getFirstOf(type);
    }

    /**
     * Returns the last page on the indicated list.
     */
    long getLast(short type) throws IOException {
        return header.getLastOf(type);
    }

其实一般不会这么直接获取，而是通过如下的代码进行的：
RecordFile f = new RecordFile(TestRecordFile.testFileName);
        pm = new PageManager(f);
        PageCursor curs = new PageCursor(pm, Magic.USED_PAGE);
        long i = 1;
        while (true) {
            long cur = curs.next();
            if (cur == 0)
          break;
            //对cur进行操作
        }
        pm.close();
        f.close();

persister 2009-05-12 15:30 发表评论

JDBM学习四（RecordFile）

persister — Mon, 11 May 2009 05:36:00 GMT

1.BlockIo状态迁移
RecordFile是很重要的一个类，几个重要的变量：

final TransactionManager txnMgr;
private final LinkedList free = new LinkedList();
private final HashMap inUse = new HashMap();
private final HashMap dirty = new HashMap();
private final HashMap inTxn = new HashMap();
private RandomAccessFile file;

free是一个LinkedList，FIFO.其他几个维护着BlockIo对象的状态，如果BlockIo对象
从free里面取出来了，那么它的状态就是inUse了，所以RecordFile类get方法最后
会将BlockIo对象放到inUse的Map中：

BlockIo node；
......
inUse.put(key, node);
node.setClean(); //注意此时node被设置为dirty=false，也就是说BlockIo也有dirty这个指标
return node;

inUse的BlockIo对象如果被修改了，那么它的状态就变成dirty了。由于从inUse中取出的对象是否发生
了改变RecordFile对象不知道，需要调用者调用一个方法release:

/**
* Releases a block.
*
* @param blockid The record number to release.
* @param isDirty If true, the block was modified since the get().
*/
void release(long blockid, boolean isDirty)
throws IOException {
  BlockIo node = (BlockIo) inUse.get(new Long(blockid));
  if (node == null)
      throw new IOException("bad blockid " + blockid + " on release");
  if (!node.isDirty() && isDirty)
      node.setDirty();
  release(node);
}

/**
* Releases a block.
*
* @param block The block to release.
*/
void release(BlockIo block) {
  Long key = new Long(block.getBlockId());
  inUse.remove(key);
  if (block.isDirty()) {
      // System.out.println( "Dirty: " + key + block );
      dirty.put(key, block);
  } else {
      if (!transactionsDisabled && block.isInTransaction()) {
          inTxn.put(key, block);
      } else {
          free.add(block);
      }
  }
}

release方法输入两个参数，其中一个是isDirty，如果取出来的BlockIo对象修改了
就应该将isDirty置为true，否则修改不会被保存。也就是说修改后，BlockIo对象
被放入map dirty中。
release以后，BlockIo对象可能有三个状态，首先它会从inUse map里面删除。如果
BlockIo对象被修改，则被放入dirty map中。如果没有修改，就有可能放入free map中。

做完修改后，可以关闭这个RecordFile对象。

RecordFile file = new RecordFile( testFileName );
        byte[] data = file.get( 0 ).getData();
        data[ 14 ] = (byte) 'b';
        file.release( 0, true );
        file.close();

close方法的工作如下：

void close() throws IOException {
         if (!dirty.isEmpty()) {
             commit();
         }
         txnMgr.shutdown();
         ......
         file.close(); //此时RandomAccessFile对象close
         file = null;
    }

可以看到close方法里面主要就是commit这个事务：

for (Iterator i = dirty.values().iterator(); i.hasNext(); ) {
            BlockIo node = (BlockIo) i.next();
            i.remove();
            // System.out.println("node " + node + " map size now " + dirty.size());
            if (transactionsDisabled) {
                long offset = node.getBlockId() * BLOCK_SIZE;
                file.seek(offset);
                file.write(node.getData());
                node.setClean();
                free.add(node);
            }
            else {
                txnMgr.add(node);
                inTxn.put(new Long(node.getBlockId()), node);
            }
        }

如果transaction被disable，那么每一个节点进行更新，如下：
long offset = node.getBlockId() * BLOCK_SIZE;
        file.seek(offset);
        file.write(node.getData());
        node.setClean();
        free.add(node);
从最后一行，BlockIo对象node的状态重新变为free。以上状态的变化是如下一个循环：
free -> inUse -> dirty -> inTxn -> free

2.BlockIo的获取
RecordFile对应两个文件，一个是.db文件，另一个是.lg文件。缓存对象即BlockIo是操作
的最小单元，在get方法中，如果指定的blockid不在inTxn,dirty和free中，那么通过
getNewNode(blockid)得到一个新的BlockIo对象，如果blockid在有效范围内（这个判断是通过
计算offset得到的，offset=blockid*BLOCK_SIZE，offset小于.db文件的大小，那说明blockid对应
的数据块在文件内），那么就从.db文件中读取去blockid对应的数据库。如果不在有效范围内，那么
数据块就是cleanData的copy，即A block of clean data。

// get a new node and read it from the file
         node = getNewNode(blockid);
         long offset = blockid * BLOCK_SIZE;
         if (file.length() > 0 && offset <= file.length()) {
             read(file, offset, node.getData(), BLOCK_SIZE);
         } else {
             System.arraycopy(cleanData, 0, node.getData(), 0, BLOCK_SIZE);
         }
         inUse.put(key, node);
         node.setClean();
         return node;

这里getNewNode()方法如下：
    private BlockIo getNewNode(long blockid)
    throws IOException
    {

        retval.setBlockId(blockid);
        retval.setView(null);
        return retval;
    }

getNewNode()不是直接new BlockIo()，而是从free中取，free中的
BlockIo对象没有被使用，则直接利用，采取的方式是Least Recently Used策略。BlockIo实现了自定义的Externalizable
序列化：
    // implement externalizable interface
    public void readExternal(ObjectInput in)
    throws IOException, ClassNotFoundException {
        blockId = in.readLong();
        int length = in.readInt();
        data = new byte[length];
        in.readFully(data);
    }

    // implement externalizable interface
    public void writeExternal(ObjectOutput out) throws IOException {
        out.writeLong(blockId);
        out.writeInt(data.length);
        out.write(data);
    }

3.TransactionManager的事务处理

序列化用在事务这块，如果没有启动事务，RecordFile直接写到.db文件中，不会进行序列化操作。

RecordFile演示了事务的操作：
final TransactionManager txnMgr;
......
txnMgr = new TransactionManager(this);
......
if (!transactionsDisabled) {
            txnMgr.start();
        }
        ......
        if (!transactionsDisabled)
     txnMgr.add(node);

......
if (!transactionsDisabled) {
            txnMgr.commit();
        }
        ......
        txnMgr.shutdown();

以上是一个完整的事务过程，下面对以上过程发生的操作深入阐述：

TransactionManager(this)以RecordFile作为参数进行构造：
TransactionManager(RecordFile owner) throws IOException {
     this.owner = owner;
     recover();
     open();
}

TransactionManager持有RecordFile的引用，然后进行recover和open操作。recover主要是
对log file进行操作，如果有事务没有执行，那么执行事务将log file中的数据写到.db文件中
并且对RecordFile进行sync()操作，最后把log file删除。

    private void recover() throws IOException {
        String logName = makeLogName();
        File logFile = new File(logName);
        if (!logFile.exists())
            return;
        if (logFile.length() == 0) {
            logFile.delete();
            return;
        }

FileInputStream fis = new FileInputStream(logFile);
ObjectInputStream ois = new ObjectInputStream(fis);

        try {
            if (ois.readShort() != Magic.LOGFILE_HEADER)
                throw new Error("Bad magic on log file");
        } catch (IOException e) {
            // corrupted/empty logfile
            logFile.delete();
            return;
        }

        while (true) {
            ArrayList blocks = null;
            try {
                blocks = (ArrayList) ois.readObject();
            } catch (ClassNotFoundException e) {
                throw new Error("Unexcepted exception: " + e);
            } catch (IOException e) {
                // corrupted logfile, ignore rest of transactions
                break;
            }
            synchronizeBlocks(blocks.iterator(), false);

            // ObjectInputStream must match exactly each
            // ObjectOutputStream created during writes
            try {
                ois = new ObjectInputStream(fis);
            } catch (IOException e) {
                // corrupted logfile, ignore rest of transactions
                break;
            }
        }
        owner.sync();
        logFile.delete();
    }

open的操作相对简单很多，只是进行一些初始化赋值工作：

    /** Opens the log file */
    private void open() throws IOException {
        fos = new FileOutputStream(makeLogName());
        oos = new ObjectOutputStream(fos);
        oos.writeShort(Magic.LOGFILE_HEADER);
        oos.flush();
        curTxn = -1;
    }

下一步就是start这个txnMgr了：
    void start() throws IOException {
        curTxn++;
        if (curTxn == _maxTxns) {
            synchronizeLogFromMemory();
            curTxn = 0;
        }
        txns[curTxn] = new ArrayList();
    }
start的时候就将当前事务数增加1，如果当前事务数等于设置的最大事务数，就进行sync处理。
sync处理的代码如下：

/** Synchs in-core transactions to data file and opens a fresh log */
private void synchronizeLogFromMemory() throws IOException {
close();

TreeSet blockList = new TreeSet( new BlockIoComparator() );

        int numBlocks = 0;
        int writtenBlocks = 0;
        for (int i = 0; i < _maxTxns; i++) {
            if (txns[i] == null)
                continue;
            // Add each block to the blockList, replacing the old copy of this
            // block if necessary, thus avoiding writing the same block twice
            for (Iterator k = txns[i].iterator(); k.hasNext(); ) {
                BlockIo block = (BlockIo)k.next();
                if ( blockList.contains( block ) ) {
                    block.decrementTransactionCount();
                }
                else {
                    writtenBlocks++;
                    boolean result = blockList.add( block );
                }
                numBlocks++;
            }

            txns[i] = null;
        }
        // Write the blocks from the blockList to disk
        synchronizeBlocks(blockList.iterator(), true);

        owner.sync();
        open();
    }

sync的主要操作就是synchronizeBlocks操作：
    private void synchronizeBlocks(Iterator blockIterator, boolean fromCore)
    throws IOException
    {
        // write block vector elements to the data file.
        while ( blockIterator.hasNext() ) {
            BlockIo cur = (BlockIo)blockIterator.next();
            owner.synch(cur);
            if (fromCore) {
                cur.decrementTransactionCount();
                if (!cur.isInTransaction()) {
                    owner.releaseFromTransaction(cur, true);
                }
            }
        }
    }

接下来的操作txnMgr.add(node)：
    /**
     * Indicates the block is part of the transaction.
     */
    void add(BlockIo block) throws IOException {
        block.incrementTransactionCount();
        txns[curTxn].add(block);
    }
这个操作很简单，就是将BlockIo对象放入到当前事务的ArrayList当中。之后commit操作：

    /**
     * Commits the transaction to the log file.
     */
    void commit() throws IOException {
        oos.writeObject(txns[curTxn]);
        sync();

// set clean flag to indicate blocks have been written to log
setClean(txns[curTxn]);

        // open a new ObjectOutputStream in order to store
        // newer states of BlockIo
        oos = new ObjectOutputStream(fos);
    }

最后的操作就是txnMgr.shutdown()：

    /**
     * Shutdowns the transaction manager. Resynchronizes outstanding
     * logs.
     */
    void shutdown() throws IOException {
        synchronizeLogFromMemory();
        close();
    }

persister 2009-05-11 13:36 发表评论

Java对象序列化二

persister — Fri, 08 May 2009 01:29:00 GMT

前面写了一个序列化的文章，这次重新整理一下。

1.Serialize概念
Java的对象序列化就是将那些实现了Serializable接口的对象转换成一个字节序列。并能够
在以后将这个字节完全恢复为原来的对象。
对象序列化的概念加入到语言当中就是为了支持两种主要特性

一是Java的远程方法调用（Remote Method Invocation, RMI）。当向远程对象发送消息时，
需要通过序列化来传输参数和返回值。

二是Javabean对象序列化。有些服务器通过将所有的SESSION 数据（包括BEAN）写入磁盘来支持任意长的SESSION生命期，即使服务器停机也不会丢失。当服务器重新启动后，串行化的数据被恢复。同样的理由，在重负载的站点上支持服务器分簇的环境中，许多服务器通过串行化来复制SESSION。如果你的BEAN不支持串行化，服务器就不能正确地保存和传输类。

只要对象实现了Serializable接口，对象的序列化处理就会非常简单。
2.Serialize方法
要序列化一个对象，首先要创建某些OutputStream对象，然后将其封装在一个ObjectOutputStream对象内。
这时，只需要调用writeObject()即可将对象序列化，并将其发送给OutputStream。反之，将一个序列化对象还原为一个对象，需要将一个InputStream封装在ObjectInputStream内，然后调用readObject()。
OutputStream和InputStream常用的是ByteArrayOutputStream/FileOutputStream和ByteArrayInputStream/FileInputStream。

下面两个类以ByteArray方式实现序列化：

public final class Serialization
{

    /**
     * Serialize the object into a byte array.
     */
    public static byte[] serialize( Object obj )
        throws IOException
    {
        ByteArrayOutputStream baos;
        ObjectOutputStream     oos;

        baos = new ByteArrayOutputStream();
        oos = new ObjectOutputStream( baos );
        oos.writeObject( obj );
        oos.close();

return baos.toByteArray();
}

    /**
     * Deserialize an object from a byte array
     */
    public static Object deserialize( byte[] buf )
        throws ClassNotFoundException, IOException
    {
        ByteArrayInputStream bais;
        ObjectInputStream     ois;

        bais = new ByteArrayInputStream( buf );
        ois = new ObjectInputStream( bais );
        return ois.readObject();
    }

}

public class DefaultSerializer
implements Serializer
{

    public static final DefaultSerializer INSTANCE = new DefaultSerializer();


    /**
     * Construct a DefaultSerializer.
     */
    public DefaultSerializer()
    {
        // no op
    }

    /**
     * Serialize the content of an object into a byte array.
     *
     * @param obj Object to serialize
     * @return a byte array representing the object's state
     */
     public byte[] serialize( Object obj )
        throws IOException
     {
         return Serialization.serialize( obj );
     }


    /**
     * Deserialize the content of an object from a byte array.
     *
     * @param serialized Byte array representation of the object
     * @return deserialized object
     */
     public Object deserialize( byte[] serialized )
        throws IOException
     {
         try {
            return Serialization.deserialize( serialized );
         } catch ( ClassNotFoundException except ) {
            throw new WrappedRuntimeException( except );
         }
     }

}

File方式的序列化大致如下：

ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(out.txt));
out.writeObject(obj);
out.close();

ObjectInputStream in = new ObjectInputStream(new FileInputStream(out.txt));
Object obj = (Object)in.readObject();
in.close();

3.Serialize定制

缺省的序列化机制并不难操纵，如果有特殊的需求那又该怎么办？例如，也许要考虑特殊的安全问题，而且
你不希望对象的某一部分被序列化；或者一个对象被还原后，某子对象需要重新创建，从而不需要将该子对象
序列化。在这样的特殊情况下，可通过实现Externalizable接口来对序列化过程进行控制。这个Externalizable
接口继承了Serializable接口，同时增加了两个方法：writeExternal(ObjectOutput out)和readExternal(ObjectInput in)

Serializable对象完全以它存储的二进制位为基础来构造，而不用调用构造器。而对于一个Externalizable对象
缺省构造器都会被调用，然后调用readExternal()。下面列子中，如果Blip3()构造器注释掉，程序会报错：no valid constructor

// Reconstructing an externalizable object.
// From 'Thinking in Java, 3rd ed.' (c) Bruce Eckel 2002
// www.BruceEckel.com. See copyright notice in CopyRight.txt.
import com.bruceeckel.simpletest.*;
import java.io.*;
import java.util.*;

public class Blip3 implements Externalizable {
private static Test monitor = new Test();
private int i;
private String s; // No initialization
public Blip3() {
    System.out.println("Blip3 Constructor");
    // s, i not initialized
}
public Blip3(String x, int a) {
    System.out.println("Blip3(String x, int a)");
    s = x;
    i = a;
    // s & i initialized only in nondefault constructor.
}
public String toString() { return s + i; }
public void writeExternal(ObjectOutput out)
throws IOException {
    System.out.println("Blip3.writeExternal");
    // You must do this:
    out.writeObject(s);
    out.writeInt(i);
}
public void readExternal(ObjectInput in)
throws IOException, ClassNotFoundException {
    System.out.println("Blip3.readExternal");
    // You must do this:
    s = (String)in.readObject();
    i = in.readInt();
}
public static void main(String[] args)
throws IOException, ClassNotFoundException {
    System.out.println("Constructing objects:");
    Blip3 b3 = new Blip3("A String ", 47);
    System.out.println(b3);
    ObjectOutputStream o = new ObjectOutputStream(
      new FileOutputStream("Blip3.out"));
    System.out.println("Saving object:");
    o.writeObject(b3);
    o.close();
    // Now get it back:
    ObjectInputStream in = new ObjectInputStream(
      new FileInputStream("Blip3.out"));
    System.out.println("Recovering b3:");
    b3 = (Blip3)in.readObject();
    System.out.println(b3);
    monitor.expect(new String[] {
      "Constructing objects:",
      "Blip3(String x, int a)",
      "A String 47",
      "Saving object:",
      "Blip3.writeExternal",
      "Recovering b3:",
      "Blip3 Constructor",
      "Blip3.readExternal",
      "A String 47"
    });
}
}

persister 2009-05-08 09:29 发表评论

JDBM学习三（RecordManager）

persister — Tue, 05 May 2009 09:50:00 GMT

JDBM中提供了一个接口RecordManager，用于对记录进行操作：

public abstract long insert( Object obj )
throws IOException;

    /**
     * Inserts a new record using a custom serializer.
     */
    public abstract long insert( Object obj, Serializer serializer )
        throws IOException;

    /**
     * Deletes a record.
     */
    public abstract void delete( long recid )
        throws IOException;

    /**
     * Updates a record using standard java object serialization.
     */
    public abstract void update( long recid, Object obj )
        throws IOException;

    /**
     * Updates a record using a custom serializer.
     */
    public abstract void update( long recid, Object obj, Serializer serializer )
        throws IOException;

    /**
     * Fetches a record using standard java object serialization.
     */
    public abstract Object fetch( long recid )
        throws IOException;

    /**
     * Fetches a record using a custom serializer.
     */
    public abstract Object fetch( long recid, Serializer serializer )
        throws IOException;

    /**
     * Closes the record manager.
     */
    public abstract void close()
        throws IOException;

具体的实现类一共两个：BaseRecordManager和CacheRecordManager，后者是前者的Cache。BaseRecordManager用于将缓存对象序列化到文件系统中，即缓存对象管理主要是文件读取方面的操作，而CacheRecordManager
对读取的文件进行了缓存，较少IO的次数提高效率。

BaseRecordManager

BaseRecordManager有四个主要的变量

    /**
     * Underlying record file.
     */
    private RecordFile _file;
    /**
     * Physical row identifier manager.
     */
    private PhysicalRowIdManager _physMgr;
    /**
     * Logigal to Physical row identifier manager.
     */
    private LogicalRowIdManager _logMgr;
    /**
     * Page manager.
     */
    private PageManager _pageman;

没有看其实现代码，但是从其构造函数可以看出一些端倪：
    public BaseRecordManager( String filename )
        throws IOException
    {
        _file = new RecordFile( filename );
        _pageman = new PageManager( _file );
        _physMgr = new PhysicalRowIdManager( _file, _pageman );
        _logMgr = new LogicalRowIdManager( _file, _pageman );
    }
jdbm.recman主要都是关于Page,PhysicalRow和LogicalRow这些相关类。

persister 2009-05-05 17:50 发表评论

SoftReference,WeakReference&WeakHashMap

persister — Tue, 05 May 2009 06:53:00 GMT

zz http://java.chinaitlab.com/oop/716371.html

在JDK1.2以前的版本中，当一个对象不被任何变量引用，那么程序就无法再使用这个对象。也就是说，只有对象处于可触及状态，程序才能使用它。这就像在日常生活中，从商店购买了某样物品后，如果有用，就一直保留它，否则就把它扔到垃圾箱，由清洁工人收走。一般说来，如果物品已经被扔到垃圾箱，想再把它捡回来使用就不可能了。

但有时候情况并不这么简单，你可能会遇到类似鸡肋一样的物品，食之无味，弃之可惜。这种物品现在已经无用了，保留它会占空间，但是立刻扔掉它也不划算，因为也许将来还会派用场。对于这样的可有可无的物品，一种折衷的处理办法是：如果家里空间足够，就先把它保留在家里，如果家里空间不够，即使把家里所有的垃圾清除，还是无法容纳那些必不可少的生活用品，那么再扔掉这些可有可无的物品。

从JDK1.2版本开始，把对象的引用分为四种级别，从而使程序能更加灵活的控制对象的生命周期。这四种级别由高到低依次为：强引用、软引用、弱引用和虚引用。

1．强引用
本章前文介绍的引用实际上都是强引用，这是使用最普遍的引用。如果一个对象具有强引用，那就类似于必不可少的生活用品，垃圾回收器绝不会回收它。当内存空间不足，Java虚拟机宁愿抛出OutOfMemoryError错误，使程序异常终止，也不会靠随意回收具有强引用的对象来解决内存不足问题。

2．软引用（SoftReference）

如果一个对象只具有软引用，那就类似于可有可物的生活用品。如果内存空间足够，垃圾回收器就不会回收它，如果内存空间不足了，就会回收这些对象的内存。只要垃圾回收器没有回收它，该对象就可以被程序使用。软引用可用来实现内存敏感的高速缓存。
软引用可以和一个引用队列（ReferenceQueue）联合使用，如果软引用所引用的对象被垃圾回收，Java虚拟机就会把这个软引用加入到与之关联的引用队列中。

3．弱引用（WeakReference）
如果一个对象只具有弱引用，那就类似于可有可物的生活用品。弱引用与软引用的区别在于：只具有弱引用的对象拥有更短暂的生命周期。在垃圾回收器线程扫描它所管辖的内存区域的过程中，一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存。不过，由于垃圾回收器是一个优先级很低的线程，因此不一定会很快发现那些只具有弱引用的对象。
弱引用可以和一个引用队列（ReferenceQueue）联合使用，如果弱引用所引用的对象被垃圾回收，Java虚拟机就会把这个弱引用加入到与之关联的引用队列中。

4．虚引用（PhantomReference）
"虚引用"顾名思义，就是形同虚设，与其他几种引用都不同，虚引用并不会决定对象的生命周期。如果一个对象仅持有虚引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收。
虚引用主要用来跟踪对象被垃圾回收的活动。虚引用与软引用和弱引用的一个区别在于：虚引用必须和引用队列（ReferenceQueue）联合使用。当垃圾回收器准备回收一个对象时，如果发现它还有虚引用，就会在回收对象的内存之前，把这个虚引用加入到与之关联的引用队列中。程序可以通过判断引用队列中是否已经加入了虚引用，来了解

被引用的对象是否将要被垃圾回收。程序如果发现某个虚引用已经被加入到引用队列，那么就可以在所引用的对象的内存被回收之前采取必要的行动。

在本书中，"引用"既可以作为动词，也可以作为名词，读者应该根据上下文来区分"引用"的含义。
在java.lang.ref包中提供了三个类：SoftReference类、WeakReference类和PhantomReference类，它们分别代表软引用、弱引用和虚引用。ReferenceQueue类表示引用队列，它可以和这三种引用类联合使用，以便跟踪Java虚拟机回收所引用的对象的活动。以下程序创建了一个String对象、ReferenceQueue对象和WeakReference对象：

//创建一个强引用
String str = new String("hello");

//创建引用队列, 为范型标记，表明队列中存放String对象的引用
ReferenceQueue rq = new ReferenceQueue();

//创建一个弱引用，它引用"hello"对象，并且与rq引用队列关联
//为范型标记，表明WeakReference会弱引用String对象
WeakReference wf = new WeakReference(str, rq);

以上程序代码执行完毕，内存中引用与对象的关系如图11-10所示。

图11-10 "hello"对象同时具有强引用和弱引用

在图11-10中，带实线的箭头表示强引用，带虚线的箭头表示弱引用。从图中可以看出，此时"hello"对象被str强引用，并且被一个WeakReference对象弱引用，因此"hello"对象不会被垃圾回收。
在以下程序代码中，把引用"hello"对象的str变量置为null，然后再通过WeakReference弱引用的get()方法获得"hello"对象的引用：

String str = new String("hello"); //①
ReferenceQueue rq = new ReferenceQueue(); //②
WeakReference wf = new WeakReference(str, rq); //③

str=null; //④取消"hello"对象的强引用
String str1=wf.get(); //⑤假如"hello"对象没有被回收，str1引用"hello"对象

//假如"hello"对象没有被回收，rq.poll()返回null
Reference ref=rq.poll(); //⑥

执行完以上第④行后，内存中引用与对象的关系如图11-11所示，此时"hello"对象仅仅具有弱引用，因此它有可能被垃圾回收。假如它还没有被垃圾回收，那么接下来在第⑤行执行wf.get()方法会返回 "hello"对象的引用，并且使得这个对象被str1强引用。再接下来在第⑥行执行rq.poll()方法会返回null，因为此时引用队列中没有任何引用。ReferenceQueue的poll()方法用于返回队列中的引用，如果没有则返回null。

图11-11 "hello"对象只具有弱引用

在以下程序代码中，执行完第④行后，"hello"对象仅仅具有弱引用。接下来两次调用System.gc()方法，催促垃圾回收器工作，从而提高 "hello"对象被回收的可能性。假如"hello"对象被回收，那么WeakReference对象的引用被加入到ReferenceQueue中，接下来wf.get()方法返回null，并且rq.poll()方法返回WeakReference对象的引用。图11-12显示了执行完第⑧行后内存中引用与对象的关系。

String str = new String("hello"); //①
ReferenceQueue rq = new ReferenceQueue(); //②
WeakReference wf = new WeakReference(str, rq); //③
str=null; //④

//两次催促垃圾回收器工作，提高"hello"对象被回收的可能性
System.gc(); //⑤
System.gc(); //⑥
String str1=wf.get(); //⑦ 假如"hello"对象被回收，str1为null
Reference ref=rq.poll(); //⑧

图11-12 "hello"对象被垃圾回收，弱引用被加入到引用队列

在以下例程11-15的References类中，依次创建了10个软引用、10个弱引用和10个虚引用，它们各自引用一个Grocery对象。从程序运行时的打印结果可以看出，虚引用形同虚设，它所引用的对象随时可能被垃圾回收，具有弱引用的对象拥有稍微长的生命周期，当垃圾回收器执行回收操作时，有可能被垃圾回收，具有软引用的对象拥有较长的生命周期，但在Java虚拟机认为内存不足的情况下，也会被垃圾回收。

例程11-15 References.java
import java.lang.ref.*;
import java.util.*;

class Grocery{
private static final int SIZE = 10000;
//属性d使得每个Grocery对象占用较多内存，有80K左右
private double[] d = new double[SIZE];
private String id;
public Grocery(String id) { this.id = id; }
public String toString() { return id; }
public void finalize() {
System.out.println("Finalizing " + id);
}
}

public class References {
private static ReferenceQueue rq = new ReferenceQueue();
public static void checkQueue() {
Reference inq = rq.poll(); //从队列中取出一个引用
if(inq != null)
System.out.println("In queue: "+inq+" : "+inq.get());
}

public static void main(String[] args) {
final int size=10;

//创建10个Grocery对象以及10个软引用
Set> sa = new HashSet>();
for(int i = 0; i < size; i++) {
SoftReference ref=
new SoftReference(new Grocery("Soft " + i), rq);
System.out.println("Just created: " +ref.get());
sa.add(ref);
}
System.gc();
checkQueue();

//创建10个Grocery对象以及10个弱引用
Set> wa = new HashSet>();
for(int i = 0; i < size; i++) {
WeakReference ref=
new WeakReference(new Grocery("Weak " + i), rq);
System.out.println("Just created: " +ref.get());
wa.add(ref);
}
System.gc();
checkQueue();

//创建10个Grocery对象以及10个虚引用
Set> pa = new HashSet>();
for(int i = 0; i < size; i++) {
PhantomReferenceref =
new PhantomReference(new Grocery("Phantom " + i), rq);
System.out.println("Just created: " +ref.get());
pa.add(ref);
}
System.gc();
checkQueue();
}
}

在Java集合中有一种特殊的Map类型：WeakHashMap，在这种Map中存放了键对象的弱引用，当一个键对象被垃圾回收，那么相应的值对象的引用会从Map中删除。WeakHashMap能够节约存储空间，可用来缓存那些非必须存在的数据。关于Map接口的一般用法，可参见本书第15章的15.4节（Map）。

以下例程11-16的MapCache类的main()方法创建了一个WeakHashMap对象，它存放了一组Key对象的弱引用，此外main()方法还创建了一个数组对象，它存放了部分Key对象的强引用。

例程11-16 MapCache.java
import java.util.*;
import java.lang.ref.*;

class Key {
String id;
public Key(String id) { this.id = id; }
public String toString() { return id; }
public int hashCode() {
return id.hashCode();
}
public boolean equals(Object r) {
return (r instanceof Key)
&& id.equals(((Key)r).id);
}
public void finalize() {
System.out.println("Finalizing Key "+ id);
}
}

class Value {
String id;
public Value(String id) { this.id = id; }
public String toString() { return id; }
public void finalize() {
System.out.println("Finalizing Value "+id);
}
}

public class MapCache {
public static void main(String[] args) throws Exception{
int size = 1000;
// 或者从命令行获得size的大小
if(args.length > 0)size = Integer.parseInt(args[0]);

Key[] keys = new Key[size]; //存放键对象的强引用
WeakHashMap whm = new WeakHashMap();
for(int i = 0; i < size; i++) {
Key k = new Key(Integer.toString(i));
Value v = new Value(Integer.toString(i));
if(i % 3 == 0) keys[i] = k; //使Key对象持有强引用
whm.put(k, v); //使Key对象持有弱引用
}
//催促垃圾回收器工作
System.gc();

//把CPU让给垃圾回收器线程
Thread.sleep(8000);
}
}

以上程序的部分打印结果如下：

Finalizing Key 998
Finalizing Key 997
Finalizing Key 995
Finalizing Key 994
Finalizing Key 992
Finalizing Key 991
Finalizing Key 989
Finalizing Key 988
Finalizing Key 986
Finalizing Key 985
Finalizing Key 983

从打印结果可以看出，当执行System.gc()方法后，垃圾回收器只会回收那些仅仅持有弱引用的Key对象。id可以被3整数的Key对象持有强引用，因此不会被回收。

persister 2009-05-05 14:53 发表评论

JDBM学习二（CachePolicy）

persister — Tue, 05 May 2009 05:33:00 GMT

CachePolicy在JDBM有两种现成的实现，一个是MRU(Most Recently Used)，另一个是SoftCache。
MRU用Hashtable来保存缓存对象，每一个对象都维护它的next和previous对象，这样形成一个双向链表。之所以采用Hashtable，应该是考虑同步的问题。

MRU的原则就是最多使用的缓存对象放在链表的最末尾，最少使用的缓存对象放在链表的头部。新加的缓存对象都是放在尾部，如果有size的限制，那么头部的缓存对象会随找size的限制会被purge，这样可以加入新的缓存对象。每次purge的时候都会调用注册的Listeners，如果抛出异常则这个缓存对象不会被删除。

        CachePolicyListener listener;
        for (int i=0; i             listener = (CachePolicyListener)listeners.elementAt(i);
            listener.cacheObjectEvicted(entry.getValue());
        }
注意传入到cacheObjectEvicted中的变量是一个value，即处理的是缓存的对象而不是缓存项(CacheEntry)。

SoftCache利用了java的一个类SoftReference(详见内存优化的两个参数SoftReference和WeakReference)。它维护了两个map，一个是MRU对象_internal，另一个是Map对象_cacheMap，用于缓存SoftReference。

put方法中有：_cacheMap.put(key, new Entry(key, value, _clearQueue));
Entry类如下：

private static class Entry extends SoftReference {
private final Object _key;

        /**
         * Constructor that uses value as the soft
         * reference's referent.
         */
        public Entry(Object key, Object value, ReferenceQueue queue) {
            super(value, queue);
            _key = key;
        }

        /**
         * Gets the key
         * @return the key associated with this value.
         */
        final Object getKey() {
            return _key;
        }

        /**
         * Gets the value
         * @return the value; null if it is no longer accessible
         */
        final Object getValue() {
            return this.get();
        }
    }

get方法：

public Object get(Object key) {
        // first try the internal cache.
        Object value = _internal.get(key);
        if (value != null) {
            return value;
        }
        // poll and remove cleared references.
        removeClearedEntries();
        Entry entry = (Entry)_cacheMap.get(key);
        if (entry == null) { // object is not in cache.
            return null;
        }
        value = entry.getValue();
        if (value == null) { // object was in cache, but it was cleared.
            return null;
        }
        // we have the object. so we try to re-insert it into internal cache
        try {
            _internal.put(key, value);
        } catch (CacheEvictionException e) {
            // if the internal cache causes a fuss, we kick the object out.
            _cacheMap.remove(key);
            return null;
        }
        return value;
    }

MRU的使用具体可以看CacheRecordManager类，它的创建在Provider类中：
            RecordManager recman = new BaseRecordManager( name );
            MRU cache = new MRU( cacheSize );
            recman = new CacheRecordManager( recman, cache );

如果使用Factory获取RecordMagener
RecordManagerFactory.createRecordManager( String name, Properties options )，
得到的就是CacheRecordManager，如果非得使用BaseRecordManager：
RecordManager recman = new BaseRecordManager( name );
直接new一个即可。

persister 2009-05-05 13:33 发表评论

JDBM学习一（简介）

persister — Mon, 04 May 2009 14:16:00 GMT

JDBM官方网站：http://jdbm.sourceforge.net/ or http://sourceforge.net/projects/jdbm/

JDBM is a transactional persistence engine for Java. It aims to be for Java what GDBM is for other languages (C/C++, Python, Perl, etc.): a fast, simple persistence engine. You can use it to store a mix of objects and BLOBs, and all updates are done in a transactionally safe manner. JDBM also provides scalable data structures, such as HTree and B+Tree, to support persistence of large object collections.

ofbiz就是使用jdbm来进行缓存的，所以就花点时间来学习这个东西。
看它代码量不是很大，决定对它的源码好好学习一下。
下面是jdbm提供的一个example，先看看

import jdbm.RecordManager;
import jdbm.RecordManagerFactory;
import jdbm.helper.FastIterator;
import jdbm.htree.HTree;

import java.io.IOException;
import java.util.Properties;

/**
* Sample JDBM application to demonstrate the use of basic JDBM operations.
*
* @author Alex Boisvert
* @version $Id: FruitBasket.java,v 1.3 2003/08/06 20:10:15 boisvert Exp $
*/
public class FruitBasket
{
    RecordManager recman;
    HTree          hashtable;
    FastIterator   iter;
    String         fruit;
    String         color;

    public FruitBasket()
        throws IOException
    {
        // create or open fruits record manager
        Properties props = new Properties();
        recman = RecordManagerFactory.createRecordManager( "fruits", props );

        // create or load fruit basket (hashtable of fruits)
        long recid = recman.getNamedObject( "basket" );
        if ( recid != 0 ) {
            System.out.println( "Reloading existing fruit basket..." );
            hashtable = HTree.load( recman, recid );
            showBasket();
        } else {
            System.out.println( "Creating new fruit basket..." );
            hashtable = HTree.createInstance( recman );
            recman.setNamedObject( "basket", hashtable.getRecid() ); //通过命名对象来实现id与名字的关联
        }
    }

    public void runDemo()
        throws IOException
    {
        // insert keys and values
        System.out.println();
        System.out.println( "Adding fruits to the basket..." );
        hashtable.put( "bananas", "yellow" );
        hashtable.put( "strawberries", "red" );
        hashtable.put( "kiwis", "green" );

showBasket();

        // display color of a specific fruit
        System.out.println();
        System.out.println( "Get the color of bananas..." );
        String bananasColor = (String) hashtable.get( "bananas" );
        System.out.println( "bananas are " + bananasColor );

        recman.commit();

        try {
            // Thread.sleep( 10 * 1000 );
        } catch ( Exception except ) {
            // ignore
        }

        // remove a specific fruit from hashtable
        System.out.println();
        System.out.print( "Removing bananas from the basket..." );
        hashtable.remove( "bananas" );
        recman.commit();
        System.out.println( " done." );

        // iterate over remaining objects
        System.out.println();
        System.out.println( "Remaining fruit colors:" );
        iter = hashtable.keys();
        fruit = (String) iter.next();
        while ( fruit != null ) {
            color = (String) hashtable.get( fruit );
            System.out.println( fruit + " are " + color );
            fruit = (String) iter.next();
        }

        // cleanup
        recman.close();
    }

    public void showBasket()
        throws IOException
    {
        // Display content of fruit basket
        System.out.println();
        System.out.print( "Fruit basket contains: " );
        iter = hashtable.keys();
        fruit = (String) iter.next();
        while ( fruit != null ) {
            System.out.print( " " + fruit );
            fruit = (String) iter.next();
        }
        System.out.println();
    }


    public static void main( String[] args )
    {
        try {
            FruitBasket basket = new FruitBasket();
            basket.runDemo();
        } catch ( IOException ioe ) {
            ioe.printStackTrace();
        }
    }

}

persister 2009-05-04 22:16 发表评论

ThreadLocal的理解和使用

persister — Mon, 04 May 2009 13:58:00 GMT

ThreadLocal的使用非常简单
ThreadLocal user = new ThreadLoca();
user.set("username", "jackliu");
String username = user.get("username");

ThreadLocal是维护线程本地变量的一个很好的方法
只有本线程才能获得本线程内设置的变量，其他线程无法获取

/**
     * Returns the value in the current thread's copy of this thread-local
     * variable. Creates and initializes the copy if this is the first time
     * the thread has called this method.
     *
     * @return the current thread's value of this thread-local
     */
    public T get() {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            return (T)map.get(this);

        // Maps are constructed lazily. if the map for this thread
        // doesn't exist, create it, with this ThreadLocal and its
        // initial value as its only entry.
        T value = initialValue(); //return null
        createMap(t, value);
        return value;
    }

    /**
     * Sets the current thread's copy of this thread-local variable
     * to the specified value. Many applications will have no need for
     * this functionality, relying solely on the {@link #initialValue}
     * method to set the values of thread-locals.
     *
     * @param value the value to be stored in the current threads' copy of
     *        this thread-local.
     */
    public void set(T value) {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
    }

    /**
     * Removes the value for this ThreadLocal. This may help reduce
     * the storage requirements of ThreadLocals. If this ThreadLocal
     * is accessed again, it will by default have its
     * initialValue.
     * @since 1.5
     **/

     public void remove() {
         ThreadLocalMap m = getMap(Thread.currentThread());
         if (m != null)
             m.remove(this);
     }

    /**
     * Get the map associated with a ThreadLocal. Overridden in
     * InheritableThreadLocal.
     *
     * @param t the current thread
     * @return the map
     */
    ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
    }

    /**
     * Create the map associated with a ThreadLocal. Overridden in
     * InheritableThreadLocal.
     *
     * @param t the current thread
     * @param firstValue value for the initial entry of the map
     * @param map the map to store.
     */
    void createMap(Thread t, T firstValue) {
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    }

前段时间有个需求就将是需要一个全局点去获取登陆用户的用户名。
这个需求看起来很简单，但是却没有合适的办法。
因为如果需要session变量，那么必须在servlet的处理类中，但是很多类并不是servlet
而且也得不到request变量，所以在普通内里面没有办法获取到登陆用户名
这个时候就需要使用到ThreadLocal类
于是写了一个Filter。要注意的是因为web服务器针对每个web请求都会启动一个Thread
所以，每次都需要调用UserUtil.setUserName方法才能保证每个线程都能得到正确的用户名。

import java.io.IOException;

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;

import org.ofbiz.base.util.Debug;
import org.ofbiz.entity.GenericValue;

import com.aicent.ccb.util.StringUtils;
import com.aicent.ccb.util.UserUtil;

public class UserLogFilter implements Filter {
public static final String module = UserLogFilter.class.getName();

public void destroy() {

}

public void doFilter(ServletRequest request, ServletResponse response,
FilterChain chain) throws IOException, ServletException {

HttpServletRequest httpRequest = (HttpServletRequest) request;

String USERNAME = httpRequest.getParameter("USERNAME");

  if (StringUtils.isValid(USERNAME)) {
   UserUtil.setUserName(USERNAME);
   Debug.logInfo("in request set user name=" + UserUtil.getUserName(),
     module);
  } else {
   HttpSession session = httpRequest.getSession();
   if (null != session) {

    GenericValue userLogin = (GenericValue) session
      .getAttribute("userLogin");
    if (userLogin != null) {
     UserUtil.setUserName(userLogin.getString("userLoginId"));
     Debug.logInfo(
       "in session set user name=" + UserUtil.getUserName(),
       module);
    }
   } else {
    Debug.logInfo("No user in the session", module);
   }
  }

chain.doFilter(request, response);
}

public void init(FilterConfig fc) throws ServletException {

}

}

public class UserUtil {
private static final ThreadLocal user = new ThreadLocal() {
         public Object initialValue() {
             return "Unknown User";
         }
     };
public static void setUserName(String userName){
   user.set(userName);
}

public static String getUserName(){
   return (String)user.get();
}
}

persister 2009-05-04 21:58 发表评论

交易中间件与xa规范

persister — Fri, 17 Apr 2009 16:05:00 GMT

xa是x／open dtp定义的交易中间件与数据库之间的接口规范（即接口函数），交易中间件用它来通知数据库事务的开始、结束以及提交、回滚等。xa接口函数则由数据库厂商提供。

　　在谈到xa规范之前，必须首先了解分布式事务处理（distributed transaction processing）的概念。transaction，即事务，指一个程序或程序段，在一个或多个资源如数据库或文件上为完成某些功能的执行过程的集合。

分布式事务处理是指一个事务可能涉及多个数据库操作，分布式事务处理的关键是必须有一种方法可以管理事务在任何地方所做的所有动作，提交或回滚事务的决定必须产生统一的结果（全部提交或全部回滚）。

x／open组织（即现在的open group）定义了分布式事务处理模型。x／open dtp模型（1994）包括应用程序（ap）、事务管理器（tm）、资源管理器（rm）、通信资源管理器（crm）四部分。一般，常见的事务管理器（tm）是交易中间件，常见的资源管理器（rm）是数据库，常见的通信资源管理器（crm）是消息中间件。为表述方便起见，在本文中直接以其常见表现形式进行描述。

通常把一个数据库内部的事务处理，如对多个表的操作，作为本地事务看待。数据库的事务处理对象是本地事务，而分布式事务处理的对象是全局事务。

所谓全局事务，是指分布式事务处理环境中，多个数据库可能需要共同完成一个工作，这个工作即是一个全局事务，例如，一个事务中可能更新几个不同的数据库。对数据库的操作发生在系统的各处但必须全部被提交或回滚。此时一个数据库对自己内部所做操作的提交不仅依赖本身操作是否成功，还要依赖与全局事务相关的其它数据库的操作是否成功，如果任一数据库的任一操作失败，则参与此事务的所有数据库所做的所有操作都必须回滚。

一般情况下，某一数据库无法知道其它数据库在做什么，因此，在一个dtp环境中，交易中间件是必需的，由它通知和协调相关数据库的提交或回滚。而一个数据库只将其自己所做的操作（可恢复）影射到全局事务中。

xa规范的基础是两阶段提交协议。

在第一阶段，交易中间件请求所有相关数据库准备提交（预提交）各自的事务分支，以确认是否所有相关数据库都可以提交各自的事务分支。当某一数据库收到预提交后，如果可以提交属于自己的事务分支，则将自己在该事务分支中所做的操作固定记录下来，并给交易中间件一个同意提交的应答，此时数据库将不能再在该事务分支中加入任何操作，但此时数据库并没有真正提交该事务，数据库对共享资源的操作还未释放（处于上锁状态）。如果由于某种原因数据库无法提交属于自己的事务分支，它将回滚自己的所有操作，释放对共享资源上的锁，并返回给交易中间件失败应答。

在第二阶段，交易中间件审查所有数据库返回的预提交结果，如所有数据库都可以提交，交易中间件将要求所有数据库做正式提交，这样该全局事务被提交。而如果有任一数据库预提交返回失败，交易中间件将要求所有其它数据库回滚其操作，这样该全局事务被回滚。

以一个全局事务为例，ap首先通知交易中间件开始一个全局事务，交易中间件通过xa接口函数通知数据库开始事务，然后ap可以对数据库管理的资源进行操作，数据库系统记录事务对本地资源的所有操作。操作完成后交易中间件通过xa接口函数通知数据库操作完成。交易中间件负责记录ap操作过哪些数据库（事务分支）。ap根据情况通知交易中间件提交该全局事务，交易中间件会通过xa接口函数要求各个数据库做预提交，所有数据库返回成功后要求各个数据库做正式提交，此时一笔全局事务结束。

xa规范对应用来说，最大好处在于事务的完整性由交易中间件和数据库通过xa接口控制，ap只需要关注与数据库的应用逻辑的处理，而无需过多关心事务的完整性，应用设计开发会简化很多。

具体来说，如果没有交易中间件，应用系统需要在程序内部直接通知数据库开始、结束和提交事务，当出现异常情况时必须由专门的程序对数据库进行反向操作才能完成回滚。如果是有很多事务分支的全局事务，回滚时情况将变得异常复杂。而使用xa接口，则全局事务的提交是由交易中间件控制，应用程序只需通知交易中间件提交或回滚事务，就可以控制整个事务（可能涉及多个异地的数据库）的全部提交或回滚，应用程序完全不用考虑冲正逻辑。

http://www.ibm.com/developerworks/cn/data/library/techarticles/dm-0505weber/index.html
这篇文章里面有非常详细的代码描绘，值得参考。

http://www.cnblogs.com/sunwei2012/archive/2010/01/08/1642295.html
这也是一篇不错的文章。

persister 2009-04-18 00:05 发表评论

泛型

persister — Tue, 14 Apr 2009 09:10:00 GMT

1，泛型中的‘万用字符’：

：表示T是实现了Comparable的类型（在‘泛型’中extends表示extends或者implement）

：表示必须是T或者T的子类

ArrayList ：以实现或继承Animal的类型为元素类型的ArrayList

2，相同功能的另一种语法：

public void takeThing(ArrayList list);

等同于：public void takeThing(ArrayList list);

更详细请参考：

http://baike.baidu.com/view/1436058.htm java泛型

persister 2009-04-14 17:10 发表评论

关闭钩子(shutdown hook)的作用

persister — Thu, 05 Mar 2009 15:13:00 GMT

JDK1.3介绍了java.lang.Runtime class的addShutdownHook()方法。如果你需要在你的程序关闭前采取什么措施，那么关闭钩子（shutdown hook）是很有用的。

要加关闭钩子（shutdown hook），需要先创建一个java.lang.Thread 类的实例，把它作为addShutdownHook()方法的参数。因为关闭钩子（shutdown hook）简短而扼要的，所以用匿名嵌套类很适合。

下面是简单的关闭钩子，它打印出"shutting down"：

Runtime.getRuntime().addShutdownHook(new Thread() {
    public void run() {
        System.out.println("shutting down");
    }
});

虚拟机关闭时，它会调用线程的start()函数。

除了加关闭钩子（shutdown hook）外，你也可以通过对前一个注册线程的引用，调用方法注销钩子。记住：为了注销钩子，你必须有它的引用，这样匿名类在注销后才不会发生作用。

如果在你的程序关闭时，你需要做一些工作，清除工作，释放资源等等，那么你会发现关闭钩子（shutdown hook）很有用。

persister 2009-03-05 23:13 发表评论

判断两个路径是否指向同一个文件

persister — Thu, 05 Mar 2009 13:48:00 GMT

我们知道在Windows操作系统下文件名是不区分大小写；

另外在不同的操作系统下可以用 . 来表示当前目录，或者直接只写文件名也表示默认为当前目录，

例如当前目录是D:\work，那么文件D:\work\aaa.txt和.\Aaa.txt 实际上指的是磁盘上的同一个文件，

但是程序怎么来判断这种情况呢？请看下面代码

/** * 判断两个File对象是否指向同一个文件

* @throws IOException */

protected static void testCanonicalFile() throws IOException

{

        File f1 = new File("D:\work\AAA.txt");

        File f2 = new File("./aaa.txt");

        boolean sameFile = f1.getCanonicalFile(). equals(f2.getCanonicalFile());

        System.out.println(sameFile);

}

通过getCanonicalFile方法来获取某个文件在当前操作系统下对应的目标文件，

只要两个路径指向同一个文件，

则两个文件对象的getCanonicalFile返回的对象一定相等，

因此上面的例子打印的值是 true.

persister 2009-03-05 21:48 发表评论

Java性能测试工具JProfiler试用

persister — Fri, 26 Dec 2008 01:37:00 GMT

JProfiler测试RCP教程

一、下载、注册：

1、下载：我们可以从JProfiler的官方网站下载到最新版本的JProfiler，我用的是目前最新版JProfiler6。

下载地址：http://www.ej-technologies.com/products/jprofiler/overview.html

2、注册：在官方网站上当我们确定了下载的版本后会出现如下界面：

我们添写对应的信息后，网站会将注册码发送到你所添写的邮箱当中，打开邮箱便可获得一个免费使用10天的Key码，10天后Key码便不可用，我们得重复上述方法重新申请Key码。

、JProfiler主要功能简介：

1．内存剖析 Memory profiler

JProfiler 的内存视图部分可以提供动态的内存使用状况更新视图和显示关于内存分配状况信息的视图。所有的视图都有几个聚集层并且能够显示现有存在的对象和作为垃圾回收的对象。

所有对象
显示类或在状况统计和尺码信息堆上所有对象的包。你可以标记当前值并显示差异值。
记录对象 Record objects
显示类或所有已记录对象的包。你可以标记出当前值并且显示差异值。
分配访问树 Allocation call tree
显示一棵请求树或者方法、类、包或对已选择类有带注释的分配信息的J2EE组件。
分配热点 Allocation hot spots
显示一个列表，包括方法、类、包或分配已选类的J2EE组件。你可以标注当前值并且显示差异值。对于每个热点都可以显示它的跟踪记录树。

2．堆遍历 Heap walker

在JProfiler的堆遍历器(Heap walker)中，你可以对堆的状况进行快照并且可以通过选择步骤下寻找感兴趣的对象。堆遍历器有五个视图：

类 Classes
显示所有类和它们的实例。
分配 Allocations
为所有记录对象显示分配树和分配热点。
索引 References
为单个对象和“显示到垃圾回收根目录的路径”提供索引图的显示功能。还能提供合并输入视图和输出视图的功能。
数据 Data
为单个对象显示实例和类数据。
时间 Time
显示一个对已记录对象的解决时间的柱状图。

3．CPU 剖析 CPU Views

JProfiler 提供不同的方法来记录访问树以优化性能和细节。线程或者线程组以及线程状况可以被所有的视图选择。所有的视图都可以聚集到方法、类、包或J2EE组件等不同层上。CPU视图部分包括：

访问树 Call tree
显示一个积累的自顶向下的树,树中包含所有在JVM中已记录的访问队列。JDBC,JMS和JNDI服务请求都被注释在请求树中。请求树可以根据Servlet和JSP对URL的不同需要进行拆分。
热点 Hot spots
显示消耗时间最多的方法的列表。对每个热点都能够显示回溯树。该热点可以按照方法请求，JDBC，JMS和JNDI服务请求以及按照URL请求来进行计算。
访问图 Call graph
显示一个从已选方法、类、包或J2EE组件开始的访问队列的图。

4．线程剖析 Thread profiler

对线程剖析，JProfiler提供以下视图:

线程历史 Thread history
显示一个与线程活动和线程状态在一起的活动时间表。
线程监控 Thread monitor
显示一个列表，包括所有的活动线程以及它们目前的活动状况。
死锁探测图表 Deadlock Detection
显示一个包含了所有在JVM里的死锁图表。
目前使用的监测器 Current monitor useage
显示目前使用的监测器并且包括它们的关联线程。
历史检测记录 History usage history
显示重大的等待事件和阻塞事件的历史记录。
监测使用状态 Monitor usage statistics
显示分组监测，线程和监测类的统计监测数据。

5．VM 遥感勘测技术 VM telemetry

观察JVM的内部状态，JProfiler提供了不同的遥感勘测视图，如下所示:

堆 Heap
显示一个堆的使用状况和堆尺寸大小活动时间表。
记录的对象 Recorded objects
显示一张关于活动对象与数组的图表的活动时间表。
垃圾回收 Garbage collector
显示一张关于垃圾回收活动的活动时间表。
类 Classes
显示一个与已装载类的图表的活动时间表。

线程 Threads
显示一个与动态线程图表的活动时间表。

三、JProfiler如何测试RCP程序

1、启动JProfiler5.1.4后会出现“Quick Start”窗口，如图：

在这里我们要选择要测试程序的类型，我们选择第二项，单击“Next”，进入“Session Settings”配置窗口。

2、Session Settings的窗口的配置

运行界面如图：

此窗口共有四个选项卡，通常情况下我们只需添写“Application Settings”中的相关信息，其中：

Session name：此次测试的名字，可任意添写。

Session Type：测试程序的类型（Local：本地程序、Remote：远程程序、Applet：JAVA小程序、Web Start：Web程序）

Java VM：本地机的所安装的jre版本。

Working dirctory：工作区目录。

注：由于本次要测试的为RCP程序，因此要先将RCP程序打包发行，这里的工作区目录本例来说是RCP发行后的主目录。

Main class or executable JAR：程序的主类或JAR包，当我们将RCP程序打包发行后，会自动生成一个startup.jar的文件，此处添写startup.jar的完整路径。

另外，在下方的“Java File Path”一栏中还需要添加程序源代码路径和类路径，如果不添写，在测试时便无法查看源代码。一切都添好了，单击“OK”。

3、Evaluation Version窗口

此窗口是用来对你使用的JProfiler的版本进行评估，通知你版本的使用期限，如图所示：

这里我们不用管它，直接单击“Evaluate”，出现“Session Startup”窗口如图所示：

这里显示了此次测试的一些配置信息，不用管理它，单击“OK”，此时将会启动要测试的程序，我测试的程序是“PDM数据管理系统”运行介面如下：

4、执行“PDM数据管理系统”，执行“PDM数据管理系统”中的查询操作后，JProfiler显示的界面如图所示：

Aggregation level：显示的方式，我们这里选“pacakge”，图中的“cn.com.panyang.pmanager.model”是我编写程序时手动创建的包，第二列“Instance count”代表程序执行的次数。

接下来标记现在的状态，界面如图：

然后再执行一次“PDM数据管理系统”中的查询操作（查询条件与先前的不一致），界面变为：

红色表示发生变化的对象及变化数量，其中的2142表示两次执行的次数总和，第三列的Difference 表示两次之间发生变化的数量。现在按F4进行垃圾回收，几秒钟后我们会发现，一些类的红色不见了，证明垃圾回收得很彻底。但是，还有一些仍然存在红色区域，说明某些地方对这个类的引用没有被释放，然后我们可以以此为依据对代码进行初步优化。

5、查看方法消耗的时间

在进行完以上的操后我们可以点击窗口左边的“CPU Views”，再点击右侧窗口的“Hot Spots”标签来查看程序运行时每个方法的消耗时间和CPU占用比，如图：

我们可以通过此图，将最耗时和CPU占用大的代码段进行优化，缩短程序的运行时间，从而达到对系统性能的提高。

persister 2008-12-26 09:37 发表评论

BlogJava-Java天空 任我翱翔-随笔分类-Java Language