面试官：你知道Android系统启动流程吗？

如果你自认为是一个Android高级工程师，或者正在通往高级工程师路上，那么Android系统启动流程你是必须要了解的，这篇文章将手把手带你阅读Android系统源码，了解Android系统启动流程。

没有源码？没关系，可以在线看嘛！


这篇文章主要涉及以下内容：
1. Zygote进程启动
2. SystemServer 进程启动
3. Launcher启动

参考8.0源码 https://www.androidos.net.cn/android/8.0.0_r4/xref/

我们开始吧~

一、Zygote 进程启动流程

首先，Zygote 进程是由init进程拉起的，
简单说下init进程，init进程是手机开机的第一个进程，
对 init进程 有兴趣的可以参考
https://www.jianshu.com/p/1d3e722871e8
init进程做的事：

  1. 创建文件并挂载
  2. 初始化和启动属性服务
  3. 解析init.rc配置文件并启动zygote进程

init进程启动之后会去解析init.rc配置文件，配置文件定义了要启动的服务，Zygote就是要启动的服务之一，除此之外还有ServerManager进程等，Zygote启动脚本可以看init.zygote32.rc，64位也是差不多的。

/system/core/rootdir/init.zygote32.rc

service zygote /system/bin/app_process -Xzygote /system/bin --zygote --start-system-server
    class main
    priority -20
    user root
    group root readproc
    socket zygote stream 660 root system
    onrestart write /sys/android_power/request_state wake
    onrestart write /sys/power/state on
    onrestart restart audioserver
    onrestart restart cameraserver
    onrestart restart media
    onrestart restart netd
    onrestart restart wificond
    writepid /dev/cpuset/foreground/tasks

  1. 第一行，创建一个名叫 zygote 的进程，这个进程的可执行程序路径是 /system/bin/app_process，-Xzygote /system/bin --zygote --start-system-server是要传入到app_process程序中的参数。

  2. socket zygote stream 660 root system，这一句是启动一个名叫zygote的socket，ActivityManagerService进程和Zygote进程通信就是通过这个socket，主要作用是AMS请求Zygote进程fork出一个新的应用程序进程，后面分析应用启动流程会详细介绍。

扩展一下，xposed的原理就是通过替换了app_process，实现对Zygote进程的控制。

1.1 Zygote进程启动之后做了什么事？

Zygote的可执行程序路径在/system/bin/app_process ，
root手机之后可以通过RE管理器查看，
对应代码在
/frameworks/base/cmds/app_process/app_main.cpp

int main(int argc, char* const argv[])
{
    AppRuntime runtime(argv[0], computeArgBlockSize(argc, argv));
...
  
    if (zygote) {
        //这里会去调用ZygoteInit 的main方法
        runtime.start("com.android.internal.os.ZygoteInit", args, zygote);
    } else if (className) {
        runtime.start("com.android.internal.os.RuntimeInit", args, zygote);
    } else {
        fprintf(stderr, "Error: no class name or --zygote supplied.\n");
        app_usage();
        LOG_ALWAYS_FATAL("app_process: no class name or --zygote supplied.");
    }
}

runtime指的就是AppRuntime，AppRuntime继承自AndroidRuntime，

