Android 之 Choreographer 详细分析

UI 优化系列专题，来聊一聊 Android 渲染相关知识，主要涉及 UI 渲染背景知识、如何优化 UI 渲染两部分内容。

UI 优化系列专题
  • UI 渲染背景知识

《View 绘制流程之 setContentView() 到底做了什么？》
《View 绘制流程之 DecorView 添加至窗口的过程》
《深入 Activity 三部曲（3）View 绘制流程》
《Android 之 LayoutInflater 全面解析》
《关于渲染，你需要了解什么？》
《Android 之 Choreographer 详细分析》

  • 如何优化 UI 渲染

《Android 之如何优化 UI 渲染（上）》
《Android 之如何优化 UI 渲染（下）》

Android 的 UI 渲染性能是 Google 长期以来非常重视的，基本每次 Google I/O 都会花很多篇幅讲这一块。不过随着 Android 系统的不断演进和完善，时至今日，关于 Android UI 卡顿的话题也越来越少。

Google 在 2012 年的 I/O 大会上宣布了 Project Butter 计划，那个曾经严重影响 Android 口碑的 UI 流程性问题，首先在这得到有效的控制。并且在 Android 4.1 中正式开启了这个机制。

Project Butter 主要包含三个组成部分：VSYNC、Triple Buffering 和今天要重点分析的 Choreographer。关于 Project Butter 的详细介绍，你可以参考这里。

Choreographer

Choreographer 是 Android 4.1 新增的机制，用于配合系统的 VSYNC 中断信号。它本质是一个 Java 类，如果直译的话为舞蹈指导，看到这个词不得不赞叹设计者除了 Coding 之外的广泛视野。舞蹈是有节奏的，节奏使舞蹈的每个动作更加协调和连贯；视图刷新也是如此，Choreographer 可以接收系统的 VSYNC 信号，统一管理应用的输入、动画和绘制等任务的执行时机。业界一般通过它来监控应用的帧率。

我们先从 Choreographer 的构造方法入手，看看 Choreographer 是如何协调任务的执行。

private Choreographer(Looper looper, int vsyncSource) {
        // 当前线程的Looper
        mLooper = looper;
        // 使用该Looper创建FrameHandler
        mHandler = new FrameHandler(looper);
        // 是否开启VSYNC，开启VSYNC后将通过FrameDisplayEventReceiver接收VSYNC脉冲信号
        mDisplayEventReceiver = USE_VSYNC
                ? new FrameDisplayEventReceiver(looper, vsyncSource)
                : null;
        mLastFrameTimeNanos = Long.MIN_VALUE;

        // 计算一帧的时间
        // Android手机屏幕采用60Hz的刷新频率
        // 这里是纳秒 ≈16000000ns 还是16ms
        mFrameIntervalNanos = (long)(1000000000 / getRefreshRate());
        // 创建一个CallbackQueu的数组，默认为4
        // CallbackQueue中存放要执行的输入、动画、遍历绘制等任务
        // 也就是 CALLBACK_INPUT、CALLBACK_ANIMATION、CALLBACK_TRAVERSAL
        mCallbackQueues = new CallbackQueue[CALLBACK_LAST + 1];
        for (int i = 0; i <= CALLBACK_LAST; i++) {
            mCallbackQueues[i] = new CallbackQueue();
        }
        // b/68769804: For low FPS experiments.
        setFPSDivisor(SystemProperties.getInt(ThreadedRenderer.DEBUG_FPS_DIVISOR, 1));
 }
  1. Choreographer 的构造方法被设计成私有，并且是线程单例的。只能通过其内部的 getInstance 方法获取当前线程的 Choreographer 实例：
public static Choreographer getInstance() {
    // Choreographer线程单例的实现方式
    return sThreadInstance.get();
}

通过 ThreadLocal 实现 Choreographer 的线程单例。

