melody157398
melody157398

System Server进程启动过程源码分析

SystemServer进程名称为System_Server，在Zygote进程启动过程源码分析一文中介绍了zygote进程通过startSystemServer函数调用将启动一个SystemServer子进程：

[java]  view plain copy
  1. private static boolean startSystemServer()  
  2.             throws MethodAndArgsCaller, RuntimeException {  
  3.         /* Hardcoded command line to start the system server */  
  4.         String args[] = {  
  5.             "--setuid=1000",  
  6.             "--setgid=1000",  
  7.             "--setgroups=1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1018,3001,3002,3003",  
  8.             "--capabilities=130104352,130104352",  
  9.             "--runtime-init",  
  10.             "--nice-name=system_server",  
  11.             "com.android.server.SystemServer",  
  12.         };  
  13.         ZygoteConnection.Arguments parsedArgs = null;  
  14.   
  15.         int pid;  
  16.   
  17.         try {  
  18.             parsedArgs = new ZygoteConnection.Arguments(args);  
  19.   
  20.             /* 
  21.              * Enable debugging of the system process if *either* the command line flags 
  22.              * indicate it should be debuggable or the ro.debuggable system property 
  23.              * is set to "1" 
  24.              */  
  25.             int debugFlags = parsedArgs.debugFlags;  
  26.             if ("1".equals(SystemProperties.get("ro.debuggable")))  
  27.                 debugFlags |= Zygote.DEBUG_ENABLE_DEBUGGER;  
  28.   
  29.             /* Request to fork the system server process */  
  30.             pid = Zygote.forkSystemServer(  
  31.                     parsedArgs.uid, parsedArgs.gid,  
  32.                     parsedArgs.gids, debugFlags, null,  
  33.                     parsedArgs.permittedCapabilities,  
  34.                     parsedArgs.effectiveCapabilities);  
  35.         } catch (IllegalArgumentException ex) {  
  36.             throw new RuntimeException(ex);  
  37.         }  
  38.   
  39.         /* For child process */  
  40.         if (pid == 0) {  
  41.             handleSystemServerProcess(parsedArgs);  
  42.         }  
  43.   
  44.         return true;  
  45.     }  
创建该进程的核心是通过调用forkSystemServer函数来完成的，这是应该native函数

[java]  view plain copy
  1. native public static int forkSystemServer(int uid, int gid,  
  2.         int[] gids, int debugFlags, int[][] rlimits,  
  3.         long permittedCapabilities, long effectiveCapabilities);  
[java]  view plain copy
  1. const DalvikNativeMethod dvm_dalvik_system_Zygote[] =   
  2. {  
  3.     { "fork",              "()I",Dalvik_dalvik_system_Zygote_fork },  
  4.     { "forkAndSpecialize", "(II[II[[I)I",Dalvik_dalvik_system_Zygote_forkAndSpecialize },  
  5.     { "forkSystemServer",  "(II[II[[IJJ)I",Dalvik_dalvik_system_Zygote_forkSystemServer },  
  6.     { NULL, NULL, NULL },  
  7. };  

在dalvik_system_Zygote.c文件中实现：

[java]  view plain copy
  1. static void Dalvik_dalvik_system_Zygote_forkSystemServer(  
  2.         const u4* args, JValue* pResult)  
  3. {  
  4.     pid_t pid;  
  5.     //根据参数，fork一个子进程  
  6.     pid = forkAndSpecializeCommon(args, true);  
  7.   
  8.     /* The zygote process checks whether the child process has died or not. */  
  9.     if (pid > 0) {  
  10.         int status;  
  11.   
  12.         LOGI("System server process %d has been created", pid);  
  13.         gDvm.systemServerPid = pid; //保存System Server的进程ID  
  14.         /* There is a slight window that the system server process has crashed 
  15.          * but it went unnoticed because we haven't published its pid yet. So 
  16.          * we recheck here just to make sure that all is well. 
  17.          *检查创建的子进程是否退出 
  18.          */  
  19.         if (waitpid(pid, &status, WNOHANG) == pid) {  
  20.             LOGE("System server process %d has died. Restarting Zygote!", pid);  
  21.             /* FIXME: reboot instead of restarting android */  
  22.             /* kill(getpid(), SIGKILL); */  
  23.             //如果SystemServer进程退出，zygote将杀死自身进程  
  24.             reboot(RB_AUTOBOOT);  
  25.         }  
  26.     }  
  27.     RETURN_INT(pid);  
  28. }  

新创建的进程会执行handleSystemServerProcess函数，来完成自己的使命。

[java]  view plain copy
  1. private static void handleSystemServerProcess(  
  2.             ZygoteConnection.Arguments parsedArgs)  
  3.             throws ZygoteInit.MethodAndArgsCaller {  
  4.         //关闭从zygote继承下来的socket  
  5.         closeServerSocket();  
  6.   
  7.         /* 
  8.          *传递剩余参数给SystemServer并调用zygoteInit函数 
  9.          * "--nice-name=system_server com.android.server.SystemServer" 
  10.          */  
  11.         RuntimeInit.zygoteInit(parsedArgs.remainingArgs);  
  12.         /* should never reach here */  
  13.     }  
由于由Zygote进程创建的子进程会继承Zygote进程在前面创建的Socket文件描述符，而这里的子进程又不会用到它，因此，这里就调用closeServerSocket函数来关闭它。这个函数接着调用RuntimeInit.zygoteInit函数来进一步执行启动SystemServer组件的操作。
RuntimeInit.java  

[java]  view plain copy
  1. public static final void zygoteInit(String[] argv)  
  2.             throws ZygoteInit.MethodAndArgsCaller {  
  3.         //设置系统输出流  
  4.         System.setOut(new AndroidPrintStream(Log.INFO, "System.out"));  
  5.         System.setErr(new AndroidPrintStream(Log.WARN, "System.err"));  
  6.         //常规初始化  
  7.         commonInit();  
  8.         //执行一个Binder进程间通信机制的初始化工作，这个工作完成之后，这个进程中的Binder对象就可以方便地进行进程间通信了  
  9.         zygoteInitNative();  
  10.   
  11.         int curArg = 0;  
  12.         //argv = ["--nice-name=system_server， com.android.server.SystemServer"]  
  13.         for ( ; curArg < argv.length; curArg++) {  
  14.             String arg = argv[curArg];  
  15.   
  16.             if (arg.equals("--")) {  
  17.                 curArg++;  
  18.                 break;  
  19.             } else if (!arg.startsWith("--")) {  
  20.                 break;  
  21.             } else if (arg.startsWith("--nice-name=")) {  
  22.                 String niceName = arg.substring(arg.indexOf('=') + 1);  
  23.                 Process.setArgV0(niceName);//设置进程名称为system_server  
  24.             }  
  25.         }  
  26.   
  27.         if (curArg == argv.length) {  
  28.             Slog.e(TAG, "Missing classname argument to RuntimeInit!");  
  29.             // let the process exit  
  30.             return;  
  31.         }  
  32.   
  33.         // Remaining arguments are passed to the start class's static main  
  34.         String startClass = argv[curArg++];//startClass =“com.android.server.SystemServer”  
  35.         String[] startArgs = new String[argv.length - curArg];  
  36.   
  37.         System.arraycopy(argv, curArg, startArgs, 0, startArgs.length);  
  38.         //调用SystemServer类中的main函数  
  39.         invokeStaticMain(startClass, startArgs);  
  40.     }  

这个函数会执行两个操作:

一个是调用zygoteInitNative函数来执行一个Binder进程间通信机制的初始化工作;

一个是调用com.android.server.SystemServer类的main函数;

[java]  view plain copy
  1. public static final native void zygoteInitNative();  
[java]  view plain copy
  1. static JNINativeMethod gMethods[] =   
  2. {  
  3.     { "finishInit", "()V",(void*) com_android_internal_os_RuntimeInit_finishInit },  
  4.     { "zygoteInitNative", "()V",(void*) com_android_internal_os_RuntimeInit_zygoteInit },  
  5.     { "isComputerOn", "()I",(void*) com_android_internal_os_RuntimeInit_isComputerOn },  
  6.     { "turnComputerOn", "()V",(void*) com_android_internal_os_RuntimeInit_turnComputerOn },      
  7.     { "getQwertyKeyboard", "()I",(void*) com_android_internal_os_RuntimeInit_getQwertyKeyboard },  
  8. };  
[java]  view plain copy
  1. static void com_android_internal_os_RuntimeInit_zygoteInit(JNIEnv* env, jobject clazz)  
  2. {  
  3.     gCurRuntime->onZygoteInit();  
  4. }  