class AppRuntime : public AndroidRuntime
{...

也就是我们调用start函数其实是调用AndroidRuntime的start函数：
先看AndroidRuntime，源码在/frameworks/base/core/jni/AndroidRuntime.cpp

1.2 AndroidRuntime

void AndroidRuntime::start(const char* className, const Vector<String8>& options, bool zygote)
{

    /* start the virtual machine */
    JniInvocation jni_invocation;
    jni_invocation.Init(NULL);
    JNIEnv* env;
//1
    if (startVm(&mJavaVM, &env, zygote) != 0) {
        return;
    }
    onVmCreated(env);
//2
    /*
     * Register android functions.
     */
    if (startReg(env) < 0) {
        ALOGE("Unable to register all android natives\n");
        return;
    }

...
//3 这里的startClass 是 com.android.internal.os.ZygoteInit
       jmethodID startMeth = env->GetStaticMethodID(startClass, "main",
            "([Ljava/lang/String;)V");
        if (startMeth == NULL) {
            ALOGE("JavaVM unable to find main() in '%s'\n", className);
            /* keep going */
        } else {
            env->CallStaticVoidMethod(startClass, startMeth, strArray);

}

start主要做三件事：
1. 调用startVm()， 启动Java虚拟机
2. 调用startReg() ，注册JNI函数
3. 调用 env->CallStaticVoidMethod(startClass, startMeth, strArray);通过JNI调用Java的 ZygoteInit 类的main方法。

看下 ZygoteInit.java 的main方法

1.3 ZygoteInit#mian

/frameworks/base/core/java/com/android/internal/os/ZygoteInit.java

public static void main(String argv[]) {
        ZygoteServer zygoteServer = new ZygoteServer();

        ...
//1.创建socket
            zygoteServer.registerServerSocket(socketName);
            // In some configurations, we avoid preloading resources and classes eagerly.
            // In such cases, we will preload things prior to our first fork.
            if (!enableLazyPreload) {
// 2.预加载资源
                preload(bootTimingsTraceLog);
            } else {
                Zygote.resetNicePriority();
            }

            // Do an initial gc to clean up after startup
            gcAndFinalize();

            // Zygote process unmounts root storage spaces.
            Zygote.nativeUnmountStorageOnInit();
//3. startSystemServer
            if (startSystemServer) {
                startSystemServer(abiList, socketName, zygoteServer);
            }

            Log.i(TAG, "Accepting command socket connections");
//4、启动loop循环
            zygoteServer.runSelectLoop(abiList);

            zygoteServer.closeServerSocket();
        }
    }

主要关注以下几点：
1. 创建服务端socket。（socket需要客户端和服务端，这个可以理解）
2. preload 预加载资源（常用的类、主题资源、共享库等）
3. startSystemServer 启动系统服务，重点
4. zygoteServer.runSelectLoop(abiList);
开启无限循环等待AMS发送通知去fork一个新的应用进程

第1、2点很好理解，
第3点的 startSystemServer 先看一下

1.3.1 startSystemServer
    private static boolean startSystemServer(String abiList, String socketName, ZygoteServer zygoteServer)
            throws Zygote.MethodAndArgsCaller, RuntimeException {
int pid;
        String args[] = {
            "--setuid=1000",
            "--setgid=1000",
            "--setgroups=1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1018,1021,1023,1032,3001,3002,3003,3006,3007,3009,3010",
            "--capabilities=" + capabilities + "," + capabilities,
            "--nice-name=system_server",
            "--runtime-args",
            "com.android.server.SystemServer",  // 注意这里类名，
        };
        ZygoteConnection.Arguments parsedArgs = null;
        try {
            parsedArgs = new ZygoteConnection.Arguments(args);
            ZygoteConnection.applyDebuggerSystemProperty(parsedArgs);
            ZygoteConnection.applyInvokeWithSystemProperty(parsedArgs);
//1 fork进程
            /* Request to fork the system server process */
            pid = Zygote.forkSystemServer(
                    parsedArgs.uid, parsedArgs.gid,
                    parsedArgs.gids,
                    parsedArgs.debugFlags,
                    null,
                    parsedArgs.permittedCapabilities,
                    parsedArgs.effectiveCapabilities);
        } catch (IllegalArgumentException ex) {
            throw new RuntimeException(ex);
        }

        /* For child process */
        if (pid == 0) {
            if (hasSecondZygote(abiList)) {
                waitForSecondaryZygote(socketName);
            }
//2. socket也复制过来了，先关掉
            zygoteServer.closeServerSocket();
            handleSystemServerProcess(parsedArgs);
        }

}

通过Zygote.forkSystemServer 创建了 SystemServer，
这也就验证了 SystemServer 是由 Zygote 负责启动的。

fork一个子进程，pid返回0，最后一句调用 handleSystemServerProcess

1.3.2 handleSystemServerProcess
private static void handleSystemServerProcess(ZygoteConnection.Arguments parsedArgs)
throws Zygote.MethodAndArgsCaller {

   ...
        if (parsedArgs.invokeWith != null) {
            ...
        } else {
            ClassLoader cl = null;
            if (systemServerClasspath != null) {
                cl = createPathClassLoader(systemServerClasspath, parsedArgs.targetSdkVersion);

                Thread.currentThread().setContextClassLoader(cl);
            }

//1.重点
            /*
             * Pass the remaining arguments to SystemServer.
             */
            ZygoteInit.zygoteInit(parsedArgs.targetSdkVersion, parsedArgs.remainingArgs, cl);
        }

        /* should never reach here */
    }

最关键的就是最后一句ZygoteInit.zygoteInit(parsedArgs.targetSdkVersion, parsedArgs.remainingArgs, cl)

1.3.3 ZygoteInit.zygoteInit
    public static final void zygoteInit(int targetSdkVersion, String[] argv,
            ClassLoader classLoader) throws Zygote.MethodAndArgsCaller {
        if (RuntimeInit.DEBUG) {
            Slog.d(RuntimeInit.TAG, "RuntimeInit: Starting application from zygote");
        }

        Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "ZygoteInit");
        //将 System.out 和 System.err 定向到Android日志中
        RuntimeInit.redirectLogStreams();