private static final ThreadLocal<Choreographer> sThreadInstance =
            new ThreadLocal<Choreographer>() {
        @Override
        protected Choreographer initialValue() {
            // 获取当前线程的Looper对象
            Looper looper = Looper.myLooper();
            if (looper == null) {
                // 如果当前线程未创建Looper对象则抛出异常
                // 主线程（UI线程）的Looper默认在ActivityThread的main方法被创建
                throw new IllegalStateException("The current thread must have a looper!");
            }
            // 为当前线程创建一个Choreographer对象
            Choreographer choreographer = new Choreographer(looper, VSYNC_SOURCE_APP);
            if (looper == Looper.getMainLooper()) {
                // 如果是UI线程赋值给成员mMainInstance
                mMainInstance = choreographer;
            }
            return choreographer;
        }
};
  1. Choreographer 的构造必须传递一个 Looper 对象，其内部会根据该 Looper 创建一个 FrameHandler。Choreographer 的所有任务最终都会发送到该 Looper 所在的线程。
private final class FrameHandler extends Handler {
        
        public FrameHandler(Looper looper) {
            super(looper);
        }

        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case MSG_DO_FRAME:
                    // 执行doFrame
                    // 如果启用VSYNC机制，当VSYNC信号到来时触发
                    doFrame(System.nanoTime(), 0);
                    break;
                case MSG_DO_SCHEDULE_VSYNC:
                    // 申请VSYNC信号，例如当前需要绘制任务时
                    doScheduleVsync();
                    break;
                case MSG_DO_SCHEDULE_CALLBACK:
                    // 需要延迟的任务，最终还是执行上述两个事件
                    doScheduleCallback(msg.arg1);
                    break;
            }
        }
}
  1. 注意 USE_VSYNC，用于判断当前是否启用 VSYNC 机制，Android 在 4.1 之后默认开启该机制。
private static final boolean USE_VSYNC = SystemProperties.getBoolean(
            "debug.choreographer.vsync", true);

FrameDisplayEventReceiver 是 DisplayEventReceiver 的子类，DisplayEventReceiver 是一个 abstract class。在 DisplayEventReceiver 的构造方法会通过 JNI 创建一个 IDisplayEventConnection 的 VSYNC 的监听者。

public DisplayEventReceiver(Looper looper, int vsyncSource) {
        if (looper == null) {
            throw new IllegalArgumentException("looper must not be null");
        }

        mMessageQueue = looper.getQueue();
        // 注册VSYNC信号监听者
        mReceiverPtr = nativeInit(new WeakReference<DisplayEventReceiver>(this), mMessageQueue,
                vsyncSource);

        mCloseGuard.open("dispose");
    }

另外 DisplayEventReceiver 内还包括用于申请 VSYNC 信号的 scheduledVsync 方法，

public void scheduleVsync() {
        if (mReceiverPtr == 0) {
            Log.w(TAG, "Attempted to schedule a vertical sync pulse but the display event "
                    + "receiver has already been disposed.");
        } else {
            // 申请VSYNC中断信号
            // 会回调onVsync方法
            nativeScheduleVsync(mReceiverPtr);
        }
}

和用于接收 VSYNC 信号的 onVsync 方法。这样，当应用需要绘制时，通过 scheduledVsync 方法申请 VSYNC 中断，来自 EventThread 的 VSYNC 信号就可以传递到 Choreographer：

public void onVsync(long timestampNanos, int builtInDisplayId, int frame) {
        // 该方法在其子类FrameDisplayEventReceiver中被重写
        // 目的是通知Choreographer
}
  1. CallbackQueue，用于保存通过 postCallback 添加的任务。目前一共定义了四种任务类型，它们分别是：
  • CALLBACK_INPUT：优先级最高，和输入事件处理有关。
  • CALLBACK_ANIMATION：优先级其次，和 Animation 的处理有关
  • CALLBACK_TRAVERSAL：优先级最低，和 UI 绘制任务有关
  • CALLBACK_COMMIT：最后执行，和提交任务有关（在 API Level 23 添加）

优先级的高低和处理顺序有关，每当收到 VSYNC 信号时，Choreographer 将首先处理 INPUT 类型的任务，然后是 ANIMATION 类型，最后才是 TRAVERSAL 类型。

通过 Choreographer 添加的任务最后都被封装成 CallbackRecord，同种任务之间按照时间顺序以链表的形式保存在 CallbackQueue 内。

private static final class CallbackRecord {
        // 链表，指向下一个
        public CallbackRecord next;
        // 到期时间
        public long dueTime;
        // Runnable or FrameCallback
        public Object action;

        public Object token;

