当前位置：网站首页>Understanding of threads in signal catcher threads

Understanding of threads in signal catcher threads

2022-04-22 02:21:00 【InfoQ】

First briefly Signal Catcher,Signal Catcher Thread received kernel The message at the bottom of the system dump The information of the current virtual machine and set the flag bit of each thread (check_point) And request thread status is suspended , This flag is checked when context switching occurs while the thread is running . Wait until all threads hang , To traverse the Dump Wake up the thread after the stack and thread data of each thread . About ANR More on my other blogs
Look up ~~
.

== This article focuses on the analysis of Singal Catcher I have an updated understanding of threads .==

stay Android It can only pass through pthread_create To create a thread ,Thread It's just Android Runtime A class in it , One Thread After the object is created, it will be saved in the thread TLS Area , So a Linux Each thread corresponds to a Thread object , Can pass Thread Of Current() Function to get the associated with the current thread Thread object , Through this Thread Object can get some important information , For example, the current thread Java Thread state ,Java Stack frame ,JNI Function pointer list and so on , The reason is Java Thread state ,Java Stack frame , Because Android The runtime doesn't have its own threading mechanism ,Java At the bottom of the thread is a Linux Threads , however Linux Threads are not like Watting,Blocked Etc , also Linux There are no threads Java Stackable , So these thread states and Java Stack frames must have a place to save , Otherwise it will be lost ,Thread The object is an ideal “ Lockers ”.

Only when created Thread Object executed attach After the function , One Linux Threads are actually associated with the virtual machine runtime , It became Java Threads , I have my own java Thread state and java Stack frame and other data structures , The pure native It cannot be executed java Code , So when the system changes crash perhaps anr Conduct dump The stack of processes , Some threads do not java Stackable , Only native and kernel Stack , That's why . So this attach() What is done in the function ：

Thread* Thread::Attach(const char* thread_name, bool as_daemon, jobject thread_group,bool create_peer) {
 Runtime* runtime = Runtime::Current();
 ......
 Thread* self;
 {
 MutexLock mu(nullptr, *Locks::runtime_shutdown_lock_);
 if (runtime->IsShuttingDownLocked()) {
 ......
 } else {
 Runtime::Current()->StartThreadBirth();
 self = new Thread(as_daemon); // Create a new one Thread object
 bool init_success = self->Init(runtime->GetThreadList(), runtime->GetJavaVM()); // call init function
 Runtime::Current()->EndThreadBirth();
 if (!init_success) {
 delete self;
 return nullptr;
 }
 }
 }
 ......
 self->InitStringEntryPoints(); 
 CHECK_NE(self->GetState(), kRunnable);
 self->SetState(kNative);
 ......
 return self;
}

First, I created a Thread object , And then we did it init() function , Then at the end, the state of the thread is modified kNative(Java The state of the thread is saved in Thread Object , Specifically, it is composed of tls32_ This structure preserves , You can modify this structure to set the current state of the thread ：

inline ThreadState Thread::SetState(ThreadState new_state) {
 // Cannot use this code to change into Runnable as changing to Runnable should fail if
 // old_state_and_flags.suspend_request is true.
 DCHECK_NE(new_state, kRunnable);
 if (kIsDebugBuild && this != Thread::Current()) {
 std::string name;
 GetThreadName(name);
 LOG(FATAL) << &quot;Thread \&quot;&quot; << name << &quot;\&quot;(&quot; << this << &quot; != Thread::Current()=&quot;
 << Thread::Current() << &quot;) changing state to &quot; << new_state;
 }
 union StateAndFlags old_state_and_flags;
 old_state_and_flags.as_int = tls32_.state_and_flags.as_int;
 tls32_.state_and_flags.as_struct.state = new_state;
 return static_cast<ThreadState>(old_state_and_flags.as_struct.state);
}

enum ThreadState {
 // Thread.State JDWP state
 kTerminated = 66, // TERMINATED TS_ZOMBIE Thread.run has returned, but Thread* still around
 kRunnable, // RUNNABLE TS_RUNNING runnable
 kTimedWaiting, // TIMED_WAITING TS_WAIT in Object.wait() with a timeout
 kSleeping, // TIMED_WAITING TS_SLEEPING in Thread.sleep()
 kBlocked, // BLOCKED TS_MONITOR blocked on a monitor
 kWaiting, // WAITING TS_WAIT in Object.wait()
 kWaitingForGcToComplete, // WAITING TS_WAIT blocked waiting for GC
 kWaitingForCheckPointsToRun, // WAITING TS_WAIT GC waiting for checkpoints to run
 kWaitingPerformingGc, // WAITING TS_WAIT performing GC
 kWaitingForDebuggerSend, // WAITING TS_WAIT blocked waiting for events to be sent
 kWaitingForDebuggerToAttach, // WAITING TS_WAIT blocked waiting for debugger to attach
 kWaitingInMainDebuggerLoop, // WAITING TS_WAIT blocking/reading/processing debugger events
 kWaitingForDebuggerSuspension, // WAITING TS_WAIT waiting for debugger suspend all
 kWaitingForJniOnLoad, // WAITING TS_WAIT waiting for execution of dlopen and JNI on load code
 kWaitingForSignalCatcherOutput, // WAITING TS_WAIT waiting for signal catcher IO to complete
 kWaitingInMainSignalCatcherLoop, // WAITING TS_WAIT blocking/reading/processing signals
 kWaitingForDeoptimization, // WAITING TS_WAIT waiting for deoptimization suspend all
 kWaitingForMethodTracingStart, // WAITING TS_WAIT waiting for method tracing to start
 kWaitingForVisitObjects, // WAITING TS_WAIT waiting for visiting objects
 kWaitingForGetObjectsAllocated, // WAITING TS_WAIT waiting for getting the number of allocated objects
 kStarting, // NEW TS_WAIT native thread started, not yet ready to run managed code
 kNative, // RUNNABLE TS_RUNNING running in a JNI native method
 kSuspended, // RUNNABLE TS_RUNNING suspended by GC or debugger
};

Here is the main analysis init() function , First of all, we need to know about it ART How to execute code ,ART Virtual machine and Dalvik The biggest change is ART virtual machine == No more explaining the execution bytecode , Instead, directly find the corresponding machine code and directly execute ==.ART It will be executed when installing the application dex2oat The process gets a oat The file completes the translation of bytecode into local machine code , This oat Documents are usually kept in /data/app/ apply name /oat/ Under the table of contents , This oat Inside the file is the compiled machine code , But these machine codes cannot exist alone , It needs help from ART Runtime （ Execute one jni Method or in heap In the operation ）, This can be compared to compiling so The library file refers to an external function （ Actually oat and so Files are ELF Executable format file , It's just oat The document is compared to the standard ELF There are several more format files section）. The difference is to open the standard so When you file , In general, it is dlopen This function , This function will put the not loaded so The library loads in , Then reposition these external functions ; and oat Files for fast loading ,ART stay == Thread TLS Area holds some functions ==, The compiled machine code is to call these function pointers to communicate with AT Establish contact at runtime , These functions are just Thread Of init Initialized in the process

版权声明
本文为[InfoQ]所创，转载请带上原文链接，感谢
https://yzsam.com/2022/04/202204211450583489.html

边栏推荐

猜你喜欢

随机推荐