当前位置：首页 > news >正文

高级进阶多线程——多任务处理、线程状态（生命周期）、三种创建多线程的方式

news 2025/6/21 7:13:39

Java多线程

Java中的多线程是一个同时执行多个线程的进程。线程是一个轻量级的子进程，是最小的处理单元。多进程和多线程都用于实现多任务处理。

但是，一般使用多线程而不是多进程，这是因为线程使用共享内存区域。它们不分配单独的内存区域以节省内存，并且线程之间的上下文切换比进程花费的时间更少。

Java多线程主要用于游戏，动画等。

优点

（1）它不会阻塞用户，因为线程是独立的，可以同时执行多个操作。
（2）可以一起执行许多操作，因此可以节省时间。
（3）线程是独立的，因此如果在单个线程中发生异常，它不会影响其他线程。

多任务处理

多任务处理是同时执行多个任务的过程。使用多任务来利用CPU，多任务处理可以通过两种方式实现：

基于进程的多任务处理（多进程）
基于线程的多任务处理（多线程）

基于进程的多任务处理（多进程）

每个进程在内存中都有一个地址。换句话说，每个进程分配一个单独的内存区域。
进程是重量级的。
进程之间的通信成本很高。
从一个进程切换到另一个进程需要一些时间来保存和加载寄存器，内存映射，更新列表等。

基于线程的多任务处理（多线程）

线程共享相同的地址空间。
线程是轻量级的。
线程之间的通信成本很低。

注意：一次只执行一个线程。

线程的生命周期（线程状态）

线程可以处于五种状态之一。根据sun解释，线程生命周期在java中有以下几种状态:初始(NEW) ，运行(RUNNABLE)，阻塞(BLOCKED)，等待(WAITING)，超时等待(TIMED_WAITING)和终止(TERMINATED)。

java中线程的生命周期由JVM控制，java线程状态如下:

初始(NEW):新创建了一个线程对象，但还没有调用start()方法。
运行(RUNNABLE):Java线程中将就绪(ready)和运行中(running)两种状态笼统的称为“运行”。
线程对象创建后，其他线程(比如main线程)调用了该对象的start()方法。该状态的线程位于可运行线程池中，等待被线程调度选中，获取CPU的使用权，此时处于就绪状态(ready)。就绪状态的线程在获得CPU时间片后变为运行中状态(running)。
阻塞(BLOCKED):表示线程阻塞于锁。
等待(WAITING):进入该状态的线程需要等待其他线程做出一些特定动作(通知或中断)。
超时等待(TIMED_WAITING):该状态不同于WAITING，它可以在指定的时间后自行返回。
终止(TERMINATED):表示该线程已经执行完毕。

新建状态:

使用 new 关键字和 Thread 类或其子类建立一个线程对象后，该线程对象就处于新建状态。它保持这个状态直到程序 start() 这个线程。

就绪状态

当线程对象调用了start()方法之后，该线程就进入就绪状态。就绪状态的线程处于就绪队列中，要等待JVM里线程调度器的调度。

运行状态

如果就绪状态的线程获取 CPU 资源，就可以执行 run()，此时线程便处于运行状态。处于运行状态的线程最为复杂，它可以变为阻塞状态、就绪状态和死亡状态。

阻塞状态:

如果一个线程执行了sleep（睡眠）、suspend（挂起）等方法，失去所占用资源之后，该线程就从运行状态进入阻塞状态。在睡眠时间已到或获得设备资源后可以重新进入就绪状态。可以分为三种：

等待阻塞：运行状态中的线程执行 wait() 方法，使线程进入到等待阻塞状态。
同步阻塞：线程在获取 synchronized 同步锁失败(因为同步锁被其他线程占用)。
其他阻塞：通过调用线程的 sleep() 或 join() 发出了 I/O 请求时，线程就会进入到阻塞状态。当sleep() 状态超时，join() 等待线程终止或超时，或者 I/O 处理完毕，线程重新转入就绪状态。

死亡状态

一个运行状态的线程完成任务或者其他终止条件发生时，该线程就切换到终止状态。

创建线程

创建一个线程有三种方法:

通过扩展Thread类。
通过实现Runnable接口。
通过 Callable 和 Future 创建线程。

Thread类
Thread类提供了在线程上创建和执行操作的构造函数和方法。Thread类扩展了Object类并实现了Runnable接口。

常用的Thread类构造函数

Thread()
Thread(String name)
Thread(Runnable r)
Thread(Runnable r,String name)

Thread类的常用方法:

public void run(): 用于执行线程的操作。
public void start(): 开始执行线程，JVM调用线程上的run()方法。
public void sleep(long miliseconds): 使当前正在执行的线程休眠(暂时停止执行)达指定的毫秒数。
public void join(): 等待线程死亡。
public void join(long miliseconds): 按指定的毫秒数等待线程死亡。
public int getPriority(): 返回线程的优先级。
public int setPriority(int priority): 更改线程的优先级。
public String getName(): 返回线程的名称。
public void setName(String name): 更改线程的名称。
public int getId():返回线程的编号(ID)。
public Thread.State getState(): 返回线程的状态。
public boolean isAlive(): 测试线程是否处于活动状态。
public void yield(): 使当前正在执行的线程对象暂时暂停并允许其他线程执行。
public void suspend(): 用于挂起线程(depricated)。
public void resume(): 用于恢复挂起的线程(depricated)。
public void stop(): 用于停止线程(depricated)。
public boolean isDaemon(): 测试该线程是否为守护进程线程。
public void setDaemon(boolean b): 将线程标记为守护进程或用户线程。
public void interrupt(): 中断线程。
public boolean isInterrupted(): 测试线程是否被中断。
public static boolean interrupted(): 测试当前线程是否已被中断。

Runnable接口:
Runnable接口应由任何其实例由线程执行类实现。Runnable接口只有一个run()方法。

public void run(): 用于执行线程的操作。

启动线程:

Thread类的start()方法用于启动新创建的线程。它执行以下任务:

一个新线程启动(使用新的callstack)。
线程从New状态移动到Runnable状态。
当线程有机会执行时，它的目标run()方法将运行。

示例

1. 通过扩展Thread类线程示例

package com.yiibai;class Multi extends Thread {public void run() {System.out.println("thread is running...");}public static void main(String args[]) {Multi t1 = new Multi();t1.start();}
}

执行上面示例代码，得到以下结果:

thread is running...

2. 通过实现Runnable接口的线程示例

package com.yiibai;class Multi implements Runnable {public void run() {System.out.println("thread is running...");}public static void main(String args[]) {Multi m1 = new Multi();Thread t1 = new Thread(m1);t1.start();}
}

执行上面示例代码，得到以下结果:

thread is running...

如果没有扩展Thread类，类对象就不会被视为一个线程对象。所以需要明确地创建Thread类对象。传递实现Runnable类的对象，以便类的run()方法可以执行。

3.通过 Callable 和 Future 创建线程

创建 Callable 接口的实现类，并实现 call() 方法，该 call() 方法将作为线程执行体，并且有返回值。
创建 Callable 实现类的示例，使用 FutureTask 类来包装 Callable 对象，该 FutureTask 对象封装了该 Callable 对象的 call() 方法的返回值。
使用 FutureTask 对象作为 Thread 对象的 target 创建并启动新线程。
调用 FutureTask 对象的 get() 方法来获得子线程执行结束后的返回值。

public class Zeus implements Callable<Integer> {public static void main(String[] args)  {  CallableThreadTest ctt = new CallableThreadTest();  FutureTask<Integer> ft = new FutureTask<>(ctt);  for(int i = 0;i < 100;i++)  {  System.out.println(Thread.currentThread().getName()+" 的循环变量i的值"+i);  if(i==20)  {  new Thread(ft,"有返回值的线程").start();  }  }  try  {  System.out.println("子线程的返回值："+ft.get());  } catch (InterruptedException e)  {  e.printStackTrace();  } catch (ExecutionException e)  {  e.printStackTrace();  }  }@Override  public Integer call() throws Exception  {  int i = 0;  for(;i<100;i++)  {  System.out.println(Thread.currentThread().getName()+" "+i);  }  return i;  }  
}

创建线程的三种方式的对比

采用实现 Runnable、Callable 接口的方式创建多线程时，线程类只是实现了 Runnable 接口或 Callable 接口，还可以继承其他类。
使用继承 Thread 类的方式创建多线程时，编写简单，如果需要访问当前线程，则无需使用 Thread.currentThread() 方法，直接使用 this 即可获得当前线程。

线程的几个主要概念

在多线程编程时，你需要了解以下几个概念：

线程同步

线程间通信

线程死锁

Java线程调度程序

Java的线程调度程序是JVM的一部分，它决定应该运行哪个线程。无法保证线程调度程序将选择运行哪个可运行线程。

一次只能有一个线程在一个进程中运行。线程调度程序主要使用抢占式或时间切片调度来调度线程。

抢占式调度与时间分片的区别

在抢占式调度下，优先级最高的任务一直执行，直到它进入等待或死亡状态或更高优先级的任务出现。在时间切片下，任务执行预定义的一段时间，然后重新进入就绪任务池。然后，调度程序根据优先级和其他因素确定接下来应执行的任务。