Java并发编程的艺术-----Java并发编程基础（线程简介）

最新推荐文章于 2025-03-10 15:08:01 发布

原创最新推荐文章于 2025-03-10 15:08:01 发布 · 279 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

Java并发编程的艺术专栏收录该内容

5 篇文章

订阅专栏

本文深入探讨Java并发编程的基础知识，包括线程概念、多线程优势、线程优先级调节、线程状态变迁及Daemon线程特性。通过示例代码解析，帮助读者理解线程在Java中的实际应用。

Java并发编程基础（线程简介）

一、什么是线程
二、为什么要使用多线程
三、线程优先级
四、线程的状态
五、Daemon线程

一、什么是线程

操作系统在运行一个程序时，会为其创建一个进程。例如，启动一个Java程序，操作系统会创建一个Java进程。现代操作系统调度的最小单元是线程，也叫轻量级进程，在一个进程中可以创建多个线程，这些线程都拥有各自的计数器、堆栈和局部变量等属性，并且能够访问共享的内存变量。处理器在这些线程上高速切换，让使用者感觉到这些线程在同时执行。
一个Java程序从main()方法开始执行，然后按照既定的代码逻辑执行，看似没有其他线程参与，但实际上Java程序天生就是多线程程序，因为执行main()方法的是一个名称为main的线程。下面使用JMX来查看一个普通Java程序包含哪些线程，代码如下：

package com.wholesmart.thread4;

import java.lang.management.ManagementFactory;
import java.lang.management.ThreadInfo;
import java.lang.management.ThreadMXBean;

/**
 * 线程管理
 * 
 * @author dyw
 * @date 2020年7月13日
 */
public class MultiThread {
	/**
	 * java程序的运行不仅仅是main()方法的运行，而是main线程和多个线程的同时运行。
	 * 
	 * <pre>
	 * [5]Attach Listener  附加侦听器
	 * [4]Signal Dispatcher  分发处理发送给JVM信号的线程
	 * [3]Finalizer  调用对象finalize方法的线程
	 * [2]Reference Handler  清除Reference的线程
	 * [1]main 主线程，用户程序的入口
	 * </pre>
	 * 
	 * @param args
	 */
	public static void main(String[] args) {
		// 获取Java线程管理MXBean
		ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();
		// 不需要获取同步的monitor和synchronize信息，仅获取线程和线程堆栈信息
		ThreadInfo[] threadInfos = threadMXBean.dumpAllThreads(false, false);
		// 遍历线程信息，仅打印线程ID和线程名称信息
		for (ThreadInfo threadInfo : threadInfos) {
			System.out.println("[" + threadInfo.getThreadId() + "]" + threadInfo.getThreadName());
		}
	}
}

二、为什么要使用多线程

（1）处理器核心数量增多。
（2）更快的响应时间，比如可以将数据一致性不强的操作派发给其他线程处理，以提高主线程的响应速度。
（3）Java为多线程编程提供了良好、考究并且一致的编程模型。

三、线程优先级

现代操作系统基本采用时分的形式调度运行的线程，不同的线程会在若干个时间片内执行。线程分配的时间片的多少就决定了线程使用处理器资源的多少，而线程优先级就是决定线程需要多或者是少分配一些处理器资源的线程属性。
在Java线程中，通过一个整型成员变量priority来控制优先级，优先级的范围从1~10，在线程构建的时候可以通过setPriority(int)方法来修改优先级，默认优先级是5，优先级高的线程分配的时间片数量要多于优先级低的线程。设置优先级时，针对频繁阻塞（I\O）的线程要设置较高的优先级，而偏重计算（需要较多CPU时间或是偏运算）的线程则需要设置较低的优先级，确保处理器不会被独占。在不同的JVM以及操作系统上，线程规划存在差异，有些系统会忽略对线程优先级的设定，示例代码：

package com.wholesmart.thread4;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;

public class Priority {
	private static volatile boolean noStart = true;
	private static volatile boolean notEnd = true;

	public static void main(String[] args) throws Exception {
		List<Job> jobs = new ArrayList<Priority.Job>();
		for (int i = 0; i < 10; i++) {
			int priority = i < 5 ? Thread.MIN_PRIORITY : Thread.MAX_PRIORITY;
			Job job = new Job(priority);
			jobs.add(job);
			Thread thread = new Thread(job, "Thread:" + i);
			thread.setPriority(priority);
			thread.start();
		}
		noStart = false;
		TimeUnit.SECONDS.sleep(10);
		notEnd = false;
		for (Job job : jobs) {
			System.out.println("Job Priority : " + job.priority + ",Count : " + job.jobCount);
		}

	}

	static class Job implements Runnable {
		private int priority;
		private long jobCount;

		public Job(int priority) {
			this.priority = priority;
		}

		@Override
		public void run() {
			while (noStart) {
				Thread.yield();
			}
			while (notEnd) {
				Thread.yield();
				jobCount++;
			}

		}
	}
}

将这段代码在不同的机器上跑，可以测试出有时候优先级的高低并不影响计算结果，这表明程序的正确性不能依赖线程的优先级高低。

四、线程的状态

Java线程运行的生命周期中可能出现下表所示的6种状态，在给定时刻，线程只能处于其中的一个状态
线程的状态
我们可以使用jstack工具，查看示例代码运行时的线程信息，示例代码：

package com.wholesmart.thread4;

public class ThreadState {
	public static void main(String[] args) {
		new Thread(new TimeWaiting(), "TimeWaitingThread").start();
		new Thread(new Waiting(), "WaitingThread").start();
		// 使用两个Blocked线程，一个获取锁成功，另一个阻塞
		new Thread(new Blocked(), "BlockedThread-1").start();
		new Thread(new Blocked(), "BlockedThread-2").start();
	}