由于SystemServer 是由zygote fork出来，因此它也拥有zygote进程中的gCurRuntime，也就是AppRuntime

[java]  view plain copy
  1. virtual void onZygoteInit()  
  2. {  
  3.    sp<ProcessState> proc = ProcessState::self();  
  4.    if (proc->supportsProcesses()) {  
  5.       LOGV("App process: starting thread pool.\n");  
  6.       proc->startThreadPool(); //启动一个线程，用于binder通信  
  7.    }         
  8. }  
因此通过调用zygoteInitNative函数，将建立Binder通信。

调用invokeStaticMain函数：

[java]  view plain copy
  1. private static void invokeStaticMain(String className, String[] argv)  
  2.             throws ZygoteInit.MethodAndArgsCaller {  
  3.   
  4.         // We want to be fairly aggressive about heap utilization, to avoid  
  5.         // holding on to a lot of memory that isn't needed.  
  6.         VMRuntime.getRuntime().setTargetHeapUtilization(0.75f);  
  7.   
  8.         Class<?> cl;  
  9.   
  10.         try {  
  11.             //com.android.server.SystemServer，通过反射加载SystemServer类  
  12.             cl = Class.forName(className);  
  13.         } catch (ClassNotFoundException ex) {  
  14.             throw new RuntimeException("Missing class when invoking static main " + className,ex);  
  15.         }  
  16.   
  17.         Method m;  
  18.         try {  
  19.             m = cl.getMethod("main", new Class[] { String[].class });//获取SystemServer类的main方法  
  20.         } catch (NoSuchMethodException ex) {  
  21.             throw new RuntimeException("Missing static main on " + className, ex);  
  22.         } catch (SecurityException ex) {  
  23.             throw new RuntimeException("Problem getting static main on " + className, ex);  
  24.         }  
  25.   
  26.         int modifiers = m.getModifiers();  
  27.         if (! (Modifier.isStatic(modifiers) && Modifier.isPublic(modifiers))) {  
  28.             throw new RuntimeException("Main method is not public and static on " + className);  
  29.         }  
  30.   
  31.         /* 
  32.          * This throw gets caught in ZygoteInit.main(), which responds 
  33.          * by invoking the exception's run() method. This arrangement 
  34.          * clears up all the stack frames that were required in setting 
  35.          * up the process. 抛出MethodAndArgsCaller异常，并在ZygoteInit.main()函数里铺货 
  36.          */  
  37.         throw new ZygoteInit.MethodAndArgsCaller(m, argv);  
  38.     }  
抛出的MethodAndArgsCaller异常会在ZygoteInit.java 中的main函数捕获：

[java]  view plain copy
  1. public static void main(String argv[]) {  
  2.         try {  
  3.             VMRuntime.getRuntime().setMinimumHeapSize(5 * 1024 * 1024);  
  4.   
  5.             // Start profiling the zygote initialization.  
  6.             SamplingProfilerIntegration.start();  
  7.   
  8.             registerZygoteSocket();  
  9.             EventLog.writeEvent(LOG_BOOT_PROGRESS_PRELOAD_START,  
  10.                 SystemClock.uptimeMillis());  
  11.             preloadClasses();  
  12.             //cacheRegisterMaps();  
  13.             preloadResources();  
  14.             EventLog.writeEvent(LOG_BOOT_PROGRESS_PRELOAD_END,  
  15.                 SystemClock.uptimeMillis());  
  16.   
  17.             // Finish profiling the zygote initialization.  
  18.             SamplingProfilerIntegration.writeZygoteSnapshot();  
  19.   
  20.             // Do an initial gc to clean up after startup  
  21.             gc();  
  22.   
  23.             // If requested, start system server directly from Zygote  
  24.             if (argv.length != 2) {  
  25.                 throw new RuntimeException(argv[0] + USAGE_STRING);  
  26.             }  
  27.   
  28.             if (argv[1].equals("true")) {  
  29.                 startSystemServer();  
  30.             } else if (!argv[1].equals("false")) {  
  31.                 throw new RuntimeException(argv[0] + USAGE_STRING);  
  32.             }  
  33.   
  34.             Log.i(TAG, "Accepting command socket connections");  
  35.   
  36.             if (ZYGOTE_FORK_MODE) {  
  37.                 runForkMode();  
  38.             } else {  
  39.                 runSelectLoopMode();  
  40.             }  
  41.   
  42.             closeServerSocket();  
  43.         } catch (MethodAndArgsCaller caller) {  
  44.             caller.run();  
  45.         } catch (RuntimeException ex) {  
  46.             Log.e(TAG, "Zygote died with exception", ex);  
  47.             closeServerSocket();  
  48.             throw ex;  
  49.         }  
  50.     }  
[java]  view plain copy
  1. public void run() {  
  2.     try {  
  3.        //mMethod 是SystemServer类的main方法        
  4.        mMethod.invoke(null, new Object[] { mArgs });  
  5.     } catch (IllegalAccessException ex) {  
  6.         throw new RuntimeException(ex);  
  7.     } catch (InvocationTargetException ex) {  
  8.         Throwable cause = ex.getCause();  
  9.         if (cause instanceof RuntimeException) {  
  10.             throw (RuntimeException) cause;  
  11.         } else if (cause instanceof Error) {  
  12.             throw (Error) cause;  
  13.         }  
  14.         throw new RuntimeException(ex);  
  15.     }  
  16. }  
SystemServer.java

[java]  view plain copy
  1. public static void main(String[] args) {  
  2.         if (System.currentTimeMillis() < EARLIEST_SUPPORTED_TIME) {  
  3.             // If a device's clock is before 1970 (before 0), a lot of  
  4.             // APIs crash dealing with negative numbers, notably  
  5.             // java.io.File#setLastModified, so instead we fake it and  
  6.             // hope that time from cell towers or NTP fixes it  
  7.             // shortly.  
  8.             Slog.w(TAG, "System clock is before 1970; setting to 1970.");  
  9.             SystemClock.setCurrentTimeMillis(EARLIEST_SUPPORTED_TIME);  
  10.         }  
  11.   
  12.         if (SamplingProfilerIntegration.isEnabled()) {  
  13.             //启动性能统计  
  14.             SamplingProfilerIntegration.start();  
  15.             timer = new Timer();  
  16.             timer.schedule(new TimerTask() {  
  17.                 @Override  
  18.                 public void run() {  
  19.             //输出性能统计结果  
  20.                     SamplingProfilerIntegration.writeSnapshot("system_server");  
  21.                 }  
  22.             }, SNAPSHOT_INTERVAL, SNAPSHOT_INTERVAL);  
  23.         }  
  24.   
  25.         // The system server has to run all of the time, so it needs to be  
  26.         // as efficient as possible with its memory usage.  
  27.         VMRuntime.getRuntime().setTargetHeapUtilization(0.8f);  
  28.         //加载android_servers.so库  
  29.         System.loadLibrary("android_servers");  
  30.         init1(args);  
  31.     }  

抛出MethodAndArgsCaller异常会导致com.android.server.SystemServer类的main函数被调用。为什么采用这种方式来调用呢，读者可以自行研究！

[java]  view plain copy
  1. native public static void init1(String[] args);  
com_android_server_SystemServer.cpp

[java]  view plain copy
  1. static JNINativeMethod gMethods[] = {  
  2.     /* name, signature, funcPtr */  
  3.     { "init1", "([Ljava/lang/String;)V", (void*) android_server_SystemServer_init1 },  
  4. };  

[cpp]  view plain copy
  1. extern "C" int system_init();  
  2.   
  3. static void android_server_SystemServer_init1(JNIEnv* env, jobject clazz)  
  4. {  
  5.     system_init();  
  6. }  
System_init.cpp

