Java 简明教程
Java - Multithreading
Java 是一种多线程编程语言，这意味着我们可以使用 Java 开发多线程程序。多线程程序包含两个或更多部分，它们可以同时运行，并且每个部分可以同时处理不同的任务，充分利用可用资源，特别是在计算机具有多个 CPUs 时。
根据定义，多任务处理是多个进程共享公共处理资源（如 CPU）时发生的情况。多线程将多任务处理的概念扩展到应用程序中，您可以在其中将单个应用程序内的特定操作细分为各个线程。每个线程都可以并行运行。操作系统不仅在不同应用程序之间划分处理时间，还在应用程序内的每个线程之间划分处理时间。
Java Multithreading
多线程使您能够以一种方式编写，以便在同一程序中可以同时进行多个活动。要实现多线程（或编写多线程代码），您需要 java.lang.Thread class 。
Life Cycle of a Thread in Java Multithreading
线程在其生命周期中经过不同的阶段。例如，一个线程诞生、启动、运行，然后死亡。下图显示了线程的完整生命周期。
以下是生命周期的阶段 -
-
New - 新线程在其生命周期中处于新的状态。它一直保持此状态，直到程序启动线程。它也被称为 born thread。
-
Runnable - 新生的线程启动后，该线程变得可运行。处于此状态的线程被认为正在执行其任务。
-
Waiting - 有时，线程在等待另一个线程执行任务时会转变为等待状态。仅当其他线程发信号指示等待线程继续执行时，线程才会转换回可运行状态。
-
Timed Waiting - 可运行线程可以进入特定时间间隔的时间等待状态。当该时间间隔到期或它正在等待的事件发生时，处于此状态的线程会转换回可运行状态。
-
Terminated (Dead) - 当可运行线程完成其任务或以其他方式终止时，它会进入终止状态。
Thread Priorities
每个 Java 线程都有一个优先级，这有助于操作系统确定线程调度的顺序。
Java 线程优先级介于 MIN_PRIORITY（常量为 1）和 MAX_PRIORITY（常量为 10）之间。默认情况下，每个线程都获得 NORM_PRIORITY（常量为 5）优先级。
具有较高优先级的线程对程序而言更为重要，并且应该在较低优先级的线程之前分配处理器时间。但是，线程优先级不能保证线程执行的顺序，并且很大程度上取决于平台。
Create a Thread by Implementing a Runnable Interface
如果准备将您的类作为线程执行，那么可以通过实现 Runnable 接口实现此目的。您需要遵循三个基本步骤 −
Step 1: Implement run() Method
第一步，您需要实现 Runnable 接口提供的 run() 方法。此方法为线程提供了一个入口点，您需要将完整业务逻辑放入此方法内。以下是 run() 方法的一个简单语法：
public void run( )Step 2: Instantiate a Thread Object
作为第二步，您将使用以下构造函数实例化一个 Thread 对象 −
Thread(Runnable threadObj, String threadName);其中，threadObj 是实现 Runnable 接口的类的实例，threadName 是赋予新线程的名称。
Step 3: Call Thread using start() Method
一旦创建了 Thread 对象，就可以通过调用 start() 方法来启动它，它执行对 run( ) 方法的调用。以下是 start() 方法的简单语法 -
void start();Example: Create Thread by Implementing Runnable Interface
下面是创建一个新线程并开始运行它的示例：
class RunnableDemo implements Runnable {
private Thread t;
private String threadName;
RunnableDemo( String name) {
threadName = name;
System.out.println("Creating " + threadName );
}
public void run() {
System.out.println("Running " + threadName );
try {
for(int i = 4; i > 0; i--) {
System.out.println("Thread: " + threadName + ", " + i);
// Let the thread sleep for a while.
Thread.sleep(50);
}
} catch (InterruptedException e) {
System.out.println("Thread " + threadName + " interrupted.");
}
System.out.println("Thread " + threadName + " exiting.");
}
public void start () {
System.out.println("Starting " + threadName );
if (t == null) {
t = new Thread (this, threadName);
t.start ();
}
}
}
public class TestThread {
public static void main(String args[]) {
RunnableDemo R1 = new RunnableDemo( "Thread-1");
R1.start();
RunnableDemo R2 = new RunnableDemo( "Thread-2");
R2.start();
}
}Output
Creating Thread-1
Starting Thread-1
Creating Thread-2
Starting Thread-2
Running Thread-1
Thread: Thread-1, 4
Running Thread-2
Thread: Thread-2, 4
Thread: Thread-1, 3
Thread: Thread-2, 3
Thread: Thread-1, 2
Thread: Thread-2, 2
Thread: Thread-1, 1
Thread: Thread-2, 1
Thread Thread-1 exiting.
Thread Thread-2 exiting.Create a Thread by Extending a Thread Class
创建线程的第二种方法是创建一个扩展 Thread 类的类，使用以下两个简单步骤。这种方法在使用 Thread 类中可用方法创建多个线程时提供了更多的灵活性。
Step 1: Override run() Method
您需要覆盖 Thread 类中可用的 run( ) 方法。此方法为线程提供一个入口点，您将把您的完整业务逻辑放在这个方法中。以下是 run() 方法的简单语法：
public void run( )Step 2: Call Thread using start() Method
一旦创建 Thread 对象，便可以通过调用 start() 方法来启动它，该调用会执行一个 run( ) 方法调用。以下是 start() 方法的一个简单语法 −
void start( );Example: Create Thread by Extending Thread Class
以下是按照 Thread 扩展重写的先前程序：
class ThreadDemo extends Thread {
private Thread t;
private String threadName;
ThreadDemo( String name) {
threadName = name;
System.out.println("Creating " + threadName );
}
public void run() {
System.out.println("Running " + threadName );
try {
for(int i = 4; i > 0; i--) {
System.out.println("Thread: " + threadName + ", " + i);
// Let the thread sleep for a while.
Thread.sleep(50);
}
} catch (InterruptedException e) {
System.out.println("Thread " + threadName + " interrupted.");
}
System.out.println("Thread " + threadName + " exiting.");
}
public void start () {
System.out.println("Starting " + threadName );
if (t == null) {
t = new Thread (this, threadName);
t.start ();
}
}
}
public class TestThread {
public static void main(String args[]) {
ThreadDemo T1 = new ThreadDemo( "Thread-1");
T1.start();
ThreadDemo T2 = new ThreadDemo( "Thread-2");
T2.start();
}
}Output
Creating Thread-1
Starting Thread-1
Creating Thread-2
Starting Thread-2
Running Thread-1
Thread: Thread-1, 4
Running Thread-2
Thread: Thread-2, 4
Thread: Thread-1, 3
Thread: Thread-2, 3
Thread: Thread-1, 2
Thread: Thread-2, 2
Thread: Thread-1, 1
Thread: Thread-2, 1
Thread Thread-1 exiting.
Thread Thread-2 exiting.Thread Methods
以下是 Thread 类中提供的重要方法列表：
Sr.No. |
Method & Description |
1 |
public void start() 在一个单独的执行路径中启动线程，然后调用此线程对象上的 run() 方法。 |
2 |
public void run() 如果此线程对象是使用单独的 Runnable 对象实例化的，则该 run() 方法将在这个 Runnable 对象上被调用。 |
3 |
public final void setName(String name) 更改线程对象名称。还有一个 getName() 方法用于检索名称。 |
4 |
public final void setPriority(int priority) 设置此 Thread 对象的优先级。可能的值介于 1 到 10 之间。 |
5 |
public final void setDaemon(boolean on) true 参数表示此 Thread 为守护程序线程。 |
6 |
public final void join(long millisec) 当前线程在此第二个线程上调用此方法，导致当前线程阻塞，直到第二个线程终止或经过指定数目的毫秒。 |
7 |
public void interrupt() 中断此线程，如果它因任何原因而被阻塞，则导致它继续执行。 |
8 |
public final boolean isAlive() 如果线程处于活动状态，则返回 true，即在启动线程之后的任何时间但在它运行完成之前。 |
之前的方法都是在特定 Thread 对象上调用的。Thread 类中的以下方法是静态的。调用其中一个静态方法对当前运行的线程执行该操作。
Sr.No. |
Method & Description |
1 |
public static void yield() 导致当前正在运行的线程向正在等待调度的相同优先级的任何其他线程让步。 |
2 |
public static void sleep(long millisec) 导致正在运行的当前线程阻塞，至少在指定毫秒数的时间内。 |
3 |
public static boolean holdsLock(Object x) 如果当前线程持有给定 Object 的锁，则返回 true。 |
4 |
public static Thread currentThread() 返回对当前正在运行的线程的引用，该线程调用此方法。 |
5 |
public static void dumpStack() 打印当前正在运行的线程的堆栈跟踪，这对在调试多线程应用程序时非常有用。 |
Example
以下 ThreadClassDemo 程序演示了 Thread 类的其中一些方法。考虑一下 DisplayMessage 类，它实现了 Runnable −
// File Name : DisplayMessage.java
// Create a thread to implement Runnable
public class DisplayMessage implements Runnable {
private String message;
public DisplayMessage(String message) {
this.message = message;
}
public void run() {
while(true) {
System.out.println(message);
}
}
}以下是另一个扩展 Thread 类的类−
// File Name : GuessANumber.java
// Create a thread to extentd Thread
public class GuessANumber extends Thread {
private int number;
public GuessANumber(int number) {
this.number = number;
}
public void run() {
int counter = 0;
int guess = 0;
do {
guess = (int) (Math.random() * 100 + 1);
System.out.println(this.getName() + " guesses " + guess);
counter++;
} while(guess != number);
System.out.println("** Correct!" + this.getName() + "in" + counter + "guesses.**");
}
}以下是使用上述定义类的主程序−
// File Name : ThreadClassDemo.java
public class ThreadClassDemo {
public static void main(String [] args) {
Runnable hello = new DisplayMessage("Hello");
Thread thread1 = new Thread(hello);
thread1.setDaemon(true);
thread1.setName("hello");
System.out.println("Starting hello thread...");
thread1.start();
Runnable bye = new DisplayMessage("Goodbye");
Thread thread2 = new Thread(bye);
thread2.setPriority(Thread.MIN_PRIORITY);
thread2.setDaemon(true);
System.out.println("Starting goodbye thread...");
thread2.start();
System.out.println("Starting thread3...");
Thread thread3 = new GuessANumber(27);
thread3.start();
try {
thread3.join();
} catch (InterruptedException e) {
System.out.println("Thread interrupted.");
}
System.out.println("Starting thread4...");
Thread thread4 = new GuessANumber(75);
thread4.start();
System.out.println("main() is ending...");
}
}
class DisplayMessage implements Runnable {
private String message;
public DisplayMessage(String message) {
this.message = message;
}
public void run() {
while(true) {
System.out.println(message);
}
}
}
class GuessANumber extends Thread {
private int number;
public GuessANumber(int number) {
this.number = number;
}
public void run() {
int counter = 0;
int guess = 0;
do {
guess = (int) (Math.random() * 100 + 1);
System.out.println(this.getName() + " guesses " + guess);
counter++;
} while(guess != number);
System.out.println("** Correct!" + this.getName() + "in" + counter + "guesses.**");
}
}