        RuntimeInit.commonInit();
        ZygoteInit.nativeZygoteInit();
        RuntimeInit.applicationInit(targetSdkVersion, argv, classLoader);
    }
  1. 将 System.out 和 System.err 定向到Android日志中
  2. 调用 commonInit()，进行基本的初始化
  3. 调用nativeZygoteInit()，这个native方法去初始化一个Binder用来做进程间通信，下面会分析
  4. 在 RuntimeInit.applicationInit(targetSdkVersion, argv, classLoader);中调用 invokeStaticMain(args.startClass, args.startArgs, classLoader);这个方法会调用SystemServer这个类的main方法

重点看3和4

下面我们先看看nativeZygoteInit()方法中做了什么

1.3.4 ZygoteInit #nativeZygoteInit

它对应的实现在
/frameworks/base/core/jni/AndroidRuntime.cpp

static AndroidRuntime* gCurRuntime = NULL;

static void com_android_internal_os_ZygoteInit_nativeZygoteInit(JNIEnv* env, jobject clazz)
{
    gCurRuntime->onZygoteInit();
}

gCurRuntime其实就是AndroidRuntime本身,然后再去找onZygoteInit()方法,但是我们在AndroidRuntime.cpp文件中没有找到，最后发现AndroidRuntime的子类AppRuntime实现了onZygoteInit()方法。

AppRuntime继承了AndroidRuntime，所以定位到AppRuntime中，源码在/frameworks/base/cmds/app_process/app_main.cpp

    virtual void onZygoteInit()
    {
        sp<ProcessState> proc = ProcessState::self();
        ALOGV("App process: starting thread pool.\n");
        proc->startThreadPool();
    }

调用了ProcessState的startThreadPool()方法，ProcessState类位于
/frameworks/native/libs/binder/ProcessState.cpp

void ProcessState::startThreadPool()
{
    AutoMutex _l(mLock);
    if (!mThreadPoolStarted) {
        mThreadPoolStarted = true;
        spawnPooledThread(true);
    }
}

这个方法主要是启动一个线程池,该线程池中的线程主要是负责和binder驱动程序进行交互的，ProcessState是Binder进程间通信的一个基础组件，这里我们就不深究了，我们只需要知道nativeZygoteInit()方法初始化了一个线程池用于Binder进程之间的通信，这个方法执行完后，Binder进程间通信基础就准备好了

回到1.3.3 的第四点继续看，RuntimeInit.applicationInit(...)

1.3.5 RuntimeInit.applicationInit

/frameworks/base/core/java/com/android/internal/os/RuntimeInit.java

    protected static void applicationInit(int targetSdkVersion, String[] argv, ClassLoader classLoader)
            throws Zygote.MethodAndArgsCaller {
        VMRuntime.getRuntime().setTargetHeapUtilization(0.75f);
        VMRuntime.getRuntime().setTargetSdkVersion(targetSdkVersion);
...
        invokeStaticMain(args.startClass, args.startArgs, classLoader);
    }

    private static void invokeStaticMain(String className, String[] argv, ClassLoader classLoader)
            throws Zygote.MethodAndArgsCaller {
        Class<?> cl;
        try {
            cl = Class.forName(className, true, classLoader);
        } 
        Method m;
        try {
            //1 调用main 方法
            m = cl.getMethod("main", new Class[] { String[].class });
        } 
...
    }

最终会通过JNI调用 SystemServer 的main方法，怎么知道className是SystemServer？
可以回去看1.3.1 startSystemServer， 里面有个参数args 会传过来。