	// 该线程不断的休眠
	static class TimeWaiting implements Runnable {

		@Override
		public void run() {
			while (true) {
				SleepUtils.second(100);
			}
		}
	}

	// 该线程在Waiting.class实例上等待
	static class Waiting implements Runnable {

		@Override
		public void run() {
			while (true) {
				synchronized (Waiting.class) {
					try {
						Waiting.class.wait();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			}
		}
	}

	// 该线程在Blocked.class实例上加锁后，不会释放该锁
	static class Blocked implements Runnable {

		@Override
		public void run() {
			synchronized (Blocked.class) {
				while (true) {
					SleepUtils.second(100);
				}
			}
		}
	}
}

使用命令行工具输入“jps”，输出如下：

3520
7856 BootLanguagServerBootApp
16312 Jps
236 ThreadState

可以看到示例进程ID为236，接着键入“jps 236”，部分输出如下：

//BlockedThread-2线程阻塞在获取Blocked.class实列锁上
"BlockedThread-2" #13 prio=5 os_prio=0 tid=0x00000000194a8800 nid=0x3f8c waiting for monitor entry [0x000000001a2af000]
   java.lang.Thread.State: BLOCKED (on object monitor)
        at com.wholesmart.thread4.ThreadState$Blocked.run(ThreadState.java:47)
        - waiting to lock <0x00000000d5b0f3b0> (a java.lang.Class for com.wholesmart.thread4.ThreadState$Blocked)
        at java.lang.Thread.run(Unknown Source)
//BlockedThread-1线程获取到了Blocked.class的锁
"BlockedThread-1" #12 prio=5 os_prio=0 tid=0x00000000194a8000 nid=0x3dd4 waiting on condition [0x000000001a1af000]
   java.lang.Thread.State: TIMED_WAITING (sleeping)
        at java.lang.Thread.sleep(Native Method)
        at java.lang.Thread.sleep(Unknown Source)
        at java.util.concurrent.TimeUnit.sleep(Unknown Source)
        at com.wholesmart.thread4.SleepUtils.second(SleepUtils.java:8)
        at com.wholesmart.thread4.ThreadState$Blocked.run(ThreadState.java:47)
        - locked <0x00000000d5b0f3b0> (a java.lang.Class for com.wholesmart.thread4.ThreadState$Blocked)
        at java.lang.Thread.run(Unknown Source)
//WaitingThread线程在Waiting实例上等待
"WaitingThread" #11 prio=5 os_prio=0 tid=0x00000000194a5000 nid=0x3ddc in Object.wait() [0x000000001a0af000]
   java.lang.Thread.State: WAITING (on object monitor)
        at java.lang.Object.wait(Native Method)
        - waiting on <0x00000000d5b0d538> (a java.lang.Class for com.wholesmart.thread4.ThreadState$Waiting)
        at java.lang.Object.wait(Unknown Source)
        at com.wholesmart.thread4.ThreadState$Waiting.run(ThreadState.java:31)
        - locked <0x00000000d5b0d538> (a java.lang.Class for com.wholesmart.thread4.ThreadState$Waiting)
        at java.lang.Thread.run(Unknown Source)
//TimeWaitingThread线程处于超时等待
"TimeWaitingThread" #10 prio=5 os_prio=0 tid=0x00000000194a2000 nid=0x3c60 waiting on condition [0x0000000019faf000]
   java.lang.Thread.State: TIMED_WAITING (sleeping)
        at java.lang.Thread.sleep(Native Method)
        at java.lang.Thread.sleep(Unknown Source)
        at java.util.concurrent.TimeUnit.sleep(Unknown Source)
        at com.wholesmart.thread4.SleepUtils.second(SleepUtils.java:8)
        at com.wholesmart.thread4.ThreadState$TimeWaiting.run(ThreadState.java:18)
        at java.lang.Thread.run(Unknown Source)

通过示例，我们了解到java程序运行中线程状态的具体含义。线程在自身的生命周期中，并不是固定处于某个状态，而是随着代码执行在不同状态之间进行切换，如图：
线程状态描述

五、Daemon线程

Daemon线程是一种支持型线程，因为它主要被用作程序中后台调度以及支持性工作。这意味着，当一个Java虚拟机中不存在非Daemon线程时，Java虚拟机将退出。可以通过调用Thread.setDaemon(true)将线程设置为Daemon线程。注意，Daemon属性需要在线程启动前设置。Daemon线程被用作完成支持性工作，但是Java虚拟机退出时Daemon线程中的finally块并不一定会执行，示例代码：

package com.wholesmart.thread4;

public class Daemon {
	public static void main(String[] args) {
		Thread thread = new Thread(new DaemonRunner(), "DaemonRunner");
		thread.setDaemon(true);
		thread.start();
	}

	static class DaemonRunner implements Runnable {

		@Override
		public void run() {
			try {
				SleepUtils.second(10);
			} finally {
				System.out.println("DaemonRunner finally run.");
			}

		}

	}
}

运行示例程序，控制台没用输出任何内容。main线程（非Daemon线程）在启动了DaemonRunner 线程之后，随着main方法执行完毕而终止，而此时Java虚拟机中已经没有非Daemon线程线程，虚拟机需要退出。Java虚拟机中所有的Daemon线程都需要立即终止，因此DaemonRunner 立即终止，但DaemonRunner 中的finally 块并没有执行。所以在构建Daemon线程时，不能依靠finally 块中的内容来确保执行关闭或是清理资源的逻辑。

大千世界，无论多遥远，那些与你同频率的人终会穿越茫茫人海，与你相遇。期待那时，我们都能有底气说出那句：你很好，我也值得。