潇风寒月
潇风寒月

死磕Android_App 启动过程（含 Activity 启动过程）

1. 前言

Activity是日常开发中最常用的组件,系统给我们做了很多很多的封装,让我们平时用起来特别简单,很顺畅.但是你有没有想过,系统内部是如何启动一个Activity的呢?Activity对象是如何创建的,又是如何回调生命周期方法的?通过对底层工作原理的学习,是通往高级工程师的必经之路,我们必须对Activity的启动原理知己知彼,才能在平时的开发中应对各种疑难杂症.本文主要是对Activity启动流程的主要流程讲解,目的是给我们一个感性的认识,不用深扣代码细节,即可对上层开发有指导意义.除非是ROM开发,那底层细节还是需要注意.

插播:ActivityManagerService(以下简称AMS)管理着四大组件的启动、切换、调度及应用进程的管理和调度等工作，是Android中非常非常核心的服务.和AMS进行通信是需要跨进程的.

ps: 本文是以API 28为例

1.1 简单介绍一下主要的类

  • Instrumentation

Instrumentation会在应用程序的任何代码运行之前被实例化,它能够允许你监视应用程序和系统的所有交互.它还会构造Application,构建Activity,以及生命周期都会经过这个对象去执行.

  • ActivityManagerService

Android核心服务,简称AMS,负责调度各应用进程,管理四大组件.实现了IActivityManager接口,应用进程能通过Binder机制调用系统服务.

  • LaunchActivityItem

相当于是一个消息对象,当ActivityThread接收到这个消息则去启动Activity.收到消息后执行execute方法启动activity.

  • ActivityThread

应用的主线程.程序的入口.在main方法中开启loop循环,不断地接收消息,处理任务.

2. 应用的启动过程

2.1 Launcher简介

Launcher,也就是我们熟悉的安卓桌面,它其实是一个APP.只不过这个APP有点特殊,特殊在于它是系统开机后第一个启动的APP,并且该APP常驻在系统中,不会被杀死,用户一按home键就会回到桌面(回到该APP).桌面上面放了很多很多我们自己安装的或者是系统自带的APP,我们通过点击这个应用的快捷方法可以打开该应用.目前Android原生的Launcher版本是Launcher3.而下面提到的Launcher.java是Launcher3中的一个Activity.该Activity中摆放着各应用的快捷方式图标.

2.2 启动应用源码分析

我们通过点击快捷方式,Launcher这个Activity的onClick方法会被调用

public void onClick(View v) {
    ......
    Object tag = v.getTag();
    if (tag instanceof ShortcutInfo) {
        //点击的是快捷方式->onClickAppShortcut
        onClickAppShortcut(v);
    }
    .....
}

protected void onClickAppShortcut(final View v) {
    ....
    // Start activities
    startAppShortcutOrInfoActivity(v);
}

private void startAppShortcutOrInfoActivity(View v) {
    //将启动信息放在了点击View的tag里面
    ItemInfo item = (ItemInfo) v.getTag();
    // 应用程序安装的时候根据 AndroidManifest.xml 由 PackageManagerService 解析并保存的
    Intent intent;
    if (item instanceof PromiseAppInfo) {
        PromiseAppInfo promiseAppInfo = (PromiseAppInfo) item;
        intent = promiseAppInfo.getMarketIntent();
    } else {
        intent = item.getIntent();
    }
    
    boolean success = startActivitySafely(v, intent, item);
    ....
}

public boolean startActivitySafely(View v, Intent intent, ItemInfo item) {
    ......
    // Prepare intent
    intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
    ......
    // Could be launching some bookkeeping activity
    startActivity(intent, optsBundle);
    ......
}

在处理点击事件时,经过onClickAppShortcut方法调用startAppShortcutOrInfoActivity方法,获取Intent信息,然后调用startActivitySafely方法,在里面调用了我们经常使用的startActivity方法.因为Launcher类是一个Activity,所以调startActivity方法是理所当然的.这里调用startActivity方法就会启动APP的第一个Activity.

3. 启动Activity

以API 28的源码为例

3.1 启动进程

来到Activity的startActivity方法,这个方法最终会调用startActivityForResult()

public void startActivityForResult(@RequiresPermission Intent intent, int requestCode,
        @Nullable Bundle options) {
    //mMainThread是ActivityThread,mMainThread.getApplicationThread()是获取ApplicationThread
    Instrumentation.ActivityResult ar =
        mInstrumentation.execStartActivity(
            this, mMainThread.getApplicationThread(), mToken, this,
            intent, requestCode, options);
}

startActivityForResult里面调用了Instrumentation的execStartActivity方法,其中mMainThread是ActivityThread(就是从这里开始启动一个应用的),mMainThread.getApplicationThread()是获取ApplicationThread.ApplicationThread是ActivityThread的内部类,待会儿会介绍到.

public ActivityResult execStartActivity(
        Context who, IBinder contextThread, IBinder token, Activity target,
        Intent intent, int requestCode, Bundle options) {
    //1. 将ApplicationThread转为IApplicationThread
    IApplicationThread whoThread = (IApplicationThread) contextThread;
    
    //2. 获取AMS实例,调用startActivity方法
    int result = ActivityManager.getService()
        .startActivity(whoThread, who.getBasePackageName(), intent,
                intent.resolveTypeIfNeeded(who.getContentResolver()),
                token, target != null ? target.mEmbeddedID : null,
                requestCode, 0, null, options);
    checkStartActivityResult(result, intent);

    return null;
}

IApplicationThread是一个Binder接口,它继承自IInterface.ApplicationThread是继承了IApplicationThread.Stub,实现了IApplicationThread的,所以可以转成IApplicationThread.

然后就是获取AMS实例,调用AMS的startActivity方法.

public static IActivityManager getService() {
    return IActivityManagerSingleton.get();
}

private static final Singleton IActivityManagerSingleton =
        new Singleton() {
            @Override
            protected IActivityManager create() {
                //1. 获取服务的Binder对象
                final IBinder b = ServiceManager.getService(Context.ACTIVITY_SERVICE);
                //2. aidl 获取AMS
                final IActivityManager am = IActivityManager.Stub.asInterface(b);
                return am;
            }
        };

ServiceManager是安卓中一个重要的类，用于管理所有的系统服务，维护着系统服务和客户端的binder通信。返回的是Binder对象,用来进行应用与系统服务之间的通信的.

下面我们继续进入AMS的startActivity方法

@Override
public final int startActivity(IApplicationThread caller, String callingPackage,
        Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
        int startFlags, ProfilerInfo profilerInfo, Bundle bOptions) {
    return startActivityAsUser(caller, callingPackage, intent, resolvedType, resultTo,
            resultWho, requestCode, startFlags, profilerInfo, bOptions,
            UserHandle.getCallingUserId());
}
@Override
public final int startActivityAsUser(IApplicationThread caller, String callingPackage,
        Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
        int startFlags, ProfilerInfo profilerInfo, Bundle bOptions, int userId) {
    return startActivityAsUser(caller, callingPackage, intent, resolvedType, resultTo,
            resultWho, requestCode, startFlags, profilerInfo, bOptions, userId,
            true /*validateIncomingUser*/);
}

public final int startActivityAsUser(IApplicationThread caller, String callingPackage,
        Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
        int startFlags, ProfilerInfo profilerInfo, Bundle bOptions, int userId,
        boolean validateIncomingUser) {

    // TODO: Switch to user app stacks here.
    return mActivityStartController.obtainStarter(intent, "startActivityAsUser")
            .setCaller(caller)
            .setCallingPackage(callingPackage)
            .setResolvedType(resolvedType)
            .setResultTo(resultTo)
            .setResultWho(resultWho)
            .setRequestCode(requestCode)
            .setStartFlags(startFlags)
            .setProfilerInfo(profilerInfo)
            .setActivityOptions(bOptions)
            .setMayWait(userId)
            .execute();

}

AMS的startActivity方法会调用AMS的startActivityAsUser方法,然后又调用另一个startActivityAsUser方法.最后来了一串链式调用,最后会来到ActivityStarter的execute方法.

