您的位置 首页 java

Java线程生命周期和锁的简单使用

分享个个人技术公众号,回复 Java 领取一整套进阶技术资料

本文介绍了java线程的生命周期, synchronized 的几个方法简单的使用。

线程 生命周期

  • 初始状态(New)
  • New Thread之后,
  • 就绪状态(Ready)
  • 表示获取到了Cpu的执行时间片,也就是cpu的执行权,等待开始执行。
  • 运行状态(Runable)
  • 执行start之后,开始运行。
  • 阻塞状态(Blocked)
  • 在进入synchronized的临界区或者Lock的临界区,等待获取监视器(monitor)锁,线程会进入同步队列(SynchronizedQueue)中。
  • 等待状态:(Waiting)
  • 在执行await(),wait(),jion(), lock Support.park()方法进入等待状态;
  • 等待超时状态
  • 在执行Object.await(time), Object.wait(time), Object.sellp(time), LockSupport.parkUntil,lockSupport.parkNanos 进入等待超时状态。
  • 终止状态
  • 线程执行完毕或者执行了Thread.interrupt() / Thread.stop(),不建议使用的Thread.stop() 因为 Thread.stop是直接 强行 结束, 不会释放资源

锁的几个简单方法

  • wait 和 notify/notifyAll
  • 解释
  • wait: 将线程状态置位 ‘等待状态’ ,进入等待队列等待。 notify/notifyAll: notify是随机唤醒一个线程进入 ‘同步队列’ ,notifyAll是唤醒全部被监视器锁wait的线程进入 ‘同步队列’,等待获取监视器锁后继续执行。
  • **提示:**wait,notify/notifyAll都需要在获取到监视器所(monitor)后才可以进行操作。
  • 代码
public class WaitAndNotifyTest {
 private static Object obj = new Object();
 public static void main(String[] args) {
 // 创建线程 thread1
 Thread thread1 = new Thread(new Runnable() {
 @ Override 
 public void run() {
 try {
 System.out.println(Thread.currentThread().getName() + " begin wait...");
 synchronized (obj) {
 obj.wait();
 }
 System.out.println(Thread.currentThread().getName() + " end wait...");
 } catch (Exception e) {
 e.printStackTrace();
 }
 }
 }, "thread1");
 // 创建线程 thread2
 Thread thread2 = new Thread(new Runnable() {
 @Override
 public void run() {
 try {
 System.out.println(Thread.currentThread().getName() + " begin wait...");
 synchronized (obj) {
 obj.wait();
 }
 System.out.println(Thread.currentThread().getName() + " end wait...");
 } catch (Exception e) {
 e.printStackTrace();
 }
 }
 }, "thread2");
 // 启动
 thread1.start();
 thread2.start();
 try {
 // 睡眠一秒
 Thread. sleep (1000L);
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 // 下面我们加上 obj.notify() 就会先输出 begin wait 然后sellp 10秒,执行obj.notify() 唤醒 thread1 线程 , 输出end wait
 // obj 上可能会存在wait 多个线程, notify唤醒是随机的,不一定能唤醒哪一个线程
 // 如果调用 notify 的线程未获取 对象锁,在调用 notify 的时候会抛出 java.lang.IllegalMonitorStateException 异常
 synchronized (obj) {
 // 唤醒 使用呢 obj 调用 wait 方法的其中一个线程 (随机)
 obj.notify();
 // 唤醒 使用呢 obj 调用 wait 方法的所有线程
 obj.notifyAll();
 }
 }
}

执行结果:
thread2 begin wait...
thread1 begin wait...
thread1 end wait...
thread2 end wait...
 
  • await,signal/signalAll
  • 解释
  • await,signal/signalAll方法是Lock Condition的方法,语义和Object的wait,notify/notifyAll是完全相同的。
  • 代码
/**
 * @Auther: lantao
 * @Date: 2019-04-15 14:49
 * @ Company :
 * @maill:
 * @Description: Condition 条件 有 singal signalAll 和 await 方法 和Object 的 notify notifyAll 和 wait 是一个意思同样会释放锁 执行singal和notify的时候也需要在等待获取锁
 */ public class LockCondition {
 public static ReentrantLock lock = new ReentrantLock();
 public static Condition a = lock.newCondition();
 public static void main(String[] args) throws InterruptedException {
 Runnable runnable = () -> {
 try {
 lock.lock();
 System.out.println(Thread.currentThread().getName());
 System.out.println("1");
 a.await();
 System.out.println(Thread.currentThread().getName() + "被唤醒了");
 } catch (InterruptedException e) {
 e.printStackTrace();
 }finally {
 lock.unlock();
 }
 };
 Runnable runnable1 = () -> {
 try {
 lock.lock();
 System.out.println("线程" +Thread.currentThread().getName() + "开始执行sinal");
 a.signalAll();
 } catch (Exception e) {
 e.printStackTrace();
 }finally {
 lock.unlock();
 }
 };
 new Thread(runnable,"Thread1").start();
 new Thread(runnable,"Thread2").start();
 Thread.sleep(100);
 new Thread(runnable1,"Thread3").start();
 }
 }

执行结果:
Thread1
Thread2
线程Thread3开始执行sinal
Thread1被唤醒了
Thread2被唤醒了
复制代码
 