        public void run(long frameTimeNanos) {
            if (token == FRAME_CALLBACK_TOKEN) {
                // 通过postFrameCallback 或 postFrameCallbackDelayed
                // 会执行这里
                ((FrameCallback)action).doFrame(frameTimeNanos);
            } else {
                ((Runnable)action).run();
            }
        }
 }

CallbackQueue 是一个容量为 4 的数组，分别对应不同的任务类型。

接下来，以 View 的绘制流程为例，从 ViewRootImpl 的 scheduleTraversals 方法开始，其内部通过 Choreographer 的 postCallback 将绘制任务添加到 Chorographer。关于 View 绘制流程的详细分析，可以参考《View 绘制流程之 DecorView 添加至窗口的过程》和《深入 Activity 三部曲（3）之 View 绘制流程》。

void scheduleTraversals() {
        if (!mTraversalScheduled) {
            mTraversalScheduled = true;
            // 同步屏障，阻塞所有的同步消息
            mTraversalBarrier = mHandler.getLooper().getQueue().postSyncBarrier();
            // 注意mTraversaRunnable是一个Runnable对象
            // 通过 Choreographer 发送绘制任务
            mChoreographer.postCallback(
                    Choreographer.CALLBACK_TRAVERSAL, mTraversalRunnable, null);
           // ...
        }
    }

Choreographer 是线程单例的，大家是否还记得 Android 系统的 Looper 对象也是 线程单例。主线程 Looper 是在 ActivityThread 的 main 方法被创建。如果要在子线程使用 Handler，必须先为其创建一个 Looper 实例。

Choreographer 提供了两种添加任务的方式，postCallback() 和 postFrameCallback()，当然还有对应的 delay 方法。

  • postCallback 对应调用 postCallbackDelayed
public void postCallbackDelayed(int callbackType,
            Runnable action, Object token, long delayMillis) {
        if (action == null) {
            throw new IllegalArgumentException("action must not be null");
        }
        if (callbackType < 0 || callbackType > CALLBACK_LAST) {
            throw new IllegalArgumentException("callbackType is invalid");
        }
        // 最终都会调用到postCallbackDelayedInternal
        postCallbackDelayedInternal(callbackType, action, token, delayMillis);
}
  • postFrameCallback 对应调用 postFrameCallbackDelayed
public void postFrameCallbackDelayed(FrameCallback callback, long delayMillis) {
        if (callback == null) {
            throw new IllegalArgumentException("callback must not be null");
        }

        //最终调用postCallbackDelayedInternal
        postCallbackDelayedInternal(CALLBACK_ANIMATION,
                callback, FRAME_CALLBACK_TOKEN, delayMillis);
 }

postCallback 相比 postFrameCallback 更加灵活一些。

它们最终都会调用到 postCallbackDelayedInternal 方法：

private void postCallbackDelayedInternal(int callbackType,
            Object action, Object token, long delayMillis) {

        synchronized (mLock) {
            // 当前时间
            final long now = SystemClock.uptimeMillis();
            // 加上延迟时间
            final long dueTime = now + delayMillis;
            // 根据任务类型添加到mCallbackQueues中
            // VSYNC信号处理任务具有优先级
            mCallbackQueues[callbackType].addCallbackLocked(dueTime, action, token);

            if (dueTime <= now) {
                //表示立即执行，立即申请VSYNC信号
                scheduleFrameLocked(now);
            } else {
                // 在指定时间运行，最终仍然会调用scheduleFrameLocked
                Message msg = mHandler.obtainMessage(MSG_DO_SCHEDULE_CALLBACK, action);
                // 到时根据callbackType在mCallbackQueues中查找执行
                msg.arg1 = callbackType;
                // 消息设置为异步
                msg.setAsynchronous(true);
                mHandler.sendMessageAtTime(msg, dueTime);
            }
        }
}

根据任务类型 callbackType 添加到对应的 CallbackQueue 内，然后判断任务是否有延迟，无延迟则立即执行 scheduleFrameLocked 方法，否则发送定时消息到 FrameHandler，不过其最终还是调用到 scheduleFrameLocked 方法：