继续看SystemServer 的main方法干了啥~
/frameworks/base/services/java/com/android/server/SystemServer.java

    public static void main(String[] args) {
        new SystemServer().run();
    }

    private void run() {
       System.loadLibrary("android_servers");
      // Start services.
        try {
            traceBeginAndSlog("StartServices");
            startBootstrapServices();  //1
            startCoreServices(); //2
            startOtherServices(); //3
            SystemServerInitThreadPool.shutdown();
        }

        // Loop forever.
        Looper.loop();

    }
  1. startBootstrapServices(); 启动引导服务，太多了，列举几个吧

DeviceIdentifiersPolicyService
PowerManagerService
LightsService
DisplayManagerService
PackageManagerService
UserManagerService
...

  1. startCoreServices(); 启动核心服务，不明白具体是什么服务就看下源码注释

DropBoxManagerService
DropBoxManagerService
BatteryService
UsageStatsService
WebViewUpdateService

  1. startOtherServices(); 其它服务有几十个，列举几个常见的

NetworkManagementService
NetworkStatsService
WindowManagerService
InputManagerService
...

各种服务启动之后，什么时候启动桌面App呢？

2、 Launcher 的启动

SystemServer启动流程上面已经分析完了，那接下来应该是Launcher启动了，Launcher 在哪里启动的呢，寻寻觅觅之后发现是在 startOtherServices里，下面具体看一下

startOtherServices 里面有个重点服务要看一下

private void startOtherServices() {
 ...
        mActivityManagerService.systemReady(() -> {
            traceBeginAndSlog("StartActivityManagerReadyPhase");
            mSystemServiceManager.startBootPhase(
                    SystemService.PHASE_ACTIVITY_MANAGER_READY);
            ...
      }
}

ActivityManagerService#systemReady

在startOtherServices函数中，会调用ActivityManagerService的systemReady函数：
/frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java

public void systemReady(final Runnable goingCallback) {
...
synchronized (this) {
           ...
            mStackSupervisor.resumeFocusedStackTopActivityLocked();
            mUserController.sendUserSwitchBroadcastsLocked(-1, currentUserId);
        }
    }

systemReady函数中调用了ActivityStackSupervisor的resumeFocusedStackTopActivityLocked函数：
/frameworks/base/services/core/java/com/android/server/am/ActivityStackSupervisor.java

    boolean resumeFocusedStackTopActivityLocked() {
        return resumeFocusedStackTopActivityLocked(null, null, null);
    }

    boolean resumeFocusedStackTopActivityLocked(
            ActivityStack targetStack, ActivityRecord target, ActivityOptions targetOptions) {
        if (targetStack != null && isFocusedStack(targetStack)) {
//1
            return targetStack.resumeTopActivityUncheckedLocked(target, targetOptions);
        }
        final ActivityRecord r = mFocusedStack.topRunningActivityLocked();
        if (r == null || r.state != RESUMED) {
            mFocusedStack.resumeTopActivityUncheckedLocked(null, null);
        } else if (r.state == RESUMED) {
            // Kick off any lingering app transitions form the MoveTaskToFront operation.
            mFocusedStack.executeAppTransition(targetOptions);
        }
        return false;
    }

在注释1处会调用ActivityStack的resumeTopActivityUncheckedLocked函数，ActivityStack对象是用来描述Activity堆栈的，resumeTopActivityUncheckedLocked函数如下所示。
/frameworks/base/services/core/java/com/android/server/am/ActivityStack.java

    boolean resumeTopActivityUncheckedLocked(ActivityRecord prev, ActivityOptions options) {
        if (mStackSupervisor.inResumeTopActivity) {
            // Don't even start recursing.
            return false;
        }

        boolean result = false;
        try {
            // Protect against recursion.
            mStackSupervisor.inResumeTopActivity = true;
//1
            result = resumeTopActivityInnerLocked(prev, options);
        } finally {
            mStackSupervisor.inResumeTopActivity = false;
        }
        // When resuming the top activity, it may be necessary to pause the top activity (for
        // example, returning to the lock screen. We suppress the normal pause logic in
        // {@link #resumeTopActivityUncheckedLocked}, since the top activity is resumed at the end.
        // We call the {@link ActivityStackSupervisor#checkReadyForSleepLocked} again here to ensure
        // any necessary pause logic occurs.
        mStackSupervisor.checkReadyForSleepLocked();

        return result;
    }

看注释1，调用了resumeTopActivityInnerLocked函数：

 private boolean resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options) {
   ...
   return isOnHomeDisplay() &&
                        mStackSupervisor.resumeHomeStackTask(returnTaskType, prev, "prevFinished");
   ...                 
}

