站在巨人的肩膀上好好学习SharedPreferences

站在巨人的肩膀上好好学习
本人小白菜，看了头条技术团队的文章 额假装有链接
特意read the fuck Souce code…
平时使用只会commit，看了大牛们的分析，才发现知之甚少

public void apply() {

        final MemoryCommitResult mcr = commitToMemory();

        //放入任务子线程
        final Runnable awaitCommit = new Runnable() {
                public void run() {
                    try {
                        //CountDownLatch .await（）会暂停调用线程
                        //直到创建时设置的count值，减到0
                        //countDown（）方法会进行减1的操作
                        mcr.writtenToDiskLatch.await();
                    } catch (InterruptedException ignored) {
                    }
                }
            };

        //添加
        QueuedWork.addFinisher(awaitCommit);

        //另一个任务
        Runnable postWriteRunnable = new Runnable() {
                public void run() {

                    //执行上一个任务，即暂停调用线程
                    awaitCommit.run();
                    //清除
                    QueuedWork.removeFinisher(awaitCommit);
                }
            };

        /**
         * 执行方法
         * 第二个参数是runnable
         * 目前看已经具备了阻塞主线程的能力
         * 那么阻塞主线程干什么了
         **/             
        SharedPreferencesImpl.this.enqueueDiskWrite(mcr, postWriteRunnable);
        //通知监听
        notifyListeners(mcr);
}

//大致来说就是：把设置到内存的sp数据，转到了一个map中，这个map是用来写到磁盘的
//同时清空了，sp数据
private MemoryCommitResult commitToMemory() {
    long memoryStateGeneration;
    List<String> keysModified = null;
    Set<OnSharedPreferenceChangeListener> listeners = null;
    Map<String, Object> mapToWriteToDisk;

    synchronized (SharedPreferencesImpl.this.mLock) {

        //enqueueDiskWrite 在写入的方法中会做mDiskWritesInFlight--
        //用来控制什么时候拷贝
        if (mDiskWritesInFlight > 0) {
            //1.mModified 是sp保存的数据，保存到内存中
            //2.在写入磁盘之前，先复制一份
            mMap = new HashMap<String, Object>(mMap);
        }

        //真正写到磁盘时使用的map
        mapToWriteToDisk = mMap;
        mDiskWritesInFlight++;

        boolean hasListeners = mListeners.size() > 0;
        if (hasListeners) {
            keysModified = new ArrayList<String>();
            listeners = new HashSet<OnSharedPreferenceChangeListener>(mListeners.keySet());
        }

        synchronized (mLock) {
            boolean changesMade = false;

            if (mClear) {
                if (!mMap.isEmpty()) {
                    changesMade = true;
                    mMap.clear();
                }
                mClear = false;
            }

            for (Map.Entry<String, Object> e : mModified.entrySet()) {
                String k = e.getKey();
                Object v = e.getValue();
                if (v == this || v == null) {
                    if (!mMap.containsKey(k)) {
                        continue;
                    }
                    mMap.remove(k);
                } else {
                    if (mMap.containsKey(k)) {
                        Object existingValue = mMap.get(k);
                        if (existingValue != null && existingValue.equals(v)) {
                            continue;
                        }
                    }

                    //保存已设置过的内容到map，也能保存到mapToWriteToDisk？
                    mMap.put(k, v);
                }

                changesMade = true;
                if (hasListeners) {
                    keysModified.add(k);
                }
            }

            //清空内存数据
            mModified.clear();

            if (changesMade) {
                mCurrentMemoryStateGeneration++;
            }

            memoryStateGeneration = mCurrentMemoryStateGeneration;
        }
    }
    return new MemoryCommitResult(memoryStateGeneration, keysModified, listeners,
            mapToWriteToDisk);
}


添加到静态常量有序的runnable集合中
static final LinkedList<Runnable> sFinishers = new LinkedList<>();
等下：研究这个东西的作用和始末
QueuedWork
public static void addFinisher(Runnable finisher) {
    synchronized (sLock) {
        sFinishers.add(finisher);
    }
}

private void enqueueDiskWrite(final MemoryCommitResult mcr,
                          final Runnable postWriteRunnable) {
//判定上一步传入的参数2是不是空，也就是区别是commit还是apply
//commit 传null      
final boolean isFromSyncCommit = (postWriteRunnable == null);

//真正写到磁盘的操作，是个runnable，那么调用这个任务的线程
//才是区别apply和commit的地方
final Runnable writeToDiskRunnable = new Runnable() {
        public void run() {

            //写入磁盘
            synchronized (mWritingToDiskLock) {
                //流操作
                writeToFile(mcr, isFromSyncCommit);
            }
            synchronized (mLock) {
                mDiskWritesInFlight--;
            }

            //启动阻塞主线程的操作
            if (postWriteRunnable != null) {
                postWriteRunnable.run();
            }
        }
    };


    //commit 同步执行
    if (isFromSyncCommit) {
        boolean wasEmpty = false;

        //前面所有的apply和commit都会调用commitToMemory
        //即每次都会递增mDiskWritesInFlight
        synchronized (mLock) {
            wasEmpty = mDiskWritesInFlight == 1;
        }

        //当前线程执行，同步执行
        if (wasEmpty) {
            writeToDiskRunnable.run();
            return;
        }
    }


    //apply 异步执行
    //加入到QueuedWork队列
    QueuedWork.queue(writeToDiskRunnable, !isFromSyncCommit);
}

