1、线程概念
1.1 进程与线程
我们知道，在linux系统里，有进程和线程的概念。进程是linux最小的资源管理单位，而线程是最小的执行单元。进程与线程不一样，他拥有自己独立的内存空间，而线程则是共享进程的内存空间。所以，相对而言，会更好的利用资源。
当然，学习过linux内核的人也知道，不管是线程还是进程，在内核中都理解为进程，他们都有Task_Struct结构进行描述。这是因为linux内核本身在cpu调度的时候，进程为最小单元，所以线程在内核中表现为一个轻量化的进程，所以我们也就知道线程的切换，实际上就是内核的进程管理器进行的切换操作，而相应的线程的优先级，同样就取决于在内核中的nice值和priority设置。而相应的用户态下线程的管理本身，则是通过进程首次建立就自动创建的管理线程进行管理，例如线程的停止，线程的创建。
通常我们在进程中创建线程，会调用pthread_create方法，这个方法会调用到_clone方法，这个跟fork()进程时调用的_fork()方法最终都会调用到do_fork()方法，而作为进程和线程定义上的差别，do_fork的参数当然有所区分。
比如我们通过do_fork创建线程时，传入进程参数，包括内存空间（堆、栈、全局变量、数据区等）、文件系统信息、文件描述符表、信号句柄表、进程ID（当前进程id、父进程id）进行共享，并让每个线程仍然保持自己独立的运行栈。这点不同于创建进程，概念上子进程则拥有独立共享内存空间、文件系统空间、信号句柄表和进程ID，当然实际实现的时候，linux使用了一种机制，在父进程fork子进程，会共享整个自己的内存空间，如果子进程只是读取，那么则是共享父进程的空，一旦修改内存中值的时候，父进程会复制一份虚拟地址空间，指向父进程的物理空间，这样就成为完全独立的子进程的内存空间，这也就是我们常说的copy-on-write写时复制，当然父子进程也存在共享的内容，一个是文件描述符表（比如父进程建立socket连接的fd，子进程也会共享，他只是在这个fd上计数+1，这时候，子进程如果用不到，就就需要关闭socket的fd，因为fd只有在计数为0的时候，才会真正关闭，所以这一步必不可少），以及mmap的映射关系。所以这一点与线程的共享存在本质的区别。
2、查看线程进程信息
2.1 进程信息
以Android设备为例，我们可以通过两种方式查看进程信息：
adb shell ps
可以看到类似如下的信息：
USER PID PPID VSZ RSS WCHAN ADDR S NAME
u0_a9 27576 239 1139076 22880 SyS_epoll_wait a7c4c1b8 S android.process.media
其中：
user 表示用户信息，在android里面，u0表示主用户，u10\u20\u30等就代表副用户，后面的数字，就表示userid，u0的userid就是0，当然他们在应用的uid里面也承担信息，比如u0表示的就表示10000，u10就表示110000，依次类推，而u0_a9在android里面就表示10000 + 0xa9 = 10169。一个应用安装之后的uid是不变的。
PID 就表示进程号。跟linux里面一样表示进程信息。
PPID 就表示该进程的父进程号，如果看过ActivityManagerService的源码，可以知道，一般android应用，都是通过zygote孵化的进程，所以这个上面的239一般就表示zygote进程（同样zygote则是由init进程初始化，android初始化进程）。如下：
root 239 1 1055008 9568 poll_schedule_timeout a7c4c390 S zygote
root 1 0 18596 1700 SyS_epoll_wait b5e34 S init
所以通过类似这样的手段，可以找到进程的关系。
除了ps的指令，我们也可以通过linux的伪文件系统，查看进程信息
adb shell ls -al /proc
实际上，运行的进程信息，全部都在/proc目录下。
2.2 线程信息
同样ps也提供的方法：
例如我们查看进程12424的所有线程。
adb shell ps -T | grep 12424
就会列出所有的线程信息，其中-T 表示列出线程信息。
当然/proc里面包含了进程的信息，同样也包含了线程信息，我们可以通过查看:
adb shell ls -al /proc/12424 查看到所有的线程信息
当然我们在定位线程泄漏问题的时候，也可以通过以下方式查看线程的数量，以判断是否不断增长：
adb shell ls /proc/12424/task | wc -l。
3、Android线程
有了以上的基础解析，对线程有了初步的理解，我们正式阅读java源码，Java有很多的线程实现方式，比如Thread，Runnable、Callable、Future、FutureTask等，那这些类如何连接起来，如何实现的呢？我们先从Thread说起。
3.1 Thread的创建和运行
因为线程这块涉及到VM调用底层的机制，android的art这块代码，是区别与Java线程代码的，但是，基本的思路类似，区别仅仅是调用native的vm代码上存在区别，上层基本一样，以start的为例：
// JAVA代码
public synchronized void start() {
if (threadStatus != 0)
throw new IllegalThreadStateException();
group.add(this);
boolean started = false;
try {
start0();
started = true;
} finally {
try {
if (!started) {
group.threadStartFailed(this);
}
} catch (Throwable ignore) {
}
}
}
Android 代码
public synchronized void start() {
if (threadStatus != 0 || started)
throw new IllegalThreadStateException();
started = false;
try {
nativeCreate(this, stackSize, daemon);
started = true;
} finally {
try {
if (!started) {
group.threadStartFailed(this);
}
} catch (Throwable ignore) {
}
}
}
所以看到只是start0()和nativeCreate()两个native方法有区别，我们这边以Android的线程的方法进行分析。这个代码可以在SDK代码里找到，也可以参见
http://androidxref.com/8.1.0_r33/xref/art/runtime/native/java_lang_Thread.cc
static void Thread_nativeCreate(JNIEnv* env, jclass, jobject java_thread, jlong stack_size, jboolean daemon) {
Runtime* runtime = Runtime::Current();
if (runtime->IsZygote() && runtime->IsZygoteNoThreadSection()) { // 判断是否为zygote进程，并且是zygote不可建立线程的部分，则抛出异常
jclass internal_error = env->FindClass("java/lang/InternalError");
CHECK(internal_error != nullptr);
env->ThrowNew(internal_error, "Cannot create threads in zygote");
return;
}
Thread::CreateNativeThread(env, java_thread, stack_size, daemon == JNI_TRUE); // 创建线程
}
我们继续看线程创建的函数：
void Thread::CreateNativeThread(JNIEnv* env, jobject java_peer, size_t stack_size, bool is_daemon) {
CHECK(java_peer != nullptr);
Thread* self = static_cast<JNIEnvExt*>(env)->GetSelf();
if (VLOG_IS_ON(threads)) { // 判断线程的日志是否打开，打开则给每个Thread命名
ScopedObjectAccess soa(env);
ArtField* f = jni::DecodeArtField(WellKnownClasses::java_lang_Thread_name);
ObjPtr<mirror::String> java_name =
f->GetObject(soa.Decode<mirror::Object>(java_peer))->AsString();
std::string thread_name;
if (java_name != nullptr) {
thread_name = java_name->ToModifiedUtf8();
} else {
thread_name = "(Unnamed)";
}
VLOG(threads) << "Creating native thread for " << thread_name;
self->Dump(LOG_STREAM(INFO));
}
Runtime* runtime = Runtime::Current();
bool thread_start_during_shutdown = false;
{
MutexLock mu(self, *Locks::runtime_shutdown_lock_);
if (runtime->IsShuttingDownLocked()) {
thread_start_during_shutdown = true; // 判断当前是否刚好是VM关闭的场景
} else {
runtime->StartThreadBirth(); // 实际就是记录线程创建数+1
}
}
if (thread_start_during_shutdown) { // 如果在VM关闭过程中新建，抛异常
ScopedLocalRef<jclass> error_class(env, env->FindClass("java/lang/InternalError"));
env->ThrowNew(error_class.get(), "Thread starting during runtime shutdown");
return;
}
Thread* child_thread = new Thread(is_daemon);
child_thread->tlsPtr_.jpeer = env->NewGlobalRef(java_peer);
stack_size = FixStackSize(stack_size); // 设置运行栈的大小
env->SetLongField(java_peer, WellKnownClasses::java_lang_Thread_nativePeer,
reinterpret_cast<jlong>(child_thread));
std::string error_msg;
std::unique_ptr<JNIEnvExt> child_jni_env_ext(
JNIEnvExt::Create(child_thread, Runtime::Current()->GetJavaVM(), &error_msg));
int pthread_create_result = 0;
if (child_jni_env_ext.get() != nullptr) {
pthread_t new_pthread;
pthread_attr_t attr;
child_thread->tlsPtr_.tmp_jni_env = child_jni_env_ext.get();
CHECK_PTHREAD_CALL(pthread_attr_init, (&attr), "new thread");
CHECK_PTHREAD_CALL(pthread_attr_setdetachstate, (&attr, PTHREAD_CREATE_DETACHED),
"PTHREAD_CREATE_DETACHED");
CHECK_PTHREAD_CALL(pthread_attr_setstacksize, (&attr, stack_size), stack_size);
// 创建线程，并创建callback用于线程创建完成回调，回调见后面的代码
pthread_create_result = pthread_create(&new_pthread,
&attr,
Thread::CreateCallback,
child_thread);
CHECK_PTHREAD_CALL(pthread_attr_destroy, (&attr), "new thread");
if (pthread_create_result == 0) {
child_jni_env_ext.release();
return;
}
}
{
MutexLock mu(self, *Locks::runtime_shutdown_lock_);
runtime->EndThreadBirth(); // 当前线程完成创建，如果发现现在没有线程创建，并且VM开始shutdown了，就返回告知退出线程。
}
// 删除掉全局的引用，因为此时init还没有运行。
env->DeleteGlobalRef(child_thread->tlsPtr_.jpeer);
child_thread->tlsPtr_.jpeer = nullptr;
delete child_thread;
child_thread = nullptr;
env->SetLongField(java_peer, WellKnownClasses::java_lang_Thread_nativePeer, 0);
{
std::string msg(child_jni_env_ext.get() == nullptr ?
StringPrintf("Could not allocate JNI Env: %s", error_msg.c_str()) :
StringPrintf("pthread_create (%s stack) failed: %s",
PrettySize(stack_size).c_str(), strerror(pthread_create_result)));
ScopedObjectAccess soa(env);
soa.Self()->ThrowOutOfMemoryError(msg.c_str());
}
}
我们看一下回调之后做了啥
void* Thread::CreateCallback(void* arg) {
Thread* self = reinterpret_cast<Thread*>(arg);
Runtime* runtime = Runtime::Current();
if (runtime == nullptr) {
LOG(ERROR) << "Thread attaching to non-existent runtime: " << *self;
return nullptr;
}
{
// 加锁，直到完成了thread的init操作
MutexLock mu(nullptr, *Locks::runtime_shutdown_lock_);
// 检查是否VM shut down
CHECK(!runtime->IsShuttingDownLocked());
// 对Thread进行init操作
CHECK(self->Init(runtime->GetThreadList(), runtime->GetJavaVM(), self->tlsPtr_.tmp_jni_env));
self->tlsPtr_.tmp_jni_env = nullptr;
Runtime::Current()->EndThreadBirth();
}
{
ScopedObjectAccess soa(self);
self->InitStringEntryPoints();
// Copy peer into self, deleting global reference when done.
CHECK(self->tlsPtr_.jpeer != nullptr);
self->tlsPtr_.opeer = soa.Decode<mirror::Object>(self->tlsPtr_.jpeer).Ptr();
self->GetJniEnv()->DeleteGlobalRef(self->tlsPtr_.jpeer);
self->tlsPtr_.jpeer = nullptr;
self->SetThreadName(self->GetThreadName()->ToModifiedUtf8().c_str());
ArtField* priorityField = jni::DecodeArtField(WellKnownClasses::java_lang_Thread_priority);
// 设置线程真实的优先级
self->SetNativePriority(priorityField->GetInt(self->tlsPtr_.opeer));
// 告知VM线程的创建
runtime->GetRuntimeCallbacks()->ThreadStart(self);
// 调用Java层Thread的run方法
ObjPtr<mirror::Object> receiver = self->tlsPtr_.opeer;
jmethodID mid = WellKnownClasses::java_lang_Thread_run;
ScopedLocalRef<jobject> ref(soa.Env(), soa.AddLocalReference<jobject>(receiver));
InvokeVirtualOrInterfaceWithJValues(soa, ref.get(), mid, nullptr);
}
// 将自己从线程列表中删除
Runtime::Current()->GetThreadList()->Unregister(self);
return nullptr;
}
通过这样的过程，我们知道线程的创建还是调用pthread_create方法。并且为了保证VM堆线程可控，也会告知VM（也就是art）线程情况，我们看一下runtime->GetRuntimeCallbacks()->ThreadStart实现：
void RuntimeCallbacks::AddThreadLifecycleCallback(ThreadLifecycleCallback* cb) {
thread_callbacks_.push_back(cb);
}
void RuntimeCallbacks::ThreadStart(Thread* self) {
for (ThreadLifecycleCallback* cb : thread_callbacks_) {
cb->ThreadStart(self);
}
}
我们看一下AddThreadLifecycleCallback的调用处，此代码在runtime.cc中：
callbacks_->AddThreadLifecycleCallback(Dbg::GetThreadLifecycleCallback());
实际上回调回来，只是为了Dbg（也就是debugger工具）获取当前的线程状况。
3.2 线程组
3.2.1 线程组概念
什么是线程组，从概念上理解很简单，就是将线程组合成一个集合，这个集合就是线程组，线程组可以包含线程，也可以嵌套线程组，可以理解成一种树状的结构。我们看一下线程组的定义：
public ThreadGroup(String name) {
this(Thread.currentThread().getThreadGroup(), name);
}
public ThreadGroup(ThreadGroup parent, String name) {
this(checkParentAccess(parent), parent, name);
}
private ThreadGroup(Void unused, ThreadGroup parent, String name) {
this.name = name;
this.maxPriority = parent.maxPriority;
this.daemon = parent.daemon;
this.vmAllowSuspension = parent.vmAllowSuspension;
this.parent = parent;
parent.add(this);
}
从这个方法中，我们知道，如果创建ThreadGroup时，没有设置父ThreadGroup，则以当前线程的线程组作为此线程组的父线程组。并且默认情况下线程组的优先级会设置成最大，这个线程组的优先级也会影响到线程的优先级（后面我们会讲到）。
我们看一下线程组在线程上的应用，我们看一下构造函数：
public Thread() {
init(null, null, "Thread-" + nextThreadNum(), 0);
}
public Thread(ThreadGroup group, Runnable target) {
init(group, target, "Thread-" + nextThreadNum(), 0);
}
也就是说，Thread可以让调用者主动设置ThreadGroup，同样也可使设置成null，我们知道线程一定是有线程组的，我们看一下如果设置成null的实现：
private void init(ThreadGroup g, Runnable target, String name, long stackSize) {
Thread parent = currentThread();
if (g == null) {
g = parent.getThreadGroup();
}
}
也就是说，如果没有设置线程组，则以当前运行线程（也就是创建当前线程的父线程）的ThreadGroup作为当前要创建的线程的ThreadGroup。这一点与我们之前讲到主动创建ThreadGroup相似却不一样，主动创建ThreadGroup，是将当前运行线程的线程组作为当前创建线程组的父线程组；而创建线程时，则是设置当前运行线程的线程组为当前要创建线程的线程组，一个是父子关系，一个是公用父亲的关系。
我们在实际使用时，一般都是不手动创建线程组的。
3.2.2 线程组作用
有了线程组的概念后，那么线程组有啥作用，个人认为有两点：
1、因为当前线程持有其线程组，可以通过如下方法获取到线程组：
public final ThreadGroup getThreadGroup() {
// Android-changed: Return null if the thread is terminated.
if (getState() == Thread.State.TERMINATED) {
return null;
}
return group;
}
我们可以获取到同组线程的一些信息，例如
a、因为ThreadGroup在线程创建的过程中，thread也会告知ThreadGroup自己的运行状态，所以就可以获取到如下：
activeGroupCount() 当前活跃线程组、activeCount()当前活跃线程。
b、调用线程组的某个thread的UncaughtException
public void uncaughtException(Thread t, Throwable e) {
if (parent != null) {
parent.uncaughtException(t, e);
} else {
Thread.UncaughtExceptionHandler ueh =
Thread.getDefaultUncaughtExceptionHandler();
if (ueh != null) {
ueh.uncaughtException(t, e);
} else if (!(e instanceof ThreadDeath)) {
System.err.print("Exception in thread \""
+ t.getName() + "\" ");
e.printStackTrace(System.err);
}
}
}
2、通过线程组统一设置的线程优先级对线程进行统一约束，结论先抛出，线程的优先级不高于线程组的优先级。
当然除了以上的两个作用，还有一个更重要的作用，就是协助排查问题，因为有了线程组的关系，我们在分析trace的时候，可以根据场景得到很多线程是由谁创建的。比如我们常见的trace中的group=main，基本上都是有主线程创建的线程，除非被创建的线程主动设置了线程组，那我们一样可以通过线程组的父线程组得到关联关系。
3.2.3 主线程组的概念
讲到这，一定有同学有个疑问，为什么主进程的group=main，name=main，如果阅读过zygote启动虚拟机流程的同学，一定知道进程启动的时候，调用art的源码会走到runtime.cc的
bool Runtime::Create(RuntimeArgumentMap&& runtime_options) {
if (!instance_->Init(std::move(runtime_options))) {
instance_ = nullptr;
return false;
}
return true;
}
继而调用到init方法，我们主要看线程相关的实现：
bool Runtime::Init(RuntimeArgumentMap&& runtime_options_in) {
Thread::Startup();
Thread* self = Thread::Attach("main", false, nullptr, false);
self->TransitionFromSuspendedToRunnable();
}
Startup主要实现创建线程的TLS（线程局部存储）
CHECK_PTHREAD_CALL(pthread_key_create, (&Thread::pthread_key_self_, Thread::ThreadExitCallback),
"self key");
Attach实际就是创建Thread线程并进行初始化的过程，可以看到设置了线程名为main线程，也就是主线程。
执行完Runtime::Create之后，就是执行Runtime::Start()，我们同样看一下主要实现：
bool Runtime::Start() {
Thread* self = Thread::Current();
InitThreadGroups(self);
Thread::FinishStartup();
}
第一句代码：获取当前的主线程
第二句：
void Runtime::InitThreadGroups(Thread* self) {
JNIEnvExt* env = self->GetJniEnv();
ScopedJniEnvLocalRefState env_state(env);
main_thread_group_ =
env->NewGlobalRef(env->GetStaticObjectField(
WellKnownClasses::java_lang_ThreadGroup,
WellKnownClasses::java_lang_ThreadGroup_mainThreadGroup));
system_thread_group_ =
env->NewGlobalRef(env->GetStaticObjectField(
WellKnownClasses::java_lang_ThreadGroup,
WellKnownClasses::java_lang_ThreadGroup_systemThreadGroup));
}
这个java_lang_ThreadGroup_mainThreadGroup实际上就是反射调用到java层的实现，对应的java层代码就是ThreadGroup.java的：
static final ThreadGroup mainThreadGroup = new ThreadGroup(systemThreadGroup, "main");
所以这一步，就是创建mainThreadGroup和systemThreadGroup。
第三句，group获取了，我们最后再把group设置给主线程，就是通过FinishStartup方法：
void Thread::FinishStartup() {
Runtime* runtime = Runtime::Current();
ScopedObjectAccess soa(Thread::Current());
Thread::Current()->CreatePeer("main", false, runtime->GetMainThreadGroup());
Thread::Current()->AssertNoPendingException();
Runtime::Current()->GetClassLinker()->RunRootClinits();
}
主要涉及实现在CreatePeer中，我们看到执行：
env->CallNonvirtualVoidMethod(peer.get(),
WellKnownClasses::java_lang_Thread,
WellKnownClasses::java_lang_Thread_init,
thread_group, thread_name.get(), thread_priority, thread_is_daemon);
经过这样的几个过程，我们创建了主线程，并且将主线程的线程组都设置成main。
3.3 线程优先级
Thread.java的源码中有优先级priority的设置
public final void setPriority(int newPriority) {
ThreadGroup g;
checkAccess();
if (newPriority > MAX_PRIORITY || newPriority < MIN_PRIORITY) {
// Android-changed: Improve exception message when the new priority
// is out of bounds.
throw new IllegalArgumentException("Priority out of range: " + newPriority);
}
if((g = getThreadGroup()) != null) {
// 如果线程优先级高于组max优先级，则设置为组的max优先级
if (newPriority > g.getMaxPriority()) {
newPriority = g.getMaxPriority();
}
synchronized(this) {
this.priority = newPriority;
if (isAlive()) {
nativeSetPriority(newPriority);
}
}
}
}
首先他先给定了优先级设置的范围：1-10
public final static int MIN_PRIORITY = 1;
public final static int MAX_PRIORITY = 10;
然后如果设置优先级大于组最大优先级了，则设置为组最大优先级。
最后，就是调用到nativeSetPriority，我们看一下主要实现：
static void Thread_nativeSetPriority(JNIEnv* env, jobject java_thread, jint new_priority) {
if (thread != nullptr) {
thread->SetNativePriority(new_priority);
}
}
我们看一下实现，代码位于art/runtime/thread_android.cc：
void Thread::SetNativePriority(int newPriority) {
if (newPriority < 1 || newPriority > 10) {
LOG(WARNING) << "bad priority " << newPriority;
newPriority = 5;
}
int newNice = kNiceValues[newPriority-1];
pid_t tid = GetTid();
if (newNice >= ANDROID_PRIORITY_BACKGROUND) {
set_sched_policy(tid, SP_BACKGROUND);
} else if (getpriority(PRIO_PROCESS, tid) >= ANDROID_PRIORITY_BACKGROUND) {
set_sched_policy(tid, SP_FOREGROUND);
}
if (setpriority(PRIO_PROCESS, tid, newNice) != 0) {
PLOG(INFO) << *this << " setPriority(PRIO_PROCESS, " << tid << ", " << newNice << ") failed";
}
}
整个过程，就是先判断优先级设置是否不在区间内，不在的话，统一设置成5。
我们再看一下kNiceValues具体怎么对应到上层的10个优先级：
static const int kNiceValues[10] = {
ANDROID_PRIORITY_LOWEST, // 1 (MIN_PRIORITY)
ANDROID_PRIORITY_BACKGROUND + 6,
ANDROID_PRIORITY_BACKGROUND + 3,
ANDROID_PRIORITY_BACKGROUND,
ANDROID_PRIORITY_NORMAL, // 5 (NORM_PRIORITY)
ANDROID_PRIORITY_NORMAL - 2,
ANDROID_PRIORITY_NORMAL - 4,
ANDROID_PRIORITY_URGENT_DISPLAY + 3,
ANDROID_PRIORITY_URGENT_DISPLAY + 2,
ANDROID_PRIORITY_URGENT_DISPLAY // 10 (MAX_PRIORITY)
};
而就算我们分了10级执行，最终android都会分成这三步设置：
1、如果nice值>ANDROID_PRIORITY_BACKGROUND，设置调度策略为SP_BACKGROUND，关于调度策略函数set_sched_policy我们后面还会提到。
2、如果根据CPU策略，也就是getpriority(PRIO_PROCESS, tid)获取的优先级是大于ANDROID_PRIORITY_BACKGROUND，则调度策略为SP_FOREGROUND。
3、最后setpriority(PRIO_PROCESS, tid, newNice)就是真正设置优先级的调用，PRIO_PROCESS表示设置进程的优先级。tid就表示对应的进程/进程组/用户id，newNice就表示进程的nice值，到这一步其实可以发现，线程的调度最后也是转换成了进程调度（进程调度的依据就是nice值，越小优先级越高），这个我们后面会详细解释。
从这个过程我们可以看到，设置thread分级的10个优先级，并不能有效的让线程出于更高的优先级，因为他会把线程的优先级转换成nice值，这个转换过程也就说明优先级不能完全对等nice值。那么线程优先级我们怎么对等进程的优先级设置等级，Android提供了android.os.Process的:
public static final native void setThreadPriority(int priority)
throws IllegalArgumentException, SecurityException;
才能真正有效的设置线程的优先级，这边主要依赖的就是进程的优先级调度，我们看代码frameworks/base/core/jni/android_util_Process.cpp：
void android_os_Process_setThreadPriority(JNIEnv* env, jobject clazz,
jint pid, jint pri)
{
int rc = androidSetThreadPriority(pid, pri);
if (rc != 0) {
if (rc == INVALID_OPERATION) {
signalExceptionForPriorityError(env, errno, pid);
} else {
signalExceptionForGroupError(env, errno, pid);
}
}
}
主要就是调用androidSetThreadPriority函数，代码位置/system/core/libutils/Threads.cpp：
int androidSetThreadPriority(pid_t tid, int pri)
{
int rc = 0;
int lasterr = 0;
if (pri >= ANDROID_PRIORITY_BACKGROUND) {
rc = set_sched_policy(tid, SP_BACKGROUND);
} else if (getpriority(PRIO_PROCESS, tid) >= ANDROID_PRIORITY_BACKGROUND) {
rc = set_sched_policy(tid, SP_FOREGROUND);
}
if (rc) {
lasterr = errno;
}
if (setpriority(PRIO_PROCESS, tid, pri) < 0) {
rc = INVALID_OPERATION;
} else {
errno = lasterr;
}
return rc;
}
这个过程跟Thread设置优先级的函数近似，只是没有了转换过程，故而也就讲线程的优先级完全对等到了进程优先级，这样才能真正生效，我们再看一下遗留的问题set_sched_policy如何设置调度策略的，代码在/system/core/libcutils/sched_policy.cpp：
int set_sched_policy(int tid, SchedPolicy policy)
{
if (tid == 0) {
tid = gettid();
}`
policy = _policy(policy);
pthread_once(&the_once, __initialize); // 初始化policy的fd
// 是否开启boost的调度方式
if (schedboost_enabled()) {
int boost_fd = -1;
switch (policy) {
case SP_BACKGROUND:
boost_fd = bg_schedboost_fd;
break;
case SP_FOREGROUND:
boost_fd = fg_schedboost_fd;
break;
default:
boost_fd = -1;
break;
}
// 将进程加入到对应的调度策略组
if (boost_fd > 0 && add_tid_to_cgroup(tid, boost_fd) != 0) {
if (errno != ESRCH && errno != ENOENT)
return -errno;
}
}
// 设置timerslack，这个表示进程可睡眠的最长时间间隔，比如你在用户态sleep了100ms，但是timerslack大于100ms，那么实际线程睡眠的时间会超过设置的sleep时长
set_timerslack_ns(tid, policy == SP_BACKGROUND ? TIMER_SLACK_BG : TIMER_SLACK_FG);
return 0;
}
首先看一下initialize初始化fd的操作
static void __initialize() {
const char* filename;
if (cpusets_enabled()) {
if (!access("/dev/cpuset/tasks", W_OK)) {
// 首先如果CPU支持调度策略，则打开cpu对应的fd
filename = "/dev/cpuset/foreground/tasks";
fg_cpuset_fd = open(filename, O_WRONLY | O_CLOEXEC);
filename = "/dev/cpuset/background/tasks";
bg_cpuset_fd = open(filename, O_WRONLY | O_CLOEXEC);
filename = "/dev/cpuset/system-background/tasks";
system_bg_cpuset_fd = open(filename, O_WRONLY | O_CLOEXEC);
filename = "/dev/cpuset/top-app/tasks";
ta_cpuset_fd = open(filename, O_WRONLY | O_CLOEXEC);
filename = "/dev/cpuset/restricted/tasks";
rs_cpuset_fd = open(filename, O_WRONLY | O_CLOEXEC);
// 如果支持boost的调度策略，初始化boost调度侧率fd
if (schedboost_enabled()) {
filename = "/dev/stune/top-app/tasks";
ta_schedboost_fd = open(filename, O_WRONLY | O_CLOEXEC);
filename = "/dev/stune/foreground/tasks";
fg_schedboost_fd = open(filename, O_WRONLY | O_CLOEXEC);
filename = "/dev/stune/background/tasks";
bg_schedboost_fd = open(filename, O_WRONLY | O_CLOEXEC);
filename = "/dev/stune/rt/tasks";
rt_schedboost_fd = open(filename, O_WRONLY | O_CLOEXEC);
}
}
}
char buf[64];
snprintf(buf, sizeof(buf), "/proc/%d/timerslack_ns", getpid());
__sys_supports_timerslack = !access(buf, W_OK);
}
然后我们看一下策略是如何应用的，主要调用函数：
static int add_tid_to_cgroup(int tid, int fd)
{
if (fd < 0) {
SLOGE("add_tid_to_cgroup failed; fd=%d\n", fd);
errno = EINVAL;
return -1;
}
// specialized itoa -- works for tid > 0
char text[22];
char *end = text + sizeof(text) - 1;
char *ptr = end;
*ptr = '\0';
while (tid > 0) {
*--ptr = '0' + (tid % 10);
tid = tid / 10;
}
if (write(fd, ptr, end - ptr) < 0) {
/*
* If the thread is in the process of exiting,
* don't flag an error
*/
if (errno == ESRCH)
return 0;
SLOGW("add_tid_to_cgroup failed to write '%s' (%s); fd=%d\n",
ptr, strerror(errno), fd);
errno = EINVAL;
return -1;
}
return 0;
}
这个过程实际上就是按照规则将进程id写入到对应策略的fd即可。这样cpu在调度的时候就会知道当前进程是怎样调度的。而且从这个分组概念中，我们也看到，每个调度策略有独立的组，这样不同的组使用不同样的调度方式。而且也可以看到，这种设置策略的方式，仅使用与支持boost调度的系统，不然调度策略都是默认的。还有一种是依赖cpu的调度方式，见Process.java的代码setThreadGroupAndCpuset以及相关调用，这里不再继续。
有了调度策略，我们看一下最终设置优先级的函数setpriority，这个实际上就是系统调用，这个就涉及到kernel代码的实现，我们这边就看一下setpriorit这个函数的功能：
int setpriority(int which, int who, int prio);
其中which的取值：PRIO_PROCESS, PRIO_PGRP, PRIO_USER分别表示设置进程
who取值则是相对于which定义的id，比如which是PRIO_PROCESS，就表示进程id，which是PRIO_PGRP，它就表进程组id，which是PRIO_USER，它就表示用户id
prio也就是nice值，nice值的取值是-19-20，nice值月底，优先级越高。
返回值int，取值有：
EINVAL which值错误，不是PRIO_PROCESS、PRIO_PGRP和PRIO_USER其中之一
ESRCH 根据who没有找到相关对象
EACCES 无法降低优先级
EPERM 权限不够
4、总结
经过我们的分析，我们知道线程和进程在内核中都是以进程表现。只是线程之间会公用pid，公用内存空间，但是各自栈独立。这也就促使我们线程优先级调节需要借助进程切换优先级的接口setpriority。
线程调用start的运行线程的时候，本质上还是调用libc的pthread_create接口，也就是说虚拟机中的线程与linux的线程是一一对应的，在底层创建线程成功之后，才会回调java层调用run的实现。这也就是为什么我们在运行线程的时候，一定要调用start的原因。
首个线程创建时即为主线程main，并且其线程组也叫主线程组main。如果创建线程的时候，未设置线程组，则线程组使用父线程的线程组。相应的如果创建线程组时，此线程组的父线程组就是当前线程的线程组。