Android线程管理之ActivityThread

public static void main(string[] args) {
trace.tracebegin(trace.trace_tag_activity_manager, "activitythreadmain");
samplingprofilerintegration.start();
// closeguard defaults to true and can be quite spammy. we
// disable it here, but selectively enable it later (via
// strictmode) on debug builds, but using dropbox, not logs.
closeguard.setenabled(false);
environment.initforcurrentuser();
// set the reporter for event logging in libcore
eventlogger.setreporter(new eventloggingreporter());
androidkeystoreprovider.install();
// make sure trustedcertificatestore looks in the right place for ca certificates
final file configdir = environment.getuserconfigdirectory(userhandle.myuserid());
trustedcertificatestore.setdefaultuserdirectory(configdir);
process.setargv0("<pre-initialized>");
looper.preparemainlooper();
activitythread thread = new activitythread();
thread.attach(false);
if (smainthreadhandler == null) {
smainthreadhandler = thread.gethandler();
}
if (false) {
looper.mylooper().setmessagelogging(new
logprinter(log.debug, "activitythread"));
}
// end of event activitythreadmain.
trace.traceend(trace.trace_tag_activity_manager);
looper.loop();
throw new runtimeexception("main thread loop unexpectedly exited");
}

private void attach(boolean system) {
scurrentactivitythread = this;
msystemthread = system;
if (!system) {
…… runtimeinit.setapplicationobject(mappthread.asbinder());
final iactivitymanager mgr = activitymanagernative.getdefault();
try {
mgr.attachapplication(mappthread);
} catch (remoteexception ex) {
// ignore
}
…… } else {
……
}
}

@override
public final void attachapplication(iapplicationthread thread) {
synchronized (this) {
int callingpid = binder.getcallingpid();
final long origid = binder.clearcallingidentity();
attachapplicationlocked(thread, callingpid);
binder.restorecallingidentity(origid);
}
}

private final boolean attachapplicationlocked(iapplicationthread thread,
int pid) {
// find the application record that is being attached... either via
// the pid if we are running in multiple processes, or just pull the
// next app record if we are emulating process with anonymous threads.
processrecord app;
if (pid != my_pid && pid >= 0) {
synchronized (mpidsselflocked) {
app = mpidsselflocked.get(pid);
}
} else {
app = null;
}
// ……
try {
// ……
thread.bindapplication(processname, appinfo, providers, app.instrumentationclass,
profilerinfo, app.instrumentationarguments, app.instrumentationwatcher,
app.instrumentationuiautomationconnection, testmode, enableopengltrace,
enabletrackallocation, isrestrictedbackupmode || !normalmode, app.persistent,
new configuration(mconfiguration), app.compat,
getcommonserviceslocked(app.isolated),
mcoresettingsobserver.getcoresettingslocked());
updatelruprocesslocked(app, false, null);
app.lastrequestedgc = app.lastlowmemory = systemclock.uptimemillis();
} catch (exception e) {
// todo: yikes! what should we do? for now we will try to
// start another process, but that could easily get us in
// an infinite loop of restarting processes...
slog.wtf(tag, "exception thrown during bind of " + app, e);
app.resetpackagelist(mprocessstats);
app.unlinkdeathrecipient();
startprocesslocked(app, "bind fail", processname);
return false;
}
// see if the top visible activity is waiting to run in this process...
if (normalmode) {
try {
if (mstacksupervisor.attachapplicationlocked(app)) {
didsomething = true;
}
} catch (exception e) {
slog.wtf(tag, "exception thrown launching activities in " + app, e);
badapp = true;
}
}
// ……
}

final boolean realstartactivitylocked(activityrecord r,
processrecord app, boolean andresume, boolean checkconfig)
throws remoteexception {
//... 
try {
//...
app.thread.schedulelaunchactivity(new intent(r.intent), r.apptoken,
system.identityhashcode(r), r.info,
new configuration(mservice.mconfiguration),
r.compat, r.icicle, results, newintents, !andresume,
mservice.isnexttransitionforward(), profilefile, profilefd,
profileautostop);
//...
} catch (remoteexception e) {
//...
}
//... 
return true;
}

