Thread 和 Runnable

Thread 和 Runnable

1. 简介

Java 主要是通过 java.lang.Thread 类以及 java.lang.Runnable 接口实现线程机制的。

1. Thread 类为底层操作系统的线程体系架构提供一套统一接口
2. Runnable 接口为关联 Thread 对象的线程提供执行代码

2. 创建 Thread 和 Runnable 对象

2.1 创建 Runnable 对象

创建 Runnable 有两种方式：

创建一个实现了 Runnable 接口的匿名类

Runnable r = new Runnable() {
    @Override
    public void run() {
        System.out.println("Hello from thread");
    }
};

或使用 lambda 表达式

Runnable r = () -> System.out.println("Hello from thread");

2.2 创建 Thread 对象

通过两种方式创建：

将 Runnable 对象作为 Thread 类的构造函数的参数

Thread t = new Thread(r);

继承 Thread 类继而重写它的 run() 方法

class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("Hello from thread");
    }
}
// ...
MyThread mt = new MyThread();

3. 获取和设置线程状态

几个方法：

• getName() : 获取线程名称
• setName(): 设置线程名称
• isAlive(): 判断线程存活状态，存活返回 true，不存活返回 false（只有执行 start() 方法，线程才启动）
• getState(): 获取线程执行状态 线程的执行状态由 Thread.State 枚举常量标识：
  • NEW：线程还没有开始执行
  • RUNNABLE：线程正在 JVM 中执行
  • BLOCKED：线程被阻塞并等待一个监听锁
  • WAITING：线程无限期地等待另外一条线程执行特定地操作
  • TIMED_WAITING：线程在特定地时间内等待另外一条线程执行某种操作
  • TERMINATED：线程已经退出
• setPriority(): 设置线程优先级 传递给优先级的值介于 Thread.MIN_PRIORITY 和 Thread.MAX_PRIORITY 之间，而 Thread.NORMAL_PRIORITY 则确定了默认的优先级
• isDaemon(): 判断线程是否为守护进程。守护进程返回 true，不是返回 false
• start(): 启动与对象关联的线程。 如果线程之前已经启动且处于运行状态，又或者线程已经死亡，这个方法就会抛出 java.lang.IllegalThreadStateException

4. 操作更高级的线程任务

中断线程

当一个线程被中断时，它会抛出 java.lang.InterruptedException，这一机制由下面的 3 种方法构成：

• void interrupt(): 中断调用此方法的 Thread 对象所关联的线程。该线程的中断状态会被清除
• static boolean interrupted(): 验证当前线程是否已经中断。该线程的中断状态会被这个方法清除掉
• boolean isInterrupted(): 验证线程是否已经中断。该线程的中断状态不受此方法的影响

等待线程

Thread 类提供了 3 种 join() 方法，允许调用线程等待执行此方法的线程对象所关联的线程执行完毕。

• void join()： 无限期地等待直至该线程死亡
• void join(long millis)：该线程死亡之前最多等待 millis 毫秒
• void join(long millis, int nanos)：该线程死亡之前最多等待 millis 毫秒加 nanos 纳秒

线程睡眠

Thread 类声明了一对静态方法致使线程睡眠（暂时性地停止执行）

• void sleep(long millis)：睡眠 millis 毫秒数
• void sleep(long millis, int nanos)：睡眠 millis 毫秒数和 nanos 纳秒数

5. Thread 和 Runnable 区别（重要）

首先讲一下多线程的实现思路，主要有两种方法：

1. 通过继承 Thread 类，重写 run() 方法

class MyThread extends Thread{
    private int ticket = 5;
    @Override
    public void run(){
        for (int i=0;i<10;i++)
        {
            if(ticket > 0){
                System.out.println("ticket = " + ticket--);
            }
        }
    }
}

class ThreadDemo{
    public static void main(String[] args){
        new MyThread().start();
        new MyThread().start();
        new MyThread().start();
    }
}

1. 通过实现 Runnable 接口，实现多线程

class MyThread implements Runnable{
    private int ticket = 5;
    @Override
    public void run(){
        for (int i=0;i<10;i++)
        {
            if(ticket > 0){
                System.out.println("ticket = " + ticket--);
            }
        }
    }
}

class RunnableDemo{
    public static void main(String[] args){
        MyThread my = new MyThread();
        new Thread(my).start();
        new Thread(my).start();
        new Thread(my).start();
    }
}

这两种方法一样的，只有执行了 start() 命令，才会开始执行线程。

其中继承 Thread 生成的线程每一个都是独立的，实现 Runnable 生成的线程是共享资源的，也就是我们上边的例子，最后输出的结果不一样：

• 第一种方式每一个线程都独立执行了 for 循环操作（资源不共享），所以最后返回的结果将轮番打印 3 次 54321 的结果。

ticket = 5
ticket = 4
ticket = 3
ticket = 2
ticket = 1
ticket = 5
ticket = 4
ticket = 3
ticket = 2
ticket = 1
ticket = 5
ticket = 4
ticket = 3
ticket = 2

• 而第二种方式中，由于 3 个 Thread 对象共同执行一个 Runnable 对象中的代码，所以实现了资源共享，最后打印出来的结果只有一次 54321，但这种方式容易造成线程的不安全。

ticket = 5
ticket = 4
ticket = 3
ticket = 2
ticket = 1

总结：

1. 继承 Thread 类的方法生成的线程每一个都是独立的，资源不能共享
2. 实现 Runnable 接口生成的线程由于共用 Runnable 方法，彼此之间能实现资源共享，但是是线程不安全的，有必要执行加锁操作
3. 只有执行 start() 操作，线程才会被创建执行
4. 一般开发过程中我们都习惯使用实现 Runnable 接口创建线程类的方法，因为可以实现资源共享，比较符合企业需求