当前位置：极客教程 > Java > Java 精品教程 > Java 多线程

Java 多线程

Java 多线程

Java 是一种多线程编程语言，这意味着我们可以使用 Java 开发多线程程序。一个多线程程序包含两个或更多个部分，可以同时运行，并且每个部分可以同时处理不同的任务，充分利用可用资源，尤其当计算机有多个 CPU 时。

根据定义，多任务处理是指多个进程共享通用的处理资源，如 CPU。多线程将多任务处理的概念扩展到应用程序中，您可以将单个应用程序中的特定操作划分为单独的线程。这些线程中的每一个都可以并行运行。操作系统不仅在不同应用程序之间分配处理时间，还在应用程序内的每个线程之间分配处理时间。

多线程使得您可以编写同时进行多个活动的程序。

线程的生命周期

一个线程在其生命周期中经历了各种阶段。例如，线程被创建、启动、运行，然后终止。下图显示了线程的完整生命周期。

Java 多线程

以下是生命周期的阶段：

  • 新建（New） - 一个新线程在新建状态开始其生命周期。它在程序启动线程之前保持在这个状态。也被称为 born thread 。

  • 可运行（Runnable） - 新建的线程启动后，线程变为可运行状态。处于该状态的线程被视为正在执行其任务。

  • 等待（Waiting） - 有时线程在等待另一个线程执行任务时会转换到等待状态。只有当另一个线程发出信号告知等待线程继续执行时，线程才会转换回可运行状态。

  • 计时等待（Timed Waiting） - 可运行的线程可以进入计时等待状态，等待一段指定的时间间隔。当时间间隔到期或等待的事件发生时，线程将转换回可运行状态。

  • 终止（Terminated） - 当一个可运行线程完成其任务或以其他方式终止时，它进入终止状态。

线程优先级

每个Java线程都有一个优先级，它帮助操作系统确定线程调度的顺序。

Java线程的优先级范围从MIN_PRIORITY（一个常数，值为1）到MAX_PRIORITY（一个常数，值为10）。默认情况下，每个线程都被赋予NORM_PRIORITY优先级（一个常数，值为5）。

优先级较高的线程对程序更重要，应在低优先级线程之前分配处理器时间。然而，线程优先级不能保证线程执行的顺序，并且在很大程度上依赖于平台。

通过实现Runnable接口创建线程

如果您的类打算作为一个线程执行，则可以通过实现 Runnable 接口来实现此目标。您需要遵循三个基本步骤：

步骤1

作为第一步，您需要实现 Runnable 接口提供的run()方法。该方法为线程提供了一个入口点，您将在此方法中放置完整的业务逻辑。以下是run()方法的简单语法：

public void run( )
Java

步骤2

作为步骤2，您将使用以下构造函数实例化一个 Thread 对象。

Thread(Runnable threadObj, String threadName);
Java

其中， threadObj 是实现 Runnable 接口的类的实例，而 threadName 是给新线程指定的名称。

步骤3

一旦创建了一个Thread对象，就可以调用 start() 方法来启动它，该方法会执行对run()方法的调用。以下是start()方法的简单语法：

void start();
Java

示例

下面是一个创建新线程并开始运行的示例栗子−

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();
   }   
}
Java

这将产生以下结果 –

输出

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.
Java

通过扩展Thread类创建线程

创建线程的第二种方法是创建一个新的类来扩展Thread类，使用以下两个简单步骤。这种方法通过在Thread类中使用可用的方法来处理创建的多个线程，提供了更大的灵活性。

步骤1

您需要重写Thread类中可用的run()方法。该方法为线程提供了一个入口点，您将在此方法中放置完整的业务逻辑。下面是run()方法的简单语法：

public void run( )
Java

步骤2

一旦Thread对象被创建，你可以通过调用 start() 方法来启动它，该方法执行对run()方法的调用。以下是start()方法的简单语法-

void start( );
Java

示例

下面是将前面的程序重新编写以扩展线程的示例：

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();
   }   
}
Java

这将产生以下结果−

输出

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.
Java

线程方法

以下是Thread类中的重要方法列表。