到这儿其实还是没有异步执行的影子，commit的同步执行已经追到
那现在这个QueuedWork就是问题关键了

发现QueuedWork从成员到方法都是静态的，那么好了，这个玩意是随进程走的。
要看apply最终被那个异步线程执行，就看那个线程run了

//handler消息机制，延时不延时的区别
public static void queue(Runnable work, boolean shouldDelay) {
    Handler handler = getHandler();

    synchronized (sLock) {
        sWork.add(work);

        if (shouldDelay && sCanDelay) {
            handler.sendEmptyMessageDelayed(QueuedWorkHandler.MSG_RUN, DELAY);
        } else {
            handler.sendEmptyMessage(QueuedWorkHandler.MSG_RUN);
        }
    }
}

//内部handler接收消息，处理，先卖个关子（Looper）    
private static class QueuedWorkHandler extends Handler {
    static final int MSG_RUN = 1;

    QueuedWorkHandler(Looper looper) {
        super(looper);
    }

    public void handleMessage(Message msg) {
        if (msg.what == MSG_RUN) {
            processPendingWork();
        }
    }
}   


//run了每一个任务
private static void processPendingWork() {
    long startTime = 0;

    if (DEBUG) {
        startTime = System.currentTimeMillis();
    }

    synchronized (sProcessingWork) {
        LinkedList<Runnable> work;

        synchronized (sLock) {
            work = (LinkedList<Runnable>) sWork.clone();
            sWork.clear();

            // Remove all msg-s as all work will be processed now
            getHandler().removeMessages(QueuedWorkHandler.MSG_RUN);
        }

        if (work.size() > 0) {
            for (Runnable w : work) {
                w.run();
            }
        }
    }
}   

还是没发现线程信息把，关子来了。。。looper
我们知道一个线程对应一个looper，looper可以说是线程的标识
那么看看这个looper

/**
 * Lazily create a handler on a separate thread.
 * 惰性地在单独的线程上创建处理程序
 * goole大神们还是很坦诚的。。。
 */
private static Handler getHandler() {
    synchronized (sLock) {
        if (sHandler == null) {
            //开线程
            HandlerThread handlerThread = new HandlerThread(
                    "queued-work-looper",//线程名
                    Process.THREAD_PRIORITY_FOREGROUND);//优先级
            handlerThread.start();
            sHandler = new QueuedWorkHandler(handlerThread.getLooper());
        }
        return sHandler;
    }
}

最终apply这个写入磁盘的runnable就是在这个线程执行的
我们的主线程就是包名
adb shell ps -t

 根据头条大神说
在activityThread 的handleStopService时，回调用
QueuedWork.waitToFinish();

无限循环，依次获取QueuedWork中linklist中的runnable执行
其中sp中apply放入的那个runnable有个CountDownLatch .await（）
所以主线程被阻塞
public static void waitToFinish() {
    try {
        while (true) {
            Runnable finisher;

            synchronized (sLock) {
                finisher = sFinishers.poll();
            }

            if (finisher == null) {
                break;
            }

            finisher.run();
        }
    } finally {
        sCanDelay = true;
    }
}   

那么这个释放线程阻塞的位置在哪？


减到0就释放阻塞
void setDiskWriteResult(boolean wasWritten, boolean result) {
        //减1
        writtenToDiskLatch.countDown();
    }

writeToFile（）方法中进行
    ....
    mcr.setDiskWriteResult(false, true);



小结：sp的apply流程
我们存了很多数据putInt（）......
sp保存到了内存中 mModified
调用apply（），将写数据到磁盘的任务，发给QueuedWork的线程 "queued-work-looper"
并设置了主线程的线程锁awaitCommit，有序的保存在QueuedWork中（QueuedWor在进程启动的时候初始化）QueuedWork.addFinisher(awaitCommit)
在service停止时，activityThread -> H ->handleStopService ,当前是在主线程中，包名
在ams 停止服务之前， QueuedWork.waitToFinish()， 开启sp的工作，阻塞线程， 写入磁盘
写入完毕，释放线程锁，主线程继续流程

遗留：头条大神们建议的apply的优化，项目亲测后再说
注：欢迎大神们指出问题