Posted 2024-07-26Updated 2024-08-09Common / JavaBasic29 minutes read (About 4385 words)

Thread

线程/进程

进程：进程是系统进行资源分配和调度的一个独立单位 (拥有独立内存空间)，一个app就是一个进程，进程包含线程。

线程：是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位。线程自己基本上不拥有系统资源,只拥有一些在运行中必不可少的资源(如程序计数器,一组寄存器和栈)，但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源。

静态的是资源和动态的是计算

进程是一个资源的容器，为进程里的所有线程提供共享资源，是对程序的一种静态描述
线程是计算机最小的调度和运行（计算）单位，是对程序的一种动态描述

Java里的线程有哪些状态？

JDK中，线程（Thread）定义了6种状态： NEW（新建）、RUNNABLE（可执行）、BLOCKED（阻塞）、WAITING（等待）、TIMED_WAITING（限时等待）、TERMINATED（结束）。

源码如下：

/**
 * A thread state.  A thread can be in one of the following  states:
 * <ul>
 * <li>{@link #NEW}

 *     A thread that has not yet started is in this state.
 *     </li>
 * <li>{@link #RUNNABLE}

 *     A thread executing in the Java virtual machine is in  this state.
 *     </li>
 * <li>{@link #BLOCKED}

 *     A thread that is blocked waiting for a monitor lock
 *     is in this state.
 *     </li>
 * <li>{@link #WAITING}

 *     A thread that is waiting indefinitely for another  thread to
 *     perform a particular action is in this state.
 *     </li>
 * <li>{@link #TIMED_WAITING}

 *     A thread that is waiting for another thread to perform  an action
 *     for up to a specified waiting time is in this state.
 *     </li>
 * <li>{@link #TERMINATED}

 *     A thread that has exited is in this state.
 *     </li>
 * </ul>
 *
 * <p>
 * A thread can be in only one state at a given point in  time.
 * These states are virtual machine states which do not  reflect
 * any operating system thread states.
 *
 * @since   1.5
 * @see #getState
 */
public enum State {
    /**
     * Thread state for a thread which has not yet started.
     */
    NEW,
    /**
     * Thread state for a runnable thread.  A thread in the  runnable
     * state is executing in the Java virtual machine but it  may
     * be waiting for other resources from the operating  system
     * such as processor.
     */
    RUNNABLE,
    /**
     * Thread state for a thread blocked waiting for a  monitor lock.
     * A thread in the blocked state is waiting for a monitor  lock
     * to enter a synchronized block/method or
     * reenter a synchronized block/method after calling
     * {@link Object#wait() Object.wait}.
     */
    BLOCKED,
    /**
     * Thread state for a waiting thread.
     * A thread is in the waiting state due to calling one of  the
     * following methods:
     * <ul>
     *   <li>{@link Object#wait() Object.wait} with no  timeout</li>
     *   <li>{@link #join() Thread.join} with no timeout</li>
     *   <li>{@link LockSupport#park() LockSupport.park}</li>
     * </ul>
     *
     * <p>A thread in the waiting state is waiting for  another thread to
     * perform a particular action.
     *
     * For example, a thread that has called  <tt>Object.wait()</tt>
     * on an object is waiting for another thread to call
     * <tt>Object.notify()</tt> or  <tt>Object.notifyAll()</tt> on
     * that object. A thread that has called  <tt>Thread.join()</tt>
     * is waiting for a specified thread to terminate.
     */
    WAITING,
    /**
     * Thread state for a waiting thread with a specified  waiting time.
     * A thread is in the timed waiting state due to calling  one of
     * the following methods with a specified positive  waiting time:
     * <ul>
     *   <li>{@link #sleep Thread.sleep}</li>
     *   <li>{@link Object#wait(long) Object.wait} with  timeout</li>
     *   <li>{@link #join(long) Thread.join} with  timeout</li>
     *   <li>{@link LockSupport#parkNanos  LockSupport.parkNanos}</li>
     *   <li>{@link LockSupport#parkUntil  LockSupport.parkUntil}</li>
     * </ul>
     */
    TIMED_WAITING,
    /**
     * Thread state for a terminated thread.
     * The thread has completed execution.
     */
    TERMINATED;
}

