Thread 和 Runnable
Thread 和 Runnable
1. 简介
Java 主要是通过 java.lang.Thread 类以及 java.lang.Runnable 接口实现线程机制的。
-
Thread类为底层操作系统的线程体系架构提供一套统一接口 -
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 区别（重要）
首先讲一下多线程的实现思路，主要有两种方法：
- 通过继承 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();
}
}
- 通过实现
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
总结：
- 继承 Thread 类的方法生成的线程每一个都是独立的，资源不能共享
- 实现 Runnable 接口生成的线程由于共用 Runnable 方法，彼此之间能实现资源共享，但是是线程不安全的，有必要执行加锁操作
- 只有执行
start()操作，线程才会被创建执行 - 一般开发过程中我们都习惯使用实现 Runnable 接口创建线程类的方法，因为可以实现资源共享，比较符合企业需求
