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

最新推荐文章于 2023-10-06 18:20:06 发布
最新推荐文章于 2023-10-06 18:20:06 发布
阅读量253 收藏
点赞数 1
分类专栏： java并发编程 文章标签： 锁 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_30257149/article/details/99587555
版权

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

线程生命周期

  • 初始状态(New)

    New Thread之后，
     

  • 就绪状态(Ready)

    表示获取到了Cpu的执行时间片，也就是cpu的执行权，等待开始执行。
     

  • 运行状态(Runable)

    执行start之后，开始运行。
     

  • 阻塞状态(Blocked)

    在进入synchronized的临界区或者Lock的临界区，等待获取监视器(monitor)锁，线程会进入同步队列(SynchronizedQueue)中。
     

  • 等待状态:(Waiting)

    在执行await(),wait(),jion(),LockSupport.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

    博客地址：https://lantaoblog.site
    在这里插入图片描述

七英里的旅行
关注
专栏目录
图解Java线程的生命周期
09-04
正确管理线程生命周期是防止死锁、资源浪费和提高程序效率的关键。合理设计线程间的协作，使用线程池来控制线程数量，以及正确处理异常，都是编写多线程程序时应考虑的重要因素。理解并掌握Java线程的生命周期转换有...
使用线程锁（Lock）实现线程同步
weixin_55450615的博客
11-20 1530
任务描述 本关任务：使用Lock，实现对于某一块代码的互斥访问。 相关知识 上一关我们谈到了synchronized关键字，synchronized关键字主要用来同步代码，实现同步互斥访问，也就是在同一时刻只能有一个线程访问临界资源。从而解决线程的安全问题。 如果一个方法或者代码块被synchronized关键字修饰，当线程获取到该方法或代码块的锁，其他线程是不能继续访问该方法或代码块的。 而其他线程要能访问该方法或代码块，就必须要等待获取到锁的线程释放这个锁，而在这里释放锁只有两种情况：
头歌 第3关：使用线程锁（Lock）实现线程同步
qq_53679247的博客
06-23 2786
java 头歌 多线程的使用
第3关：使用线程锁（Lock）实现线程同步
qq_46342449的博客
12-01 1485
任务描述 本关任务：使用Lock，实现对于某一块代码的互斥访问。 package lam; import java.util.concurrent.*; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; public class MyThread { public static void main(String[] args) { final Insert ins
Educoder/头歌JAVA——JAVA高级特性：多线程基础（3）线程同步
舟舟的博客
12-22 3668
近年来，由于网民越来越多，很多使用Java的后端项目，对于并发的要求越来越来，开发出一套高可用，高性能的后端项目至关重要，而这些都离不开线程，要开发出一套性能强大项目，是避不开多线程的，线程同步与线程池是多线程进阶的必备知识，也是成为一名优秀的Java开发者必不可少的技能。
lock（obj）锁的使用
qq_34848928的博客
04-11 1595
lock（obj）锁的使用 个人学习总结： using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading; using System.Threading.Tasks; namespace product { class Program...
Java 线程的生命周期完整实例分析
08-25
Java 中的线程生命周期主要包括以下几个阶段：新建（New）、可运行（Runnable）、运行（Running）、等待（Waiting）、阻塞（Blocked）、死亡（Dead）。在 Java 中，我们可以通过使用 Thread 的生命周期来实现多线程...
Java多线程-线程的生命周期
最新发布
01-27
线程生命周期的终点是死亡状态。线程在以下三种情况下结束：`run()`方法执行完毕、执行过程中抛出未捕获异常或错误，或者调用已过时的`stop()`方法。 6. 等待（Waiting）： 从JDK1.5开始，线程可以进入等待状态，这...
java线程之线程的生命周期的使用
09-05
Java线程的生命周期主要包括以下几个阶段：新建（New）、可运行（Runnable）、运行（Running）、阻塞（Blocked）、等待（Waiting）、超时等待（Timed Waiting）和终止（Terminated）。这些状态之间的转换是由线程...
Java线程的生命周期和状态控制_动力节点Java学院整理
08-30
"Java线程的生命周期和状态控制" Java线程的生命周期是指从线程创建到线程结束的整个过程，而状态控制是指线程在不同的状态之间的转换。Java线程的生命周期主要包括五个状态：新建状态、就绪状态、运行状态、阻塞...
java开发：java多线程（三）：lock方式实现线程同步机制
一个程序员-二白的博客
12-01 465
java多线程系列文章： jaiva多线程（一）：synchronized 对象锁和类锁的区别 java多线程（二）： wait（）、sleep（）、 join（）和yield（）区别 这章博客讲解lock如何实现同步机制，比较和synchronized 的区别： JDK1.5中新增加了ReentrantLock类也能达到synchronized 同样的效果，并且在扩展功能上也更加强大，...
线程同步的三种方式
qq_45453784的博客
04-13 7559
线程同步的三种方式：解决了多线程操作的安全问题。
LOCK实现线程同步
weixin_43163153的博客
05-28 73
LOCK实现线程同步 一、简介 线程安全概念：线程安全是指在当一个线程访问该类的某个数据时，进行保护，其他线程不能进行访问直到该线程读取完，其他线程才可使用。不会出现数据不一致或者数据污染。 线程有可能和其他线程共享一些资源，比如，内存，文件，数据库等。当多个线程同时读写同一份共享资源的时候，可能会引起冲突。这时候，我们需要引入线程“同步”机制，即各位线程之间要有个先来后到，不能一窝蜂挤上去抢...
(20)线程安全问题:Lock,双锁问题,Monitor,死锁
白话魔法师
09-15 387
解决线程安全问题，有两个常用lock与monitor，双锁死锁情况。
Java多线程编程系列：使用Lock锁实现线程同步
PixelCoder的博客
10-06 145
除了基本的获取锁和释放锁操作之外，Lock接口还提供了其他一些常用的方法，比如tryLock()方法用于尝试获取锁，如果锁可用则立即返回true，否则返回false；在doSomething()方法中，我们先调用lock()方法获取锁，然后执行需要进行线程同步的代码块，最后在finally块中调用unlock()方法释放锁。在代码块执行完毕后，使用finally块来释放锁，确保锁的释放不会受到异常的影响。在需要进行线程同步的代码块前调用Lock对象的lock()方法获取锁。
多线程--线程同步锁Lock锁
qq_31142237的博客
03-11 1493
多线程–线程同步锁–Lock锁-ReentrantLock 之前说了线程同步机制Synchronize锁，其实除此之外还有一种JUC的Lock锁也能实现线程同步。而且Lock实现类ReentrantLock相比Synchronize有更大的灵活性，更加丰富，更是适合大多场景的使用。 先来简单的对比下ReentrantLock和Synchronize吧。 Synchronsize锁是独占锁，加锁和释放锁都是自动的，只要加上关键字synchronize或者代码块就行。使用起来很简单，但是呢灵活性较差。Ree
Java中的锁
Jet_Green的博客
08-14 347
Java中的锁 Lock锁 Lock锁介绍 JavaSE 5之后，并发包中新增了Lock**接口（以及相关实现类）锁功能，它提供了与synchronized关键字类似的同步功能，只是在使用时需要显式地获取和释放锁，虽然它缺少了(通过synchronized块或者方法所提供的)隐式获取释放锁的编写性，但是却拥有了锁获取与释放的可操作性、可中断性以及超时获取锁**等多种synchroni...
线程的同步状态
一切的困难都来自于自己内心的恐惧
11-08 658
线程的各个流程之间转换的关系图： 说明 ： 线程的同步状态主要包含5种状态的转换： 1. 初始状态(New) : 也就是线程对象被新建后就进入初始状态。例如，Thread thread = new Thread()。 2. 就绪状态(Runnable): 也被称为“可执行状态”。线程对象被创建后，调用该对象的start()方法启动了线程。此时线程就进入到了就绪状态。注意...
Java线程生命周期、Synchronized同步、互斥锁、死锁、释放锁基本入门
安逸
03-04 863
Java线程生命周期、Synchronized同步、互斥锁、死锁、释放锁基本入门
Java线程生命周期与状态转换详解
本文主要探讨的是线程的生命周期及其状态控制，这对于理解和优化Java应用程序至关重要。 线程的生命周期通常包括以下几个阶段： 1. 新建状态（New）： 当我们使用`new`关键字创建了一个`Thread`对象时，线程就...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值