状态说明

线程在一个给定的时间点只能处于下面其中一种状态：

这些状态是虚拟机状态，并不能反映任何操作系统的线程状态。

NEW：尚未启动的线程处于这个状态。Thread thread = new Thread(new Runnable(){…});处于这个状态。
RUNNABLE：可运行的线程处于这个状态。对应操作系统中的两种状态：ready和running，也就是说RUNNABLE状态既可以是可运行的，也可以是实际运行中的，有可能正在执行，也有可能没有正在执行。关于这个问题的理解，可以对比想一下，thread.start()调用之后线程会立刻执行吗？
BLOCKED：阻塞，进入synchronized修饰的方法或者代码块，等待监视器锁的线程处于这个状态。
WAITING：无限期等待另一个线程执行特定操作的线程处于这种状态。
TIMED_WAITING：正在等待另一个线程执行某个操作的线程在指定的等待时间内处于这种状态。
TERMINATED：已经退出的线程处于这个状态。

状态转移

NEW：线程尚未启动的线程状态。当在程序中创建一个线程的时候Thread t = new Thread(Runnable);，线程处于NEW状态。

RUNNABLE：可运行线程的线程状态。处于可运行状态的线程正在Java虚拟机中执行，但它可能正在等待操作系统中的其他资源，比如处理器。也就是说，这个状态就是可运行也可不运行的状态。注意Runnable ≠ Running。

BLOCKED：进入synchronized修饰的方法或者代码块，等待监视器锁的阻塞线程的线程状态。比如，线程试图通过synchronized去获取监视器锁，但是其他线程已经独占了，那么当前线程就会处于阻塞状态。等到获得了监视器锁之后会再次进入RUNNABLE状态。

WAITING：调用以下方法之一，线程会处于等待状态：

Object.wait()注意：括号内不带参数；
Thread.join()注意：扩号内不带参数；
LockSupport.park()；

其实wait()方法有多重形式，可以不带参数，可以带参数，参数表示等待时间（单位ms），如图所示：

“BLOCKED（阻塞状态）”和“WAITING（等待状态）”的区别：阻塞状态在等待获取一个排它锁，这个事件将会在另外一个线程放弃这个锁的时候发生，然后由阻塞状态变为可执行状态；而等待状态则是在等待一段时间，或者等待唤醒动作的发生。

TIMED_WAITING：一个线程调用了以下方法之一（方法需要带具体的等待时间），会处于定时等待状态：

Thread.sleep(long timeout)
Object.wait(long timeout)
Thread.join(long timeout)
LockSupport.parkNanos()
LockSupport.parkUntil()

TERMINATED：该线程已经执行完毕。执行完毕指的是线程正常执行完了run方法之后退出，也可以是遇到了未捕获的异常而退出。

初始(NEW)

新创建了一个线程对象，但还没有调用start()方法。

运行(RUNNABLE)

Ready

Running

