技术进阶：深入理解Java虚拟机，Java与线程

 

1. 线程的三种实现方式

1.1 使用内核线程实现

实现方式

• 内核线程就是直接由操作系统内核支持的线程。这种线程由内核来完成线程切换，内核通过操纵调度器对线程进行调度，并负责将线程的任务映射到各个处理器上。
• 每个内核线程都可以看做是内核的一个分身，这样的操作系统就由能力同事处理多件事情，支持多线程的内核就叫做多线程内核（Muliti-Threads Kernel）。
• 程序一般不会直接去使用内核线程，而是去使用内核线程的一种高级接口——轻量级进程(Light Weight Process,LWP),轻量级进程就是我们通常意义上所讲的线程，由于每个轻量级进程都由一个内核线程支持，因此只有先支持内核线程，才能有轻量级进程。
• 线程模型：这种轻量级进程与内核线程之间的1:1关系为一对一线程模型。

 

 

 

优势及局限性

优势

• 由于内核线程的支持，每个轻量级进程都成为一个独立的调度单元，即使有一个轻量级进
• 程在系统调用中阻塞了，也不会影响整个进程继续工作。

局限性

• 由于是基于内核实现的，所以各种进程操作，如创建、析构及同步都需要进行系统调用。而系统调用的代价相对较高，需要在用户态和内核态中来回切换。
• 每一个轻量级进程都需要一个内核线程支持，因此轻量级线程需要消耗一定的内核资源（如内核线程的栈空间），因此一个系统支持轻量级进程数量是有限的 。

1.2 使用用户线程实现

实现方式

• 广义上来讲，一个线程只要不是内核线程，那就可以认为是用户线程（User Thread UT）,因此从这个定义上来讲轻量级进程也属于用户线程，但轻量级进程的实现始终是建立在内核之上的，许多草垛都要进行系统调用，因此效率会受到限制。
• 狭义上的用户线程指的是完全建立在用户空间的线程库上，系统内核不能感知到线程存在的实现。
• 线程模型：进程与用户线程之间1:N的关系成为一对多的线程模型

 

 

 

优势及不足

优势

• 使用用户线程的优势在于不需要系统内核支援，如果实现得当，这种线程不需要切换到内核态，因此操作可以是非常快速和低消耗的，也可以支持更大规模的线程数量。

劣势

• 劣势也在与没有系统内核的支援，所有线程操作都需要用户程序自己处理。
• 线程的创建、切换、调度都是需要考虑的问题，而且由于操作系统只把处理器资源分配到进程，那诸如“阻塞如何处理”，“多处理器的系统中如何将线程映射到其它处理器上”这类问题解决起来会异常困难，甚至不可能完成。
• 使用用户线程实现的程序一般都会比较复杂，现在使用用户线程的程序越来越少了 。

 

1.3 混合实现

实现方式

• 将内核线程与用户线程一起使用，这种混合实现下，既存在用户线程，也存在轻量级进程。
• 线程模型：用户线程与轻量级进程的数量比是不定的，为M:N关系，这种就是多对多的线程模型

 

 

 

优势

• 综合内核线程与用户线程的优势,扬长避短
• 用户线程还是完全建立在用户空间中，因此用户线程的创建、切换、析构等操作依然廉价，并且可以支持大规模的用户线程并发。
• 操作系统提供支持的轻量级进程则作为用户线程和内核线程之间的桥梁，这样可以使用内核提供的线程调度功能及处理器映射。
•  
• 用户线程的系统调用要通过轻量级线程来完成，大大降低了进程被阻塞的风险。

2. Java线程的实现

上面所说的3中实现方式是跟具体语言无关的实现，对应到java语言来看，java线程的实现使用的是哪种方式呢？这就需要看jdk的版本了。

2.1 JDK1.2之前

基于名为“绿色线程”（Green Thread）的用户线程实现。

2.2 JDK1.2之后