int execute() {
    return startActivityMayWait(mRequest.caller, mRequest.callingUid,
            mRequest.callingPackage, mRequest.intent, mRequest.resolvedType,
            mRequest.voiceSession, mRequest.voiceInteractor, mRequest.resultTo,
            mRequest.resultWho, mRequest.requestCode, mRequest.startFlags,
            mRequest.profilerInfo, mRequest.waitResult, mRequest.globalConfig,
            mRequest.activityOptions, mRequest.ignoreTargetSecurity, mRequest.userId,
            mRequest.inTask, mRequest.reason,
            mRequest.allowPendingRemoteAnimationRegistryLookup);
}
private int startActivityMayWait(IApplicationThread caller, int callingUid,
        String callingPackage, Intent intent, String resolvedType,
        IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
        IBinder resultTo, String resultWho, int requestCode, int startFlags,
        ProfilerInfo profilerInfo, WaitResult outResult,
        Configuration globalConfig, SafeActivityOptions options, boolean ignoreTargetSecurity,
        int userId, TaskRecord inTask, String reason,
        boolean allowPendingRemoteAnimationRegistryLookup) {
    ......
    int res = startActivity(caller, intent, ephemeralIntent, resolvedType, aInfo, rInfo,
            voiceSession, voiceInteractor, resultTo, resultWho, requestCode, callingPid,
            callingUid, callingPackage, realCallingPid, realCallingUid, startFlags, options,
            ignoreTargetSecurity, componentSpecified, outRecord, inTask, reason,
            allowPendingRemoteAnimationRegistryLookup);
    ......
}

private int startActivity(IApplicationThread caller, Intent intent, Intent ephemeralIntent,
        String resolvedType, ActivityInfo aInfo, ResolveInfo rInfo,
        IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
        IBinder resultTo, String resultWho, int requestCode, int callingPid, int callingUid,
        String callingPackage, int realCallingPid, int realCallingUid, int startFlags,
        SafeActivityOptions options, boolean ignoreTargetSecurity, boolean componentSpecified,
        ActivityRecord[] outActivity, TaskRecord inTask, String reason,
        boolean allowPendingRemoteAnimationRegistryLookup) {
    ......
    mLastStartActivityResult = startActivity(caller, intent, ephemeralIntent, resolvedType,
            aInfo, rInfo, voiceSession, voiceInteractor, resultTo, resultWho, requestCode,
            callingPid, callingUid, callingPackage, realCallingPid, realCallingUid, startFlags,
            options, ignoreTargetSecurity, componentSpecified, mLastStartActivityRecord,
            inTask, allowPendingRemoteAnimationRegistryLookup);
    ......
}

private int startActivity(IApplicationThread caller, Intent intent, Intent ephemeralIntent,
        String resolvedType, ActivityInfo aInfo, ResolveInfo rInfo,
        IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
        IBinder resultTo, String resultWho, int requestCode, int callingPid, int callingUid,
        String callingPackage, int realCallingPid, int realCallingUid, int startFlags,
        SafeActivityOptions options,
        boolean ignoreTargetSecurity, boolean componentSpecified, ActivityRecord[] outActivity,
        TaskRecord inTask, boolean allowPendingRemoteAnimationRegistryLookup) {
    ......
    return startActivity(r, sourceRecord, voiceSession, voiceInteractor, startFlags,
            true /* doResume */, checkedOptions, inTask, outActivity);
}

ActivityStarter的execute方法会继续调用startActivityMayWait方法.startActivityMayWait会去调用startActivity方法,然后调用另一个startActivity方法.然后又是调用另一个startActivity方法,

不得不说,这些方法的参数可真是长啊,,,,可能是由于历史原因吧.

private int startActivity(final ActivityRecord r, ActivityRecord sourceRecord,
            IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
            int startFlags, boolean doResume, ActivityOptions options, TaskRecord inTask,
            ActivityRecord[] outActivity) {
    ......
    result = startActivityUnchecked(r, sourceRecord, voiceSession, voiceInteractor,
                startFlags, doResume, options, inTask, outActivity);
    ......
}

private int startActivityUnchecked(final ActivityRecord r, ActivityRecord sourceRecord,
        IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
        int startFlags, boolean doResume, ActivityOptions options, TaskRecord inTask,
        ActivityRecord[] outActivity) {
    .......
    mSupervisor.resumeFocusedStackTopActivityLocked(mTargetStack, mStartActivity, mOptions);

    return START_SUCCESS;
}

终于不用调用startActivity方法了,调用startActivityUnchecked方法,在里面调用了ActivityStackSupervisor的resumeFocusedStackTopActivityLocked方法

 boolean resumeFocusedStackTopActivityLocked(
        ActivityStack targetStack, ActivityRecord target, ActivityOptions targetOptions) {
    ......
    return targetStack.resumeTopActivityUncheckedLocked(target, targetOptions);
    ......
}

targetStack是ActivityStack,会调用ActivityStack的resumeTopActivityUncheckedLocked方法,然后调用resumeTopActivityInnerLocked方法.

boolean resumeTopActivityUncheckedLocked(ActivityRecord prev, ActivityOptions options) {
    ......
    result = resumeTopActivityInnerLocked(prev, options);
    .....
    return result;
}


private boolean resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options) {
    ......
    mStackSupervisor.startSpecificActivityLocked(next, true, false);
    ......
    return true;
}

然后又会回到ActivityStackSupervisor的startSpecificActivityLocked方法


void startSpecificActivityLocked(ActivityRecord r,
            boolean andResume, boolean checkConfig) {
    ....
    //进程存在则启动
    if (app != null && app.thread != null) {
        realStartActivityLocked(r, app, andResume, checkConfig);
        return;
    }
    
    //进程不存在则创建
    mService.startProcessLocked(r.processName, r.info.applicationInfo, true, 0,
            "activity", r.intent.getComponent(), false, false, true);
}

这里会判断一下进程是否存在,如果不存在则创建一下.这里的mService是AMS,会调用AMS的startProcessLocked方法.

final ProcessRecord startProcessLocked(String processName,
            ApplicationInfo info, boolean knownToBeDead, int intentFlags,
        String hostingType, ComponentName hostingName, boolean allowWhileBooting,
        boolean isolated, boolean keepIfLarge) {
    return startProcessLocked(processName, info, knownToBeDead, intentFlags, hostingType,
            hostingName, allowWhileBooting, isolated, 0 /* isolatedUid */, keepIfLarge,
            null /* ABI override */, null /* entryPoint */, null /* entryPointArgs */,
            null /* crashHandler */);
}

final ProcessRecord startProcessLocked(String processName, ApplicationInfo info,
        boolean knownToBeDead, int intentFlags, String hostingType, ComponentName hostingName,
        boolean allowWhileBooting, boolean isolated, int isolatedUid, boolean keepIfLarge,
        String abiOverride, String entryPoint, String[] entryPointArgs, Runnable crashHandler) {
    ......
    final boolean success = startProcessLocked(app, hostingType, hostingNameStr, abiOverride);
    ......
}

private final boolean startProcessLocked(ProcessRecord app,
        String hostingType, String hostingNameStr, String abiOverride) {
    return startProcessLocked(app, hostingType, hostingNameStr,
            false /* disableHiddenApiChecks */, abiOverride);
}

private final boolean startProcessLocked(ProcessRecord app, String hostingType,
            String hostingNameStr, boolean disableHiddenApiChecks, String abiOverride) {
    ......
    return startProcessLocked(hostingType, hostingNameStr, entryPoint, app, uid, gids,
            runtimeFlags, mountExternal, seInfo, requiredAbi, instructionSet, invokeWith,
            startTime);
    ......
}

private boolean startProcessLocked(String hostingType, String hostingNameStr, String entryPoint,
            ProcessRecord app, int uid, int[] gids, int runtimeFlags, int mountExternal,
            String seInfo, String requiredAbi, String instructionSet, String invokeWith,
            long startTime) {
    ......
    final ProcessStartResult startResult = startProcess(app.hostingType, entryPoint,
            app, app.startUid, gids, runtimeFlags, mountExternal, app.seInfo,
            requiredAbi, instructionSet, invokeWith, app.startTime);
    ......
}

private ProcessStartResult startProcess(String hostingType, String entryPoint,
        ProcessRecord app, int uid, int[] gids, int runtimeFlags, int mountExternal,
        String seInfo, String requiredAbi, String instructionSet, String invokeWith,
        long startTime) {
    ......
    startResult = Process.start(entryPoint,
            app.processName, uid, uid, gids, runtimeFlags, mountExternal,
            app.info.targetSdkVersion, seInfo, requiredAbi, instructionSet,
            app.info.dataDir, invokeWith,
            new String[] {PROC_START_SEQ_IDENT + app.startSeq});
    ......
}

