Java中的多线程一

news2024/11/15 17:05:16

概述

进程

是正在运行的程序
- 是系统进行资源分配和调用的独立单位
- 每一个进程都有它自己的内存空间和系统资源

线程

进程中的单个顺序控制流，是一条执行路径
- 单线程：一个进程如果只有一条执行路径，则称为单线程程序
- 多线程：一个进程如果有多条执行路径，则称为多线程程序

多线程

线程两种常见实现方式

方法一：将一个类声明为Thread的子类（继承），这个子类应该重写Thread类的run方法。然后可以分配并启动子类的实例。
- 实现步骤
  1. 定义一个类 MyThread 继承 Thread 类
  2. 在 MyThread 类中重写 run() 方法
  3. 创建 MyThread 类的对象
  4. 启动线程 start() 导致此线程开始执行，Java 虚拟机调用此线程的 run 方法
- 示例代码
```
class MyThread extends Thread{
    @Override
    public void run() {
        System.out.println("你好！");
    }
}

public class Test1 {
    public static void main(String[] args) {
        // 创建 MyThread 对象
        MyThread mt = new MyThread();
        // 启动线程
        mt.start();
    }
}
```
运行结果：你好！

方法二：声明实现类 Runnable 接口(实现)，那个类

实现步骤
1. 定义一个类 MyRunnable 实现 Runnable 接口
2. 在 MyRunnable 类中重写 run() 方法
3. 创建 MyRunnable 类的对象
4. 创建 Thread 类的对象，把 MyRunnable 对象作为构造方法的参数
5. 启动线程 start() 导致此线程开始执行，Java 虚拟机调用此线程的 run 方法
示例代码

class MyRunnable implements Runnable{
    @Override
    public void run() {
        System.out.println("欢迎来到编程世界！");
    }
}

public class Test2 {
    public static void main(String[] args) {
        // 创建 线程类对象
        MyRunnable mr = new MyRunnable();
        // 创建 Thread 对象
        Thread t = new Thread(mr);
        // 启动线程
        t.start();
    }
}

运行结果：欢迎来到编程世界！

问题？
1. 为什么重写 run() 方法？
  - run() 方法是用来封装被线程执行的代码，也就是线程要做的任务
2. run() 方法和 start() 方法的区别？
  - 直接调用 run() 方法，相当于 main 线程去执行 run() 方法，并无新的线程产生
  - 调用 start() 方法，创建并启动线程，由 JVM 调用 run() 方法

异常 IllegalThreadStateException

同一个线程对象，只能调用一次 start() 方法，不能两次调用，调用两次会，抛出上述异常。
示例代码

class MyThread extends Thread{
    @Override
    public void run() {
        System.out.println("你好！");
    }
}

public class Test1 {
    public static void main(String[] args) {
        // 创建 MyThread 对象
        MyThread mt = new MyThread();
        // 启动线程
        mt.start();
        mt.start();
    }
}

异常演示

为什么会产生上述异常呢？我们来看下 start() 的源码

A zero status value corresponds to state “NEW” 意思是零状态值对应于状态“NEW”

状态	描述
新建（NEW）	表示线程已经创建好了，但是还没有调用 start() 方法
就绪（RUNNABLE）	表示线程可能在运行，也可能在就绪队列
阻塞（BLOCKED）	表示线程处于等在锁的状态
等待（WAITING）	表示线程处于条件等待状态，当触发条件后会唤醒
计时等待（TIME_WAIT）	比 WAITING 多了个超时条件触发的机制
终止（TERMINATED）	表示线程执行结束

线程第二次调用 start() 方法时，可能处于终止或者其他非 NEW 状态，对线程判断是否处于 NEW 状态，不是，就会抛出异常

两种实现方式的好处？

相比继承 Thread 类，实现 Runnable 接口的好处？
- 避免了Java单继承的局限性
- 适合多个相同程序的代码去处理同一个资源的情况，把线程和程序的代码、数据有效分离，较好的体现了面向对象的设计思想

线程执行的随机性

线程执行的随机性，原因是线程"抢占式执行"的方式，谁先抢到，CPU分配资源，谁先执行的缘故。

示例代码

class MyThread extends Thread{
    private int value;
    public MyThread(int value){
        this.value = value;
    }
    @Override
    public void run() {
        System.out.println(value);
    }
}

public class Test1 {
    public static void main(String[] args) {
        // 创建 MyThread 对象
        MyThread mt1 = new MyThread(1);
        MyThread mt2 = new MyThread(2);
        MyThread mt3 = new MyThread(3);
        MyThread mt4 = new MyThread(4);
        // 启动线程
        mt1.start();
        mt2.start();
        mt3.start();
        mt4.start();
    }
}