Java线程中将就绪（ready）和运行中（running）两种状态笼统的称为“运行”。线程对象创建后，其他线程(比如main线程）调用了该对象的start()方法。该状态的线程位于可运行线程池中，等待被线程调度选中，获取CPU的使用权，此时处于就绪状态（ready）。就绪状态的线程在获得CPU时间片后变为运行中状态（running）。

阻塞(BLOCKED)

表示线程阻塞于锁。或称“挂起”

阻塞或唤醒一个Java线程需要操作系统切换CPU状态来完成，这种状态转换需要耗费处理器时间

等待(WAITING)

等待状态，处于等待状态的线程是由于执行了Thread.join或Object.wait方法

处于waiting状态的线程会等待另外一个线程处理特殊的行为。再举个例子，如果一个线程调用了一个对象的wait方法，那么这个线程就会处于waiting状态直到另外一个线程调用这个对象的notify或者notifyAll方法后才会解除这个状态

超时等待(TIMED_WAITING)

有等待时间的等待状态，比如调用了**Thread.sleep(long timeout)、Thread.join(long timeout)、Object.wait(long timeout)**，并且指定了等待时间，线程就会处于这个状态。

终止(TERMINATED)

表示该线程已经执行完毕。

对比分析Java中的各个线程相关的wait()、notify()、sleep()、interrupt()方法

线程相关方法

Thread类

sleep：暂停当前正在执行的线程；（类方法）

是Thread的静态方法，很显然它是让当前线程按照指定的时间休眠，其休眠时间的精度取决于处理器的计时器和调度器。需要注意的是如果当前线程获得了锁，sleep方法并不会失去锁。sleep方法经常拿来与Object.wait()方法进行比价，这也是面试经常被问的地方。

sleep() VS wait()

两者主要的区别：

1. sleep()方法是Thread的静态方法，而wait是Object实例方法
2. wait()方法必须要在同步方法或者同步块中调用，也就是必须已经获得对象锁。而sleep()方法没有这个限制可以在任何地方种使用。另外，wait()方法会释放占有的对象锁，使得该线程进入等待池中，等待下一次获取资源。而sleep()方法只是会让出CPU并不会释放掉对象锁；
3. sleep()方法在休眠时间达到后如果再次获得CPU时间片就会继续执行，而wait()方法必须等待Object.notift/Object.notifyAll通知后，才会离开等待池，并且再次获得CPU时间片才会继续执行。

yield：暂停当前正在执行的线程，并执行其他线程；（类方法）

是Thread的静态方法，一旦执行，它会是当前线程让出CPU，但是，需要注意的是，让出的CPU并不是代表当前线程不再运行了，如果在下一次竞争中，又获得了CPU时间片当前线程依然会继续运行。另外，让出的时间片只会分配给当前线程相同优先级的线程。

yield()方法使当前线程出让CPU执行时间，但并不会释放当前线程所持有的锁。执行完yield()方法后，线程从Running状态转变为Runnable状态，既然是Runnable状态，那么也很可能马上会被CPU调度再次进入Running状态。

什么是线程优先级了？下面就来具体聊一聊。

现代操作系统基本采用时分的形式调度运行的线程，操作系统会分出一个个时间片，线程会分配到若干时间片，当前时间片用完后就会发生线程调度，并等待这下次分配。线程分配到的时间多少也就决定了线程使用处理器资源的多少，而线程优先级就是决定线程需要或多或少分配一些处理器资源的线程属性。

在Java程序中，通过一个整型成员变量Priority来控制优先级，优先级的范围从1~10.在构建线程的时候可以通过**setPriority(int)**方法进行设置，默认优先级为5，优先级高的线程相较于优先级低的线程优先获得处理器时间片。需要注意的是在不同JVM以及操作系统上，线程规划存在差异，有些操作系统甚至会忽略线程优先级的设定。

另外需要注意的是，sleep()和yield()方法，同样都是当前线程会交出处理器资源，而它们不同的是，sleep()交出来的时间片其他线程都可以去竞争，也就是说都有机会获得当前线程让出的时间片。而yield()方法只允许与当前线程具有相同优先级的线程能够获得释放出来的CPU时间片。

join：等待该线程终止；

join()方法的作用，是等待这个线程结束，是主线程等待子线程的终止。也就是说主线程的代码块中，如果碰到了t.join()方法，此时主线程需要等待（阻塞），等待子线程结束了(Waits for this thread to die.),才能继续执行t.join()之后的代码块。

interrupt：中断该线程，

interrupt()方法的工作仅仅是改变中断状态，并不是直接中断正在运行的线程。中断的真正原理是当线程被Object.wait(),Thread.join()或sleep()方法阻塞时，调用interrupt()方法后改变中断状态，而wait/join/sleep这些方法内部会不断地检查线程的中断状态值，当发现中断状态值改变时则抛出InterruptedException异常；对于没有阻塞的线程，调用interrupt()方法是没有任何作用。

Object类

wait：暂停当前正在执行的线程，直到调用notify()或notifyAll()方法或超时，退出等待状态；
notify：唤醒在该对象上等待的一个线程；
notifyAll：唤醒在该对象上等待的所有线程；

对比

sleep VS wait

sleep()和wait()方法都是暂停当前正在执行的线程，出让CPU资源。

方法	所属类	方法类型	锁	解除方法	场景	用途
sleep	Thread	静态方法	不释放锁	timeout,interrupt	无限制	线程内的控制
wait	Object	非静态方法	释放锁	timeout,notify,interrupt	同步语句块	线程间的通信

public static void sleep(long millis) throws InterruptedException 
	public static void sleep(long millis, int nanos) throws InterruptedException 
   
 public final void wait() throws InterruptedException 
 public final void wait(long timeout) throws InterruptedException 
 public final void wait(long timeout, int nanos) throws InterruptedException

wait && notify

调用对象的wait()、notify()、notifyAll()方法的线程，必须是作为此对象监视器的所有者。常见的场景便是就是synchronized关键字的语句块内部使用这3个方法，如果直接在线程中使用wait()、notify()、notifyAll()方法，那么会抛出异常IllegalMonitorStateException，抛出的异常表明某一线程已经试图等待对象的监视器，或者试图通知其他正在等待对象的监视器而本身没有指定监视器的线程。。

调用wait()方法的线程，在调用该线程的interrupt()方法，则会重新尝试获取对象锁。只有当获取到对象锁，才开始抛出相应的异常，则执行该线程之后的程序。

怎么终止一个线程

首先，一个线程不应该由其他线程来强制中断或停止，而是应该由线程自己自行停止。

所以，Thread.stop, Thread.suspend, Thread.resume 都已经被废弃了。

interrupt：

Thread.interrupt 的作用其实也不是中断线程，而是「通知线程应该中断了」，

具体到底中断还是继续运行，应该由被通知的线程自己处理。

具体来说，当对一个线程，调用 interrupt() 时，

① 如果线程处于被阻塞状态（例如处于sleep, wait, join 等状态），那么线程将立即退出被阻塞状态，并抛出一个InterruptedException异常。仅此而已。

② 如果线程处于正常活动状态，那么会将该线程的中断标志设置为 true，仅此而已。被设置中断标志的线程将继续正常运行，不受影响。

interrupt() 并不能真正的中断线程，需要被调用的线程自己进行配合才行。

① 在正常运行任务时，经常检查本线程的中断标志位，如果被设置了中断标志就自行停止线程。

② 在调用阻塞方法时正确处理InterruptedException异常。（例如，catch异常后就结束线程。）

Thread thread = new Thread(() -> {
    while (!Thread.interrupted()) {
        // do more work.
    }
});
thread.start();

// 一段时间以后
thread.interrupt();

stop():

弃用，因为在stop时会释放所有的锁，可能导致线程不同步，另一个也可能导致资源如文件文件数据库的关闭行为不被执行

调用 stop() 方法会立刻停止 run() 方法中剩余的全部工作，包括在 catch 或 finally 语句中的，并抛出ThreadDeath异常(通常情况下此异常不需要显示的捕获)，因此可能会导致一些清理性的工作的得不到完成，如文件，数据库等的关闭。

调用 stop() 方法会立即释放该线程所持有的所有的锁，导致数据得不到同步，出现数据不一致的问题。

使用volatile标志位

以标志位为循环条件

Thread

http://example.com/2024/07/26/Tread/

Author

white crow

Posted on

2024-07-26

Updated on

2024-08-09

Licensed under

#Core

Thread

线程/进程

Java里的线程有哪些状态？

状态说明

状态转移

初始(NEW)

运行(RUNNABLE)

Ready

Running

阻塞(BLOCKED)

等待(WAITING)

超时等待(TIMED_WAITING)

终止(TERMINATED)

线程相关方法

Thread类

sleep：暂停当前正在执行的线程；（类方法）

yield：暂停当前正在执行的线程，并执行其他线程；（类方法）

join：等待该线程终止；

interrupt：中断该线程，

Object类

对比

sleep VS wait

wait && notify

怎么终止一个线程

interrupt：

stop():

使用volatile标志位

Author

Posted on

Updated on

Licensed under

Catalogue