这里AMS调用了很多层startProcessLocked,最终都会调用startProcess方法,然后通过Process调用start方法.

public static final ProcessStartResult start(final String processClass,
                              final String niceName,
                              int uid, int gid, int[] gids,
                              int debugFlags, int mountExternal,
                              int targetSdkVersion,
                              String seInfo,
                              String abi,
                              String instructionSet,
                              String appDataDir,
                              String[] zygoteArgs) {
    return startViaZygote(processClass, niceName, uid, gid, gids,
            debugFlags, mountExternal, targetSdkVersion, seInfo,
            abi, instructionSet, appDataDir, zygoteArgs);
}

private static ProcessStartResult startViaZygote(final String processClass,
                              final String niceName,
                              final int uid, final int gid,
                              final int[] gids,
                              int debugFlags, int mountExternal,
                              int targetSdkVersion,
                              String seInfo,
                              String abi,
                              String instructionSet,
                              String appDataDir,
                              String[] extraArgs)
                              throws ZygoteStartFailedEx {
    ......           
    //如果需要,则打开Socket,用来和zygote通讯
    return zygoteSendArgsAndGetResult(openZygoteSocketIfNeeded(abi), argsForZygote);
}

private static Process.ProcessStartResult zygoteSendArgsAndGetResult(
        ZygoteState zygoteState, ArrayList args)
        throws ZygoteStartFailedEx {
    ......
    final BufferedWriter writer = zygoteState.writer;
    final DataInputStream inputStream = zygoteState.inputStream;

    writer.write(Integer.toString(args.size()));
    writer.newLine();

    for (int i = 0; i < sz; i++) {
        String arg = args.get(i);
        writer.write(arg);
        writer.newLine();
    }

    writer.flush();

    // Should there be a timeout on this?
    Process.ProcessStartResult result = new Process.ProcessStartResult();

    // Always read the entire result from the input stream to avoid leaving
    // bytes in the stream for future process starts to accidentally stumble
    // upon.
    result.pid = inputStream.readInt();
    result.usingWrapper = inputStream.readBoolean();

    if (result.pid < 0) {
        throw new ZygoteStartFailedEx("fork() failed");
    }
    return result;
    ......
}

上一步拿到了zygoteState 现在进行通讯，首先通过一个一个参数write方法传输过去给zygote.zygote拿到这些参数就会给你创建好需要的进程.然后返回结果通过read读取出来。这里创建的进程就是APP的进程.zygote通过fork出子进程.

3.2 启动主线程

进程的入口,也就是被我们熟知的ActivityThread的main方法,这个方法思路异常清晰,非常简洁.当然,这里也是主线程的入口.

public static void main(String[] args) {
    
    //分析1 主线程Looper安排上
    Looper.prepareMainLooper();

    ......
    //分析2  
    ActivityThread thread = new ActivityThread();
    thread.attach(false, startSeq);
    
    //分析3 死循环,接收主线程上的消息
    Looper.loop();

    throw new RuntimeException("Main thread loop unexpectedly exited");
}

其中分析1和分析3在死磕Android_Handler机制你需要知道的一切已进行详细的描述讲解,这里不再赘述.

我们来分析一下第2点:

final ApplicationThread mAppThread = new ApplicationThread();
private void attach(boolean system, long startSeq) {
    ......
    if (!system) {
        //这一步是获取AMS实例,上面已经出现过
        final IActivityManager mgr = ActivityManager.getService();
        //然后跨进程通信
        mgr.attachApplication(mAppThread, startSeq);
    } 
}

通过获取AMS,进行跨进程通信,调用AMS的attachApplication方法

public final void attachApplication(IApplicationThread thread, long startSeq) {
    synchronized (this) {
        int callingPid = Binder.getCallingPid();
        final int callingUid = Binder.getCallingUid();
        final long origId = Binder.clearCallingIdentity();
        attachApplicationLocked(thread, callingPid, callingUid, startSeq);
        Binder.restoreCallingIdentity(origId);
    }
}

@GuardedBy("this")
private final boolean attachApplicationLocked(IApplicationThread thread,
        int pid, int callingUid, long startSeq) {

    ......
    //这里的thread就是ActivityThread中的ApplicationThread
    thread.bindApplication(processName, appInfo, providers,
            app.instr.mClass,
            profilerInfo, app.instr.mArguments,
            app.instr.mWatcher,
            app.instr.mUiAutomationConnection, testMode,
            mBinderTransactionTrackingEnabled, enableTrackAllocation,
            isRestrictedBackupMode || !normalMode, app.persistent,
            new Configuration(getGlobalConfiguration()), app.compat,
            getCommonServicesLocked(app.isolated),
            mCoreSettingsObserver.getCoreSettingsLocked(),
            buildSerial, isAutofillCompatEnabled);

    // See if the top visible activity is waiting to run in this process...
    //看一下是不是有需要运行的Activity
    if (normalMode) {
        try {
            if (mStackSupervisor.attachApplicationLocked(app)) {
                didSomething = true;
            }
        } catch (Exception e) {
            Slog.wtf(TAG, "Exception thrown launching activities in " + app, e);
            badApp = true;
        }
    }

    ......
    return true;
}

这里有2个需要注意的点

  • 第一个是通过跨进程调用AMS的attachApplication方法,然后继续调用attachApplicationLocked方法,然而却又跨进程调用ActivityThread中的mAppThread(ApplicationThread)中的bindApplication方法.一看便知道是创建Application
  • 第二个是开启第一个Activity,调用ActivityStackSupervisor的attachApplicationLocked方法.

3.3 创建Application

我们先来看ApplicationThread的bindApplication方法

public final void bindApplication(String processName, ApplicationInfo appInfo,
        List providers, ComponentName instrumentationName,
        ProfilerInfo profilerInfo, Bundle instrumentationArgs,
        IInstrumentationWatcher instrumentationWatcher,
        IUiAutomationConnection instrumentationUiConnection, int debugMode,
        boolean enableBinderTracking, boolean trackAllocation,
        boolean isRestrictedBackupMode, boolean persistent, Configuration config,
        CompatibilityInfo compatInfo, Map services, Bundle coreSettings,
        String buildSerial, boolean autofillCompatibilityEnabled) {

    AppBindData data = new AppBindData();
    .......
    //主要就是发送一个消息
    sendMessage(H.BIND_APPLICATION, data);
}

void sendMessage(int what, Object obj) {
    sendMessage(what, obj, 0, 0, false);
}

private void sendMessage(int what, Object obj, int arg1, int arg2, boolean async) {
    if (DEBUG_MESSAGES) Slog.v(
        TAG, "SCHEDULE " + what + " " + mH.codeToString(what)
        + ": " + arg1 + " / " + obj);
    Message msg = Message.obtain();
    msg.what = what;
    msg.obj = obj;
    msg.arg1 = arg1;
    msg.arg2 = arg2;
    if (async) {
        msg.setAsynchronous(true);
    }
    //mH是一个Handler,发送了一个消息
    mH.sendMessage(msg);
}


 class H extends Handler {
        //先看看这个Handler的部分消息名称,一看就知道是干嘛的,什么绑定Application,绑定Service,停止Service什么的.这个Handler和这些组件的启动停止什么的,关系非常大.
        //其实这个Handler在API 28之前的时候消息更多,(API 28只是融合了一下,多个消息变成1个消息,还是会走到这个Handler),之前Activity的各种生命周期回调都有对应的消息名称里.现在是融合了.
        public static final int BIND_APPLICATION        = 110;
        public static final int EXIT_APPLICATION        = 111;
        public static final int RECEIVER                = 113;
        public static final int CREATE_SERVICE          = 114;
        public static final int SERVICE_ARGS            = 115;
        public static final int STOP_SERVICE            = 116;
        public static final int CONFIGURATION_CHANGED   = 118;
        public static final int CLEAN_UP_CONTEXT        = 119;
        public static final int GC_WHEN_IDLE            = 120;
        public static final int BIND_SERVICE            = 121;
        public static final int RELAUNCH_ACTIVITY = 160;
}

