Java线程阻塞状态

原创 于 2025-10-22 20:37:19 发布 · 690 阅读 · 11 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测

1 概述

Java线程提供了六种状态，其中三种是阻塞状态，用例子来了解一下这些阻塞状态，方便使用堆栈信息里的线程状态来协助定位问题。

2 线程的状态和转换

2.1 六种状态

JDK提供的线程支持六种状态，可以通过java.lang.Thread.State类定义来了解。
  • NEW：新建的线程，但还没有运行。这个在堆栈中不体现。
  • RUNNABLE：运行中的线程。
  • BLOCK/WAITING/TIMED_WAITING：阻塞的线程。
  • TERMINATED：运行结束的线程。
// java.lang.Thread.State
public enum State {
    NEW,
    RUNNABLE,
    BLOCKED,
    WAITING,
    TIMED_WAITING,
    TERMINATED;
}

2.2 synchronized阻塞的线程

下面例子使用synchronized关键字来提供锁，观察没有拿到锁的线程状态。

public class TestTask1 extends Thread {
    private final Object lock;
    private final String taskName;
    public TestTask1(String taskName, Object lock) {
        this.lock = lock;
        this.taskName = taskName;
        setName(taskName);
    }
    @Override
    public void run() {
        synchronized (lock) {
            System.out.println("Running in " + taskName);
            try {
                Thread.sleep(100000); // 使用sleep()
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

public class ThreadStatusDemo1 {
    public static void main(String[] args) {
        ThreadStatusDemo1 demo = new ThreadStatusDemo1();
        demo.test();
    }

    private void test() {
        Object lock = new Object();
        TestTask1 t1 = new TestTask1("my-test-1", lock);
        TestTask1 t2 = new TestTask1("my-test-2", lock);
        t1.start();
        t2.start();
        try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

打印堆栈信息：

"main" #1 prio=5 os_prio=0 tid=0x0000000002e84800 nid=0x7b80 in Object.wait() [0x0000000002caf000]
   java.lang.Thread.State: WAITING (on object monitor)
    at java.lang.Object.wait(Native Method)
    - waiting on <0x0000000718f992b0> (a com.qqian.stepfmk.srvpro.tstatus.TestTask)
    at java.lang.Thread.join(Thread.java:1245)
    - locked <0x0000000718f992b0> (a com.qqian.stepfmk.srvpro.tstatus.TestTask)
    at java.lang.Thread.join(Thread.java:1319)
    at com.qqian.stepfmk.srvpro.tstatus.ThreadStatusDemo.test(ThreadStatusDemo.java:16)
    at com.qqian.stepfmk.srvpro.tstatus.ThreadStatusDemo.main(ThreadStatusDemo.java:6)
   Locked ownable synchronizers:
       - None

"my-test-1" #20 prio=5 os_prio=0 tid=0x000000002aea7000 nid=0x6918 waiting on condition [0x000000002c30e000]
   java.lang.Thread.State: TIMED_WAITING (sleeping)
    at java.lang.Thread.sleep(Native Method)
    at com.qqian.stepfmk.srvpro.tstatus.TestTask.run(TestTask.java:16)
    - locked <0x0000000718f95d80> (a java.lang.Object)
   Locked ownable synchronizers:
       - None
 
 "my-test-2" #21 prio=5 os_prio=0 tid=0x000000002aeaa000 nid=0x85c4 waiting for monitor entry [0x000000002c40f000]
   java.lang.Thread.State: BLOCKED (on object monitor)
    at com.qqian.stepfmk.srvpro.tstatus.TestTask.run(TestTask.java:14)
    - waiting to lock <0x0000000718f95d80> (a java.lang.Object)
   Locked ownable synchronizers:
       - None
从堆栈信息可以看出（线程1抢到锁）：
  • 用synchronized阻塞的线程（没有拿到锁），状态为BLOCKED。
  • 线程1抢到锁，里面用了Thread.sleep(timeout)，状态为TIMED_WAITING。
  • main线程用了Thread.join()，不带参数，状态为WAITING。

2.3 Ojbect.wait()阻塞

还是使用synchronized加锁，但在代码块里用了Object.wait()方法来等待。

public class TestTask3 extends Thread {
    private final Object lock;
    private final String taskName;
    public TestTask3(String taskName, Object lock) {
        this.lock = lock;
        this.taskName = taskName;
        setName(taskName);
    }
    @Override
    public void run() {
        synchronized (lock) {
            System.out.println("Running in " + taskName);
            try {
                lock.wait(); // 使用wait()等待
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

public class ThreadStatusDemo3 {
    public static void main(String[] args) {
        ThreadStatusDemo3 demo = new ThreadStatusDemo3();
        demo.test();
    }

    private void test() {
        Object lock = new Object();
        TestTask3 t1 = new TestTask3("my-test-1", lock);
        TestTask3 t2 = new TestTask3("my-test-2", lock);
        t1.start();
        t2.start();
        try {
            t1.join(10000000);
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

打印堆栈信息：

"main" #1 prio=5 os_prio=0 tid=0x0000000002d35000 nid=0x8444 in Object.wait() [0x0000000002b4f000]
   java.lang.Thread.State: TIMED_WAITING (on object monitor)
    at java.lang.Object.wait(Native Method)
    - waiting on <0x00000007194ae888> (a com.qqian.stepfmk.srvpro.tstatus.TestTask3)
    at java.lang.Thread.join(Thread.java:1253)
    - locked <0x00000007194ae888> (a com.qqian.stepfmk.srvpro.tstatus.TestTask3)
    at com.qqian.stepfmk.srvpro.tstatus.ThreadStatusDemo3.test(ThreadStatusDemo3.java:16)
    at com.qqian.stepfmk.srvpro.tstatus.ThreadStatusDemo3.main(ThreadStatusDemo3.java:6)
   Locked ownable synchronizers:
       - None
 
"my-test-1" #23 prio=5 os_prio=0 tid=0x000000002bb9f800 nid=0x5c10 in Object.wait() [0x000000002c42e000]
   java.lang.Thread.State: WAITING (on object monitor)
    at java.lang.Object.wait(Native Method)
    - waiting on <0x00000007194aad28> (a java.lang.Object)
    at java.lang.Object.wait(Object.java:502)
    at com.qqian.stepfmk.srvpro.tstatus.TestTask3.run(TestTask3.java:16)
    - locked <0x00000007194aad28> (a java.lang.Object)
   Locked ownable synchronizers:
       - None
 
 "my-test-2" #24 prio=5 os_prio=0 tid=0x000000002bba0000 nid=0x50d0 in Object.wait() [0x000000002c52e000]
   java.lang.Thread.State: WAITING (on object monitor)
    at java.lang.Object.wait(Native Method)
    - waiting on <0x00000007194aad28> (a java.lang.Object)
    at java.lang.Object.wait(Object.java:502)
    at com.qqian.stepfmk.srvpro.tstatus.TestTask3.run(TestTask3.java:16)
    - locked <0x00000007194aad28> (a java.lang.Object)
   Locked ownable synchronizers:
       - None
从上面堆栈可以看出：
  • Object.wait()会释放锁，所以两个线程都阻塞在了wait()处，线程状态都为WAITING。
  • Thread.join(timeout)带参数时，线程状态为TIMED_WAITING。

2.4 Object.wait(timeout)阻塞

还是使用synchronized加锁，在代码块里用了Object.wait(timeout)方法来等待，增加了timeout参数。

public class TestTask3 extends Thread {
    private final Object lock;
    private final String taskName;
    public TestTask3(String taskName, Object lock) {
        this.lock = lock;
        this.taskName = taskName;
        setName(taskName);
    }
    @Override
    public void run() {
        synchronized (lock) {
            System.out.println("Running in " + taskName);
            try {
                lock.wait(100000); // 增加timeout参数
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

public class ThreadStatusDemo3 {
    public static void main(String[] args) {
        ThreadStatusDemo3 demo = new ThreadStatusDemo3();
        demo.test();
    }

    private void test() {
        Object lock = new Object();
        TestTask3 t1 = new TestTask3("my-test-1", lock);
        TestTask3 t2 = new TestTask3("my-test-2", lock);
        t1.start();
        t2.start();
        try {
            t1.join(10000000);
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

打印堆栈信息：

"main" #1 prio=5 os_prio=0 tid=0x00000000039c4800 nid=0x7f5c in Object.wait() [0x00000000037df000]
   java.lang.Thread.State: TIMED_WAITING (on object monitor)
    at java.lang.Object.wait(Native Method)
    - waiting on <0x0000000718f992d0> (a com.qqian.stepfmk.srvpro.tstatus.TestTask3)
    at java.lang.Thread.join(Thread.java:1253)
    - locked <0x0000000718f992d0> (a com.qqian.stepfmk.srvpro.tstatus.TestTask3)
    at com.qqian.stepfmk.srvpro.tstatus.ThreadStatusDemo3.test(ThreadStatusDemo3.java:16)
    at com.qqian.stepfmk.srvpro.tstatus.ThreadStatusDemo3.main(ThreadStatusDemo3.java:6)
   Locked ownable synchronizers:
       - None
 
 "my-test-1" #20 prio=5 os_prio=0 tid=0x000000002b9a3000 nid=0x24cc in Object.wait() [0x000000002ce5f000]
   java.lang.Thread.State: TIMED_WAITING (on object monitor)
    at java.lang.Object.wait(Native Method)
    - waiting on <0x0000000718f95d80> (a java.lang.Object)
    at com.qqian.stepfmk.srvpro.tstatus.TestTask3.run(TestTask3.java:16)
    - locked <0x0000000718f95d80> (a java.lang.Object)
   Locked ownable synchronizers:
       - None
 
 "my-test-2" #21 prio=5 os_prio=0 tid=0x000000002b9a4000 nid=0x3b0c in Object.wait() [0x000000002cf5f000]
   java.lang.Thread.State: TIMED_WAITING (on object monitor)
    at java.lang.Object.wait(Native Method)
    - waiting on <0x0000000718f95d80> (a java.lang.Object)
    at com.qqian.stepfmk.srvpro.tstatus.TestTask3.run(TestTask3.java:16)
    - locked <0x0000000718f95d80> (a java.lang.Object)
   Locked ownable synchronizers:
       - None
从上面可以看出：
  • Object.wait(timeout)会释放锁，所以两个线程都阻塞在了wait()处，线程状态都为TIMED_WAITING。

2.5 ReentrantLock.lock()阻塞

把锁换成ReentrantLock，不使用timeout参数：
import java.util.concurrent.locks.ReentrantLock;

public class TestTask2 extends Thread {
    private final ReentrantLock lock;
    private final String taskName;
    public TestTask2(String taskName, ReentrantLock lock) {
        this.lock = lock;
        this.taskName = taskName;
        setName(taskName);
    }
    @Override
    public void run() {
        try {
            lock.lock(); // 改为用ReentrantLock锁，不带timeout参数
            System.out.println("Running in " + taskName);
            try {
                Thread.sleep(100000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        } finally {
            lock.unlock();
        }
    }
}

public class ThreadStatusDemo2 {
    public static void main(String[] args) {
        ThreadStatusDemo2 demo = new ThreadStatusDemo2();
        demo.test();
    }

    private void test() {
        ReentrantLock lock = new ReentrantLock();
        TestTask2 t1 = new TestTask2("my-test-1", lock);
        TestTask2 t2 = new TestTask2("my-test-2", lock);
        t1.start();
        t2.start();
        try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

打印堆栈信息：

"main" #1 prio=5 os_prio=0 tid=0x0000000003134800 nid=0x66dc in Object.wait() [0x0000000002edf000]
   java.lang.Thread.State: WAITING (on object monitor)
    at java.lang.Object.wait(Native Method)
    - waiting on <0x0000000718f9f390> (a com.qqian.stepfmk.srvpro.tstatus.TestTask2)
    at java.lang.Thread.join(Thread.java:1245)
    - locked <0x0000000718f9f390> (a com.qqian.stepfmk.srvpro.tstatus.TestTask2)
    at java.lang.Thread.join(Thread.java:1319)
    at com.qqian.stepfmk.srvpro.tstatus.ThreadStatusDemo2.test(ThreadStatusDemo2.java:18)
    at com.qqian.stepfmk.srvpro.tstatus.ThreadStatusDemo2.main(ThreadStatusDemo2.java:8)

   Locked ownable synchronizers:
       - None
 
"my-test-1" #20 prio=5 os_prio=0 tid=0x000000002af7b800 nid=0x6e78 waiting on condition [0x000000002c50f000]
   java.lang.Thread.State: TIMED_WAITING (sleeping)
    at java.lang.Thread.sleep(Native Method)
    at com.qqian.stepfmk.srvpro.tstatus.TestTask2.run(TestTask2.java:19)
   Locked ownable synchronizers:
       - <0x0000000718f9bd80> (a java.util.concurrent.locks.ReentrantLock$NonfairSync)
 
 "my-test-2" #21 prio=5 os_prio=0 tid=0x000000002af7c000 nid=0x88c4 waiting on condition [0x000000002c60e000]
   java.lang.Thread.State: WAITING (parking)
    at sun.misc.Unsafe.park(Native Method)
    - parking to wait for  <0x0000000718f9bd80> (a java.util.concurrent.locks.ReentrantLock$NonfairSync)
    at java.util.concurrent.locks.LockSupport.park(LockSupport.java:175)
    at java.util.concurrent.locks.AbstractQueuedSynchronizer.parkAndCheckInterrupt(AbstractQueuedSynchronizer.java:836)
    at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireQueued(AbstractQueuedSynchronizer.java:870)
    at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquire(AbstractQueuedSynchronizer.java:1199)
    at java.util.concurrent.locks.ReentrantLock$NonfairSync.lock(ReentrantLock.java:209)
    at java.util.concurrent.locks.ReentrantLock.lock(ReentrantLock.java:285)
    at com.qqian.stepfmk.srvpro.tstatus.TestTask2.run(TestTask2.java:16)
   Locked ownable synchronizers:
       - None
从上面可以看出：
  • ReentrantLock.lock()最终调的是sun.misc.Unsafe.park()来阻塞，线程状态为WAITING，并不是BLOCKED。

2.6 ReentrantLock.tryLock(timeout)阻塞

把锁换成ReentrantLock，使用timeout参数：
import java.util.concurrent.locks.ReentrantLock;

public class TestTask2 extends Thread {
    private final ReentrantLock lock;
    private final String taskName;
    public TestTask2(String taskName, ReentrantLock lock) {
        this.lock = lock;
        this.taskName = taskName;
        setName(taskName);
    }
    @Override
    public void run() {
        try {
            lock.tryLock(100000, TimeUnit.MILLISECONDS); // 改为带timeout参数
            System.out.println("Running in " + taskName);
            try {
                Thread.sleep(100000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        } finally {
            lock.unlock();
        }
    }
}

public class ThreadStatusDemo2 {
    public static void main(String[] args) {
        ThreadStatusDemo2 demo = new ThreadStatusDemo2();
        demo.test();
    }

    private void test() {
        ReentrantLock lock = new ReentrantLock();
        TestTask2 t1 = new TestTask2("my-test-1", lock);
        TestTask2 t2 = new TestTask2("my-test-2", lock);
        t1.start();
        t2.start();
        try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

堆栈信息：

"main" #1 prio=5 os_prio=0 tid=0x0000000003c44800 nid=0x12f0 in Object.wait() [0x000000000397f000]
   java.lang.Thread.State: WAITING (on object monitor)
    at java.lang.Object.wait(Native Method)
    - waiting on <0x0000000718f9f4e0> (a com.qqian.stepfmk.srvpro.tstatus.TestTask2)
    at java.lang.Thread.join(Thread.java:1245)
    - locked <0x0000000718f9f4e0> (a com.qqian.stepfmk.srvpro.tstatus.TestTask2)
    at java.lang.Thread.join(Thread.java:1319)
    at com.qqian.stepfmk.srvpro.tstatus.ThreadStatusDemo2.test(ThreadStatusDemo2.java:18)
    at com.qqian.stepfmk.srvpro.tstatus.ThreadStatusDemo2.main(ThreadStatusDemo2.java:8)
   Locked ownable synchronizers:
       - None

"my-test-1" #20 prio=5 os_prio=0 tid=0x000000002bb53800 nid=0x7a80 waiting on condition [0x000000002d00f000]
   java.lang.Thread.State: TIMED_WAITING (sleeping)
    at java.lang.Thread.sleep(Native Method)
    at com.qqian.stepfmk.srvpro.tstatus.TestTask2.run(TestTask2.java:20)
   Locked ownable synchronizers:
       - <0x0000000718f9b9a0> (a java.util.concurrent.locks.ReentrantLock$NonfairSync)
 
 "my-test-2" #21 prio=5 os_prio=0 tid=0x000000002bb56000 nid=0x391c waiting on condition [0x000000002d10f000]
   java.lang.Thread.State: TIMED_WAITING (parking)
    at sun.misc.Unsafe.park(Native Method)
    - parking to wait for  <0x0000000718f9b9a0> (a java.util.concurrent.locks.ReentrantLock$NonfairSync)
    at java.util.concurrent.locks.LockSupport.parkNanos(LockSupport.java:215)
    at java.util.concurrent.locks.AbstractQueuedSynchronizer.doAcquireNanos(AbstractQueuedSynchronizer.java:934)
    at java.util.concurrent.locks.AbstractQueuedSynchronizer.tryAcquireNanos(AbstractQueuedSynchronizer.java:1247)
    at java.util.concurrent.locks.ReentrantLock.tryLock(ReentrantLock.java:442)
    at com.qqian.stepfmk.srvpro.tstatus.TestTask2.run(TestTask2.java:17)
   Locked ownable synchronizers:
       - None
从上面可以看出：
  • ReentrantLock.tryLock(timeout)最终调的是sun.misc.Unsafe.park()来阻塞，线程状态为TIMED_WAITING，并不是BLOCKED。

3 小结

1、当由synchronized关键字提供的锁阻塞没有取到锁的线程时，状态为BLOCKED，其它锁阻塞的都不是BLOCKED状态。
2、锁时通过Unsafe.park()阻塞、调用Object.wait()、Thread.join()时，线程状态为WAITING。
3、锁是通过Unsafe.park(timeout)阻塞、调用Object.wait(timeout)、Thread.sleep(timeout)、Thread.join(timeout)时，线程状态为TIMED_WAITING。
标签
#java #开发语言
秋千码途
关注
Java进阶-第五篇：Java多线程 - 阻塞状态之其他阻塞
最新发布
无
04-15 216
接下来，我将详细阐述引发的阻塞以及其他阻塞情况，通过对比和示例让你更清晰地理解不同阻塞状态的原理与应用。
yolov8 PTQ和QAT量化实战(源码详解)
@bangbang的博客
01-07 5251
量化（）：是指将高精度浮点数(FP32)转换为低精度(8bit或4bit)整数的过程，它是模型部署中的一种非常重要的优化方法，可以在较少的精度损失下，大幅提供神经网络的效率和性能。目前主流的神经网络量化方式有PTQ和QATPTQ是训练后量化()，无需数据集和训练，直接量化模型权重QAT是量化感知训练()，量化后需要在数据集上继续微调训练。QAT过程中，我们首先需要选择哪些层需要进行finetune训练，并利用FP32对应层的输出作为监督进行训练。
Java线程唤醒与阻塞
hugh 的博客
03-17 1228
阻塞指的是暂停一个线程的执行以等待某个条件发生（如某资源就绪），学过操作系统的同学对它一定已经很熟悉了。Java 提供了大量方法来支持阻塞，下面让我们逐一分析。　　1. sleep() 方法：sleep() 允许 指定以毫秒为单位的一段时间作为参数，它使得线程在指定的时间 内进入阻塞状态，不能得到CPU 时间，指定的时间一过，线程重新进入可执行状态。 　　典型地，sleep() 被用在等待某个资
广东雀神麻将资源
麻将资源 麻将声音 图集
Java那些“锁”事 - 死锁及排查
大后生大大大的博客
07-29 2055
死锁是两个或者两个以上的线程在执行过程中，因争夺资源而造成的一种互斥等待现象，若没有外界干涉那么它们将无法推进下去。如果系统资源不足，进程的资源请求都得到满足，死锁出现的可能性就很低，否则就会因为争夺有限的资源而陷入死锁。
Java-线程的运行状态
火星男孩的分享空间
06-17 2641
参考： 学习java线程状态和看懂thread dump文件中的线程信息 Java线程中wait状态和block状态的区别? 1，线程状态为“waiting for monitor entry”： 意味着它 在等待进入一个临界区 ，所以它在”Entry Set“队列中等待。 此时线程状态一般都是 Blocked： java.lang.Thread.State: BLOCKED (o
并发编程之死锁
ouYang的博客
08-02 796
死锁 死锁就是两个或以上线程互相争抢对方资源，导致没有任何一个线程能获得所需所有资源的一种僵持状态。死锁下的线程是 BLOCKED 状态。 下面我们来使用Synchronized 关键字 造一个死锁。 ServiceOne类： public class ServiceOne { private ServiceTwo serviceTwo; private final Object LOCK_ONE = new Object(); public void setServiceTwo(
java线程阻塞问题排查方法
热门推荐
bruce128的专栏
08-10 4万+
我开发的worker，每隔几个月线上都会阻塞一次，一直都没查出问题。今天终于了了这个心结。把解决过程总结下和大家分享。 首先用jstack命令打出这个进程的全部线程堆栈。拿到线程dump文件之后，搜索自己的worker名字。 "DefaultQuartzScheduler_Worker-10" prio=10 tid=0x00007f55cd54d800 nid=0x3e2e wait
Java基础系列：多线程（二）阻塞状态与控制
古树清风的博客
10-09 315
Java多线程的阻塞状态与控制 上文已经提到Java阻塞的几种具体类型。下面分别看下引起Java线程阻塞的主要方法。 等待加入：join() join —— 让一个线程等待另一个线程完成才继续执行。如A线程线程执行体中调用B线程的join()方法，则A线程被阻塞，知道B线程执行完为止，A才能得以继续执行。 public class MyRunnable implements Runnable { ...
以下会使线程进入到阻塞状态的是_java多线程试题_答案
weixin_36019375的博客
02-22 2845
多线程一．选择题1.下列说法中错误的一项是(A)A.线程就是程序B.线程是一个程序的单个执行流B.多线程是指一个程序的多个执行流 D.多线程用于实现并发2.下列哪个一个操作不能使线程从等待阻塞状态进入对象阻塞状态(D)A.等待阴塞状态下的线程被notify()唤B.等待阻塞状态下的纯种被interrput()中断C.等待时间到D.等待阻塞状态下的线程调用wait()方法3.下列哪个方法可以使线程从...
以下会使线程进入到阻塞状态的是_浅析Java中的线程状态
weixin_29958569的博客
01-04 1415
一、线程的5种状态 众所周知，Java的线程状态有5种，分别对应上图中五种不同颜色，下面对这5种状态及状态间的转化做相应的解释： 1. 初始化状态：新建一个线程对象 2. 可运行状态：其他线程调用了该线程对象的start()方法。该状态的线程位于可运行线程池中，变得可运行，等待获取CPU的使用权 3. 运行状态：可运行状态的线程获得了cpu 时间片（timeslice），执行程序代码 4....
java线程的五大状态，阻塞状态详解
LifeGoesOn
08-17 1万+
一、状态简介 一个线程的生命周期里有五大状态，分别是： 新生 就绪 运行 死亡 运行后可能遇到的阻塞状态 二、相关方法 2.1 新生状态 Thread t = new Thread(); 正如我们前面所说的，一个线程开始之后有自己的内存空间，这些工作空间和主内存进行交互，从主内存拷贝数据到工作空间。 当这个语句执行的时候，线程创建，开辟工作空间，也就是线程进入了新生状态。 2.2 就绪状态 普通情况，一旦调用了： t.start(); start 方法被调用，线程立即进入了就绪状态，表示这个线程具
以下会使线程进入到阻塞状态的是_java线程的五大状态，阻塞状态详解
weixin_39769703的博客
01-04 2047
Life Goes On | 作者urlify.cn/rIfI3m | 来源一、状态简介一个线程的生命周期里有五大状态，分别是：新生就绪运行死亡运行后可能遇到的阻塞状态二、相关方法2.1 新生状态Thread t =newThread();正如我们前面所说的，一个线程开始之后有自己的内存空间，这些工作空间和主内存进行交互，从主内存拷贝数据到工作空间。当这个语句执行的时候，线程创建，开辟工作空...
Java多线程（二）Java多线程的阻塞状态与线程控制
iDark 的博客空间
08-31 1005
Thread.join() 让一个线程等待另一个线程完成才继续执行。 示例：如A线程线程执行体中调用B线程的join()方法，则A线程被阻塞，知道B线程执行完为止，A才能得以继续执行。 Thread.sleep() 让当前的正在执行的线程暂停指定的时间，并进入阻塞状态。在其睡眠的时间段内，该线程由于不是处于就绪状态，因此不会得到执行的机会。即使此时系统中没有任何其他可执行的线程，出于sle...
java线程的五大状态，阻塞状态 笔记
weixin_44416759的博客
07-09 643
状态简介 一个线程生命周期里有五大状态：新生、就绪、运行、死亡、运行后可能遇到的阻塞状态。 新生态： Thread t=new Thread();一个线程开始之后有私有的工作内存，工作内存和主内存交互，从主内存拷贝数据到工作内存。当线程创建，开辟工作内存，线程就进入了新生态； 就绪态： t.start(); start方法被调用，线程进入就绪态，这表示线程有了运行的条件，但还没开始运行。注意线程就绪还要等待CPU调度运行，一般是进入就绪队列。进入就绪状态还有３情况： 从阻塞状态解除； 运行的时候调用yie
void join()：使Java线程主动进入阻塞状态——以模拟图片的下载和加载两个过程为例
我以我心Coding You
03-19 469
package day09; /** * void join() * join方法可以使调用该方法的线程进入阻塞状态 * 直到该方法所属线程完成工作才会解除调用该方法线程的阻塞状态。 * join方法一般用于完成多个线程之间的同步工作问题。 * * 实例：模拟图片的下载和加载两个过程。 * @author kaixu * */ public class ThreadDemo9 ...
Java多线程死锁问题
MieMieFly的专栏
10-23 3178
百科的定义是: 死锁是指两个或两个以上的进程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程。 死锁的产生需要四个条件: 1）互斥条件：指进程对所分配到的资源进行排它性使用，即在一段时间内某资源只由一个进程占用。如果此时还有其它进程请求资源，则请求者只能等待，直至占有资源的进程用毕释放。 2）请求和保持条件：指进程已经保持至少一个资源，但又提出了新的资源请求，而该资.
JVM hang时，Eden区100％，所有线程包括gc线程被 blocked分析
诗剑书生的专栏
08-14 1万+
jstat -gcutil pid 1000  S0     S1     E      O      P     YGC     YGCT    FGC    FGCT     GCT     5.68  36.18 100.00   1.50  11.93     14    0.555     0    0.000    0.555  5.68  36.18 100.00   1.50  1
java 如何优雅的阻塞主线程
weixin_44927769的博客
06-06 846
一般可以直接使用下面的方法，阻塞主线程，可是这种方法不够的优雅。框架，需要阻塞主线程，防止程序退出，方便一些定时任务的执行。在某些时候，尤其是不带有容器的。
三个实例演示 Java Thread Dump 日志分析
weixin_33709219的博客
01-06 1193
jstack Dump 日志文件中的线程状态 dump 文件里，值得关注的线程状态有： 死锁，Deadlock（重点关注）  执行中，Runnable    等待资源，Waiting on condition（重点关注）  等待获取监视器，Waiting on monitor entry（重点关注） 暂停，Suspended 对象等待中，Object.wait() 或 TIMED...
线程的状态
u012068323的博客
11-12 294
在线程Thread类中，有一个枚举类State，列举了线程的六大状态 public enum State {     /**      * Thread state for a thread which has not yet started.      * 刚刚新建好的线程所处的状态      */     NEW,     /**      * Thread state f
java 中阻塞线程的方法整理
爱的叹息的专栏
03-18 1055
java 中阻塞线程的方法整理，join,wait,park+unpark,sleep
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值