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
    {

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