resumeTopActivityInnerLocked函数的代码很长，我们截取我们要分析的关键的一句：调用ActivityStackSupervisor的resumeHomeStackTask函数，代码如下所示。
/frameworks/base/services/core/java/com/android/server/am/ActivityStackSupervisor.java

boolean resumeHomeStackTask(int homeStackTaskType, ActivityRecord prev, String reason) {
    ...
    if (r != null && !r.finishing) {
        mService.setFocusedActivityLocked(r, myReason);
        return resumeFocusedStackTopActivityLocked(mHomeStack, prev, null);
    }
    return mService.startHomeActivityLocked(mCurrentUser, myReason);//1
}

最终调用了ActivityManagerService的startHomeActivityLocked函数，如下所示。
/frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java

    boolean startHomeActivityLocked(int userId, String reason) {
        if (mFactoryTest == FactoryTest.FACTORY_TEST_LOW_LEVEL
                && mTopAction == null) {
            // We are running in factory test mode, but unable to find
            // the factory test app, so just sit around displaying the
            // error message and don't try to start anything.
            return false;
        }
  //1 getHomeIntent
        Intent intent = getHomeIntent();
        ActivityInfo aInfo = resolveActivityInfo(intent, STOCK_PM_FLAGS, userId);
        if (aInfo != null) {
            intent.setComponent(new ComponentName(aInfo.applicationInfo.packageName, aInfo.name));
            // Don't do this if the home app is currently being
            // instrumented.
            aInfo = new ActivityInfo(aInfo);
            aInfo.applicationInfo = getAppInfoForUser(aInfo.applicationInfo, userId);
            ProcessRecord app = getProcessRecordLocked(aInfo.processName,
                    aInfo.applicationInfo.uid, true);
            if (app == null || app.instr == null) {
                intent.setFlags(intent.getFlags() | Intent.FLAG_ACTIVITY_NEW_TASK);
                final int resolvedUserId = UserHandle.getUserId(aInfo.applicationInfo.uid);
                // For ANR debugging to verify if the user activity is the one that actually
                // launched.
                final String myReason = reason + ":" + userId + ":" + resolvedUserId;
                mActivityStarter.startHomeActivityLocked(intent, aInfo, myReason);
            }
        } else {
            Slog.wtf(TAG, "No home screen found for " + intent, new Throwable());
        }

        return true;
    }

getHomeIntent 看下

    Intent getHomeIntent() {
        Intent intent = new Intent(mTopAction, mTopData != null ? Uri.parse(mTopData) : null);
        intent.setComponent(mTopComponent);
        intent.addFlags(Intent.FLAG_DEBUG_TRIAGED_MISSING);
        if (mFactoryTest != FactoryTest.FACTORY_TEST_LOW_LEVEL) {
            intent.addCategory(Intent.CATEGORY_HOME);
        }
        return intent;
    }

通过Intent 启动了Launcher App，
也就是AMS的systemReady 函数做的事就是通过Intent 启动了桌面app

三、总结

Android系统的启动流程基本分析完了，画一张简陋的图总结一下。

Android系统启动流程

一般面试问到Android系统启动流程，可以根据这个流程图，说一下Zygote、SystemServer、Launcher的启动流程大概是怎么样的。

如果你没有了解Android系统启动流程，面试刚好问到这个问题，你回答说不会，那么即使你后面问题都回答的很好，最终得到的评价也就是中级偏上。

todo：
1.3 ZygoteInit 的最后一个 zygoteServer.runSelectLoop(abiList);
方法开启一个无限循环,等待ActivityManagerService来连接这个socket然后调用ZygoteConnection.runOnce函数来创建新的应用程序进程，后面分析应用启动流程的时候再说。

Launcher启动参考：
https://www.jianshu.com/p/33152a7bec26

大家最好找个时间自己动手去实践一下，源码分析类的文章，从头看到尾，不去实践，很快就忘掉了，不会有太大的收获。

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