基本概念
进程 & 线程的概念：
进程：在某种程度上表示相互隔离的、独立运行的程序。
线程：也称作轻量级进程。就象进程一样，线程在程序中是独立的、并发的执行路径，每个线程有它自己的堆栈、自己的程序计数器和自己的局部变量。
进程 & 线程的区别：
与分隔的进程相比，进程中的线程之间的隔离程度要小。
进程可以支持多个线程，它们看似同时执行，但互相之间并不同步。一个进程中的多个线程共享相同的内存地址空间，这就意味着它们可以访问相同的变量和对象，而且它们从同一堆中分配对象。
在 Java 中，用 Thread 类表示线程。
线程状态
在 Thtead 的内部有个枚举类，它定义了线程的状态：
public enum State {
NEW, // 新建状态
RUNNABLE, // 就绪状态（即可执行状态）
BLOCKED, // 阻塞状态
WAITING, // 等待状态
TIMED_WAITING, // 等待状态（有时间限制）
TERMINATED; // 死亡状态
}1.新建状态
NEW ，指线程刚创建, 尚未启动。
2.就绪状态
RUNNABLE ，表示线程可以正常参与竞争 CPU 资源，成功率与其优先级高低有关。
3.阻塞状态
BLOCKED，表示线程进入阻塞并监视锁的状态。
它存在于多个线程有同步操作的场景。比如正在等待另一个线程的 synchronized 块的执行释放。
4.等待状态
WAITING ，该状态下的线程表示正在等待另外一个线程的动作。
例如：
- 调用了 wait 方法且没有超时，进入等待状态，等待另一个线程调用 notify/notiyfAll 方法。
- 调用了 join 方法且没有超时 ，进入等待状态，等待另一个线程终止。
- 调用了 LockSupport.park ，进入等待状态，等待另一个线程调用 LockSupport.park。
5.有时间限制的等待状态
TIMED_WAITING ，存在于：
- 调用了 wait / wait(long) 方法且没有超时
- 调用了 join 方法且没有超时
- 调用了 LockSupport.parkNanos/LockSupport.parkUntil 方法
6.终止状态
- TERMINATED ，表示线程已完成执行。
线程优先级
线程的优先级具有以下特点：
优先级代表获取 CPU 资源的概率，优先级高的线程获取的概率较大。
优先级无法保证线程的执行次序，因为这个一个概率问题。
线程的优先级用1-10之间的整数表示，数值越大优先级越高，默认的优先级为5。
在一个线程中开启另外一个新线程，则新开线程称为该线程的子线程，子线程初始优先级与父线程相同。
在 Thhtead 类中，定义了三个优先级常量：
// 最小
public final static int MIN_PRIORITY = 1;
// 默认
public final static int NORM_PRIORITY = 5;
// 最大
public final static int MAX_PRIORITY = 10;源码分析
1.线程创建
在 Java 中，用 Thread 表示线程类，它实现了 Runnbale 接口。
首先来看它的签名：
// 签名
public class Thread implements Runnable
// 接口
public interface Runnable {
public abstract void run();
}再来看它的部分构造函数：
public Thread() {
init(null, null, "Thread-" + nextThreadNum(), 0);
}
public Thread(Runnable target) {
init(null, target, "Thread-" + nextThreadNum(), 0);
}
public Thread(String name) {
init(null, null, name, 0);
}
public Thread(Runnable target, String name) {
init(null, target, name, 0);
}
private void init(ThreadGroup g, Runnable target, String name, long stackSize) {
init(g, target, name, stackSize, null);
}
// 关键
private void init(ThreadGroup g, Runnable target, String name, long stackSize, AccessControlContext acc){...}从代码可知，构建线程的真正过程在 init 方法中实现。构建一个线程所需要的必要参数有：
ThreadGroup ：线程组，表示一个线程的集合。此外，线程组也可以包含其他线程组。线程组构成一棵树，在树中，除了初始线程组外，每个线程组都有一个父线程组。
target：目标，即运行内容，可通过 run 方法执行。
name：线程名称，默认是 Thread-id，每个线程都不有不同的线程名。
stackSize：开辟新增线程所需的栈空间，为 0 表示忽略该参数。
AccessControlContext ：上下文。
2.线程就绪
构建一个线程后，可以通过 start 方法来启动它，同时也表示线程进入就绪状态。
同样的，也可以同调用 Thread 的 yeid 方法来已经运行线程重新进入就绪状态。
yield
public static native void yield();
start
// 线程状态，默认为 0，表示线程还未启动，即 NEW 状态 private volatile int threadStatus = 0; // 表示线程的线程组 private ThreadGroup group; public synchronized void start() { if (threadStatus != 0){ //抛出异常... } // 加入线程组 group.add(this); boolean started = false; try { // 关键 start0(); started = true; } finally { try { // 启动失败，通知线程组 if (!started) { group.threadStartFailed(this); } } catch (Throwable ignore) { // do nothing... } } } // 使用了本地调用，通过 C 代码初始化线程需要的系统资源。 private native void start0();
3.线程运行
线程在启动之后，会自动调用 run 方法，执行规定好的内容。
private Runnable target;
public void run() {
if (target != null) {
target.run();
}
}由代码可知，线程在启动后会自动执行 Runnable.run 定义的内容。
4.线程中断
线程中断，并不是指中断线程的运行，而是指设置线程的中断标记位。
在 Thread 类中，有三个方法跟中断标记位有关：
public static void main(String[] args) {
// interrupt：设置线程的中断状态
Thread.currentThread().interrupt();
// interrupted：返回线程的上次的中断状态，并清除中断状态
System.out.println(Thread.currentThread().interrupted());
// isInterrupt：返回线程的上次的中断状态
System.out.println(Thread.currentThread().isInterrupted());
}下面来看它们的具体实现：
- interrupt，设置线程的中断状态
// 用于同步，表示锁对象
private final Object blockerLock = new Object();
private volatile Interruptible blocker;
public void interrupt() {
if (this != Thread.currentThread()){
// 检查系统访问权限
checkAccess();
}
synchronized (blockerLock) {
Interruptible b = blocker;
if (b != null) {
// 关键 -> 调用本地方法，设置线程中断标志位
interrupt0();
b.interrupt(this);
return;
}
}
interrupt0();
}
// 设置线程中断标志位
private native void interrupt0();- interrupted，返回线程的上次的中断状态，并清除中断状态
public static boolean interrupted() {
return currentThread().isInterrupted(true);
}
public static native Thread currentThread();
// 入参表示是否清除线程中断标记位
private native boolean isInterrupted(boolean ClearInterrupted);- isInterrupt，返回线程的上次的中断状态
public boolean isInterrupted() {
return isInterrupted(false);
}
5.线程阻塞
若想要令线程进入阻塞状态，可以调用 Thread 类的 sleep 方法实现。
public static void sleep(long millis, int nanos) throws InterruptedException {
if (millis < 0) {
// 抛出异常...
}
if (nanos < 0 || nanos > 999999) {
// 抛出异常...
}
if (nanos >= 500000 || (nanos != 0 && millis == 0)) {
millis++;
}
sleep(millis);
}
public static native void sleep(long millis) throws InterruptedException;6.线程等待
在 Thread 类中，想要让线程进入等待，可以调用 join 方法实现。
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
try {
Thread.sleep(3000);
System.out.println("t1 完成工作");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
t1.start();
// 关键把 t1 线程加入到当前线程，等待 t1 执行结束，main 才能继续执行
t1.join();
System.out.println("main 完成工作");下面再来看看它的具体实现：
public final void join() throws InterruptedException {
join(0);
}
public final synchronized void join(long millis) throws InterruptedException {
long base = System.currentTimeMillis();
long now = 0;
if (millis < 0) {
// 抛出异常...
}
if (millis == 0) {
// 关键 -> 线程（指代例子中 t1）存活，则（main）进入等待
while (isAlive()) {
wait(0);
}
} else {
while (isAlive()) {
long delay = millis - now;
if (delay <= 0) {
break;
}
wait(delay);
now = System.currentTimeMillis() - base;
}
}
}
// 判断线程是否存活
public final native boolean isAlive();这里同样有个疑问，既然 mian 进入等待，那么在 t1 结束后如何被唤醒？
正常情况下进入 wait 的 线程，需要其他线程调用 notify/notifyAll 来唤醒。答案在 t1 线程结束后在 JVM 中会调用 notify 方法：
void JavaThread::exit(bool destroy_vm, ExitType exit_type) ；
// 确保 join 函数
ensure_join(this);
static void ensure_join(JavaThread* thread) {
Handle threadObj(thread, thread->threadObj());
ObjectLocker lock(threadObj, thread);
thread->clear_pending_exception();
java_lang_Thread::set_thread_status(threadObj(),
java_lang_Thread::TERMINATED);
java_lang_Thread::set_thread(threadObj(), NULL);
// 关键 -> 调用线程的 notifyAll 方法。
lock.notify_all(thread);
thread->clear_pending_exception();
}
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