// we use token to identify this activity without having to send the
// activity itself back to the activity manager. (matters more with ipc)
@override
public final void schedulelaunchactivity(intent intent, ibinder token, int ident,
activityinfo info, configuration curconfig, configuration overrideconfig,
compatibilityinfo compatinfo, string referrer, ivoiceinteractor voiceinteractor,
int procstate, bundle state, persistablebundle persistentstate,
list<resultinfo> pendingresults, list<referrerintent> pendingnewintents,
boolean notresumed, boolean isforward, profilerinfo profilerinfo) {
updateprocessstate(procstate, false);
activityclientrecord r = new activityclientrecord();
……
sendmessage(h.launch_activity, r);
}

public void handlemessage(message msg) {
if (debug_messages) slog.v(tag, ">>> handling: " + codetostring(msg.what));
switch (msg.what) {
case launch_activity: {
trace.tracebegin(trace.trace_tag_activity_manager, "activitystart");
final activityclientrecord r = (activityclientrecord) msg.obj;
r.packageinfo = getpackageinfonocheck(
r.activityinfo.applicationinfo, r.compatinfo);
handlelaunchactivity(r, null);
trace.traceend(trace.trace_tag_activity_manager);
} break;
……
}

/** initialize the current thread as a looper.
* this gives you a chance to create handlers that then reference
* this looper, before actually starting the loop. be sure to call
* {@link #loop()} after calling this method, and end it by calling
* {@link #quit()}.
*/
public static void prepare() {
prepare(true);
}
private static void prepare(boolean quitallowed) {
if (sthreadlocal.get() != null) {
throw new runtimeexception("only one looper may be created per thread");
}
sthreadlocal.set(new looper(quitallowed));
}
/**
* initialize the current thread as a looper, marking it as an
* application's main looper. the main looper for your application
* is created by the android environment, so you should never need
* to call this function yourself. see also: {@link #prepare()}
*/
public static void preparemainlooper() {
prepare(false);
synchronized (looper.class) {
if (smainlooper != null) {
throw new illegalstateexception("the main looper has already been prepared.");
}
smainlooper = mylooper();
}
}

/**
* return the looper object associated with the current thread. returns
* null if the calling thread is not associated with a looper.
*/
public static looper mylooper() {
return sthreadlocal.get();
}

/** returns the application's main looper, which lives in the main thread of the application.
*/
public static looper getmainlooper() {
synchronized (looper.class) {
return smainlooper;
}
}

private class h extends handler {
……
}
final h mh = new h();
final handler gethandler() {
return mh;
}

/**
* run the message queue in this thread. be sure to call
* {@link #quit()} to end the loop.
*/
public static void loop() {
final looper me = mylooper();
if (me == null) {
throw new runtimeexception("no looper; looper.prepare() wasn't called on this thread.");
}
final messagequeue queue = me.mqueue;
// make sure the identity of this thread is that of the local process,
// and keep track of what that identity token actually is.
binder.clearcallingidentity();
final long ident = binder.clearcallingidentity();
for (;;) {
message msg = queue.next(); // might block
if (msg == null) {
// no message indicates that the message queue is quitting.
return;
}
// this must be in a local variable, in case a ui event sets the logger
printer logging = me.mlogging;
if (logging != null) {
logging.println(">>>>> dispatching to " + msg.target + " " +
msg.callback + ": " + msg.what);
}
msg.target.dispatchmessage(msg);
if (logging != null) {
logging.println("<<<<< finished to " + msg.target + " " + msg.callback);
}
// make sure that during the course of dispatching the
// identity of the thread wasn't corrupted.
final long newident = binder.clearcallingidentity();
if (ident != newident) {
log.wtf(tag, "thread identity changed from 0x"
+ long.tohexstring(ident) + " to 0x"
+ long.tohexstring(newident) + " while dispatching to "
+ msg.target.getclass().getname() + " "
+ msg.callback + " what=" + msg.what);
}
msg.recycle();
}
}