在ApplicationThread的bindApplication中会调用sendMessage(该方法是ActivityThread中的,因为ApplicationThread是内部类,所以可以调用)方法发送一条消息,通过H(这个类是ActivityThread的内部类)这个Handler进行接收消息.因为ApplicationThread是运行在Binder线程池中,所以需要切换到主线程中进行一些UI上的操作,比如开启Activity什么的.最后会来到H的BIND_APPLICATION消息处

public void handleMessage(Message msg) {
    switch (msg.what) {
        case BIND_APPLICATION:
            AppBindData data = (AppBindData)msg.obj;
            handleBindApplication(data);
            break;
        ......
    }
}

private void handleBindApplication(AppBindData data) {

    // Continue loading instrumentation.
    if (ii != null) {
        ApplicationInfo instrApp;
        instrApp = getPackageManager().getApplicationInfo(ii.packageName, 0,
                UserHandle.myUserId());
        //构建ContextImpl
        final ContextImpl instrContext = ContextImpl.createAppContext(this, pi);
        //获取其classLoader
        final ClassLoader cl = instrContext.getClassLoader();
        //构建Instrumentation 
        mInstrumentation = (Instrumentation)
            cl.loadClass(data.instrumentationName.getClassName()).newInstance();
    } else {
        mInstrumentation = new Instrumentation();
        mInstrumentation.basicInit(this);
    }

    Application app;
    // If the app is being launched for full backup or restore, bring it up in
    // a restricted environment with the base application class.
    //构建Application
    app = data.info.makeApplication(data.restrictedBackupMode, null);

    //调用Application的onCreate方法
    mInstrumentation.callApplicationOnCreate(app);
}

//sources/android-28/android/app/LoadedApk.java#makeApplication
public Application makeApplication(boolean forceDefaultAppClass,
        Instrumentation instrumentation) {
    //注意,如果Application已经初始化,那么就不重新初始化了  
    if (mApplication != null) {
        return mApplication;
    }

    Application app = null;

    String appClass = mApplicationInfo.className;
    if (forceDefaultAppClass || (appClass == null)) {
        appClass = "android.app.Application";
    }
    //构建Application
    app = mActivityThread.mInstrumentation.newApplication(
            cl, appClass, appContext);
    appContext.setOuterContext(app);

    return app;
}

//sources/android-28/android/app/Instrumentation.java#newApplication
public Application newApplication(ClassLoader cl, String className, Context context)
        throws InstantiationException, IllegalAccessException, 
        ClassNotFoundException {
    //通过反射构建Application
    Application app = getFactory(context.getPackageName())
            .instantiateApplication(cl, className);
    //赋值Context
    app.attach(context);
    return app;
}
public @NonNull Application instantiateApplication(@NonNull ClassLoader cl,
        @NonNull String className)
        throws InstantiationException, IllegalAccessException, ClassNotFoundException {
    return (Application) cl.loadClass(className).newInstance();
}

在H这个Handler中处理BIND_APPLICATION这个消息,首先是通过ClassLoader加载构建Instrumentation对象,然后通过LoadedApk调用Instrumentation的newApplication 方法(这里有点奇怪,为什么不用构建出来的mInstrumentation直接调用newApplication方法..),通过loadClass的方式将Application对象创建出来,然后调用Application的onCreate生命周期方法.

3.4 创建Activity

下面我们继续ActivityStackSupervisor的attachApplicationLocked方法

boolean attachApplicationLocked(ProcessRecord app) throws RemoteException {
    ......
    realStartActivityLocked(activity, app,top == activity, true);
    ......
}

final boolean realStartActivityLocked(ActivityRecord r, ProcessRecord app,
            boolean andResume, boolean checkConfig) throws RemoteException {
    ......
    // Create activity launch transaction.
    //创建活动启动事务。
    final ClientTransaction clientTransaction = ClientTransaction.obtain(app.thread,
            r.appToken);
    //构建LaunchActivityItem对象,并传入clientTransaction中,用作callback
    clientTransaction.addCallback(LaunchActivityItem.obtain(new Intent(r.intent),
            System.identityHashCode(r), r.info,
            // TODO: Have this take the merged configuration instead of separate global
            // and override configs.
            mergedConfiguration.getGlobalConfiguration(),
            mergedConfiguration.getOverrideConfiguration(), r.compat,
            r.launchedFromPackage, task.voiceInteractor, app.repProcState, r.icicle,
            r.persistentState, results, newIntents, mService.isNextTransitionForward(),
            profilerInfo));

    // Schedule transaction.
    //执行事务  这里getLifecycleManager获取的是ClientLifecycleManager
    mService.getLifecycleManager().scheduleTransaction(clientTransaction);
    ......
}

//ClientLifecycleManager#scheduleTransaction
void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
    //继续深入
    transaction.schedule();
}

//ClientTransaction#schedule
public void schedule() throws RemoteException {
    //这里的mClient是ApplicationThread
    mClient.scheduleTransaction(this);
}

//ApplicationThread#scheduleTransaction
@Override
public void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
    //ActivityThread是继承自ClientTransactionHandler的,scheduleTransaction方法在ClientTransactionHandler里面
    ActivityThread.this.scheduleTransaction(transaction);
}

//ClientTransactionHandler#scheduleTransaction
void scheduleTransaction(ClientTransaction transaction) {
    transaction.preExecute(this);
    //注意啦,这里向ActivityThread里面的H这个Handler发送了一个EXECUTE_TRANSACTION的消息,并且将ClientTransaction对象也传了进去
    sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);
}
//ClientTransactionHandler#sendMessage   这个方法是抽象方法,是在ActivityThread里面实现的,当然是给H这个Handler发消息啦
abstract void sendMessage(int what, Object obj);

在Android8.0中，是通过ApplicationThread.scheduleLaunchActivity()对相关数据进行封装，然后通过调用ActivityThread类的sendMessage()发送出去。
但是在Android9.0中，引入了ClientLifecycleManager和ClientTransactionHandler来辅助管理Activity生命周期。 相当于将生命周期抽象了出来,一个生命周期取而代之的是一个对象.

通过上面方法调用的辗转反侧,最后来到了ClientTransactionHandler的scheduleTransaction方法,然后向ActivityThread的H发送了一个EXECUTE_TRANSACTION消息.
在API 28里面,ActivityThread的H这个Handler里面已经没了之前的那些什么LAUNCH_ACTIVITY、PAUSE_ACTIVITY、RESUME_ACTIVITY这些消息了,取而代之的是EXECUTE_TRANSACTION这一个消息.

//ActivityThread里面的H  
private final TransactionExecutor mTransactionExecutor = new TransactionExecutor(this);  //这里传入的是ClientTransactionHandler对象(即ActivityThread),ClientTransactionHandler是ActivityThread的父类
class H extends Handler {
    public void handleMessage(Message msg) {
        switch (msg.what) {
            case EXECUTE_TRANSACTION:
                //首先取出ClientTransaction对象
                final ClientTransaction transaction = (ClientTransaction) msg.obj;
                //将ClientTransaction传入execute方法
                mTransactionExecutor.execute(transaction);
        }
    }
}

//TransactionExecutor#execute
public void execute(ClientTransaction transaction) {
    final IBinder token = transaction.getActivityToken();
    log("Start resolving transaction for client: " + mTransactionHandler + ", token: " + token);

    executeCallbacks(transaction);

    executeLifecycleState(transaction);
    mPendingActions.clear();
    log("End resolving transaction");
}

//TransactionExecutor#executeCallbacks
public void executeCallbacks(ClientTransaction transaction) {
    //取出ClientTransaction对象里面的callback,即上面的LaunchActivityItem
    final List callbacks = transaction.getCallbacks();

    final int size = callbacks.size();
    for (int i = 0; i < size; ++i) {
        final ClientTransactionItem item = callbacks.get(i);
        final int postExecutionState = item.getPostExecutionState();
        final int closestPreExecutionState = mHelper.getClosestPreExecutionState(r,
                item.getPostExecutionState());

        item.execute(mTransactionHandler, token, mPendingActions);
        item.postExecute(mTransactionHandler, token, mPendingActions);
    }
}

//LaunchActivityItem#execute
@Override
public void execute(ClientTransactionHandler client, IBinder token,
        PendingTransactionActions pendingActions) {
    //调用ActivityThread的handleLaunchActivity方法
    client.handleLaunchActivity(r, pendingActions, null);
}