[java]  view plain copy
  1. extern "C" status_t system_init()  
  2. {  
  3.     LOGI("Entered system_init()");  
  4.       
  5.     sp<ProcessState> proc(ProcessState::self());  
  6.     //获取Service manager的远程调用接口  
  7.     sp<IServiceManager> sm = defaultServiceManager();  
  8.     LOGI("ServiceManager: %p\n", sm.get());  
  9.       
  10.     sp<GrimReaper> grim = new GrimReaper();  
  11.     sm->asBinder()->linkToDeath(grim, grim.get(), 0);  
  12.       
  13.     char propBuf[PROPERTY_VALUE_MAX];  
  14.     property_get("system_init.startsurfaceflinger", propBuf, "1");  
  15.     //在SystemServer中启动各种服务  
  16.     if (strcmp(propBuf, "1") == 0) {  
  17.         // Start the SurfaceFlinger  
  18.         SurfaceFlinger::instantiate();  
  19.     }  
  20.   
  21.     // Start the sensor service  
  22.     SensorService::instantiate();  
  23.   
  24.     // On the simulator, audioflinger et al don't get started the  
  25.     // same way as on the device, and we need to start them here  
  26.     if (!proc->supportsProcesses()) {  
  27.   
  28.         // Start the AudioFlinger  
  29.         AudioFlinger::instantiate();  
  30.   
  31.         // Start the media playback service  
  32.         MediaPlayerService::instantiate();  
  33.   
  34.         // Start the camera service  
  35.         CameraService::instantiate();  
  36.   
  37.         // Start the audio policy service  
  38.         AudioPolicyService::instantiate();  
  39.     }  
  40.   
  41.     // And now start the Android runtime.  We have to do this bit  
  42.     // of nastiness because the Android runtime initialization requires  
  43.     // some of the core system services to already be started.  
  44.     // All other servers should just start the Android runtime at  
  45.     // the beginning of their processes's main(), before calling  
  46.     // the init function.  
  47.     LOGI("System server: starting Android runtime.\n");  
  48.       
  49.     AndroidRuntime* runtime = AndroidRuntime::getRuntime();  
  50.   
  51.     LOGI("System server: starting Android services.\n");  
  52.     //调用SystemServer.java 类中的init2函数  
  53.     runtime->callStatic("com/android/server/SystemServer", "init2");  
  54.           
  55.     // If running in our own process, just go into the thread  
  56.     // pool.  Otherwise, call the initialization finished  
  57.     // func to let this process continue its initilization.  
  58.     //将SystemServer进程的主线程加入Binder通信中  
  59.     if (proc->supportsProcesses()) {  
  60.         LOGI("System server: entering thread pool.\n");  
  61.         ProcessState::self()->startThreadPool();  
  62.         IPCThreadState::self()->joinThreadPool();  
  63.         LOGI("System server: exiting thread pool.\n");  
  64.     }  
  65.     return NO_ERROR;  
  66. }  
这里的main函数首先会执行JNI方法init1，然后init1会调用这里的init2函数，在init2函数里面，会创建一个ServerThread线程对象来执行一些系统关键服务的启动操作:

[java]  view plain copy
  1. public static final void init2() {  
  2.         Slog.i(TAG, "Entered the Android system server!");  
  3.         Thread thr = new ServerThread();  
  4.         thr.setName("android.server.ServerThread");  
  5.     //启动一个线程  
  6.         thr.start();  
  7. }  
init2只是简单创建一个线程，在该ServerThread线程中启动各种系统服务：

