NameNode的双缓冲机制代码实现

每次请求NameNode修改一条元数据（比如说申请上传一个文件，那么就需要在内存目录树中加入一个文件），都要写一条edits log，包括两个步骤：

• 写入本地磁盘。
• 通过网络传输给JournalNodes集群。

NameNode在写edits log时的第一条原则：

必须保证每条edits log都有一个全局顺序递增的transactionId（简称为txid），这样才可以标识出来一条一条的edits log的先后顺序。

那么如果要保证每条edits log的txid都是递增的，就必须得加锁。

每个线程修改了元数据，要写一条edits log的时候，都必须按顺序排队获取锁后，才能生成一个递增的txid，代表这次要写的edits log的序号。

那NameNode是如何保证在高并发的情况，既保证了高性能，又同时保证了命令的有序性呢？下面就引入本文的双缓冲机制。

由于Hadoop源码中的双缓冲机制考虑到更多的情况，所以代码阅读起来会比较费劲，本文通过模仿hadoop的实现方式完成Demo代码，方便理解。话不多说，先上流程图：

代码实现：

public class FSEdit {
    long taxid = 0L;
    DoubleBuffer doubleBuffer = new DoubleBuffer();
    //每个线程自己拥有的副本
    ThreadLocal<Long> threadLocal = new ThreadLocal<>();

    //正在同步磁盘的内存块里面最大的一个事务ID号
    long maxTaxid = 0L;

    //后台是否正在执行数据同步到磁盘上
    public boolean isSyncRunning = false;

    boolean isWait =false;
    /**
     * 写元数据日志的核心方法
     * @param log
     */
    public void logEdit(String log) {
        synchronized (this) { //保证线程安全
            taxid++;
            threadLocal.set(taxid); //给每个线程设置一个事务ID号
            EditLog editLog = new EditLog(taxid, log);
            doubleBuffer.write(editLog);//往内存中写日志，加了锁也不会影响性能，能支撑高并发
        } //释放锁

        //没有回锁，这个过程称为分段加锁，提高性能

        //重新加锁，因为刷写磁盘性能低
        logFlush();
    }

    /**
     * 内存数据刷写到磁盘
     */
    private void logFlush() {
        //重新加锁
        synchronized (this){
            if (isSyncRunning) { //true
                //获取当前线程的事务ID
                Long localTaxid = threadLocal.get();
                if (localTaxid <= maxTaxid) { //说明前面有线程在同步了，则不用再同步，直接返回
                    return;
                }
                //代码走到这里，说明localTaxid > maxTaxid，有数据需要被已刷写到磁盘
                if(isWait) { //如果有线程睡眠要执行任务，那也不需要其它线程处理了，直接退出
                    return;
                }
                isWait = true;
                while (isSyncRunning) {
                    try {
                        //wait方法会让出锁，所以其他线程也会拿到锁进入这个方法，
                        this.wait(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                isWait = false;
            }
            //代码走到这里，说明没有正在同步数据
            doubleBuffer.exchange();
            if (doubleBuffer.syncBuffer.size() > 0) {
                maxTaxid = doubleBuffer.getMaxTaxid();
            }
            isSyncRunning = true;
        }//释放锁

        //数据持久化到磁盘，此处比较耗费性能，没有加锁
        doubleBuffer.flush();

        //此处又为分段加锁
        synchronized (this) {
            //修改标志位
            isSyncRunning = false;
            //唤醒await
            this.notifyAll();
        }
    }

    /**
     * 代表一条元数据信息
     */
    public class EditLog {
        //事务ID
        public long taxid;
        public String log;

        public EditLog(long taxid, String log) {
            this.taxid = taxid;
            this.log = log;
        }

        @Override
        public String toString() {
            return "EditLog{" +
                    "taxid=" + taxid +
                    ", log='" + log + '\'' +
                    '}';
        }
    }

    public class DoubleBuffer{
        //写数据缓存
        LinkedList<EditLog> currentBuffer = new LinkedList<>();
        //用来持久化到磁盘的内存
        LinkedList<EditLog> syncBuffer = new LinkedList<>();

        /**
         * 写元数据信息
         * @param log
         */
        public void write(EditLog log) {
            currentBuffer.add(log);
        }

        /**
         * 把数据写到磁盘
         */
        public void flush() {
            for (EditLog log : syncBuffer) {
                //用打印代替写到磁盘
                System.out.println(log);
            }
            //写完后清空空间
            syncBuffer.clear();
        }

        /**
         * 交换内存
         */
        public void exchange() {
            LinkedList<EditLog> tmp = currentBuffer;
            currentBuffer = syncBuffer;
            syncBuffer = tmp;
        }

        /**
         * 获取正在同步数据的内存里面事务ID的最大ID
         * @return
         */
        public long getMaxTaxid() {
            return syncBuffer.getLast().taxid;
        }
    }

}