private void scheduleFrameLocked(long now) {
        //mFrameScheduled默认为false
        if (!mFrameScheduled) {
            mFrameScheduled = true;
            // 判断是否开启VSYNC
            if (USE_VSYNC) {
                // 判断是否在原线程
                if (isRunningOnLooperThreadLocked()) {
                    //默认会走这里
                    scheduleVsyncLocked();
                } else {
                    // 否则不在原线程，发送消息到原线程
                    // 最后还是调用scheduleVsyncLocked方法
                    Message msg = mHandler.obtainMessage(MSG_DO_SCHEDULE_VSYNC);
                    msg.setAsynchronous(true);
                    mHandler.sendMessageAtFrontOfQueue(msg);
                }
            } else {
                // 如果未开启VSYNC则直接doFrame方法
                final long nextFrameTime = Math.max(
                        mLastFrameTimeNanos / TimeUtils.NANOS_PER_MS + sFrameDelay, now);
                Message msg = mHandler.obtainMessage(MSG_DO_FRAME);
                msg.setAsynchronous(true);
                mHandler.sendMessageAtTime(msg, nextFrameTime);
            }
        }
}

注意 USE_VSYNC，如果系统未开启 VSYNC 机制，此时直接发送 MSG_DO_FRAME 消息到 FrameHandler。注意查看上面贴出的 FrameHandler 代码，此时直接执行 doFrame 方法。

不过 Android 4.1 之后系统默认开启 VSYNC，还记得在 Choreographer 的构造方法会创建一个 FrameDisplayEventReceiver，scheduleVsyncLocked 方法将会通过它申请 VSYNC 信号。

  • 这里注意 isRunningOnLooperThreadLocked 方法，其内部根据 Looper 判断是否在原线程，否则发送消息到 FrameHandler。最终还是会调用 scheduleVsyncLocked 方法申请 VSYNC 信号。

通过 FrameDisplayEventReceiver 申请 VSYNC 信号的过程如下：

private void scheduleVsyncLocked() {
    // 调用 FrameDisplayEventReceiver 的scheduleVsync
   // 实际调用到其父类DisplayEventReceiver
    mDisplayEventReceiver.scheduleVsync();
}

前面我们也有说过，申请 VSYNC 信号实际是在其父类 DisplayEventReceiver。

public void scheduleVsync() {
        if (mReceiverPtr == 0) {
            Log.w(TAG, "Attempted to schedule a vertical sync pulse but the display event "
                    + "receiver has already been disposed.");
        } else {
            // 申请VSYNC信号
            nativeScheduleVsync(mReceiverPtr);
        }
}

接着看下 VSYNC 信号的接收方法 onVsync，该方法在其子类 FrameDisplayEventReceiver 中重写：

private final class FrameDisplayEventReceiver extends DisplayEventReceiver
            implements Runnable {
        private boolean mHavePendingVsync;
        private long mTimestampNanos;
        private int mFrame;

        public FrameDisplayEventReceiver(Looper looper, int vsyncSource) {
            super(looper, vsyncSource);
        }

        @Override
        public void onVsync(long timestampNanos, int builtInDisplayId, int frame) {
            if (builtInDisplayId != SurfaceControl.BUILT_IN_DISPLAY_ID_MAIN) {              
                // 忽略来自非主屏的VSYNC信号
                scheduleVsync();
                return;
            }

             // ... 省略

            if (mHavePendingVsync) {
                Log.w(TAG, "Already have a pending vsync event.  There should only be "
                        + "one at a time.");
            } else {
                mHavePendingVsync = true;
            }

            mTimestampNanos = timestampNanos;
            mFrame = frame;
            // 发送消息执行doFrame
            // 注意this，表示当前Runnable
            Message msg = Message.obtain(mHandler, this);
            msg.setAsynchronous(true);
            mHandler.sendMessageAtTime(msg, timestampNanos / TimeUtils.NANOS_PER_MS);
        }

        @Override
        public void run() {
            mHavePendingVsync = false;
            // 回调这里，执行doFrame方法
            doFrame(mTimestampNanos, mFrame);
        }
}

FrameDisplayEventReceiver 实现了 Runnable，将其作为 callback 发送到 FrameHandler，此时 run 方法便得到执行并且执行 doFrame 方法：