在ActivityThread中的EXECUTE_TRANSACTION消息中,执行了TransactionExecutor对象的execute方法,然后在里面我们执行了executeCallbacks方法.在executeCallbacks方法里面拿出ClientTransaction对象的callback,即上面存进去的LaunchActivityItem.
再执行LaunchActivityItem的execute方法,调用的是ActivityThread的handleLaunchActivity方法,终于来到了我们熟悉的环节.

//ActivityThread#handleLaunchActivity
@Override
public Activity handleLaunchActivity(ActivityClientRecord r,
        PendingTransactionActions pendingActions, Intent customIntent) {
    .....
    //终于要开始调用performLaunchActivity这个熟悉的方法了
    final Activity a = performLaunchActivity(r, customIntent);
    ......
}

//ActivityThread#performLaunchActivity
private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
    ......
    ContextImpl appContext = createBaseContextForActivity(r);
    Activity activity = null;

    //获取ClassLoader
    java.lang.ClassLoader cl = appContext.getClassLoader();
    
    //通过(Activity) cl.loadClass(className).newInstance()创建
    //重点来啦:Activity是在ActivityThread的performLaunchActivity方法中用ClassLoader类加载器创建出来的。
    activity = mInstrumentation.newActivity(cl, component.getClassName(), r.intent);
    
    //底层也是通过反射构建Application,如果已经构建则不会重复构建,毕竟一个进程只能有一个Application
    Application app = r.packageInfo.makeApplication(false, mInstrumentation);

    if (activity != null) {
        Window window = null;
        appContext.setOuterContext(activity);
        //在这里实例化了PhoneWindow,并将该Activity设置为PhoneWindow的Callback回调,还初始化了WindowManager
        activity.attach(appContext, this, getInstrumentation(), r.token,
                r.ident, app, r.intent, r.activityInfo, title, r.parent,
                r.embeddedID, r.lastNonConfigurationInstances, config,
                r.referrer, r.voiceInteractor, window, r.configCallback);
                
        //间接调用了Activity的performCreate方法,间接调用了Activity的onCreate方法.
        mInstrumentation.callActivityOnCreate(activity, r.state);
        
        //这里和上面onCreate过程差不多,调用Activity的onStart方法
        if (!r.activity.mFinished) {
            activity.performStart();
            r.stopped = false;
        }
        ....
    }

    return activity;
}

这个流程就比较熟悉了,重点是:Activity是在ActivityThread的performLaunchActivity方法中用ClassLoader类加载器创建出来的. 创建出来之后就会调用Activity的onCreate方法和onStart方法.

关于后面的Activity创建出来之后的View的绘制,请看这里

参考

  • Launcher3--初识Launcher3
  • App 启动过程（含 Activity 启动过程） | 安卓 offer 收割基
  • Android app启动流程：Process.start（3）
  • Android9.0 Activity启动流程分析（二）
  • Android Render(一)Activity窗口构成和绘制解析