线程模型被替换为基于操作系统原生线程模型来实现—native

• Windows版和Linux版都是使用一对一的线程模型来实现，一条Java线程就映射到一条轻量级进程之中，因为Windows和Linux系统提供的线程模型就是一对一的。（Windows下有迁程包Fiber Package,Linux下也有NGPT来实现M:N模型，但是它们都没有成为主流）。
• 在Solaris平台中，操作系统可以同时支持一对一和多对多的线程模型，因此在Solaris版的JDK中也对应提供了两个平台专有的虚拟机参数：-XX:+UserLwpSynchronization(默认值)和-XX:+UseBoundThreads来明确指定虚拟机使用的是哪种线程模型。

 

3. Java线程的两种调度方式

3.1 协调式线程调度

实现方式

• 线程的执行时间有线程本身来控制，线程把自己的工作执行完了之后，要主动通知系统切换到另外一个线程上去。

好处

• 最大的好处是实现简单，而且由于线程要把自己的事情干完后才会进行线程切换，切换操作多线程自己是可知的，所以没有什么线程同步的问题。Lua语言中的“协同例程”就是这类实现。

缺点

• 它的坏处也很明显：线程执行时间不可控制，甚至如果一个线程编写有问题，一致不告知系统进行线程切换，那么程序就会一致阻塞在那里。很久以前的Windows3.x系统就是使用协同式来实现多进程多任务的，那是相当的不稳定，一个进程坚持不让出CPU执行时间就会导致整个系统崩溃。

3.2 抢占式线程调度

实现方式

• 使用抢占式调度的多线程系统，每个线程将由系统来分配执行时间，线程的切换不由线程本身来决定。
• 在这种实现线程调度的方式下，线程的执行时间是系统可控的，也不会有一个线程导致整个进程阻塞的问题。
• Java使用的线程调度方式就是抢占式调度。

优势

• 当一个进程出现问题，可以使用任务管理器把这个进程杀掉，而不至于导致系统崩溃。

3.3 疑问：Java Thread类中的优先级设置靠谱吗，对线程的调度影响有多大？

• Java语言中一共设置了10个级别的线程优先级（默认值：5），优先级越高的线程越容易被系统选择执行 。
• Java的线程是被映射到系统的原生线程上来实现的，所以线程调度最终还是由操作系统说了算，虽然现在很多操作系统都提供线程优先级的概念，但是并不见得能与JAVA线程的优先级一一对应（java中的多个优先级可能映射到操作系统中变为同一个优先级，导致无法通过优先级设置影响线程的调度）。
• 此外，优先级可能会被系统自行改变。
• 因此，线程优先级并不是太靠谱，我们不能在程序中通过优先级来完全准确地判断一组状态都为Ready的线程将会先执行哪一个。

4. 线程的6种状态转换

4.1 线程的六种状态

Java线程既然能够创建，那么也势必会被销毁，所以线程是存在生命周期的，那么我们接下来从线程的生命周期开始去了解线程。线程一共有6种状态,详见java.lang.Thread类中定义的枚举：State

java.lang.Thread.State
 /**
 * @since 1.5
 * @see #getState
 */
 public enum State {
 NEW,
 RUNNABLE, 
 BLOCKED,
 WAITING,
 TIMED_WAITING,
 TERMINATED;
 }

• 新建（NEW）：初始状态，线程被构建，但是还没有调用start方法。
• 运行（RUNNABLE）：运行中状态，JAVA线程把操作系统中的就绪(Ready)和运行(Running)两种状态统一称为“运行中”，这就意味着处于这个状态的线程可能是正在执行，也有可能是等待CPU为它分配执行时间。
• 阻塞(BLOCKED)：表示线程进入等待状态,也就是线程因为某种原因未获得CPU使用权。
• 无限期等待（WAITING）：需要等待被其他线程显式地唤醒，否则将一直等待。
• 限期等待（TIME_WAITING）：带超时时间的等待，超时以后自动返回。
• 结束（TERMINATED）：终止状态，表示当前线程执行完毕。