  • Join 和 Join(time)
  • 解释
  • 等待 调用Join的线程 执行完成后 再继续执行 ,或者 等待时间超过了超时时间继续执行
  • 代码
/**
 * @Auther: lantao
 * @Date:
 * @Company:
 * @maill:
 * @Description: Join 核心是等待指定线程运行完后再继续运行 Join(time) 就是等待线程执行的一个超时时间 超过了就继续执行了
 */ public class JoinTest {
 public static void main(String[] args) throws InterruptedException {
 Thread thread1 = new Thread(new Runnable() {
 @Override
 public void run() {
 System.out.println("1");
 try {
 Thread.sleep(2000L);
 System.out.println("正常完成");
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 System.out.println("2");
 }
 });
 thread1.start();
 // 执行 jion 等待线程 thread1 执行完后再继续执行
 thread1.join();
// thread1.join(1000);
 // 这样最终执行的顺序是 1 2 3 如果不增加 thread1.join() 结果可能是 312 也可能是 132
 // Join 核心是等待指定线程运行完后再继续运行
 System.out.println("3");
 }
 }

执行结果:
1
正常完成
2
3

 
  • yield
  • 解释
  • yeid 方法的核心是 让出 cpu 时间片 ,也就是 cpu执行权 ,线程会直接进入 就绪状态 ,线程调度器会从线程就绪队列里获取一个线程优先级最高的线程来执行,当然也有可能直接会去到刚刚让出cpu执行权的线程,继续执行yield 后续的代码。
  • 代码
/**
 * @Auther: lantao
 * @Date: 2019-03-25 17:20
 * @Company:
 * @maill:
 * @Description:
 */ public class YieldTest {
 private static Object obj = new Object();
 public static void main(String[] args) {
 Thread thread1 = new Thread(new Runnable() {
 @Override
 public void run() {
 for (int i = 0; i <= 5; i++) {
 if (0 / 5 == i) {
 System.out.println(Thread.currentThread().getName() + " 开始执行 yield ");
 Thread.yield();
 System.out.println("trhead1");
 }
 }
 }
 }, "thread1");
 Thread thread2 = new Thread(new Runnable() {
 @Override
 public void run() {
 for (int i = 0; i <= 5; i++) {
 if (0 / 5 == i) {
 System.out.println(Thread.currentThread().getName() + " 开始执行 yield ");
 Thread.yield();
 System.out.println("trhead2");
 }
 }
 }
 }, "thread2");
 Thread thread3 = new Thread(new Runnable() {
 @Override
 public void run() {
 for (int i = 0; i <= 5; i++) {
 if (0 / 5 == i) {
 System.out.println(Thread.currentThread().getName() + " 开始执行 yield ");
 Thread.yield();
 System.out.println("trhead3");
 }
 }
 }
 }, "thread3");
 // 执行三个线程, 正常当运行到yield 是 就会让出cpu执行权,线程到 就绪状态,线程调度器会从 线程就绪队列里获取一个线程优先级最高的线程来执行,
 // 当然也有可能直接会去到刚刚让出cpu的线程,继续执行yield 后续的代码
 thread1.start();
 thread3.start();
 thread2.start();
 }
 }

执行结果:
thread1 开始执行 yield
thread2 开始执行 yield
thread3 开始执行 yield
 trhead2
trhead1
trhead3
 
  • interrupt 和 stop
  • 解释
  • interrupt和stop都代表中断线程,区别是 interrupt 会释放资源而stop不会,interrupt也不会立马就中断;说道interrupt就得说一下isInterrupted方法,他是判断线程中断标志的,如果线程A执行了线程B的interrupt方法,线程B在自己的线程中也可以使用 isInterrupted 方法判断自己的中断标志。 注意:在使用 interrupt方法时,如果线程在sleep wait wait(time)状态, 抛出InterruptedException异常后会清除 isInterrupted 方法获取的中断标志位,反之则不会
  • 代码
/**
 * @Auther: lantao
 * @Date: 2019-04-17 17:18
 * @Company:
 * @maill:
 * @Description: 在使用 interrupt方法是,如果线程咋sleep wait wait(time) 在抛出InterruptedException异常后会 清除 isInterrupted 方法获取的标志位 其他则不会
 */ public class InterruptTest {
 public static void main(String[] args) throws InterruptedException {
 Thread thread1 = new Thread(() -> {
 while (true) {}
 }, "循环线程");
 Thread thread2 = new Thread(() -> {
 while (true) {
 try {
 Thread.sleep(200);
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 }
 }, "睡眠线程");
 Thread thread3 = new Thread(() -> {
 Object o = new Object();
 while (true) {
 synchronized (o){
 try {
 o.wait();
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 }
 }
 }, "等待线程");
 thread1.start();
 thread2.start();
 thread3.start();
 Thread.sleep(500);
 thread1.interrupt();
 thread2.interrupt();
 thread3.interrupt();
 Thread.sleep(500);
 System.out.println("循环线程isInteryupt is " + thread1.isInterrupted());
 System.out.println("睡眠线程isInteryupt is " + thread2.isInterrupted());
 System.out.println("等待线程isInteryupt is " + thread3.isInterrupted());
 }
 }

执行结果:
java.lang.InterruptedException: sleep interrupted
at java.lang.Thread.sleep(Native Method)
at com.com.concurrenncy.InterruptTest.lambda$main$1(InterruptTest.java:20)
at java.lang.Thread.run(Thread.java:748)
java.lang.InterruptedException
at java.lang.Object.wait(Native Method)
at java.lang.Object.wait(Object.java:502)
at com.com.concurrenncy.InterruptTest.lambda$main$2(InterruptTest.java:32)
at java.lang.Thread.run(Thread.java:748)
循环线程isInteryupt is true
睡眠线程isInteryupt is false
等待线程isInteryupt is false
 

文章来源:智云一二三科技

文章标题:Java线程生命周期和锁的简单使用

文章地址:https://www.zhihuclub.com/194153.shtml

关于作者: 智云科技

热门文章

发表回复

您的电子邮箱地址不会被公开。

网站地图