序号 方法和描述
1 public void start() 在一个独立的执行路径上启动线程，然后调用这个线程对象的run()方法。
2 public void run() 如果这个Thread对象是使用一个独立的Runnable目标实例化的，则调用该Runnable对象的run()方法。
3 public final void setName(String name) 改变线程对象的名称。还有一个getName()方法用于获取名称。
4 public final void setPriority(int priority) 设置该线程对象的优先级。可能的值介于1和10之间。
5 public final void setDaemon(boolean on) 参数为true表示这个线程是一个守护线程。
6 public final void join(long millisec) 当前线程在第二个线程上调用这个方法，导致当前线程阻塞，直到第二个线程终止或指定的毫秒数过去。
7 public void interrupt() 中断这个线程，如果它因任何原因被阻塞，则继续执行。
8 public final boolean isAlive() 如果线程是活动的，则返回true，即在线程启动之后但在运行完成之前的任何时间。

以前的方法是在特定的Thread对象上调用的。Thread类中的以下方法是静态的。调用其中一个静态方法会在当前运行的线程上执行操作。

序号 方法与描述
1 public static void yield() 使当前正在运行的线程放弃执行，让出CPU资源给同优先级的等待线程。
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程序演示了Thread类的一些方法。考虑一个实现了Runnable接口的DisplayMessage类。

// 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);
      }
   }
}
Java

以下是另一个扩展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.**");
   }
}
Java

以下是主程序，使用了上述定义的类 –

// 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...");
   }
}
Java

这将产生以下结果。您可以一次又一次地尝试这个示例，每次都会得到不同的结果。

输出

Starting hello thread...
Starting goodbye thread...
Hello
Hello
Hello
Hello
Hello
Hello
Goodbye
Goodbye
Goodbye
Goodbye
Goodbye
.......
Java

主要的Java多线程概念

在Java中进行多线程编程时，您需要非常了解以下概念：

  • 什么是线程同步？

  • 处理线程间通信

  • 处理线程死锁

  • 主要的线程操作

Python教程

Python 教程

Python 教程
Tkinter 教程

Tkinter 教程
Pandas 教程

Pandas 教程
NumPy 教程

NumPy 教程
Flask 教程

Flask 教程
Django 教程

Django 教程
PySpark 教程

PySpark 教程
wxPython 教程

wxPython 教程
SymPy 教程

SymPy 教程
Seaborn 教程

Seaborn 教程
SciPy 教程

SciPy 教程
RxPY 教程

RxPY 教程
Pycharm 教程

Pycharm 教程
Pygame 教程

Pygame 教程
PyGTK 教程

PyGTK 教程
PyQt 教程

PyQt 教程
PyQt5 教程

PyQt5 教程
PyTorch 教程

PyTorch 教程
Matplotlib 教程

Matplotlib 教程
Web2py 教程

Web2py 教程
BeautifulSoup 教程

BeautifulSoup 教程

Java教程

Java 教程

Java 教程

Web教程

HTML 教程

HTML 教程
CSS 教程

CSS 教程
CSS3 教程

CSS3 教程
jQuery 教程

jQuery 教程
Ajax 教程

Ajax 教程
AngularJS 教程

AngularJS 教程
TypeScript 教程

TypeScript 教程
WordPress 教程

WordPress 教程
Laravel 教程

Laravel 教程
Next.js 教程

Next.js 教程
PhantomJS 教程

PhantomJS 教程
Three.js 教程

Three.js 教程
Underscore.JS 教程

Underscore.JS 教程
WebGL 教程

WebGL 教程
WebRTC 教程

WebRTC 教程
VueJS 教程

VueJS 教程

数据库教程

SQL 教程

SQL 教程
MySQL 教程

MySQL 教程
MongoDB 教程

MongoDB 教程
PostgreSQL 教程

PostgreSQL 教程
SQLite 教程

SQLite 教程
Redis 教程

Redis 教程
MariaDB 教程

MariaDB 教程

图形图像教程

Vulkan 教程

Vulkan 教程
OpenCV 教程

OpenCV 教程

大数据教程

R语言 教程

R语言 教程

开发工具教程

Git 教程

Git 教程
VSCode 教程

VSCode 教程
Docker 教程

Docker 教程
Gerrit 教程

Gerrit 教程
Excel 教程

Excel 教程

计算机教程

Go语言 教程

Go语言 教程
C++ 教程

C++ 教程

Java 精品教程

登录

找回密码？

注册