4.2 线程的状态转换

 

 

 

4.2.1 验证New状态

• 验证代码

 /**
 * 验证线程的New状态
 */
 @Test
 public void testNew(){
 Thread t = new Thread(()->{},"new Thread");
 System.out.println("线程的状态："+t.getState());
 }

• 验证结果：

 

 

 

 

4.2.2 验证Runable转Waiting状态

4.2.2.1 调用wait()方法

• 验证代码

 

@Test
public void testWait() throws InterruptedException {
Object lock = new Object();
Thread t = new Thread(()->{
 synchronized (lock){
 try {lock.wait();} 
 catch (InterruptedException e)
 {e.printStackTrace();}
 }
 },"t1");
 t.start();
 TimeUnit.SECONDS.sleep(1);
 System.out.println("线程的状态："+t.getState());
}

• 验证结果：

 

 

 

 

4.2.2.2：调用join()方法

验证代码

 

public static void main(String[] args) throws InterruptedException {
 Thread t1 = new Thread(()->{while (true){}},"t1");
 t1.start();
 t1.join();
}

验证结果

• 运行main方法，通过jps命令查询当前运行的线程ID

 

 

 

• 通过jstack命令查询指定线程的堆栈信息：jstack 8760，验证main线程是否阻塞

 

 

 

• 注：t1.join()阻塞的是主线程，对于这点如果不理解，建议查看下Thread.join()方法的源码(底层基于wait())

4.2.2.3 调用LockSupport.park()方法

验证代码：

 

public static void main(String[] args) throws InterruptedException {
LockSupport.park();
}

验证结果：

 

 

 

4.2.3 验证Runable转TimedWaiting状态

方式1：wait(long)

验证代码

 

private static Object lock = new Object();
public static void main(String[] args) throws InterruptedException {
 synchronized (lock) {
 lock.wait(100000);
 }
}

验证结果：

 

 

 

 

方式2：join(long)

验证代码

public static void main(String[] args) throws InterruptedException{
 Thread t1 = new Thread(()->{ while (true){}},"t1");
 t1.start();
 t1.join(30000);
 System.out.println("不再等待了！");
}

验证结果

 

 

 

方式3：sleep(long)

验证代码

public static void main(String[] args) throws InterruptedException {
 Thread.sleep(50000);
}

验证结果

 

 

方式4：LockSupport.parkUntil(long)或LockSupport.parkNanos(long)

验证代码

public static void main(String[] args) throws InterruptedException {
LockSupport.parkUntil(System.currentTimeMillis()+100000);
//LockSupport.parkNanos(System.currentTimeMillis()+100000;
}

验证结果

 

 

 

4.2.4 验证Runable转Blocked状态

验证方式：synchronized锁

验证代码

private static void blockedMethod(){
 synchronized (TestBlocked.class){
 while (true){}
 }
}
public static void main(String[] args) throws IOException {
new Thread(TestBlocked::blockedMethod,"t1").start();
new Thread(TestBlocked::blockedMethod,"t2").start();
}

验证结果

 

 

 

• 注：从结果上看t1线程获得锁，并持续占有锁，状态为"Runnable",而t2线程由于无法获取到锁，其状态为“Blocked”,符合我们预期，验证正确。

5. 总结

本节内容详细介绍了线程的3种实现方式，从中可以了解到jdk不同的版本中的实现方式是不同的；介绍了线程调度的两种方式，了解到java线程是采用“抢占”方式调度的；详细介绍了线程的状态及变更流程，并对关键的状态变化进行了代码层面的分析和验证，从而可以对Thread类相关的核心API及原理有个较为清晰的认识和理解。

获取以上Java高级架构最新视频，欢迎

加入Java进阶架构交流群：142019080。直接点击链接加群。https://jq.qq.com/?_wv=1027&k=5lXBNZ7