[java]  view plain copy
  1. @Override  
  2. public void run() {  
  3.     EventLog.writeEvent(EventLogTags.BOOT_PROGRESS_SYSTEM_RUN,  
  4.         SystemClock.uptimeMillis());  
  5.   
  6.     Looper.prepare();  
  7.   
  8.     android.os.Process.setThreadPriority(  
  9.             android.os.Process.THREAD_PRIORITY_FOREGROUND);  
  10.   
  11.     BinderInternal.disableBackgroundScheduling(true);  
  12.     android.os.Process.setCanSelfBackground(false);  
  13.   
  14.     // Check whether we failed to shut down last time we tried.  
  15.     {  
  16.         final String shutdownAction = SystemProperties.get(  
  17.                 ShutdownThread.SHUTDOWN_ACTION_PROPERTY, "");  
  18.         if (shutdownAction != null && shutdownAction.length() > 0) {  
  19.             boolean reboot = (shutdownAction.charAt(0) == '1');  
  20.   
  21.             final String reason;  
  22.             if (shutdownAction.length() > 1) {  
  23.                 reason = shutdownAction.substring(1, shutdownAction.length());  
  24.             } else {  
  25.                 reason = null;  
  26.             }  
  27.   
  28.             ShutdownThread.rebootOrShutdown(reboot, reason);  
  29.         }  
  30.     }  
  31.   
  32.     String factoryTestStr = SystemProperties.get("ro.factorytest");  
  33.     int factoryTest = "".equals(factoryTestStr) ? SystemServer.FACTORY_TEST_OFF  
  34.             : Integer.parseInt(factoryTestStr);  
  35.   
  36.     LightsService lights = null;  
  37.     PowerManagerService power = null;  
  38.     BatteryService battery = null;  
  39.     ConnectivityService connectivity = null;  
  40.     IPackageManager pm = null;  
  41.     Context context = null;  
  42.     WindowManagerService wm = null;  
  43.     BluetoothService bluetooth = null;  
  44.     BluetoothA2dpService bluetoothA2dp = null;  
  45.     HeadsetObserver headset = null;  
  46.     DockObserver dock = null;  
  47.     UsbService usb = null;  
  48.     UiModeManagerService uiMode = null;  
  49.     RecognitionManagerService recognition = null;  
  50.     ThrottleService throttle = null;  
  51.   
  52.     // Critical services...  
  53.     try {  
  54.         Slog.i(TAG, "Entropy Service");  
  55.         ServiceManager.addService("entropy", new EntropyService());  
  56.   
  57.         Slog.i(TAG, "Power Manager");  
  58.         power = new PowerManagerService();  
  59.         ServiceManager.addService(Context.POWER_SERVICE, power);  
  60.   
  61.         Slog.i(TAG, "Activity Manager");  
  62.         context = ActivityManagerService.main(factoryTest);  
  63.   
  64.         Slog.i(TAG, "Telephony Registry");  
  65.         if (PhoneFactory.isMultiSim()) {  
  66.             TelephonyRegistry[] telephonyRegistry = new TelephonyRegistry[PhoneFactory.getPhoneCount()];  
  67.             for (int i = 0; i < PhoneFactory.getPhoneCount(); i++) {  
  68.                 telephonyRegistry[i] = new TelephonyRegistry(context, i);  
  69.                 ServiceManager.addService(PhoneFactory.getServiceName("telephony.registry", i),  
  70.                         telephonyRegistry[i]);  
  71.             }  
  72.             ServiceManager.addService("telephony.registry",  
  73.                     new CompositeTelephonyRegistry(context, telephonyRegistry));  
  74.         } else {  
  75.             ServiceManager.addService("telephony.registry",  
  76.                     new TelephonyRegistry(context, 0));  
  77.         }  
  78.   
  79.         AttributeCache.init(context);  
  80.   
  81.         Slog.i(TAG, "Package Manager");  
  82.         pm = PackageManagerService.main(context,  
  83.                 factoryTest != SystemServer.FACTORY_TEST_OFF);  
  84.   
  85.         ActivityManagerService.setSystemProcess();  
  86.   
  87.         mContentResolver = context.getContentResolver();  
  88.   
  89.         // The AccountManager must come before the ContentService  
  90.         try {  
  91.             Slog.i(TAG, "Account Manager");  
  92.             ServiceManager.addService(Context.ACCOUNT_SERVICE,  
  93.                     new AccountManagerService(context));  
  94.         } catch (Throwable e) {  
  95.             Slog.e(TAG, "Failure starting Account Manager", e);  
  96.         }  
  97.   
  98.         Slog.i(TAG, "Content Manager");  
  99.         ContentService.main(context,  
  100.                 factoryTest == SystemServer.FACTORY_TEST_LOW_LEVEL);  
  101.   
  102.         Slog.i(TAG, "System Content Providers");  
  103.         ActivityManagerService.installSystemProviders();  
  104.   
  105.         Slog.i(TAG, "Battery Service");  
  106.         battery = new BatteryService(context);  
  107.         ServiceManager.addService("battery", battery);  
  108.   
  109.         Slog.i(TAG, "Lights Service");  
  110.         lights = new LightsService(context);  
  111.   
  112.         Slog.i(TAG, "Vibrator Service");  
  113.         ServiceManager.addService("vibrator", new VibratorService(context));  
  114.   
  115.         // only initialize the power service after we have started the  
  116.         // lights service, content providers and the battery service.  
  117.         power.init(context, lights, ActivityManagerService.getDefault(), battery);  
  118.   
  119.         Slog.i(TAG, "Alarm Manager");  
  120.         AlarmManagerService alarm = new AlarmManagerService(context);  
  121.         ServiceManager.addService(Context.ALARM_SERVICE, alarm);  
  122.   
  123.         Slog.i(TAG, "Init Watchdog");  
  124.         Watchdog.getInstance().init(context, battery, power, alarm,  
  125.                 ActivityManagerService.self());  
  126.   
  127.         Slog.i(TAG, "Window Manager");  
  128.         wm = WindowManagerService.main(context, power,  
  129.                 factoryTest != SystemServer.FACTORY_TEST_LOW_LEVEL);  
  130.         ServiceManager.addService(Context.WINDOW_SERVICE, wm);  
  131.   
  132.         ((ActivityManagerService)ServiceManager.getService("activity"))  
  133.                 .setWindowManager(wm);  
  134.   
  135.         // Skip Bluetooth if we have an emulator kernel  
  136.         // TODO: Use a more reliable check to see if this product should  
  137.         // support Bluetooth - see bug 988521  
  138.         if (SystemProperties.get("ro.kernel.qemu").equals("1")) {  
  139.             Slog.i(TAG, "Registering null Bluetooth Service (emulator)");  
  140.             ServiceManager.addService(BluetoothAdapter.BLUETOOTH_SERVICE, null);  
  141.         } else if (factoryTest == SystemServer.FACTORY_TEST_LOW_LEVEL) {  
  142.             Slog.i(TAG, "Registering null Bluetooth Service (factory test)");  
  143.             ServiceManager.addService(BluetoothAdapter.BLUETOOTH_SERVICE, null);  
  144.         } else {  
  145.             Slog.i(TAG, "Bluetooth Service");  
  146.             bluetooth = new BluetoothService(context);  
  147.             ServiceManager.addService(BluetoothAdapter.BLUETOOTH_SERVICE, bluetooth);  
  148.             bluetooth.initAfterRegistration();  
  149.             bluetoothA2dp = new BluetoothA2dpService(context, bluetooth);  
  150.             ServiceManager.addService(BluetoothA2dpService.BLUETOOTH_A2DP_SERVICE,  
  151.                                       bluetoothA2dp);  
  152.   
  153.             int bluetoothOn = Settings.Secure.getInt(mContentResolver,  
  154.                 Settings.Secure.BLUETOOTH_ON, 0);  
  155.             if (bluetoothOn > 0) {  
  156.                 bluetooth.enable();  
  157.             }  
  158.         }  
  159.   
  160.     } catch (RuntimeException e) {  
  161.         Slog.e("System", "Failure starting core service", e);  
  162.     }  
  163.   
  164.     DevicePolicyManagerService devicePolicy = null;  
  165.     StatusBarManagerService statusBar = null;  
  166.     InputMethodManagerService imm = null;  
  167.     AppWidgetService appWidget = null;  
  168.     NotificationManagerService notification = null;  
  169.     WallpaperManagerService wallpaper = null;  
  170.     LocationManagerService location = null;  
  171.   
  172.     if (factoryTest != SystemServer.FACTORY_TEST_LOW_LEVEL) {  
  173.         try {  
  174.             Slog.i(TAG, "Device Policy");  
  175.             devicePolicy = new DevicePolicyManagerService(context);  
  176.             ServiceManager.addService(Context.DEVICE_POLICY_SERVICE, devicePolicy);  
  177.         } catch (Throwable e) {  
  178.             Slog.e(TAG, "Failure starting DevicePolicyService", e);  
  179.         }  
  180.   
  181.         try {  
  182.             Slog.i(TAG, "Status Bar");  
  183.             statusBar = new StatusBarManagerService(context);  
  184.             ServiceManager.addService(Context.STATUS_BAR_SERVICE, statusBar);  
  185.         } catch (Throwable e) {  
  186.             Slog.e(TAG, "Failure starting StatusBarManagerService", e);  
  187.         }  
  188.   
  189.         try {  
  190.             Slog.i(TAG, "Clipboard Service");  
  191.             ServiceManager.addService(Context.CLIPBOARD_SERVICE,  
  192.                     new ClipboardService(context));  
  193.         } catch (Throwable e) {  
  194.             Slog.e(TAG, "Failure starting Clipboard Service", e);  
  195.         }  
  196.   
  197.         try {  
  198.             Slog.i(TAG, "Input Method Service");  
  199.             imm = new InputMethodManagerService(context, statusBar);  
  200.             ServiceManager.addService(Context.INPUT_METHOD_SERVICE, imm);  
  201.         } catch (Throwable e) {  
  202.             Slog.e(TAG, "Failure starting Input Manager Service", e);  
  203.         }  
  204.   
  205.         try {  
  206.             Slog.i(TAG, "NetStat Service");  
  207.             ServiceManager.addService("netstat", new NetStatService(context));  
  208.         } catch (Throwable e) {  
  209.             Slog.e(TAG, "Failure starting NetStat Service", e);  
  210.         }  
  211.   
  212.         try {  
  213.             Slog.i(TAG, "NetworkManagement Service");  
  214.             ServiceManager.addService(  
  215.                     Context.NETWORKMANAGEMENT_SERVICE,  
  216.                     NetworkManagementService.create(context));  
  217.         } catch (Throwable e) {  
  218.             Slog.e(TAG, "Failure starting NetworkManagement Service", e);  
  219.         }  
  220.   
  221.         try {  
  222.             Slog.i(TAG, "Connectivity Service");  
  223.             connectivity = ConnectivityService.getInstance(context);  
  224.             ServiceManager.addService(Context.CONNECTIVITY_SERVICE, connectivity);  
  225.         } catch (Throwable e) {  
  226.             Slog.e(TAG, "Failure starting Connectivity Service", e);  
  227.         }  
  228.   
  229.         try {  
  230.             Slog.i(TAG, "Throttle Service");  
  231.             throttle = new ThrottleService(context);  
  232.             ServiceManager.addService(  
  233.                     Context.THROTTLE_SERVICE, throttle);  
  234.         } catch (Throwable e) {  
  235.             Slog.e(TAG, "Failure starting ThrottleService", e);  
  236.         }  
  237.   
  238.         try {  
  239.           Slog.i(TAG, "Accessibility Manager");  
  240.           ServiceManager.addService(Context.ACCESSIBILITY_SERVICE,  
  241.                   new AccessibilityManagerService(context));  
  242.         } catch (Throwable e) {  
  243.           Slog.e(TAG, "Failure starting Accessibility Manager", e);  
  244.         }  
  245.   
  246.         try {  
  247.             /* 
  248.              * NotificationManagerService is dependant on MountService, 
  249.              * (for media / usb notifications) so we must start MountService first. 
  250.              */  
  251.             Slog.i(TAG, "Mount Service");  
  252.             ServiceManager.addService("mount", new MountService(context));  
  253.         } catch (Throwable e) {  
  254.             Slog.e(TAG, "Failure starting Mount Service", e);  
  255.         }  
  256.   
  257.         try {  
  258.             Slog.i(TAG, "Notification Manager");  
  259.             notification = new NotificationManagerService(context, statusBar, lights);  
  260.             ServiceManager.addService(Context.NOTIFICATION_SERVICE, notification);  
  261.         } catch (Throwable e) {  
  262.             Slog.e(TAG, "Failure starting Notification Manager", e);  
  263.         }  
  264.   
  265.         try {  
  266.             Slog.i(TAG, "Device Storage Monitor");  
  267.             ServiceManager.addService(DeviceStorageMonitorService.SERVICE,  
  268.                     new DeviceStorageMonitorService(context));  
  269.         } catch (Throwable e) {  
  270.             Slog.e(TAG, "Failure starting DeviceStorageMonitor service", e);  
  271.         }  
  272.   
  273.         try {  
  274.             Slog.i(TAG, "Location Manager");  
  275.             location = new LocationManagerService(context);  
  276.             ServiceManager.addService(Context.LOCATION_SERVICE, location);  
  277.         } catch (Throwable e) {  
  278.             Slog.e(TAG, "Failure starting Location Manager", e);  
  279.         }  
  280.   
  281.         try {  
  282.             Slog.i(TAG, "Search Service");  
  283.             ServiceManager.addService(Context.SEARCH_SERVICE,  
  284.                     new SearchManagerService(context));  
  285.         } catch (Throwable e) {  
  286.             Slog.e(TAG, "Failure starting Search Service", e);  
  287.         }  
  288.   
  289.         if (INCLUDE_DEMO) {  
  290.             Slog.i(TAG, "Installing demo data...");  
  291.             (new DemoThread(context)).start();  
  292.         }  
  293.   
  294.         try {  
  295.             Slog.i(TAG, "DropBox Service");  
  296.             ServiceManager.addService(Context.DROPBOX_SERVICE,  
  297.                     new DropBoxManagerService(context, new File("/data/system/dropbox")));  
  298.         } catch (Throwable e) {  
  299.             Slog.e(TAG, "Failure starting DropBoxManagerService", e);  
  300.         }  
  301.   
  302.         try {  
  303.             Slog.i(TAG, "Wallpaper Service");  
  304.             wallpaper = new WallpaperManagerService(context);  
  305.             ServiceManager.addService(Context.WALLPAPER_SERVICE, wallpaper);  
  306.         } catch (Throwable e) {  
  307.             Slog.e(TAG, "Failure starting Wallpaper Service", e);  
  308.         }  
  309.   
  310.         try {  
  311.             Slog.i(TAG, "Audio Service");  
  312.             ServiceManager.addService(Context.AUDIO_SERVICE, new AudioService(context));  
  313.         } catch (Throwable e) {  
  314.             Slog.e(TAG, "Failure starting Audio Service", e);  
  315.         }  
  316.   
  317.         try {  
  318.             Slog.i(TAG, "Headset Observer");  
  319.             // Listen for wired headset changes  
  320.             headset = new HeadsetObserver(context);  
  321.         } catch (Throwable e) {  
  322.             Slog.e(TAG, "Failure starting HeadsetObserver", e);  
  323.         }  
  324.   
  325.         try {  
  326.             Slog.i(TAG, "Dock Observer");  
  327.             // Listen for dock station changes  
  328.             dock = new DockObserver(context, power);  
  329.         } catch (Throwable e) {  
  330.             Slog.e(TAG, "Failure starting DockObserver", e);  
  331.         }  
  332.   
  333.         try {  
  334.             Slog.i(TAG, "USB Service");  
  335.             // Listen for USB changes  
  336.             usb = new UsbService(context);  
  337.             ServiceManager.addService(Context.USB_SERVICE, usb);  
  338.         } catch (Throwable e) {  
  339.             Slog.e(TAG, "Failure starting UsbService", e);  
  340.         }  
  341.   
  342.         try {  
  343.             Slog.i(TAG, "UI Mode Manager Service");  
  344.             // Listen for UI mode changes  
  345.             uiMode = new UiModeManagerService(context);  
  346.         } catch (Throwable e) {  
  347.             Slog.e(TAG, "Failure starting UiModeManagerService", e);  
  348.         }  
  349.   
  350.         try {  
  351.             Slog.i(TAG, "Backup Service");  
  352.             ServiceManager.addService(Context.BACKUP_SERVICE,  
  353.                     new BackupManagerService(context));  
  354.         } catch (Throwable e) {  
  355.             Slog.e(TAG, "Failure starting Backup Service", e);  
  356.         }  
  357.   
  358.         try {  
  359.             Slog.i(TAG, "AppWidget Service");  
  360.             appWidget = new AppWidgetService(context);  
  361.             ServiceManager.addService(Context.APPWIDGET_SERVICE, appWidget);  
  362.         } catch (Throwable e) {  
  363.             Slog.e(TAG, "Failure starting AppWidget Service", e);  
  364.         }  
  365.   
  366.         try {  
  367.             Slog.i(TAG, "Recognition Service");  
  368.             recognition = new RecognitionManagerService(context);  
  369.         } catch (Throwable e) {  
  370.             Slog.e(TAG, "Failure starting Recognition Service", e);  
  371.         }  
  372.           
  373.         try {  
  374.             Slog.i(TAG, "DiskStats Service");  
  375.             ServiceManager.addService("diskstats", new DiskStatsService(context));  
  376.         } catch (Throwable e) {  
  377.             Slog.e(TAG, "Failure starting DiskStats Service", e);  
  378.         }  
  379.   
  380.         try {  
  381.             Slog.i(TAG, "AnotherWatchdog Service");  
  382.             ServiceManager.addService("another_watchdog", new AnotherWatchdogService());  
  383.         } catch (Throwable e) {  
  384.             Slog.e(TAG, "Failure starting AnotherWatchdog Service", e);  
  385.         }  
  386.     }  
  387.   
  388.     // make sure the ADB_ENABLED setting value matches the secure property value  
  389.     Settings.Secure.putInt(mContentResolver, Settings.Secure.ADB_ENABLED,  
  390.             "1".equals(SystemProperties.get("persist.service.adb.enable")) ? 1 : 0);  
  391.   
  392.     // register observer to listen for settings changes  
  393.     mContentResolver.registerContentObserver(Settings.Secure.getUriFor(Settings.Secure.ADB_ENABLED),  
  394.             false, new AdbSettingsObserver());  
  395.   
  396.     // Before things start rolling, be sure we have decided whether  
  397.     // we are in safe mode.  
  398.     final boolean safeMode = wm.detectSafeMode();  
  399.     if (safeMode) {  
  400.         try {  
  401.             ActivityManagerNative.getDefault().enterSafeMode();  
  402.             // Post the safe mode state in the Zygote class  
  403.             Zygote.systemInSafeMode = true;  
  404.             // Disable the JIT for the system_server process  
  405.             VMRuntime.getRuntime().disableJitCompilation();  
  406.         } catch (RemoteException e) {  
  407.         }  
  408.     } else {  
  409.         // Enable the JIT for the system_server process  
  410.         VMRuntime.getRuntime().startJitCompilation();  
  411.     }  
  412.   
  413.     // It is now time to start up the app processes...  
  414.   
  415.     if (devicePolicy != null) {  
  416.         devicePolicy.systemReady();  
  417.     }  
  418.   
  419.     if (notification != null) {  
  420.         notification.systemReady();  
  421.     }  
  422.   
  423.     if (statusBar != null) {  
  424.         statusBar.systemReady();  
  425.     }  
  426.     wm.systemReady();  
  427.     power.systemReady();  
  428.     try {  
  429.         pm.systemReady();  
  430.     } catch (RemoteException e) {  
  431.     }  
  432.   
  433.     // These are needed to propagate to the runnable below.  
  434.     final StatusBarManagerService statusBarF = statusBar;  
  435.     final BatteryService batteryF = battery;  
  436.     final ConnectivityService connectivityF = connectivity;  
  437.     final DockObserver dockF = dock;  
  438.     final UsbService usbF = usb;  
  439.     final ThrottleService throttleF = throttle;  
  440.     final UiModeManagerService uiModeF = uiMode;  
  441.     final AppWidgetService appWidgetF = appWidget;  
  442.     final WallpaperManagerService wallpaperF = wallpaper;  
  443.     final InputMethodManagerService immF = imm;  
  444.     final RecognitionManagerService recognitionF = recognition;  
  445.     final LocationManagerService locationF = location;  
  446.   
  447.     // We now tell the activity manager it is okay to run third party  
  448.     // code.  It will call back into us once it has gotten to the state  
  449.     // where third party code can really run (but before it has actually  
  450.     // started launching the initial applications), for us to complete our  
  451.     // initialization.  
  452.     ((ActivityManagerService)ActivityManagerNative.getDefault())  
  453.             .systemReady(new Runnable() {  
  454.         public void run() {  
  455.             Slog.i(TAG, "Making services ready");  
  456.   
  457.             if (statusBarF != null) statusBarF.systemReady2();  
  458.             if (batteryF != null) batteryF.systemReady();  
  459.             if (connectivityF != null) connectivityF.systemReady();  
  460.             if (dockF != null) dockF.systemReady();  
  461.             if (usbF != null) usbF.systemReady();  
  462.             if (uiModeF != null) uiModeF.systemReady();  
  463.             if (recognitionF != null) recognitionF.systemReady();  
  464.             Watchdog.getInstance().start();  
  465.   
  466.             // It is now okay to let the various system services start their  
  467.             // third party code...  
  468.   
  469.             if (appWidgetF != null) appWidgetF.systemReady(safeMode);  
  470.             if (wallpaperF != null) wallpaperF.systemReady();  
  471.             if (immF != null) immF.systemReady();  
  472.             if (locationF != null) locationF.systemReady();  
  473.             if (throttleF != null) throttleF.systemReady();  
  474.         }  
  475.     });  
  476.   
  477. w Thread(new WakelockMonitor(power))).start();  
  478.     // For debug builds, log event loop stalls to dropbox for analysis.  
  479.     if (StrictMode.conditionallyEnableDebugLogging()) {  
  480.         Slog.i(TAG, "Enabled StrictMode for system server main thread.");  
  481.     }  
  482.   
  483.     Looper.loop();  
  484.     Slog.d(TAG, "System ServerThread is exiting!");  
  485. }  

