Java多线程-前述

最新推荐文章于 2024-11-03 11:01:20 发布

JTuring~

最新推荐文章于 2024-11-03 11:01:20 发布

阅读量117

点赞数

分类专栏： JavaEE 文章标签： java 多线程并发编程

本文链接：https://blog.csdn.net/weixin_42376667/article/details/113947244

版权

JavaEE 专栏收录该内容

16 篇文章 0 订阅

订阅专栏

本文详细介绍了Java线程的生命周期，包括新建、可执行、阻塞、等待、超时等待和终止六种状态，并解析了状态转换。线程优先级用于调整线程执行的相对顺序，具有继承、随机性等特点。线程间的通信主要通过资源共享和消息传递实现，确保数据的一致性。此外，讨论了线程的原子性、可见性和有序性等关键特性。

摘要由CSDN通过智能技术生成

概述：

线程是JVM调度的最小单元。线程依赖于进程，进程由线程组成。

同一时刻一个线程只能在一个CPU上运行。但随着CPU核数的增加，计算机硬件的计算能力得到提升，这样的运行方式显然造成了资源浪费。其次，为了提高系统的响应速度，同一时刻处理不同的请求，所以我们需要多线程来更加充分地利用计算机资源，实现更快的请求响应。

线程的生命周期

Java线程的五大状态

NEW：线程对象被创建后，就进入了新建状态。
RUNNABLE：也称为可执行状态。线程对象被创建后，其他线程调用了该对象的start()方法，但该线程并以一定会被立即执行。
BLOCKED：阻塞状态是线程因为某种原因放弃CPU使用权，直到线程进入到就绪状态，才有机会转到运行状态。
- 等待阻塞：调用线程对象的wait()方法，让线程等待某工作的完成。
- 同步阻塞：线程在获取synchronized同步锁失败时，会进入同步阻塞状态。
- 其他阻塞：通过调用线程的sleep()或join()或发出了I/O请求，线程会进入到阻塞状态。当sleep状态超时、join等待线程终止或者超时，或者I/O处理完毕时，线程重新转入就绪状态。
WAITING：进入该状态的线程需要等待其他线程做出一些特定动作（通知或中断）。
TIMED_WAITING：该状态不同于WAITING，它可以在指定的时间后自行返回。
TERMINATED：表示该线程已经执行完毕。

Java线程状态转换

源码分析

Java1.5在Thread类中定义了State枚举来列举了线程的状态：

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;
}

线程的优先级

线程的优先级是在多线程环境中，开发者给线程定义的一个被分配CPU概率的一个相对量化，优先级越高的线程被分配CPU的概率高于优先级低的线程。

一个线程的优先级设置遵循以下原则：

线程被创建时，继承父线程的优先级
线程被创建后，可通过调用setPriority()方法改变优先级
线程的优先级是1-10之间的整数，默认为5

下面是Thread类内置的3个线程级别：

 /**
 * The minimum priority that a thread can have.
 */
public static final int MIN_PRIORITY = 1;

/**
 * The default priority that is assigned to a thread.
 */
public static final int NORM_PRIORITY = 5;

/**
 * The maximum priority that a thread can have.
 */
public static final int MAX_PRIORITY = 10;