Java 线程:创建、属性以及状态控制

前言


本文将对 Java 线程 Thread 进行学习和总结,以下是概览:

目录

一、Thread 创建

线程的创建主要依靠实现 Runnable 接口。调用 start() 方法使线程进入就绪状态,等待 CPU 调度,然后 run () 方法由 JVM 调用。

1.1 实现 Runnable

public interface Runnable {
    public abstract void run();
}

例子

public class TestThread implements Runnable{

    @Override
    public void run() {
        System.out.println("TestThread Running");
    }
}

使用

public static void main(String[] args) {
     // 创建线程
     TestThread testThread = new TestThread();
     // 将 Runnable 对象作为参数传递给 Thread
     Thread thread = new Thread(testThread);
     thread.start();
}

为什么不能直接创建 TestThread 对象并调用 run() 方法呢,因为这样只是普通地调用了对象的方法,并没有经历创建线程的过程。

所以还是需要利用 Java 为我们写好的 Thread 类对线程对象(实现了 Runnable 的对象)进行一次包装,然后由 Thread 类替我们完成创建并执行线程的过程。

1.2 继承 Thread

Thread 类本身实现了 Runnable 接口,内部又包装了一个 Thread 对象 target,执行 run 方法的时候实际调用 target 的 run 方法。

public class Thread implements Runnable {
    private Runnable target;
    ...
    public void run() {
        if (target != null) {
            target.run();
        }
    }
}

所以本质上还是实现了 Runnable 接口实现线程的创建。

二、部分属性


Thread 类的部分属性:

// 对象锁,用于使当前线程占有 CPU
private final Object lock = new Object();
// 该值不等于0,说明线程存活,尚不知原理
private volatile long nativePeer;
// 线程名称
private volatile String name;
// 线程优先级
private int         priority;
// 是否守护线程
private boolean     daemon = false;

接下来将逐个分析。

2.1 lock 锁对象

lock 对象用于加锁和使调用者线程进入阻塞状态。

阻塞

调用 join 方法会使当前线程获取 lock 对象的锁,然后 lock 对象执行 wait 方法进入阻塞状态,实现阻塞当前线程的效果。

public final void join() throws InterruptedException {
    // 传入 0 表示无限阻塞
    join(0);
}

public final void join(long millis) throws InterruptedException {
    synchronized(lock) { // 同步锁
    long base = System.currentTimeMillis();
    long now = 0;

    if (millis < 0) {
        throw new IllegalArgumentException("timeout value is negative");
    }

    if (millis == 0) { // 等于 0 无限阻塞
        while (isAlive()) {
            lock.wait(0);
        }
    } else {
        while (isAlive()) {
            long delay = millis - now;
            if (delay <= 0) {
                break;
            }
            lock.wait(delay);
            now = System.currentTimeMillis() - base;
        }
    }
    }
}

比如现在有个线程 Thread1,在运行过程中需要执行 Thread2 的相关逻辑。Thread2 在 Thread1 的 run() 方法中调用了 join() 方法,这样 Thread1 就获取到了 Thread2 中 lock 对象的锁。

lock 对象循环调用 wait() 方法进行阻塞。因为这时是处于 Thread1 的运行环境下,并且由 synchronized 获取了 monitor(相当于同步锁),所以 Thread1 进入了阻塞状态。

Java Object wait() 方法

注意:

当前线程必须是此对象的监视器所有者,否则还是会发生 IllegalMonitorStateException 异常。
如果当前线程在等待之前或在等待时被任何线程中断,则会抛出 InterruptedException 异常。

解除阻塞

解除阻塞有两种方式,但不限于这两种。一种是 超时 自动释放,另一种是由 JVM 释放。

  • join() 方法传入 millis (毫秒数),在时间达到之后跳出循环,lock 对象不再加锁。这样 Thread1 持有的 lock 对象不再阻塞,由此该线程回到就绪状态。
  • 加入线程执行完毕,JVM 释放锁。线程死亡时 JVM 会调用 lock 对象的 notify_all() 方法来释放所有锁。

以下代码摘自 Thread.join的作用和原理 中的 hotspot 虚拟机源码:

void JavaThread::exit(bool destroy_vm, ExitType exit_type) {
  assert(this == JavaThread::current(),  "thread consistency check");
  ...
  // Notify waiters on thread object. This has to be done after exit() is called
  // on the thread (if the thread is the last thread in a daemon ThreadGroup the
  // group should have the destroyed bit set before waiters are notified).
  ensure_join(this); 
  assert(!this->has_pending_exception(), "ensure_join should have cleared");
  ...

可以看到线程退出方法 exit() 调用了 ensure_join(this) 释放锁:

static void ensure_join(JavaThread* thread) {
  // We do not need to grap the Threads_lock, since we are operating on ourself.
  Handle threadObj(thread, thread->threadObj());
  assert(threadObj.not_null(), "java thread object must exist");
  ObjectLocker lock(threadObj, thread);
  // Ignore pending exception (ThreadDeath), since we are exiting anyway
  thread->clear_pending_exception();
  // Thread is exiting. So set thread_status field in  java.lang.Thread class to TERMINATED.
  java_lang_Thread::set_thread_status(threadObj(), java_lang_Thread::TERMINATED);
  // Clear the native thread instance - this makes isAlive return false and allows the join()
  // to complete once we've done the notify_all below
  //这里是清除native线程,这个操作会导致isAlive()方法返回false
  java_lang_Thread::set_thread(threadObj(), NULL);
  lock.notify_all(thread);//注意这里
  // Ignore pending exception (ThreadDeath), since we are exiting anyway
  thread->clear_pending_exception();
}

这里的 lock 对象大概就是 Thread 中的同步锁对象了,调用 Java Object notifyAll() 方法 用来唤醒所有持有该对象锁的线程。

2.2 其它参数

  • nativePeer: 判断线程是否存活依靠此字段,可能在线程销毁的时候把该值置为 0。
public final boolean isAlive() {
    return nativePeer != 0;
}
  • priority: 优先级,默认 NORM_PRIORITY=5。最小 MIN_PRIORITY = 1,最大 MAX_PRIORITY = 10。
    设置该参数的作用在于希望较高优先级的线程可以先行执行,但实际可能并非总是如此。

优先级和操作系统及虚拟机版本相关。
优先级只是代表告知了 「线程调度器」该线程的重要度有多大。如果有大量线程都被堵塞,都在等候运
行,调试程序会首先运行具有最高优先级的那个线程。然而,这并不表示优先级较低的线程不会运行(换言之,不会因为存在优先级而导致死锁)。若线程的优先级较低,只不过表示它被准许运行的机会小一些而已。

  • daemon: 是否为守护线程。守护线程就像一个卫士,追随用户线程。当用户线程销毁时,守护线程也就没有了意义,可能会被随时回收。

参考:什么是守护线程?

三、Thread 状态


3.1 线程的几种状态

有关线程状态,大概有两种说法。

  • 一种是概括性的五种状态:
    • 创建状态 已经创建出对象,并未调用 start;
    • 就绪状态 调用 start 方法之后,并未开始运行;
    • 运行状态 被 cpu 执行,run 方法被调用;
    • 阻塞状态 在运行过程中被暂停,调用 wait() 或被别的线程 join() 等;
    • 死亡状态 run 方法执行结束,或者调用 stop() 结束运行。
  • 另一种是根据源码的六种状态:
    • NEW 刚 new 出来;
    • RUNNABLE 运行中;
    • BLOCKED 等待同步锁;
    • WAITING 阻塞状态,wait() 或被 join();
    • TIMED_WAITING 阻塞状态,限时;
    • TERMINATED 被终止。

个人感觉没有必要纠结孰对孰错,这是两个层面上的理解。前者更倾向于总览,后者更为细化。

3.2 线程状态控制

线程调度

简单地说就是设置优先级,使 JVM 进行协调。避免多个线程抢夺有限资源造成的死机或者崩溃。上文已经提到过,最低优先级 MIN_PRIORITY =1、最高优先级 MAX_PRIORITY = 10,默认优先级 NORM_PRIORITY=5。

为了控制线程的运行策略,Java定义了线程调度器来监控系统中处于就绪状态的所有线程。线程调度器按照线程的优先级决定那个线程投入处理器运行。在多个线程处于就绪状态的条件下,具有高优先级的线程会在低优先级线程之前得到执行。

守护线程

特殊的低优先级守护(Daemon)线程,它是为系统中的其它对象或线程服务。

典型的守护线程例子是JVM中的系统资源自动回收线程,它始终在低级别的状态中运行,用于实时监控和管理系统中的可回收资源。

当所有用户线程销毁后,也不会产生垃圾了。守护线程会随着 JVM 销毁。

线程分组

Java定义了在多线程运行系统中的线程组(ThreadGroup)对象,用于实现按照特定功能对线程进行集中式分组管理。

用户创建的每个线程均属于某线程组,这个线程组可以在线程创建时指定,也可以不指定线程组以使该线程处于默认的线程组之中。但是,一旦线程加入某线程组,该线程就一直存在于该线程组中直至线程死亡,不能在中途改变线程所属的线程组。

与线程类似,可以针对线程组对象进行线程组的调度、状态管理以及优先级设置等。在对线程组进行管理过程中,加入到某线程组中的所有线程均被看作统一的对象。

四、Thread 其它


4.1 线程同步

  • synchronized: 依赖 JVM 实现,通过锁住 对象、方法、类 等实现线程同步;
  • volatile: 特殊域变量,使用该关键字修饰对象,保证其 可见性。使其无论在哪个线程读取时都从内存重新读取,而不是在 CPU 缓存中读取;
  • 重入锁: ReentrantLock 可重入,内含 CAS+AQS 机制。CAS 保证数据准确性,AQS 保证顺序。
  • ThreadLocal: 为每一条线程创建数据副本,这样各个线程间处理的数据互不影响。因为处理的不是同一数据,要注意数据的一致性。

4.2 终止线程

终止线程三种方法:

  • 设置 flag 标记:为 false 时结束代码运行,JVM 会回收掉线程;
  • stop 方法(不推荐):强行结束线程,但是可能会因马上释放锁造成数据产生误差;
  • interrupt 方法:使线程进入中断状态,代码逻辑中 catch InterruptedException 用来结束逻辑执行。

总结

线程使用时要特别注意同步、锁的使用。由于多个线程不易管理,实际使用时一般用 线程池 进行处理。后面讲对线程池原理进行记录。

参考资料

线程的状态控制

©著作权归作者所有,转载或内容合作请联系作者
【社区内容提示】社区部分内容疑似由AI辅助生成,浏览时请结合常识与多方信息审慎甄别。
平台声明:文章内容(如有图片或视频亦包括在内)由作者上传并发布,文章内容仅代表作者本人观点,简书系信息发布平台,仅提供信息存储服务。

相关阅读更多精彩内容

友情链接更多精彩内容