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

Java多线程

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

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

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

优点

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

多任务处理

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

基于进程的多任务处理(多进程)
基于线程的多任务处理(多线程)

基于进程的多任务处理(多进程)
  • 每个进程在内存中都有一个地址。 换句话说,每个进程分配一个单独的内存区域。
  • 进程是重量级的。
  • 进程之间的通信成本很高。
  • 从一个进程切换到另一个进程需要一些时间来保存和加载寄存器,内存映射,更新列表等。
基于线程的多任务处理(多线程)
  • 线程共享相同的地址空间。
  • 线程是轻量级的。
  • 线程之间的通信成本很低。

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

线程的生命周期(线程状态)

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

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

  1. 初始(NEW):新创建了一个线程对象,但还没有调用start()方法。
  2. 运行(RUNNABLE):Java线程中将就绪(ready)和运行中(running)两种状态笼统的称为“运行”。
    线程对象创建后,其他线程(比如main线程)调用了该对象的start()方法。该状态的线程位于可运行线程池中,等待被线程调度选中,获取CPU的使用权,此时处于就绪状态(ready)。就绪状态的线程在获得CPU时间片后变为运行中状态(running)。
  3. 阻塞(BLOCKED):表示线程阻塞于锁。
  4. 等待(WAITING):进入该状态的线程需要等待其他线程做出一些特定动作(通知或中断)。
  5. 超时等待(TIMED_WAITING):该状态不同于WAITING,它可以在指定的时间后自行返回。
  6. 终止(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的一部分,它决定应该运行哪个线程。无法保证线程调度程序将选择运行哪个可运行线程。

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

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

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

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值