Java是一种多线程编程语言,可以使用Java来开发多线程程序。多线程程序包含两个或多个可以同时运行的部分,每个部分可以同时处理不同的任务,特别是当计算机有多个CPU时,可以充分利用可用它的CPU资源。
根据定义,多任务处理是指多个进程共享公共处理资源(如CPU)。多线程将多任务处理的概念扩展到可以将单个应用程序中的特定操作细分为单个线程的应用程序中。每个线程可以并行运行。操作系统不仅在不同的应用程序之间划分处理时间,而且在应用程序中的每个线程之间划分处理时间。
1. 线程的生命周期
线程在它的生命周期中经历几个阶段。例如,线程诞生,启动,运行,然后死亡。下图显示了线程的完整生命周期。
以下是生命周期的各个阶段 -
新线程(New) - 在新状态下开始它的生命周期。它一直处于这种状态,直到程序启动线程。它也被称为诞生线程。
可运行(Runnable) - 启动新生成的线程后,线程变为可运行。处于此状态的线程正在执行任务。
等待(Waiting) - 有时线程在等待另一个线程执行任务时转换到等待状态。仅当另一个线程通知等待线程继续执行时,线程才会转换回可运行状态。
定时等待(Timed Waiting) - 可运行的线程可以在指定的时间间隔内进入定时等待状态。当该时间间隔到期或者等待的事件发生时,处于此状态的线程将转换回可运行状态。
终止(Dead) - 可运行线程在完成任务或以其他方式终止时进入终止状态。
2. 线程优先级
每个Java线程都有一个优先级,可帮助操作系统确定线程的调度顺序。
Java线程优先级在MIN_PRIORITY
(常量值为1
)和MAX_PRIORITY
(常量值为10
)之间。默认情况下,每个线程都被赋予优先级NORM_PRIORITY
(常量值为5
)。
具有较高优先级的线程对于程序更重要,应该在较低优先级的线程之前分配处理器时间。但是,线程优先级不能保证线程执行的顺序,并且非常依赖于平台。
3. 通过实现Runnable接口创建线程
如果要将类要作为线程执行,那么可以通过实现Runnable
接口来实现。需要遵循以下三个基本步骤 -
第1步:
实现Runnable
接口提供的run()
方法。此方法为线程提供了一个入口点,把完整的业务逻辑放在此方法中。以下是run()
方法的语法 -
public void run()
第2步:
使用以下构造函数实例化Thread
对象 -
Thread(Runnable threadObj, String threadName);
其中,threadObj
是实现Runnable
接口的类的实例,threadName
是新线程的名称。
第3步:
当创建了Thread
对象,就可以通过调用start()
方法来启动它,该方法执行并调用run()
方法。以下是start()
方法的语法 -
void start();
示例
下面是一个创建新线程并开始运行它的示例 -
class RunnableDemo implements Runnable {
private Thread t;
private String threadName;
RunnableDemo(String name) {
threadName = name;
System.out.println("创建了一新的线程:" + threadName);
}
public void run() {
System.out.println("正在运行线程:" + threadName);
try {
for (int i = 4; i > 0; i--) {
System.out.println("线程:" + threadName + ", " + i);
// 休眠一段时间
Thread.sleep(50);
}
} catch (InterruptedException e) {
System.out.println("线程:" + threadName + " 中断");
}
System.out.println("线程: " + threadName + " 退出");
}
public void start() {
System.out.println("开始线程:" + 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();
}
}
执行上面示例代码,得到以下结果 -
创建了一新的线程:Thread-1
开始线程:Thread-1
创建了一新的线程:Thread-2
开始线程:Thread-2
正在运行线程:Thread-1
线程:Thread-1, 4
正在运行线程:Thread-2
线程:Thread-2, 4
线程:Thread-2, 3
线程:Thread-1, 3
线程:Thread-2, 2
线程:Thread-1, 2
线程:Thread-1, 1
线程:Thread-2, 1
线程: Thread-1 退出
线程: Thread-2 退出
4. 通过扩展 Thread 类创建线程
创建线程的第二种方法是通过扩展Thread
类的新类来实现多线程功能。使用Thread
类中的方法来创建多线程提供了更大的灵活性。
第1步:
覆盖Thread
类中可用的run()
方法。此方法为线程提供了一个入口点,应该把完整的业务逻辑放在此方法中。以下是run()
方法的语法 -
public void run()
第2步:
当创建了Thread
对象,就可以调用start()
方法来启动它,该方法执行对run()
方法的调用。以下是start()
方法的语法 -
void start( );
示例
下是是一个扩展Thread
类实现多线程的示例程序 -
class ThreadDemo extends Thread {
private Thread t;
private String threadName;
ThreadDemo(String name) {
threadName = name;
System.out.println("创建:" + threadName);
}
public void run() {
System.out.println("运行:" + threadName);
try {
for (int i = 4; i > 0; i--) {
System.out.println("线程: " + threadName + ", " + i);
// 让线程休眠一会儿。
Thread.sleep(50);
}
} catch (InterruptedException e) {
System.out.println("线程:" + threadName + " 中断");
}
System.out.println("线程: " + threadName + " 退出");
}
public void start() {
System.out.println("开始:" + 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();
}
}
执行上面示例代码,得到以下结果 -
创建:Thread-1
开始:Thread-1
创建:Thread-2
开始:Thread-2
运行:Thread-1
运行:Thread-2
线程: Thread-1, 4
线程: Thread-2, 4
线程: Thread-2, 3
线程: Thread-1, 3
线程: Thread-2, 2
线程: Thread-1, 2
线程: Thread-1, 1
线程: Thread-2, 1
线程: Thread-2 退出
线程: Thread-1 退出
5. Thread类的方法
以下是Thread
类中的方法列表 -
编号 | 方法 | 描述 |
---|---|---|
1 | public void start() |
在单独的执行路径中启动线程,然后在Thread 对象上调用run() 方法。 |
2 | public void run() |
如果使用单独的Runnable 目标实例化Thread 对象,则在该Runnable 对象上调用run() 方法。 |
3 | public final void setName(String name) |
设置Thread 对象的名称。 |
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
类中的以下方法是静态的。调用其中一个静态方法会对当前运行的线程执行操作。
编号 | 方法 | 描述 |
---|---|---|
1 | public static void yield() |
导致当前运行的线程屈服于等待调度的其他具有相同优先级的线程。 |
2 | public static void sleep(long millisec) |
导致当前运行的线程阻塞至少指定的毫秒数。 |
3 | public static boolean holdsLock(Object x) |
如果当前线程持有给定对象的锁,则返回true 。 |
4 | public static Thread currentThread() |
返回对当前运行的线程的引用,该线程是调用此方法的线程。 |
5 | public static void dumpStack() |
打印当前运行的线程的堆栈跟踪,这在调试多线程应用程序时很有用。 |
示例
下面的ThreadClassDemo.java
程序演示了如何使用Thread
类的一些方法。代码中有一个实现了Runnable
接口的DisplayMessage
类 -
// 文件 : 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
类的类 -
// 文件 : 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...");
}
}
执行上面示例代码,将产生以下结果。可以反复尝试此示例,每次都会得到不同的结果。
Starting hello thread...
Starting goodbye thread...
Hello
Hello
Hello
Hello
Hello
Hello
Goodbye
Goodbye
Goodbye
Goodbye
Goodbye
.......
6. Java多线程概念
在使用Java进行多线程编程时,需要了解和使用以下概念 -