void doFrame(long frameTimeNanos, int frame) {
        final long startNanos;
        synchronized (mLock) {
            if (!mFrameScheduled) {
                // 不是在执行Frame任务直接return
                return;
            }

            // ... 省略

            // 预期执行时间
            long intendedFrameTimeNanos = frameTimeNanos;
            // 当前时间
            startNanos = System.nanoTime();
            final long jitterNanos = startNanos - frameTimeNanos;
            // 超时时间是否超过一帧的时间
            if (jitterNanos >= mFrameIntervalNanos) {
                // 计算掉帧数
                final long skippedFrames = jitterNanos / mFrameIntervalNanos;
                // 掉帧超过30帧打印Log提示
                if (skippedFrames >= SKIPPED_FRAME_WARNING_LIMIT) {
                    // 著名的掉帧Log
                    Log.i(TAG, "Skipped " + skippedFrames + " frames!  "
                            + "The application may be doing too much work on its main thread.");
                }
                final long lastFrameOffset = jitterNanos % mFrameIntervalNanos;

                frameTimeNanos = startNanos - lastFrameOffset;
            }

            if (frameTimeNanos < mLastFrameTimeNanos) {
                // 未知原因，居然小于最后一帧的时间
                // 重新申请VSYNC信号
                scheduleVsyncLocked();
                return;
            }

            if (mFPSDivisor > 1) {
                long timeSinceVsync = frameTimeNanos - mLastFrameTimeNanos;
                if (timeSinceVsync < (mFrameIntervalNanos * mFPSDivisor) && timeSinceVsync > 0) {
                    scheduleVsyncLocked();
                    return;
                }
            }

            mFrameInfo.setVsync(intendedFrameTimeNanos, frameTimeNanos);
            // Frame标志位恢复
            mFrameScheduled = false;
            // 记录最后一帧时间
            mLastFrameTimeNanos = frameTimeNanos;
        }

        try {
            Trace.traceBegin(Trace.TRACE_TAG_VIEW, "Choreographer#doFrame");
            AnimationUtils.lockAnimationClock(frameTimeNanos / TimeUtils.NANOS_PER_MS);

            mFrameInfo.markInputHandlingStart();
            // 先执行CALLBACK_INPUT任务
            doCallbacks(Choreographer.CALLBACK_INPUT, frameTimeNanos);

            mFrameInfo.markAnimationsStart();
            // 再执行CALLBACK_ANIMATION
            doCallbacks(Choreographer.CALLBACK_ANIMATION, frameTimeNanos);

            mFrameInfo.markPerformTraversalsStart();
            // 其次执行CALLBACK_TRAVERSAL
            doCallbacks(Choreographer.CALLBACK_TRAVERSAL, frameTimeNanos);
            // API Level 23 之后加入，
            doCallbacks(Choreographer.CALLBACK_COMMIT, frameTimeNanos);
        } finally {
            AnimationUtils.unlockAnimationClock();
            Trace.traceEnd(Trace.TRACE_TAG_VIEW);
        }
}
  1. 注意第一个 if 语句，不知道大家是否在自己项目的 Logcat 台遇到过这样一条日志：
Skipped （该值>=30） frames!  The application may be doing too much work on its main thread

该 Log 用于提示开发人员当前存在耗时的任务导致 UI 绘制掉帧超过 30 帧（≈ 16ms * 30 >= 480ms）。

  1. 注意看方法的最后，按照类型顺序触发 doCallbacks 回调相关任务。
doCallbacks(Choreographer.CALLBACK_INPUT, frameTimeNanos);
doCallbacks(Choreographer.CALLBACK_ANIMATION, frameTimeNanos);
doCallbacks(Choreographer.CALLBACK_TRAVERSAL, frameTimeNanos);
doCallbacks(Choreographer.CALLBACK_COMMIT, frameTimeNanos);

doCallbacks 方法将根据不同的任务类型依次执行其 run 方法：

