Java 多线程

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

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

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

线程的生命周期

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

以下是生命周期的阶段：

• 新建（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( )

步骤2

作为步骤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("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();
   }   
}

这将产生以下结果 –

输出

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类创建线程

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

步骤1

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

public void run( )

步骤2

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

void start( );

示例

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

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

这将产生以下结果−

输出

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类中的重要方法列表。

序号	方法和描述
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);
      }
   }
}

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

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

输出

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

主要的Java多线程概念

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

• 什么是线程同步？

• 处理线程间通信

• 处理线程死锁

• 主要的线程操作