Thread 状态及volatile关键字作用join方法的使用

最新推荐文章于 2024-08-25 21:01:45 发布
最新推荐文章于 2024-08-25 21:01:45 发布
阅读量299 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： java基础 文章标签： 线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq85469769/article/details/78547686
本文详细介绍了Java中线程的五种状态：NEW、RUNNABLE、BLOCKED、TIMED_WAITING和TERMINATED，解释了每种状态的含义及线程如何在这些状态之间转换。此外还探讨了volatile关键字的作用及其对线程间数据一致性的保障。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

线程状态 Thread.State
1 Thread.State BLOCKED 阻塞状态

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 Object.wait.
线程正在等待线程锁的阻塞状态，阻塞状态正在等待线程锁进入同步方法或者同步代码块，或者是调用该线程调用wait后等待重新进入同步方法。

2 Thread.State NEW

Thread state for a thread which has not yet started.
线程创建未开始状态

3 Thread.State RUNNABLE

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.

线程运行状态，正在运行状态的线程正在被java虚拟机执行，但是也可能正在等待来自操作系统的其他资源例如处理器。

4 Thread.State TERMINATED

Thread state for a terminated thread. The thread has completed execution.
线程终止状态，这个线程被执行完成。

5 Thread.State TIMED_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:
Thread.sleep // sleep(long millis) or sleep(long millis, int nanos)，The thread does not lose ownership of any monitors. 不会释放锁。
Object.wait with timeout
This method causes the current thread (call it T) to place itself in the wait set for this object and then to relinquish
any and all synchronization claims on this object.
这个方法会引起当前线程成为等待状态，并放弃这个对象上的同步的权益，就是释放了对象锁。
Thread.join with timeout
LockSupport.parkNanos
LockSupport.parkUntil
正在等待特定时间的线程状态，一个线程处在定时定时等待状态是因为调用了如下其中之一，带有明确的指定等待时间的方法

volatile 关键字的作用 保证该数据在多线程保持一致性。

如果使用volatile修饰变量，java代码编译后，运行指令会带有lock 前缀，jvm在处理这个lock信号时会引发两个操作
1 会将缓存数据写到主内存，lock前缀指令执行执行时 会锁住缓存区域，利用缓存一致性保证原子操作，并阻止多个处理器同时修改内存数据。
2 回写主内存的操作会使其他线程缓存的该内存地址的数据失效。
根据处理器的一致性协议，处理器会嗅探总线上的传播数据来检查自己缓存的数据是否是过期了，当处理器发现缓存地址失效，
会将缓存数据设置成失效，当处理这个数据时，从主内存中重新读取。
api 注释 join()方法

/*Waits at most {@code millis} milliseconds for this thread to
die. A timeout of {@code 0} means to wait forever.
*/
最多等待这个线程死亡多少毫秒，如果参数是0，则永远等待这个线程死亡
例 A线程正在运行，b线程对象join（args）
如果args == 0.则A线程一直等到B线程执行完成再执行
如果args >0 ,则A线程等待B线程执行args 毫秒时间后继续执行

