概念梳理类之Java中的多线程简介

Java中的多线程之线程概念简介

提示：线程概念梳理

---

---

前言

该文介绍了Java中的多线程概念，并介绍了多线程的内部原理及Java实现的代码。之后会有关于多线程的进一步讨论，如有问题，欢迎指正。

---

提示：以下是本篇文章正文内容，下面案例可供参考

一、多线程是什么？

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

根据定义，多任务是指多个进程共享诸如CPU之类的通用处理资源。多线程将多任务的概念扩展到应用程序中，你可以在其中将单个应用程序内的特定操作细分为各个线程。每个线程可以并行运行。
Tips:不仅在不同的应用程序之间分配处理时间，还在应用程序内的每个线程之间分配处理时间。

多线程使你可以编写一种方式，使多个活动可以在同一程序中同时进行。

二、线程的生命周期

线程在其生命周期中会经历各个阶段。例如，线程是新建，启动，运行然后消亡的。下图显示了线程的完整生命周期


以下是生命周期的各个阶段-

新建-新线程以新状态开始其生命周期。它将保持这种状态，直到程序启动线程为止。它也称为出生线程。

启动-一个刚出生的线程启动后，该线程进入可运行状态。处于此状态的线程被视为正在执行其任务。

等待-有时，线程在等待另一个线程执行任务时会转换为等待状态。仅当另一个线程发出信号通知等待的线程继续执行时，一个线程才转换回可运行状态。

定时等待-可运行线程可以在指定的时间间隔内进入定时等待状态。当该时间间隔到期或发生等待事件时，处于此状态的线程将转换回可运行状态。

消亡（终止） -可运行线程在完成其任务或终止时进入终止状态。

2.线程优先级

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

Java线程优先级在MIN_PRIORITY（1）和MAX_PRIORITY（10）之间。默认情况下，每个线程的优先级为NORM_PRIORITY（5）。

具有较高优先级的线程对程序更重要，应在较低优先级的线程之前为其分配处理器时间。但是，线程优先级不能保证线程执行的顺序，这很大程度上取决于平台。

3.通过 Implements Runnable接口创建线程

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

第一步，你需要实现Runnable接口提供的run（）方法。该方法为线程提供了一个入口点，你应该将把完整的逻辑放入该方法中。以下是run（）方法的简单语法。
public void run( )

第二步，你将使用以下构造函数实例化Thread对象。
Thread(Runnable threadObj, String threadName);

其中，threadObj是实现Runnable接口的类的实例，而threadName是新线程的名称。
第三步，创建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.

4.通过extends Thread类创建线程

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

第一步，你将需要重写Thread类中可用的run（）方法。该方法为线程提供了一个入口点，你应该将把完整的逻辑放入该方法中。以下是run（）方法的简单语法。
public void run( )

第二步，创建线程对象后，可以通过调用start（）方法来启动它，该方法执行对run（）方法的调用。以下是start（）方法的简单语法。

void start( );

程序实现：
tip:将之前的程序通过此方法改写的代码如下

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.

上述两种方法均可以实现多线程的操作，但我个人比较偏向于使用第二种方法。

5.Thread类中的线程方法：

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

序号	方法
1	public void start()—— 在单独的执行路径中启动线程，然后在此Thread对象上调用run（）方法。
2	public void run()——如果使用单独的Runnable目标实例化此Thread对象，则会在该Runnable对象上调用run（）方法
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类中的以下方法是静态的。调用静态方法之一对当前正在运行的线程执行操作。

序号	方法
1	public static void yield()—— 在使当前正在运行的线程转换为等待调度的具有相同优先级的任何其他线程。
2	public static void sleep(long millisec)——使当前正在运行的线程阻塞至少指定的毫秒数。
3	public static boolean holdsLock(Object x)—— 如果当前线程holdlock指定参数，则返回true。
4	public static Thread currentThread()——返回对当前运行线程的引用，该线程是调用此方法的线程。
5	public static void dumpStack()—— 打印当前正在运行的线程的堆栈跟踪，这在调试多线程应用程序时很有用。

部分代码演示：
使用DisplayMessage 继承Thread类；

// File Name : DisplayMessage.java
//新建一个线程来继承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
// 新建一个类来继承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
.......

tips:可多次运行代码，每次的结果均不相同。

总结

以上就是今天总结的内容，本文仅仅简单介绍了线程的简单应用，在之后将使用多线程概念来完成小游戏的制作，同时也会将详细游戏制作教程上传。