void doCallbacks(int callbackType, long frameTimeNanos) {
        CallbackRecord callbacks;
        synchronized (mLock) {
            final long now = System.nanoTime();
            // 根据指定的类型CallbackkQueue中查找到达执行时间的CallbackRecord
            callbacks = mCallbackQueues[callbackType].extractDueCallbacksLocked(
                    now / TimeUtils.NANOS_PER_MS);
            if (callbacks == null) {
                return;
            }
            mCallbacksRunning = true;

            if (callbackType == Choreographer.CALLBACK_COMMIT) {
                final long jitterNanos = now - frameTimeNanos;
                Trace.traceCounter(Trace.TRACE_TAG_VIEW, "jitterNanos", (int) jitterNanos);
                if (jitterNanos >= 2 * mFrameIntervalNanos) {
                    final long lastFrameOffset = jitterNanos % mFrameIntervalNanos
                            + mFrameIntervalNanos;
                    if (DEBUG_JANK) {
                        Log.d(TAG, "Commit callback delayed by " + (jitterNanos * 0.000001f)
                                + " ms which is more than twice the frame interval of "
                                + (mFrameIntervalNanos * 0.000001f) + " ms!  "
                                + "Setting frame time to " + (lastFrameOffset * 0.000001f)
                                + " ms in the past.");
                        mDebugPrintNextFrameTimeDelta = true;
                    }
                    frameTimeNanos = now - lastFrameOffset;
                    mLastFrameTimeNanos = frameTimeNanos;
                }
            }
        }
        try {
            Trace.traceBegin(Trace.TRACE_TAG_VIEW, CALLBACK_TRACE_TITLES[callbackType]);
            // 迭代执行所有任务
            for (CallbackRecord c = callbacks; c != null; c = c.next) {
                // 回调CallbackRecord的run
                // 其内部回调Callback的run
                c.run(frameTimeNanos);
            }
        } finally {
            synchronized (mLock) {
                mCallbacksRunning = false;
                do {
                    final CallbackRecord next = callbacks.next;
                    recycleCallbackLocked(callbacks);
                    callbacks = next;
                } while (callbacks != null);
            }
            Trace.traceEnd(Trace.TRACE_TAG_VIEW);
        }
}

注意遍历 CallbackRecord 链表调用其 run 方法：

public void run(long frameTimeNanos) {
            if (token == FRAME_CALLBACK_TOKEN) {
                // 通过postFrameCallback 或 postFrameCallbackDelayed
                // 会执行这里
                ((FrameCallback)action).doFrame(frameTimeNanos);
            } else {
                ((Runnable)action).run();
            }
    }

注意 token == FRAME_CALLBACK_TOKEN 表示通过 postFrameCallback 添加的任务。这里就是按照 Callback 类型回调其 run 方法。

回到 ViewRootImpl 发起的绘制任务，此时 View 的绘制流程便开始了。

final class TraversalRunnable implements Runnable{

    @Override
    public void run(){
        // View 的绘制任务开始
        doTraversal();
    }
}

至此 Choreographer 的工作流程就已经分析清楚了，Choreographer 支持四种类型任务：输入、动画、绘制和提交，并配合系统的 VSYNC 进行刷新、绘制等流程。确实做到了统一协调管理。

下面，再通过一张图来加深对 Choreographer 的工作流程的理解。

正如文章开头介绍 Choreographer 可以配合系统的 VSYNC 信号完成 UI 的绘制任务。那我们便可以通过它来监控应用的帧率，虽然 Choreographer 内部也实现了对掉帧的监控，但是默认只能监控超过 30 帧及以上。

不过通过今天的分析，你是否也可以实现一个任意掉帧数的监控呢？并且可以将其用于线上统计，更好的帮助我们优化应用的渲染性能。

关于 UI 渲染所涉及的内容非常多，文章最后也会附上一些扩展资料，便于更好的学习理解。

文中如有不妥或有更好的分析结果，欢迎您的分享留言或指正。

文章如果对你有帮助，请留个赞吧。

扩展阅读

其他系列专题

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 203,547评论 6赞 477
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 85,399评论 2赞 381
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 150,428评论 0赞 337
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 54,599评论 1赞 274
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 63,612评论 5赞 365
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 48,577评论 1赞 281
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 37,941评论 3赞 395
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 36,603评论 0赞 258
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 40,852评论 1赞 297
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 35,605评论 2赞 321
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 37,693评论 1赞 329
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 33,375评论 4赞 318
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 38,955评论 3赞 307
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 29,936评论 0赞 19
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 31,172评论 1赞 259
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 43,970评论 2赞 349
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 42,414评论 2赞 342