在run函数中启动Java中的各种Service。至此SystemServer进程启动过程分析完毕！启动过程序列图如下所示：

System Server进程启动过程源码分析_第1张图片


你可能感兴趣的:(System Server进程启动过程源码分析)

  • android系统selinux中添加新属性property 辉色投像
    1.定位/android/system/sepolicy/private/property_contexts声明属性开头：persist.charge声明属性类型：u:object_r:system_prop:s0图12.定位到android/system/sepolicy/public/domain.te删除neverallow{domain-init}default_prop:property
  • 理解Gunicorn：Python WSGI服务器的基石 范范0825 ipythonlinux运维
    理解Gunicorn：PythonWSGI服务器的基石介绍Gunicorn，全称GreenUnicorn，是一个为PythonWSGI（WebServerGatewayInterface）应用设计的高效、轻量级HTTP服务器。作为PythonWeb应用部署的常用工具，Gunicorn以其高性能和易用性著称。本文将介绍Gunicorn的基本概念、安装和配置，帮助初学者快速上手。1.什么是Gunico
  • C#中使用split分割字符串 互联网打工人no1 c#
    1、用字符串分隔：usingSystem.Text.RegularExpressions;stringstr="aaajsbbbjsccc";string[]sArray=Regex.Split(str,"js",RegexOptions.IgnoreCase);foreach(stringiinsArray)Response.Write(i.ToString()+"");输出结果：aaabbbc
  • SQL Server_查询某一数据库中的所有表的内容 qq_42772833 SQLServer数据库sqlserver
    1.查看所有表的表名要列出CrabFarmDB数据库中的所有表（名），可以使用以下SQL语句：USECrabFarmDB;--切换到目标数据库GOSELECTTABLE_NAMEFROMINFORMATION_SCHEMA.TABLESWHERETABLE_TYPE='BASETABLE';对这段SQL脚本的解释：SELECTTABLE_NAME：这个语句的作用是从查询结果中选择TABLE_NAM
  • SpringBlade dict-biz/list 接口 SQL 注入漏洞 文章永久免费只为良心 oracle数据库
    SpringBladedict-biz/list接口SQL注入漏洞POC:构造请求包查看返回包你的网址/api/blade-system/dict-biz/list?updatexml(1,concat(0x7e,md5(1),0x7e),1)=1漏洞概述在SpringBlade框架中，如果dict-biz/list接口的后台处理逻辑没有正确地对用户输入进行过滤或参数化查询（PreparedSta
  • Linux MariaDB使用OpenSSL安装SSL证书 Meta39 MySQLOracleMariaDBLinuxWindowsssllinuxmariadb
    进入到证书存放目录，批量删除.pem证书警告：确保已经进入到证书存放目录find.-typef-iname\*.pem-delete查看是否安装OpenSSLopensslversion没有则安装yuminstallopensslopenssl-devel开启SSL编辑/etc/my.cnf文件（没有的话就创建，但是要注意，在/etc/my.cnf.d/server.cnf配置了datadir的，
  • openssl+keepalived安装部署 _小亦_ 项目部署keepalivedopenssl
    文章目录OpenSSL安装下载地址编译安装修改系统配置版本Keepalived安装下载地址安装遇到问题安装完成配置文件keepalived运行检查运行状态查看系统日志修改服务service重新加载systemd检查配置文件语法错误OpenSSL安装下载地址考虑到后面设备可能没法连接到外网，所以采用安装包的方式进行部署，下载地址：https://www.openssl.org/source/old/
  • 网络编程基础 记得开心一点啊 网络
    目录♫什么是网络编程♫Socket套接字♪什么是Socket套接字♪数据报套接字♪流套接字♫数据报套接字通信模型♪数据报套接字通讯模型♪DatagramSocket♪DatagramPacket♪实现UDP的服务端代码♪实现UDP的客户端代码♫流套接字通信模型♪流套接字通讯模型♪ServerSocket♪Socket♪实现TCP的服务端代码♪实现TCP的客户端代码♫什么是网络编程网络编程，指网络上
  • CentOS的根目录下，/bin 和 /sbin 用途和权限 Energet!c Linux日常centoslinux运维
    CentOS的根目录下，/bin和/sbin用途和权限一、/bin(Binary)二、/sbin(SystemBinary)三、总结在CentOS的根目录下，/bin和/sbin目录有不同的用途和权限一、/bin(Binary)用途:存放系统的基本命令，这些命令对所有用户都是可用的。例如：ls、cp、mv、rm等。权限:普通用户和系统管理员都可以使用这些命令。二、/sbin(SystemBinar
  • 5月23日能量阅读打卡 free森
    当我走在人生路上的时候，我只能往前因为身后是飞逝的光阴。如果我因为过去与未来而瞻前顾后我的道路与生命进程就会停下来我的生命就会成为恐惧的俘虏所以我不应该因为过去与未来而驻足即便我的道路上充满了坎坷，即便我的道路上充满了考验，可是坎坷与考验都不能成为我停下的理由！我要跟坎坷说对不起，我爱你！我要跟考验说请原谅，谢谢你！我要在人生路上勇往直前，面对坎坷与重重生命的考验，我要毅然高歌猛进去追求精彩的人生
  • [Unity]在场景中随机生成不同位置且不重叠的物体 Bartender_Jill Graphics图形学笔记unity游戏引擎动画
    1.前言最近任务需要用到Unity在场景中随机生成物体，且这些物体不能重叠，简单记录一下。参考资料:Howtoensurethatspawnedtargetsdonotoverlap?2.结果与代码结果如下所示：代码如下所示：usingSystem.Collections.Generic;usingUnityEngine;namespaceAssets.Scripts{publicclassNew
  • ubuntu安装wordpress lissettecarlr
    1安装nginx网上安装方式很多，这就就直接用apt-get了apt-getinstallnginx不用启动啥，然后直接在浏览器里面输入IP:80就能看到nginx的主页了。如果修改了一些配置可以使用下列命令重启一下systemctlrestartnginx.service2安装mysql输入安装前也可以更新一下软件源，在安装过程中将会让你输入数据库的密码。sudoapt-getinstallmy
  • python结束子进程_如何清除python中的子进程 weixin_39995943 python结束子进程
    我们使用python进程来管理长时间运行的python子进程。有时需要终止子进程。kill命令不会完全终止进程，只会使其失效。运行以下脚本将演示此行为。importsubprocessp=subprocess.Popen(['sleep','400'],stdout=subprocess.PIPE,shell=False)或者p=subprocess.Popen('sleep400',stdout
  • python获取子进程返回值_Python对进程Multiprocessing子进程返回值 weixin_39752157 python获取子进程返回值
    在实际使用多进程的时候，可能需要获取到子进程运行的返回值。如果只是用来存储，则可以将返回值保存到一个数据结构中；如果需要判断此返回值，从而决定是否继续执行所有子进程，则会相对比较复杂。另外在Multiprocessing中，可以利用Process与Pool创建子进程，这两种用法在获取子进程返回值上的写法上也不相同。这篇中，我们直接上代码，分析多进程中获取子进程返回值的不同用法，以及优缺点。初级用法
  • 最简单将静态网页挂载到服务器上(不用nginx) 全能全知者 服务器nginx运维前端html笔记
    最简单将静态网页挂载到服务器上(不用nginx)如果随便弄个静态网页挂在服务器都要用nignx就太麻烦了，所以直接使用Apache来搭建一些简单前端静态网页会相对方便很多检查Web服务器服务状态：sudosystemctlstatushttpd#ApacheWeb服务器如果发现没有安装web服务器：安装Apache：sudoyuminstallhttpd启动Apache：sudosystemctl
  • 经纬恒润二面&三七互娱一面&元象二面 Redstone Monstrosity 面试前端
    1.请尽可能详细地说明，进程和线程的区别，分别有哪些应用场景？进程间如何通信？线程间如何通信？你的回答中不要写出示例代码。进程和线程是操作系统中的两个基本概念，它们在计算机系统中扮演着不同的角色，并且在不同的应用场景中发挥作用。进程和线程的区别定义：进程：进程是操作系统进行资源分配和调度的基本单位。每个进程都有独立的内存空间和系统资源。线程：线程是进程内的一个执行单元，是操作系统进行调度的最小单位
  • wandb一直上传 解决方案 行业边缘的摸鱼怪 bug解决方案服务器linux服务器
    问题描述运行带有wandb的代码时，虽然可以实现及时同步非常方便，但当设置错参数或其他原因不得不使用ctrl+C停止运行时，总会出现wandb一直上传个不停的现象，给在同一终端重新运行新的代码造成困难。解决方案运行以下代码把wandb的进程直接杀死。psaux|grepwandb|grep-vgrep|awk'{print$2}'|xargskill-9参考链接[CLI]:Ctrl+Ctokill
  • 新能源汽车 BMS 学习笔记篇—BMS 基本定义及分类 WPG大大通 其他笔记汽车BMS经验分享新能源电池
    一、BMS定义1、概念：BMS（BatteryManagementSystem）即电池管理系统，其管理对象是二次电池（充电电池或蓄电池），其主要目的是电池的利用率，防止电池出现过度充电和过度放电，可应用于电动汽车、电瓶车、机器人、无人机等图片来源：腾讯网https://new.qq.com《标准普尔警告，电动汽车电池生产面临供应链和地缘政治风险》2、四大功能①感知和测量：检测电池的电压、电流、温度
  • You have an error in your SQL syntax； check the manual that corresponds to your MySQL server version 努力的菜鸟~ sql数据库
    YouhaveanerrorinyourSQLsyntax;checkthemanualthatcorrespondstoyourMySQLserverversionfortherightsyntaxtousenear‘IDENTIFIEDBY‘123456’WITHGRANTOPTION’atline1在mysql5.7之前GRANTALLPRIVILEGESON*.*TO'root'@'%'I
  • 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
  • C++常见知识掌握 nfgo c++开发语言
    1.Linux软件开发、调试与维护内核与系统结构Linux内核是操作系统的核心，负责管理硬件资源，提供系统服务，它是系统软件与硬件之间的桥梁。主要组成部分包括：进程管理：内核通过调度器分配CPU时间给各个进程，实现进程的创建、调度、终止等操作。使用进程描述符（task_struct）来存储进程信息，包括状态（就绪、运行、阻塞等）、优先级、内存映射等。内存管理：包括物理内存和虚拟内存管理。通过页表映
  • mysql学习教程，从入门到精通，TOP 和MySQL LIMIT 子句（15） 知识分享小能手 大数据数据库MySQLmysql学习oracle数据库开发语言adb大数据
    1、TOP和MySQLLIMIT子句内容在SQL中，不同的数据库系统对于限制查询结果的数量有不同的实现方式。TOP关键字主要用于SQLServer和Access数据库中，而LIMIT子句则主要用于MySQL、PostgreSQL（通过LIMIT/OFFSET语法）、SQLite等数据库中。下面将分别详细介绍这两个功能的语法、语句以及案例。1.1、TOP子句（SQLServer和Access）1.1
  • JVM源码分析之堆外内存完全解读 HeapDump性能社区
    概述广义的堆外内存说到堆外内存，那大家肯定想到堆内内存，这也是我们大家接触最多的，我们在jvm参数里通常设置-Xmx来指定我们的堆的最大值，不过这还不是我们理解的Java堆，-Xmx的值是新生代和老生代的和的最大值，我们在jvm参数里通常还会加一个参数-XX:MaxPermSize来指定持久代的最大值，那么我们认识的Java堆的最大值其实是-Xmx和-XX:MaxPermSize的总和，在分代算法
  • Istio pilot-discovery服务发现源码解析（1.13版本） xidianjiapei001 #Istioistio云原生服务发现
    Istiopilot-discovery服务发现介绍工作机制初始化初始化Config控制器初始化Service控制器controller初始化NamespaceServiceNodePodPilotDiscovery各组件启动流程DiscoveryServer接收Envoy的gRPC连接请求流程Config变化后向Envoy推送更新的流程总结参考介绍IstioPilot的代码分为Pilot-Dis
  • 【显示 后台运行 & 的命令】 晨春计 debuglinux服务器运维
    目录背景步骤详解示例背景当你在Linuxshell中使用&符号将一个命令放到后台运行时，你可以使用jobs命令来查看这些后台进程的状态。但是，jobs命令并不会直接显示进程的PID（进程ID）。它会显示一个作业列表，其中包括每个作业的状态和一个作业标识符（通常是百分号%后面跟着一个数字），但不会直接显示PID。获取后台进程的PID步骤：1、使用jobs命令查看后台作业。2、使用ps命令配合grep
  • Android shell 常用 debug 命令 晨春计 Audiodebugandroidlinux
    目录1、查看版本2、am命令3、pm命令4、dumpsys命令5、sed命令6、log定位查看APK进程号7、log定位使用场景1、查看版本1.1、Android串口终端执行getpropro.build.version.release#获取Android版本uname-a#查看linux内核版本信息uname-r#单独查看内核版本1.2、linux服务器执行lsb_release-a#查看Lin
  • Ubuntu常用命令整理 十里染林
    ubuntu16.04server开启ssh:使用x-shell连接主机，发现22端口没有打开，开启ssh服务：安装openssh-serversudoapt-getinstallopenssh-server检查安装是否成功sudops-e|grepssh开启ssh服务sudoservicesshstartUbuntu开启/关闭防火墙:开启防火墙sudoufwenable关闭防火墙sudoufwd
  • 代码的执行效果 高天
    packagecom20210409;publicclassdemo04{publicstaticvoidmain(String[]args){//////&&当前的条件不满足,则最后结果一定不满足,后面的条件不再执行////&不管条件是否满足所有条件均作判断//intx=1,y=1;//if(++y==2&&x++==2){//x=7;//}//System.out.println("x="+x
  • Kubernetes部署MySQL数据持久化 沫殇-MS KubernetesMySQL数据库kubernetesmysql容器
    一、安装配置NFS服务端1、安装nfs-kernel-server：sudoapt-yinstallnfs-kernel-server2、服务端创建共享目录#列出所有可用块设备的信息lsblk#格式化磁盘sudomkfs-text4/dev/sdb#创建一个目录：sudomkdir-p/data/nfs/mysql#更改目录权限：sudochown-Rnobody:nogroup/data/nfs
  • Hadoop 傲雪凌霜，松柏长青 后端大数据hadoop大数据分布式
    ApacheHadoop是一个开源的分布式计算框架，主要用于处理海量数据集。它具有高度的可扩展性、容错性和高效的分布式存储与计算能力。Hadoop核心由四个主要模块组成，分别是HDFS（分布式文件系统）、MapReduce（分布式计算框架）、YARN（资源管理）和HadoopCommon（公共工具和库）。1.HDFS（HadoopDistributedFileSystem）HDFS是Hadoop生
  • java数字签名三种方式 知了ing javajdk
    以下3钟数字签名都是基于jdk7的 1，RSA String password="test"; // 1.初始化密钥 KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA"); keyPairGenerator.initialize(51
  • Hibernate学习笔记 caoyong Hibernate
    1>、Hibernate是数据访问层框架，是一个ORM(Object Relation Mapping)框架，作者为:Gavin King 2>、搭建Hibernate的开发环境      a>、添加jar包:      aa>、hibernatte开发包中/lib/required/所
  • 设计模式之装饰器模式Decorator（结构型） 漂泊一剑客 Decorator
    1. 概述        若你从事过面向对象开发，实现给一个类或对象增加行为，使用继承机制，这是所有面向对象语言的一个基本特性。如果已经存在的一个类缺少某些方法，或者须要给方法添加更多的功能（魅力），你也许会仅仅继承这个类来产生一个新类—这建立在额外的代码上。      
  • 读取磁盘文件txt，并输入String 一炮送你回车库 String
    public static void main(String[] args) throws IOException {    String fileContent = readFileContent("d:/aaa.txt");    System.out.println(fileContent);   
  • js三级联动下拉框 3213213333332132 三级联动
    //三级联动 省/直辖市<select id="province"></select> 市/省直辖<select id="city"></select> 县/区 <select id="area"></select>
  • erlang之parse_transform编译选项的应用 616050468 parse_transform游戏服务器属性同步abstract_code
             最近使用erlang重构了游戏服务器的所有代码，之前看过C++/lua写的服务器引擎代码，引擎实现了玩家属性自动同步给前端和增量更新玩家数据到数据库的功能，这也是现在很多游戏服务器的优化方向，在引擎层面去解决数据同步和数据持久化，数据发生变化了业务层不需要关心怎么去同步给前端。由于游戏过程中玩家每个业务中玩家数据更改的量其实是很少
  • JAVA JSON的解析 darkranger java
    // { // “Total”：“条数”， // Code: 1, // // “PaymentItems”:[ // { // “PaymentItemID”:”支款单ID”, // “PaymentCode”:”支款单编号”, // “PaymentTime”:”支款日期”, // ”ContractNo”:”合同号”， //
  • POJ-1273-Drainage Ditches aijuans ACM_POJ
    POJ-1273-Drainage Ditches http://poj.org/problem?id=1273 基本的最大流，按LRJ的白书写的 #include<iostream> #include<cstring> #include<queue> using namespace std; #define INF 0x7fffffff int ma
  • 工作流Activiti5表的命名及含义 atongyeye 工作流Activiti
    activiti5 - http://activiti.org/designer/update在线插件安装 activiti5一共23张表 Activiti的表都以ACT_开头。 第二部分是表示表的用途的两个字母标识。 用途也和服务的API对应。 ACT_RE_*: 'RE'表示repository。 这个前缀的表包含了流程定义和流程静态资源 （图片，规则，等等）。 A
  • android的广播机制和广播的简单使用 百合不是茶 android广播机制广播的注册
          Android广播机制简介 在Android中，有一些操作完成以后，会发送广播，比如说发出一条短信，或打出一个电话，如果某个程序接收了这个广播，就会做相应的处理。这个广播跟我们传统意义中的电台广播有些相似之处。之所以叫做广播，就是因为它只负责“说”而不管你“听不听”，也就是不管你接收方如何处理。另外，广播可以被不只一个应用程序所接收，当然也可能不被任何应
  • Spring事务传播行为详解 bijian1013 javaspring事务传播行为
            在service类前加上@Transactional，声明这个service所有方法需要事务管理。每一个业务方法开始时都会打开一个事务。         Spring默认情况下会对运行期例外(RunTimeException)进行事务回滚。这
  • eidtplus operate 征客丶 eidtplus
    开启列模式: Alt+C 鼠标选择   OR   Alt+鼠标左键拖动 列模式替换或复制内容(多行): 右键-->格式-->填充所选内容-->选择相应操作 OR Ctrl+Shift+V(复制多行数据,必须行数一致) -------------------------------------------------------
  • 【Kafka一】Kafka入门 bit1129 kafka
    这篇文章来自Spark集成Kafka(http://bit1129.iteye.com/blog/2174765)，这里把它单独取出来，作为Kafka的入门吧   下载Kafka http://mirror.bit.edu.cn/apache/kafka/0.8.1.1/kafka_2.10-0.8.1.1.tgz 2.10表示Scala的版本，而0.8.1.1表示Kafka
  • Spring 事务实现机制 BlueSkator spring代理事务
    Spring是以代理的方式实现对事务的管理。我们在Action中所使用的Service对象，其实是代理对象的实例，并不是我们所写的Service对象实例。既然是两个不同的对象，那为什么我们在Action中可以象使用Service对象一样的使用代理对象呢？为了说明问题，假设有个Service类叫AService，它的Spring事务代理类为AProxyService，AService实现了一个接口
  • bootstrap源码学习与示例：bootstrap-dropdown（转帖） BreakingBad bootstrapdropdown
    bootstrap-dropdown组件是个烂东西，我读后的整体感觉。 一个下拉开菜单的设计： <ul class="nav pull-right"> <li id="fat-menu" class="dropdown">
  • 读《研磨设计模式》-代码笔记-中介者模式-Mediator bylijinnan java设计模式
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ /* * 中介者模式（Mediator）：用一个中介对象来封装一系列的对象交互。 * 中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。 * * 在我看来，Mediator模式是把多个对象（
  • 常用代码记录 chenjunt3 UIExcelJ#
      1、单据设置某行或某字段不能修改 //i是行号,"cash"是字段名称 getBillCardPanelWrapper().getBillCardPanel().getBillModel().setCellEditable(i, "cash", false); //取得单据表体所有项用以上语句做循环就能设置整行了 getBillC
  • 搜索引擎与工作流引擎 comsci 算法工作搜索引擎网络应用
          最近在公司做和搜索有关的工作，(只是简单的应用开源工具集成到自己的产品中)工作流系统的进一步设计暂时放在一边了，偶然看到谷歌的研究员吴军写的数学之美系列中的搜索引擎与图论这篇文章中的介绍，我发现这样一个关系(仅仅是猜想)   -----搜索引擎和流程引擎的基础--都是图论，至少像在我在JWFD中引擎算法中用到的是自定义的广度优先
  • oracle Health Monitor daizj oracleHealth Monitor
    About Health Monitor Beginning with Release 11g, Oracle Database includes a framework called Health Monitor for running diagnostic checks on the database. About Health Monitor Checks Health M
  • JSON字符串转换为对象 dieslrae javajson
        作为前言,首先是要吐槽一下公司的脑残编译部署方式,web和core分开部署本来没什么问题,但是这丫居然不把json的包作为基础包而作为web的包,导致了core端不能使用,而且我们的core是可以当web来用的(不要在意这些细节),所以在core中处理json串就是个问题.没办法,跟编译那帮人也扯不清楚,只有自己写json的解析了.   
  • C语言学习八结构体，综合应用，学生管理系统 dcj3sjt126com C语言
    实现功能的代码： # include <stdio.h> # include <malloc.h> struct Student { int age; float score; char name[100]; }; int main(void) { int len; struct Student * pArr; int i,
  • vagrant学习笔记 dcj3sjt126com vagrant
    想了解多主机是如何定义和使用的, 所以又学习了一遍vagrant   1. vagrant virtualbox 下载安装 https://www.vagrantup.com/downloads.html https://www.virtualbox.org/wiki/Downloads   查看安装在命令行输入vagrant     2.
  • 14.性能优化-优化-软件配置优化 frank1234 软件配置性能优化
    1.Tomcat线程池 修改tomcat的server.xml文件： <Connector port="8080" protocol="HTTP/1.1" connectionTimeout="20000" redirectPort="8443" maxThreads="1200" m
  • 一个不错的shell 脚本教程 入门级 HarborChung linuxshell
    一个不错的shell 脚本教程 入门级 建立一个脚本 　　Linux中有好多中不同的shell，但是通常我们使用bash (bourne again shell) 进行shell编程，因为bash是免费的并且很容易使用。所以在本文中笔者所提供的脚本都是使用bash（但是在大多数情况下，这些脚本同样可以在 bash的大姐，bourne shell中运行）。 　　如同其他语言一样
  • Spring4新特性——核心容器的其他改进 jinnianshilongnian spring动态代理spring4依赖注入
    Spring4新特性——泛型限定式依赖注入 Spring4新特性——核心容器的其他改进 Spring4新特性——Web开发的增强 Spring4新特性——集成Bean Validation 1.1(JSR-349)到SpringMVC  Spring4新特性——Groovy Bean定义DSL Spring4新特性——更好的Java泛型操作API  Spring4新
  • Linux设置tomcat开机启动 liuxingguome tomcatlinux开机自启动
    执行命令sudo gedit /etc/init.d/tomcat6 然后把以下英文部分复制过去。（注意第一句#!/bin/sh如果不写，就不是一个shell文件。然后将对应的jdk和tomcat换成你自己的目录就行了。 #!/bin/bash # # /etc/rc.d/init.d/tomcat # init script for tomcat precesses
  • 第13章 Ajax进阶（下） onestopweb Ajax
    index.html <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/
  • Troubleshooting Crystal Reports off BW blueoxygen BO
    http://wiki.sdn.sap.com/wiki/display/BOBJ/Troubleshooting+Crystal+Reports+off+BW#TroubleshootingCrystalReportsoffBW-TracingBOE   Quite useful, especially this part: SAP BW connectivity For t
  • Java开发熟手该当心的11个错误 tomcat_oracle javajvm多线程单元测试
    #1、不在属性文件或XML文件中外化配置属性。比如，没有把批处理使用的线程数设置成可在属性文件中配置。你的批处理程序无论在DEV环境中，还是UAT（用户验收 测试）环境中，都可以顺畅无阻地运行，但是一旦部署在PROD 上，把它作为多线程程序处理更大的数据集时，就会抛出IOException，原因可能是JDBC驱动版本不同，也可能是#2中讨论的问题。如果线程数目 可以在属性文件中配置，那么使它成为
  • 正则表达式大全 yang852220741 html编程正则表达式
    今天向大家分享正则表达式大全，它可以大提高你的工作效率 正则表达式也可以被当作是一门语言，当你学习一门新的编程语言的时候，他们是一个小的子语言。初看时觉得它没有任何的意义，但是很多时候，你不得不阅读一些教程，或文章来理解这些简单的描述模式。 一、校验数字的表达式 数字：^[0-9]*$ n位的数字：^\d{n}$ 至少n位的数字：^\d{n,}$ m-n位的数字：^\d{m,n}$
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他