【C语言】volatile 关键字详解
LuckiBit
07-03 2316
volatile关键字在系统编程和嵌入式编程中非常重要，正确使用它可以确保程序在面对异步事件和并发访问时能够正常工作。
Java 并发编程：volatile 关键字介绍与使用
栗筝i的博客
08-04 3904
volatile关键字在 Java 中用于修饰变量，使其具有可见性和有序性。可见性：在多线程环境下，当一个线程修改了volatile变量的值，新值对于其他线程是立即可见的。通常情况下，线程之间对变量的读写操作是不可见的，这意味着一个线程修改了变量的值，另一个线程可能看不到这个修改，仍然使用旧值。使用volatile关键字可以确保所有线程看到的是变量的最新值；volatile关键字还可以防止指令重排序优化。编译器和处理器通常会对指令进行重排序，以提高性能，但这种重排序可能会破坏多线程程序的正确性。
Thread -- Volatile
weixin_30515513的博客
06-14 102
1,可见性也就是说一旦某个线程修改了该被volatile修饰的变量，它会保证修改的值会立即被更新到主存，当有其他线程需要读取时，可以立即获取修改之后的值。 在Java中为了加快程序的运行效率，对一些变量的操作通常是在该线程的寄存器或是CPU缓存上进行的，之后才会同步到主存中，而加了volatile修饰符的变量则是直接读写主存。 2,Volatile特性 　　1.保证此变量对所有的线程的可见性...
java线程里关键字与关键方法
你不该把世界让给你所鄙视的人。
07-29 2637
java线程里关键字与关键方法@线程 @sleep @yield @synchronized @wait @join @notify @notifyAll @run @start @volatilejava线程里关键字与关键方法 sleep yield synchronized waitnotifynotifyAll join runstart volatile sleep()-Thread.sle
多线程之volatile方法(3)
qq_27581753的博客
05-20 148
1.只通知一个线程 调用方法notify()一次只随机通知一个线程进行唤醒。 示例代码如下： package volatileTest; /** * @Author LiBinquan */ public class Service { public void testMethod(Object lock){ try{ synchronized (lock){ System.out.println("begin wait
Thread之volatile
xiewz1112的博客
09-07 484
volatile volatile：一致性 static：唯一性 final：持续性 volatile与Runnable 在class implements Runnable时，如果在class中定义了volatile变量，为使该变量能够在多线程下被所有线程读写，即保证变量的唯一性，需要加上static。 如下例，在SafeShutdownThread中，thread2中修改线程t...
深入分析Volatile的实现原理
weixin_33748818的博客
08-28 104
2019独角兽企业重金招聘Python工程师标准>>> ...
什么是 C 语言中的 volatile 关键字？
2401_86074221的博客
07-10 2016
volatile关键字在 C 语言中是一个重要的工具，用于处理那些可能被意外修改或者与硬件、中断、多线程等特殊情况相关的变量。正确使用volatile可以避免由于编译器优化而导致的错误，但也要注意它的局限性，不能将其视为解决多线程同步问题的万能钥匙。在复杂的多线程和并发环境中，还需要结合其他同步机制来确保程序的正确性和稳定性。理解volatile的工作原理和适用场景对于编写可靠的 C 语言程序，特别是在与底层硬件交互和多线程编程方面，是非常重要的。🎉相关推荐📙C 语言百万年薪修炼课程。
volatile关键字实现原理【源码解析】
wang_luwei的博客
08-25 1808
volatile关键字实现原理【源码解析】
volatile关键字详解
q495673918的博客
03-29 420
目录 1.干什么用的 2.可见性 3.禁止指令重排序 1.干什么用的 volatile在英文当中的解释表示“易变的”，在java中我们可以简单理解“这个东西很容易变，所以你要多关注他(直接从main memory去读)” 一旦类中的成员变量，不管是静态变量还是非静态变量被volatile修饰之后，那么就具备了2重含义，一般也就用到可见性，禁止指令重排很少用 保证了不同线程对这个变量操作时的可见性，也就是一个线程修改了这个变量之后，其他线程是可以立即知道这个新值的 禁止指令重排序 需要
Thread--volatile详细
weixin_30924087的博客
02-04 125
转载于:https://www.cnblogs.com/microcat/p/6364039.html
Java基础-Thread-volatile
小安灬的博客
06-28 285
volatile 关键字的两层语义 1）可见性 **ps:volatile不能保证原子性** 简单地说就是当线程A对变量X进行了修改后，在线程A后面执行的其他线程能看到变量X的变动，更详细地说是要符合以下两个规则： - 线程对变量进行修改之后，要立刻回写到主内存。 - 线程对变量读取的时候，要从主内存中读，而不是缓存。 2）禁止进行指令重排序 [**这个有人测出并不能完全保证禁止指令重排序*...
多线程笔记（一）关键字volatile、join、synchronized、Lock、Thread和Runnable
qq_34749144的博客
12-17 254
1. 关于volatile关键字 http://www.cnblogs.com/dolphin0520/p/3920373.html 2. 关于join的基础知识 join()方法的作用是等待线程对象销毁。 join()方法具有能使线程排队运行的作用，有点类似于同步的效果。 join与synchronize的区别： join在内部使用wait()方法进行等待，底层用wait()来实现。 ...
volatile
g_l_xz的博客
09-26 404
还记得之前面某大公司回答volatile当时说的多么的垃圾，幸好当时离秋招还早。。。所以种一棵树最好的时机是十年前，其次是现在 ♡♡♡ volatile：是java虚拟机提供的轻量级的同步机制 三大特性： 1：保证可见性【某一个线程修改数据并写回主物理线程，另外的线程要立刻知道(机制)称为它的可见性】 2：不保证原子性【number++在多线程下是非安全的】 3：禁止指令重排 如何解决原子性...
Thread之volatile关键字
会者定离，一期一祈
02-07 855
当一个共享变量被volatile修饰时，它会保证修改的值立即被更新到主存“， 这里的”保证“ 是如何做到的?和 JIT的具体编译后的CPU指令相关吧? volatile特性 内存可见性：通俗来说就是，线程A对一个volatile变量的修改，对于其它线程来说是可见的，即线程每次获取volatile变量的值都是最新的。 volatile的使用场景 通过关键字sychronize可以防止多个线程进入同一段代码，在某些特定场景中，volatile相当于一个轻量级的sychronize，因为不会引起线程的上下文切换，
java thread volatile 理解
移动生活，幸福代码
12-18 1523
     Java Thread有一个 volatile关键字，主要用来防止多线程访问公共变量，不能及时被其它线程正确访问, 而造成的不同步问题。    比如ThreadA 和ThreadB 同时访问一个 int a = 0;  并且修改，   可能会造成 ThreadA 修改a变量后，ThreadB访问a变量还是原来的值。   因此要加上  volatile int a =
线程的volatile关键字详解
weixin_41979002的博客
04-19 632
系列文章目录 文章目录系列文章目录简述解决死循环示例分析不能保证原子性 简述 关键字 volatile 的主要作用是使变量在多个线程间可见 解决死循环 示例 class ThreadTest7 implements Runnable{ private boolean isRunnning = true; @Override public void run() { System.out.println("Thread begin: "+Thread.curr
java并发(三)——wait()、notify()、notifyAll()、join()
hxyascx的博客
09-17 428
锁池和等待池 wait() ,notifyAll(),notify() 三个方法都是Object类中的方法。学习他们之前先要了解俩个概念。java中，每个对象都有两个池，锁(monitor)池和等待池。 锁池：假设线程A已经拥有了某个对象(注意:不是类)的锁，而其它的线程想要调用这个对象的某个synchronized方法(或者synchronized块)，由于这些线程在进入对象的syn...
Java Thread多线程volatile问题
jamesluozhiwei的博客
06-18 319
问题 当多个线程并发同时进行set、get时，其它线程能否感知到flag的变化 public class ThreadSafeCache { boolean flag = true;//默认设置true public boolean isFlag() { return flag; } public synchronized ThreadSafe...
Java 中的 volatile 关键字使用案例
最新发布
08-10
<think>在Java中，`volatile`关键字用于确保变量的可见性和有序性，但不保证原子性。它告诉编译器和运行时环境，该变量可能被多个线程同时访问，因此每次读取都应该从主内存中获取，而不是从线程的本地缓存（如CPU缓存）中读取；每次写入都应该立即刷新到主内存中。这样可以避免一个线程修改了变量值而另一个线程看不到的情况。 然而，需要注意的是，`volatile`并不能保证复合操作（如自增操作）的原子性。对于原子性操作，我们通常使用`java.util.concurrent.atomic`包中的原子类，或者使用`synchronized`关键字。 下面是一个使用`volatile`关键字的经典案例：使用一个标志位来控制线程的终止。 ### 案例：使用volatile作为终止线程的标志 ```java public class VolatileExample { // 使用volatile关键字修饰标志位 private volatile boolean running = true; public void stop() { running = false; } public void run() { while (running) { // 执行任务 System.out.println("Thread is running..."); try { Thread.sleep(1000); } catch (InterruptedException e) { Thread.currentThread().interrupt(); System.out.println("Thread was interrupted"); } } System.out.println("Thread stopped."); } public static void main(String[] args) throws InterruptedException { VolatileExample example = new VolatileExample(); Thread thread = new Thread(example::run); thread.start(); // 主线程休眠3秒后，停止子线程 Thread.sleep(3000); example.stop(); // 等待子线程结束 thread.join(); } } ``` ### 代码解释： 1. **`volatile`变量**：`running`被声明为`volatile`，确保当主线程调用`stop()`方法将`running`设置为`false`时，子线程能立即看到这个变化，从而跳出循环，终止线程。 2. **如果没有`volatile`**：如果没有`volatile`，子线程可能因为缓存的原因，一直看不到`running`变为`false`，导致循环无法终止。 3. **线程启动与停止**：在`main`方法中，启动子线程后，主线程休眠3秒，然后调用`stop()`方法将`running`置为`false`，并等待子线程结束（`thread.join()`）。 ### 注意事项： - 这个例子中，`volatile`保证了可见性，使得对`running`的修改对所有线程立即可见。 - 但是，如果多个线程同时修改`running`（这个例子中只有一个修改线程，所以安全），并且`running`是`boolean`类型（赋值是原子操作），那么使用`volatile`是安全的。如果变量是`long`或`double`等64位变量，在32位JVM上，非`volatile`的64位操作可能被拆分为两个32位操作，从而需要`volatile`来保证原子性（但Java中对于64位的`long`和`double`，即使没有`volatile`，在大多数现代JVM上也是原子操作，但规范允许拆分为两个32位操作，所以为了可移植性，最好加上`volatile`）。 ### 另一个案例：单例模式的双重检查锁（DCL） `volatile`在双重检查锁定（Double-Checked Locking）中也是必要的，用于防止指令重排序导致的问题。 ```java public class Singleton { private static volatile Singleton instance; private Singleton() {} public static Singleton getInstance() { if (instance == null) { // 第一次检查 synchronized (Singleton.class) { if (instance == null) { // 第二次检查 instance = new Singleton(); } } } return instance; } } ``` ### 解释： - 如果没有`volatile`，在`instance = new Singleton();`这行代码中，由于指令重排序，可能会先分配内存空间，然后将引用赋值给`instance`，最后再初始化对象。这样，另一个线程可能在对象还没有完全初始化时就访问它，导致问题。 - `volatile`关键字禁止了指令重排序，保证了对象的初始化在赋值操作之前完成。 ### 总结： `volatile`关键字适用于： 1. 状态标志（如上面的终止标志）。 2. 双重检查锁定（DCL）的单例模式。 3. 其他需要可见性保证的场景，但注意不能保证原子性（如自增操作）。 ### 相关问题： 1. 什么时候使用volatile？ 2. volatile和synchronized有什么区别？ 3. 为什么双重检查锁定中需要volatile？ 4. volatile能保证原子性吗？如果不能，如何保证原子性？</think>### Java 中 `volatile` 关键字的使用案例 `volatile` 关键字在 Java 中用于解决多线程环境下的 **可见性问题** 和 **禁止指令重排序**。它确保： 1. **可见性**：当线程修改 `volatile` 变量时，新值立即对其他线程可见 2. **有序性**：禁止 JVM 对 `volatile` 变量的读写操作进行重排序优化 #### 经典案例：状态标志位 以下是一个使用 `volatile` 作为线程终止标志的示例： ```java public class VolatileExample { // volatile 确保 running 的修改对所有线程立即可见 private volatile boolean running = true; public void start() { new Thread(() -> { while (running) { // 循环检查 volatile 变量 System.out.println("Thread is running..."); try { Thread.sleep(500); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } } System.out.println("Thread stopped."); }).start(); } public void stop() { running = false; // 修改 volatile 变量 } public static void main(String[] args) throws InterruptedException { VolatileExample example = new VolatileExample(); example.start(); // 启动线程 Thread.sleep(2000); // 主线程等待2秒 example.stop(); // 终止子线程 } } ``` #### 代码解释： 1. **`volatile boolean running`**： - 确保主线程调用 `stop()` 修改 `running=false` 后，子线程能**立即看到**这个变化 - 若无 `volatile`，子线程可能因 JVM 优化而永远看不到 `running` 的变化 2. **工作线程**： - 通过 `while(running)` 循环检查标志位 - 收到停止信号后立即退出循环 3. **主线程流程**： - 启动工作线程后休眠 2 秒 - 调用 `stop()` 修改 `volatile` 变量 - 工作线程检测到变化后自动终止 #### 执行结果： ``` Thread is running... Thread is running... Thread is running... Thread is running... Thread stopped. // 约2秒后停止 ``` #### 使用注意事项： 1. **不保证原子性**： ```java volatile int count = 0; count++; // 这不是原子操作！需要 synchronized 或 AtomicInteger ``` 2. **适用场景**： - 状态标志（如示例） - 一次性安全发布（如双重检查锁单例模式） - 独立观察（定期更新状态值） 3. **双重检查锁单例模式中的 volatile**： ```java public class Singleton { private static volatile Singleton instance; public static Singleton getInstance() { if (instance == null) { // 第一次检查 synchronized (Singleton.class) { if (instance == null) { // 第二次检查 instance = new Singleton(); // volatile 防止指令重排序 } } } return instance; } } ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值