你可能感兴趣的:(死磕Android_App 启动过程（含 Activity 启动过程）)

  • 放下是一段成长的修行 小莳玥
    人来到这个世界上，只有两件事：生和死。一件事已经做完了，另一件你还急什么呢?是人，都有七情六欲。是心，都有喜怒哀乐，这些再正常不过了。别总抱怨自己活得累，过得辛苦。永远记住：舒坦是留给死人的。苦，才是生活；累，才是工作；变，才是命运；忍，才是历练；容，才是智慧；静，才是修养；舍，才会得到；做，才会拥有。人生，活得太清楚，才是最大的不明白。有些事，看得很清，却说不清；有些人，了解很深，却猜不透；有些
  • 《庄子.达生9》 钱江潮369
    【原文】孔子观于吕梁，县水三十仞，流沫四十里，鼋鼍鱼鳖之所不能游也。见一丈夫游之，以为有苦而欲死也，使弟子并流而拯之。数百步而出，被发行歌而游于塘下。孔子从而问焉，曰：“吾以子为鬼，察子则人也。请问，‘蹈水有道乎’”曰：“亡，吾无道。吾始乎故，长乎性，成乎命。与齐俱入，与汩偕出，从水之道而不为私焉。此吾所以蹈之也。”孔子曰：“何谓始乎故，长乎性，成乎命？”曰：“吾生于陵而安于陵，故也；长于水而安于
  • 如何成为段子手 欣雅阅读
    我是一个尬聊大师，与朋友聊天经常把话题聊死，留我一个人在群里，望着自己打下的最后一句话无语凝噎。看到风趣幽默的朋友与人聊天，很是艳羡，觉得自己何时才能成为这样的段子手呢？一、段子是什么？“段子”一词在百度百科上的解释：本是相声中的一个艺术术语，指的是相声作品中一节或一段艺术内容。我的理解：段子就是一些搞笑的故事或者笑话。二、为什么要会说段子？不知道大家有没有这样的朋友，本来很无趣的聚会，只要有他参
  • 学霸父母学渣娃，这孩子真是亲生的？太扎心了！ 东北SK皇家成长中心
    现在的社会，每个家庭基本都把孩子的教育放在第一位，哪怕父母平时上班再苦再累也不敢在孩子的教育上有丝毫的马虎，平时对孩子的照顾真的是无微不至，每天早起送孩子上学，晚上回家辅导孩子写作业，有的父母的文化程度非常高，但是每每到了辅导孩子写作业这个时候，父母们内心都有这样一种想法，这个孩子真的是我亲生的吗？真想一巴掌拍死他，我上辈子是做了什么孽生出这么一个智障的孩子，家里每每就要上演全武行，看看这些孩子到
  • 生命如花 坦释空
    每个人的心中都有一株妙莲花。这是禅家语。禅家总是站在理性的高处，以超越红尘的洒脱来参悟人生和自省生命。那么，凡俗中人呢？生如夏花之绚丽，死如秋叶之静美。这是诗人语。多少人在赞美：姑娘好像花一样！又有多少人在咏歌：花儿与少年。的确，人生如花。花一样的生命，理应自诞生之日起，就一瓣一瓣地绽放她的美丽与清香，使这个原本死寂荒凉的世界五彩缤纷，充满快乐。事实上，人类自诞生起，就一代一代地做着这方面的努力，
  • 小燕子的故事 同楼秀才
    有则寓言故事：秋天来了，一只小燕子问正在忙碌的蚂蚁：“你们这是在做什么？”“我们在贮藏食物过冬。”它们迅速地回答。“这很聪明，”燕子说，“我也要这样做。”她立即动手把一些死蜘蛛、死苍蝇衔往自己的巢里去。“弄这做什么？”她的母亲终于忍不住问道。“预备过严寒的冬天呀，亲爱的妈妈；是蚂蚁把这种方法教给我的。”老燕说，“适合于它们做的并不适合于优秀的燕子。仁慈的大自然给我们安排了一个更吉利的命运。如果丰腴
  • 「原创」海丰阿东：人若不死生有何欢，长命百岁只是梦想 海丰阿东
    「原创」海丰阿东：人若不死生有何欢，长命百岁只是梦想有生必有死，人生的规律如此，任何人都无法回避。但如果一个人能长命百岁，永远活着，其实也并不是一件好事情。你永远活着，在你身边那些熟悉的东西都渐渐的离你而去，你成了一个孤家寡人。最后你只能在回忆中生活着，一定是十分的孤独啊。其实有生必有死，因为死亡的存在，让生便有了意义。人活着才有价值，正是因为有死亡，才凸显出来了。编辑当然了，同样是活着也会产生不
  • 2019年8月6日 星期二 晴 李佳晨宝宝
    今天我写完作业以后，我玩儿了一会儿我的拼装玩具，拼装玩具是我的世界的游戏里面的乐高，我拿出乐高把它拼成上次的迷宫，然后又给他升级了一下，我拆出上面一些部分的零件加大了游戏的难度，然后我又做了一个小牛圈。这个小牛圈里面住的是猪和牛，还有羊，给那里摆了一块草地，他们想吃东西直接在草地上吃，然后我把牛圈建了一个遮阳伞，防止天气太热把它们晒死。然后这样我的小牛就万无一失了，我再看看加大难度后的迷宫，实在是
  • 读《房思琪的初恋乐园》——林奕含 芥末绿zq
    小说的描写就像一座文字殿堂一样，将每个细节都堆砌得如此繁复精美，我读不懂，我只拣了其中粗暴恶俗、直扎人心的现实。强暴、诱奸、家暴、冷漠、助纣为虐……，故事里全是罪恶的词，不管用什么贬义的词都无法形容。文中无限重复的文学素养，譬喻就像作者无声的哀嚎，撞进我的心头。脑子里无限重复着“温良恭俭让”。就像她在采访里说的，她最痛苦的一点就是，一个真正相信文学的人，他怎么可以背叛这个浩浩汤汤已经超过五千年的语
  • 【Python搞定车载自动化测试】——Python实现车载以太网DoIP刷写（含Python源码） 疯狂的机器人 Python搞定车载自动化pythonDoIPUDSISO142291SO13400Bootloadertcp/ip
    系列文章目录【Python搞定车载自动化测试】系列文章目录汇总文章目录系列文章目录前言一、环境搭建1.软件环境2.硬件环境二、目录结构三、源码展示1.DoIP诊断基础函数方法2.DoIP诊断业务函数方法3.27服务安全解锁4.DoIP自动化刷写四、测试日志1.测试日志五、完整源码链接前言随着智能电动汽车行业的发展，汽车=智能终端+四个轮子，各家车企都推出了各自的OTA升级方案，本章节主要介绍如何使
  • 苦与甜 天天天很蓝lwy
    佛说有人生有七苦：生、老、病、死，怨憎会、爱别离、求不得。没有人会追求苦难，因为我不是佛。我做不到，像佛一样割肉喂鹰。做不到，他一样去经历六道轮回。我发现，我能够做到和改变的就是面对苦难的心境。希望有一天，面对所谓的苦，我能够甘之如饴。希望有一天，我能够成为积极主动有选择的人。不因外物改变自己的心境。少说一些，不得不，必须。多说一些，我能够，我希望，我可以。图片发自App
  • 封侯非吾意但愿海波平 修源正本
    《韬钤深处》明·戚继光小筑暂高枕，忧时旧有盟。呼樽来揖客，挥麈坐谈兵。云护牙签满，星含宝剑横。封侯非我意，但愿海波平。嘉靖二十五年（1546年），戚继光负责管理登州卫所的屯田事务，当时山东沿海一带，遭受到倭寇的烧杀抢掠，戚继光有心杀贼，于是在一本兵书的空白处，写下了“封侯非我意，但愿海波平”的诗句。“养心莫若寡欲，至乐无如读书”是戚继光又一句名言。从这句话中可以得知戚继光对读书做学问的真知灼见。戚
  • TC27x启动过程（2）-TC277 赞哥哥s TC277学习笔记gnu单片机
    接上文，继续学习TC277的启动过程。分析启动函数有关用的寄存器说明，参考文章TC27x寄存器学习目录TC27x寄存器学习start函数分析isync汇编指令（同步指令）dsync汇编指令（同步数据），1清除endinit2设置中断堆栈3启用对系统全局寄存器的写访问4初始化SDA基指针5关闭对系统全局寄存器的写访问6关闭看门狗，恢复Endinit位7初始化CSA8初始化ram,拷贝rom数据到ra
  • 正常化的同理 迷你旅客
    郑璐宜昌焦点网络中级七期原创持续分享第214天SBFT的同理方式除了反应来访者的感受之外，更会暗示事情有其他可能性的存在，以试图动摇来访者的负面感受，改变她的自我觉知。其原则包括：1、将来访者所说的内容以“过去式”的动词（如：加上“曾经”）进行回应，暗示现在的负向可以成为过去。2、把来访者所用的含绝对性、强烈性的字眼，换为严重程度较低或发生比例较少的用字。例如，来访者说：“每天总是觉得快要发疯了。
  • 生老病死 贝贝_1
    生老病死是生命的必然过程，是人生的必由之路。人生在世不过几十年，所包罗的生、老、病、死是不以人的意志为转移的。我们唯一能做到的就是顺乎自然，珍惜生命，老有所乐，战胜病魔，笑对死亡。生图片发自App“生”不由己，尽管你不愿睁开眼睛，尽管你哭着喊着，但你还是被带到了这个世界，而所有围着你的人包括你的父母，就是要听见你离开母体发出的这一串串生命的哭声，他们才会笑，并且笑得那般的欣慰。是啊，这第一声哭是你
  • 《乖，摸摸头》精彩桥段摘要 第二說
    职业是职业，事业是事业，没必要把职业升迁和事业成就混为一谈，也没必要把一份工作当唯一的轴心，别把工作和生活硬搞成对立面，兼顾温饱没有错，可一辈子被一份工作拴死，那也太无趣了。——《大冰.乖，摸摸头》精彩桥段摘要
  • 《历史》与《战国策》札记（一百四） 刘子曰_b08e
    卫鞅亡魏入秦，孝公以为相，封之于商，号曰商君。商君治秦，法令至行，公平无私，罚不讳强大，赏不私亲近，法及太子，黥劓其傅。期年之后，道不拾遗，民不妄取，兵革大强，诸侯畏惧。然刻深寡恩，特以强服之耳。孝公行之八年，疾且不起，欲傅商君，辞不受。孝公已死，惠王代后，莅政有顷，商君告归。人说惠王曰：“大臣太重者国危，左右太亲者身危。今秦妇人婴儿皆言商君之法，莫言大王之法。是商君反为主，大王更为臣也。且夫商君
  • 小时候的“年”（四） 春风拂林绿
    初一早起我们这儿叫“起五更（jing）”，大约是早晨五、六点钟左右，每家都不一样，但大约是这样一个时间。早晨吃饺子前也要放一支鞭，一般听到各家的鞭炮声，就能知道自己家里起的早还是晚了。关于吃饺子的习俗前面已经说过，在此就不加赘述了。吃完饺子后，就要开始拜年了。未出嫁的女孩子是无须去拜年的，一般都是一大家人，男人们一队，媳妇们一队，挨门挨户的去给自家的长辈们拜年。也就是一群人一起给长辈们磕头，过年磕
  • 一份特殊的礼物–日记 041 艳艳秦
    非常时期，无法走出门回娘家，但电话聊天是每天必不可少的项目之一。早饭后，跟老娘电话聊天了近半个小时，老娘是一个七十多岁、身体硬朗、意志坚定的老太太，是一个生活非常规律的人。每天三顿饭，虽是简简单单，但都是按正常就餐点吃，每天都要看会书、磕会瓜子，晚上看会电视，这几天迷恋诗词大会，告诉我虽然记不住多少，但整个观看的过程是非常的开心，坐在家里浏览祖国的大好河山(因为今年的诗词大会上添加了身临其境题)。
  • 《相面天师》第六百四十三章 死在你前面 先峰老师
    说实话，安东尼马库斯的进攻套路虽然很简单，来来去去就是左右腿的侧踢。但是经过千万次的训练，安东尼马库斯已经将这扫腿练得炉火纯青，就是这简单的侧踢，最少带给李尚鸿三次以上致命的威胁。交战了大约有七八分钟的时间了，安东尼马库斯时而像是西伯利亚的猛虎，大开大合硬拼硬打，时而又像是狐狸一般，数次都逃过了李尚鸿的致命一击。虽然也对安东尼马库斯造成了一些伤害，但至今为止，李尚鸿也未能找到一击毙敌的机会，可是眼
  • 2023-05-09 棉麻布衣
    文学类文本阅读——矛盾冲突一、典型例题一加利福尼亚人的故事马克·吐温三十五年前，我曾到斯达尼斯劳斯河找矿。我手拿着鹤嘴锄，带着淘盘，背着号角，成天跋涉。我走遍了各处，淘洗了不少的含金沙，总想着找到矿藏发笔大财，却总是一无所获。这是一个风景秀丽的地区，树木葱茏，气候温和，景色宜人。很多年前，这儿人烟稠密，而现在，人们早已消失殆尽了，富有魅力的极乐园成了一个荒凉冷僻的地方。他们把地层表面给挖了个遍，然
  • 时光再快，也不如你笑靥如花！ 安安萌
    老婆，你怎么又在看《父母爱情》，看了多少遍了有意思吗？”老公风尘仆仆下班回家之后看见我又边吃边看电视剧就开始絮絮叨叨的没完。而我呢，他说他的，我看我的，被逼无奈他也只能坐下来陪我一起看！我喜欢这个电视剧，记有深刻印象的是，在《父母爱情》中郭涛饰演的江德福，梅婷饰演的安杰，在决定送大儿子卫国去当兵后，江德福和安杰两个人散步去海边的时候，海风吹拂着安杰恬静的脸庞，江德福眼中满含爱意说：“老婆子还是老婆
  • PMP冲刺一 Cynric
    记录考点一、计算类考题一般就1题，主要涉及在三大过程组：启动过程组、规划过程组、控制过程组。1.启动过程组项目选择方法涉及名词：NPV净现值、IRR内部收益率、BCR投资回报率、ROI投资利润率、回收期2.规划过程组三点估算PERT法（默认使用贝塔分布）三角分布：Te=(O+M+P)/3贝塔分布：Te=(O+4M+P)/6关键路径法CPM关键路径是相对的，也可以是变化的。路径汇聚固定资产折旧沟通渠
  • 人为什么会烦恼 燕山山人
    人生除了烦恼之外，就只剩下一样东西了：死。只要活着，就是活在烦恼中，除了烦恼，我们并无别的。我们这个地球是一个烦恼的客栈，我们无论行住坐卧无不活在烦恼中，甚至在睡梦也是一座不断上演烦恼节目的剧院。今天，我们要从哲学的角度去看一下烦恼的真谛。从宗教和哲学的角度看，烦恼是有限的生命通往无限的终极世界的唯一路程，这个路程就叫做烦恼。一切烦恼源于有限，而我们的希望的状态却是无限。当与无限融合为一时，我们便
  • 华为坤灵路由器初始化开局的注意事项，含NAT配置 redmond88 网络技术华为服务器运维
    坤灵路由器比较坑，无web界面，全程命令行配置，但是版本更新导致和华为企业路由器配置很多不一样的地方，今天介绍下1、aaa密码复杂度修改：#使能设备对密码进行四选三复杂度检查功能。system-view[HUAWEI]aaa[HUAWEI-aaa]local-aaa-userpasswordpolicyadministrator[HUAWEI-aaa-lupp-admin]passwordcomp
  • 【华为OD机试真题 python】输出指定字母在字符串的中的索引【2022 Q4 | 100分】 无痕de泪 华为OD机试真题python输出指定字母在字符串的中的索引字符串华为odpython
    前言《华为OD笔试真题python》专栏含华为OD机试真题、华为面试题、牛客网华为专栏真题。如果您正在准备华为的面试，或者华为od的机会，有任何想了解的可以私信我进行交流。我会尽可能的给一些建议，和帮您解答！PS：文中答案仅供参考，不能照抄哦■题目描述【输出指定字母在字符串的中的索引】给定一个字符串，把字符串按照大写在前小写在后排序，输出排好后的第K个字母在原来字符串的索引。相同字母输出第一个出现
  • 大难未死，后福在何方 吴江月
    每个人的一生都会经历几次磨难，甚至是接近死亡。图片发自App今天回家的时候听家里人说村里的一个人出了车祸，很严重，差点就没有抢救过来，说幸亏他命大，要是赶别人，早就撞死了。然后突然想到了自己年轻的时候，那时候经历的几次磨难，是真真切切体会到了死神的气息。第一次是在我上小学的时候，忘了是几岁了，只记得那时候家里还有羊。我是在去放羊的时候，爬到树上掰树叶给羊吃，结果一下树枝断了，我从树上掉了下来，后背
  • 人生最好是小满 周哥建辉
    苦菜秀，靡草死，麦秋至。夏天已至，炽热未满。今日小满。小满，是二十四节气之一，是夏季的第二个节气——四月中，小满者，物致于此小得盈满。其含义是夏熟作物的籽粒开始灌浆、饱满，但还未成熟，只是小满，还未大满。小满是一个充满传统智慧的节气。中国传统文化讲中庸之道，二十四节气中很多是相对着的，比如小暑大暑、小雪大雪、小寒大寒等等，唯独有小满，没有大满。俗话有“月满则亏，水满则溢”，以及“盛极必衰”的说法，
  • 京东三八妇女节优惠券怎么领?领券规则有哪些? 高省APP珊珊
    京东三八妇女节优惠券的领取方式和领券规则如下：高省-淘宝38密令（超红密令）领取/核销时间一致：2月29日10点——3月8号（含）你真漂亮377【高省】APP（高佣金领导者）是一个自用省钱佣金高，分享推广赚钱多的平台，2000万用户信赖的四年老平台，稳定可靠。高省APP佣金更高，模式更好，终端用户不流失。高省是公认的返利最高的软件。珊珊导师高省邀请码666123，注册送2皇冠会员，送万元推广大礼包
  • 故事：蟾蜍斗老鼠，蟾蜍胜利，本以为事情已结束，却出现一道黑影 星尘讲故事
    第5章（前面章节在后面）今年的大年初一是我最轻松的一年，只给大爷爷磕了一个头，这个年就算过完了。回到家中，天还没亮，儿子还在睡觉，我把羽绒服脱下来，又重新躺在了床上，前几个小时发生的一切，让我感觉那么的不真实。若不是手指头有点疼，我还真的以为是做了一个梦。迷迷糊糊中，有人在摇晃我，我以为是儿子醒了，立马坐了起来，结果发现是婶子来了。“小胖，你黄二叔让我来喊你，让你给帮帮忙！”婶子有些不好意思地说道
  • Java实现的简单双向Map，支持重复Value superlxw1234 java双向map
    关键字：Java双向Map、DualHashBidiMap     有个需求，需要根据即时修改Map结构中的Value值，比如，将Map中所有value=V1的记录改成value=V2，key保持不变。   数据量比较大，遍历Map性能太差，这就需要根据Value先找到Key，然后去修改。   即：既要根据Key找Value，又要根据Value
  • PL/SQL触发器基础及例子 百合不是茶 oracle数据库触发器PL/SQL编程
      触发器的简介; 触发器的定义就是说某个条件成立的时候，触发器里面所定义的语句就会被自动的执行。因此触发器不需要人为的去调用，也不能调用。触发器和过程函数类似 过程函数必须要调用,   一个表中最多只能有12个触发器类型的,触发器和过程函数相似 触发器不需要调用直接执行, 触发时间：指明触发器何时执行，该值可取： before：表示在数据库动作之前触发
  • [时空与探索]穿越时空的一些问题 comsci 问题
          我们还没有进行过任何数学形式上的证明,仅仅是一个猜想.....       这个猜想就是; 任何有质量的物体(哪怕只有一微克)都不可能穿越时空,该物体强行穿越时空的时候,物体的质量会与时空粒子产生反应,物体会变成暗物质,也就是说,任何物体穿越时空会变成暗物质..(暗物质就我的理
  • easy ui datagrid上移下移一行 商人shang js上移下移easyuidatagrid
    /** * 向上移动一行 * * @param dg * @param row */ function moveupRow(dg, row) { var datagrid = $(dg); var index = datagrid.datagrid("getRowIndex", row); if (isFirstRow(dg, row)) {
  • Java反射 oloz 反射
    本人菜鸟，今天恰好有时间，写写博客，总结复习一下java反射方面的知识，欢迎大家探讨交流学习指教 首先看看java中的Class package demo; public class ClassTest { /*先了解java中的Class*/ public static void main(String[] args) { //任何一个类都
  • springMVC 使用JSR-303 Validation验证 杨白白 springmvc
    JSR-303是一个数据验证的规范，但是spring并没有对其进行实现，Hibernate Validator是实现了这一规范的，通过此这个实现来讲SpringMVC对JSR-303的支持。 JSR-303的校验是基于注解的，首先要把这些注解标记在需要验证的实体类的属性上或是其对应的get方法上。 登录需要验证类 public class Login { @NotEmpty
  • log4j 香水浓 log4j
    log4j.rootCategory=DEBUG, STDOUT, DAILYFILE, HTML, DATABASE #log4j.rootCategory=DEBUG, STDOUT, DAILYFILE, ROLLINGFILE, HTML #console log4j.appender.STDOUT=org.apache.log4j.ConsoleAppender log4
  • 使用ajax和history.pushState无刷新改变页面URL agevs jquery框架Ajaxhtml5chrome
    表现 如果你使用chrome或者firefox等浏览器访问本博客、github.com、plus.google.com等网站时，细心的你会发现页面之间的点击是通过ajax异步请求的，同时页面的URL发生了了改变。并且能够很好的支持浏览器前进和后退。 是什么有这么强大的功能呢？ HTML5里引用了新的API，history.pushState和history.replaceState，就是通过
  • centos中文乱码 AILIKES centosOSssh
    一、CentOS系统访问 g.cn ，发现中文乱码。 于是用以前的方式：yum -y install fonts-chinese CentOS系统安装后，还是不能显示中文字体。我使用 gedit 编辑源码，其中文注释也为乱码。       后来，终于找到以下方法可以解决，需要两个中文支持的包： fonts-chinese-3.02-12.
  • 触发器 baalwolf 触发器
    触发器(trigger)：监视某种情况，并触发某种操作。 触发器创建语法四要素：1.监视地点(table) 2.监视事件(insert/update/delete) 3.触发时间(after/before) 4.触发事件(insert/update/delete) 语法： create trigger triggerName after/before 
  • JS正则表达式的i m g bijian1013 JavaScript正则表达式
            g:表示全局（global)模式，即模式将被应用于所有字符串，而非在发现第一个匹配项时立即停止。         i:表示不区分大小写（case-insensitive）模式，即在确定匹配项时忽略模式与字符串的大小写。         m:表示
  • HTML5模式和Hashbang模式 bijian1013 JavaScriptAngularJSHashbang模式HTML5模式
            我们可以用$locationProvider来配置$location服务（可以采用注入的方式，就像AngularJS中其他所有东西一样）。这里provider的两个参数很有意思，介绍如下。 html5Mode         一个布尔值，标识$location服务是否运行在HTML5模式下。 ha
  • [Maven学习笔记六]Maven生命周期 bit1129 maven
    从mvn test的输出开始说起   当我们在user-core中执行mvn test时，执行的输出如下：   /software/devsoftware/jdk1.7.0_55/bin/java -Dmaven.home=/software/devsoftware/apache-maven-3.2.1 -Dclassworlds.conf=/software/devs
  • 【Hadoop七】基于Yarn的Hadoop Map Reduce容错 bit1129 hadoop
    运行于Yarn的Map Reduce作业，可能发生失败的点包括 Task Failure Application Master Failure Node Manager Failure Resource Manager Failure 1. Task Failure 任务执行过程中产生的异常和JVM的意外终止会汇报给Application Master。僵死的任务也会被A
  • 记一次数据推送的异常解决端口解决 ronin47 记一次数据推送的异常解决
    　　 需求：从db获取数据然后推送到B         程序开发完成，上jboss,刚开始报了很多错，逐一解决，可最后显示连接不到数据库。机房的同事说可以ping 通。 　　  自已画了个图，逐一排除，把linux 防火墙　和　setenforce　设置最低。 　　　service iptables stop
  • 巧用视错觉-UI更有趣 brotherlamp UIui视频ui教程ui自学ui资料
    我们每个人在生活中都曾感受过视错觉（optical illusion）的魅力。 视错觉现象是双眼跟我们开的一个玩笑，而我们往往还心甘情愿地接受我们看到的假象。其实不止如此，视觉错现象的背后还有一个重要的科学原理——格式塔原理。 格式塔原理解释了人们如何以视觉方式感觉物体，以及图像的结构，视角，大小等要素是如何影响我们的视觉的。 在下面这篇文章中，我们首先会简单介绍一下格式塔原理中的基本概念，
  • 线段树-poj1177-N个矩形求边长（离散化+扫描线） bylijinnan 数据结构算法线段树
    package com.ljn.base; import java.util.Arrays; import java.util.Comparator; import java.util.Set; import java.util.TreeSet; /** * POJ 1177 (线段树+离散化+扫描线)，题目链接为http://poj.org/problem?id=1177
  • HTTP协议详解 chicony http协议
    引言                                 
  • Scala设计模式 chenchao051 设计模式scala
    Scala设计模式                我的话： 在国外网站上看到一篇文章，里面详细描述了很多设计模式，并且用Java及Scala两种语言描述，清晰的让我们看到各种常规的设计模式，在Scala中是如何在语言特性层面直接支持的。基于文章很nice，我利用今天的空闲时间将其翻译，希望大家能一起学习，讨论。翻译
  • 安装mysql daizj mysql安装
    安装mysql   (1)删除linux上已经安装的mysql相关库信息。rpm  -e  xxxxxxx   --nodeps (强制删除)      执行命令rpm -qa |grep mysql 检查是否删除干净   (2)执行命令  rpm -i MySQL-server-5.5.31-2.el
  • HTTP状态码大全 dcj3sjt126com http状态码
    完整的 HTTP 1.1规范说明书来自于RFC 2616，你可以在http://www.talentdigger.cn/home/link.php?url=d3d3LnJmYy1lZGl0b3Iub3JnLw%3D%3D在线查阅。HTTP 1.1的状态码被标记为新特性，因为许多浏览器只支持 HTTP 1.0。你应只把状态码发送给支持 HTTP 1.1的客户端，支持协议版本可以通过调用request
  • asihttprequest上传图片 dcj3sjt126com ASIHTTPRequest
    NSURL *url =@"yourURL"; ASIFormDataRequest*currentRequest =[ASIFormDataRequest requestWithURL:url]; [currentRequest setPostFormat:ASIMultipartFormDataPostFormat];[currentRequest se
  • C语言中，关键字static的作用 e200702084 C++cC#
    在C语言中，关键字static有三个明显的作用： 1)在函数体，局部的static变量。生存期为程序的整个生命周期，（它存活多长时间）；作用域却在函数体内（它在什么地方能被访问（空间））。 一个被声明为静态的变量在这一函数被调用过程中维持其值不变。因为它分配在静态存储区，函数调用结束后并不释放单元，但是在其它的作用域的无法访问。当再次调用这个函数时，这个局部的静态变量还存活，而且用在它的访
  • win7/8使用curl geeksun win7
    1.  WIN7/8下要使用curl，需要下载curl-7.20.0-win64-ssl-sspi.zip和Win64OpenSSL_Light-1_0_2d.exe。 下载地址：  http://curl.haxx.se/download.html 请选择不带SSL的版本，否则还需要安装SSL的支持包   2.  可以给Windows增加c
  • Creating a Shared Repository; Users Sharing The Repository hongtoushizi git
    转载自：   http://www.gitguys.com/topics/creating-a-shared-repository-users-sharing-the-repository/ Commands discussed in this section: git init –bare git clone git remote git pull git p
  • Java实现字符串反转的8种或9种方法 Josh_Persistence 异或反转递归反转二分交换反转java字符串反转栈反转
    注：对于第7种使用异或的方式来实现字符串的反转，如果不太看得明白的，可以参照另一篇博客： http://josh-persistence.iteye.com/blog/2205768   /** * */ package com.wsheng.aggregator.algorithm.string; import java.util.Stack; /**
  • 代码实现任意容量倒水问题 home198979 PHP算法倒水
    形象化设计模式实战             HELLO!架构                     redis命令源码解析   倒水问题：有两个杯子，一个A升，一个B升，水有无限多，现要求利用这两杯子装C
  • Druid datasource zhb8015 druid
    推荐大家使用数据库连接池 DruidDataSource. http://code.alibabatech.com/wiki/display/Druid/DruidDataSource DruidDataSource经过阿里巴巴数百个应用一年多生产环境运行验证，稳定可靠。 它最重要的特点是：监控、扩展和性能。 下载和Maven配置看这里： http
  • 两种启动监听器ApplicationListener和ServletContextListener spjich javaspring框架
    引言:有时候需要在项目初始化的时候进行一系列工作，比如初始化一个线程池，初始化配置文件，初始化缓存等等，这时候就需要用到启动监听器，下面分别介绍一下两种常用的项目启动监听器   ServletContextListener  特点: 依赖于sevlet容器，需要配置web.xml 使用方法: public class StartListener implements
  • JavaScript Rounding Methods of the Math object 何不笑 JavaScriptMath
        The next group of methods has to do with rounding decimal values into integers. Three methods — Math.ceil(),  Math.floor(), and  Math.round() — handle rounding in differen
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他