Java筑基30-线程02-生命周期&同步方法

已于 2022-09-13 14:59:02 修改
阅读量103 收藏
点赞数
分类专栏： Java筑基系列 文章标签： java 状态模式 开发语言
于 2022-06-07 02:11:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lu_xin5056/article/details/125157805
版权

目录

一、线程生命周期

1.线程六大状态

2.线程状态转换图

二、线程同步

1.同步介绍

2.同步方法

3.案例（模拟三个线程同时售票）

4.同步原理

5.同步注意事项

三、线程死锁

四、释放锁

1.会释放锁

2.不会释放锁

五、线程练习题

1.线程调用练习

2.线程同步练习

一、线程生命周期

1.线程六大状态

JDK中用线程的枚举表示了线程的集中状态。

  • public static enum Thread.State extends Enum<Thread.State>线程状态。线程可以处于以下状态之一：一个线程可以在给定时间点处于一个状态。这些状态是不反映任何操作系统线程状态的虚拟机状态。
    • NEW尚未启动的线程处于此状态。
    • RUNNABLE在Java虚拟机中执行的线程处于此状态。
    • BLOCKED被阻塞等待监视器锁定的线程处于此状态。
    • WAITING正在等待另一个线程执行特定动作的线程处于此状态。
    • TIMED_WAITING正在等待另一个线程执行动作达到指定等待时间的线程处于此状态。
    • TERMINATED已退出的线程处于此状态。

一个线程可以在给定时间点处于一个状态。这些状态是不反映任何操作系统线程状态的虚拟机状态。

2.线程状态转换图

/**
 * @author: 程序员飞扬
 * @公众hao：程序员飞扬
 * @description:
 */
public class ThreadState_ {
    public static void main(String[] args) throws InterruptedException {
        T0 t0 = new T0();
        System.out.println(t0.getName() + "状态:" + t0.getState());
        t0.start();
        while(Thread.State.TERMINATED != t0.getState()){
            System.out.println(t0.getName() + "状态:" + t0.getState());
            Thread.sleep(1000);
        }
        System.out.println(t0.getName() + "状态:" + t0.getState());
    }
}

class T0 extends Thread{
    @Override
    public void run() {
        while(true){
            for (int i = 1; i <= 5; i++) {
                System.out.println("hi" + i + "状态：" + Thread.currentThread().getState());

                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            break;
        }
    }
}

输出：

Thread-0状态:NEW

Thread-0状态:RUNNABLE

hi1状态：RUNNABLE

Thread-0状态:RUNNABLE

hi2状态：RUNNABLE

Thread-0状态:RUNNABLE

hi3状态：RUNNABLE

Thread-0状态:RUNNABLE

hi4状态：RUNNABLE

Thread-0状态:RUNNABLE

hi5状态：RUNNABLE

Thread-0状态:RUNNABLE

Thread-0状态:TERMINATED

二、线程同步

1.同步介绍

2.同步方法

3.案例（模拟三个线程同时售票）

/**
 * @author:程序员飞扬
 * @公众hao：程序员飞扬
 * @description:
 */
public class SellTicket {
    public static void main(String[] args) {
        Sell sell = new Sell();
        new Thread(sell).start();
        new Thread(sell).start();
        new Thread(sell).start();
    }

}

class Sell implements Runnable{
    static int ticket = 10;
    private boolean loop = true;
    public synchronized void m(){
        if(ticket <= 0){
            setLoop(false);
            System.out.println("没票了，售票结束");
            return;
        }
        try {
            Thread.sleep(30);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("窗口" + Thread.currentThread().getName()+"卖出了一张票，剩余" + (--ticket) );
    }

    @Override
    public void run() {
        while(loop){
            m();
        }
    }

    public void setLoop(boolean loop) {
        this.loop = loop;
    }
}

输出：

窗口Thread-0卖出了一张票，剩余9

窗口Thread-0卖出了一张票，剩余8

窗口Thread-0卖出了一张票，剩余7

窗口Thread-0卖出了一张票，剩余6

窗口Thread-0卖出了一张票，剩余5

窗口Thread-0卖出了一张票，剩余4

窗口Thread-0卖出了一张票，剩余3

窗口Thread-0卖出了一张票，剩余2

窗口Thread-0卖出了一张票，剩余1

窗口Thread-0卖出了一张票，剩余0

没票了，售票结束

没票了，售票结束

没票了，售票结束

4.同步原理

5.同步注意事项

/**
 * @author:程序员飞扬
 * @公众hao：程序员飞扬
 * @description:
 */
public class SellTicket {
    public static void main(String[] args) {
        Sell sell = new Sell();
        new Thread(sell).start();
        new Thread(sell).start();
        new Thread(sell).start();
    }
}

class Sell implements Runnable{
    Object object = new Object();
    static int ticket = 10;
    private boolean loop = true;

    //同步方法（静态的）的锁为当前类本身
    public synchronized static void m1(){//此时锁是加在Sell.class

    }

    public static void m2(){//在静态方法中实现同步代码快，类名.class
        synchronized (Sell.class){
            System.out.println("lalalala");
        }
    }

    public /*synchronized*/ void m(){//同步方法
        synchronized (/*this*/ object){//同步锁代码块，此时this指当前对象，锁object也可以，因为是操作的同一个对象
            if(ticket <= 0){
                setLoop(false);
                System.out.println("没票了，售票结束");
                return;
            }
            try {
                Thread.sleep(30);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("窗口" + Thread.currentThread().getName()+"卖出了一张票，剩余" + (--ticket) );
        }
    }

    @Override
    public void run() {
        while(loop){
            m();
        }
    }

    public void setLoop(boolean loop) {
        this.loop = loop;
    }
}

三、线程死锁

/**
 * @author:程序员飞扬
 * @公众hao：程序员飞扬
 * @description:
 */
public class DeadLock_ {
    public static void main(String[] args) {
        DeadLockDemo deadLockDemo1 = new DeadLockDemo(true);
        DeadLockDemo deadLockDemo2 = new DeadLockDemo(false);
        deadLockDemo1.start();
        deadLockDemo2.start();
    }
}

class DeadLockDemo extends Thread{
    static Object o1 = new Object();
    static Object o2 = new Object();
    boolean flag;

    public DeadLockDemo(boolean flag){
        this.flag = flag;
    }

    public void run(){
        if(flag){
            synchronized (o1){
                System.out.println(Thread.currentThread().getName() + "进入1");
                synchronized (o2){
                    System.out.println(Thread.currentThread().getName() + "进入2");
                }
            }
        }else{
            synchronized (o2){
                System.out.println(Thread.currentThread().getName() + "进入3");
                synchronized (o1){
                    System.out.println(Thread.currentThread().getName() + "进入4");
                }
            }
        }
    }
}

运行结果：

四、释放锁

1.会释放锁

2.不会释放锁

d91663ba1ba58fa5b79577dbe02ab0fc.png

五、线程练习题

1.线程调用练习

import java.util.Scanner;

/**
 * @author:程序员飞扬
 * @公众hao：程序员飞扬
 * @description:
 */
public class HomeWork01 {
    public static void main(String[] args) {
        A a = new A();
        B b = new B(a);
        a.start();
        b.start();
    }


}

class A extends Thread{
    private boolean loop = true;

    public void setLoop(boolean loop) {
        this.loop = loop;
    }

    int count;
    @Override
    public void run() {
        while(loop){
            ++count;
            System.out.print((int)((Math.random()*100 + 1))+ " ");//随机打印1~100之间的整数
            if(count%10 == 0){
                System.out.println();//每打印10个数换行
            }
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

class B extends Thread{
    private A a;
    private Scanner scanner = new Scanner(System.in);

    public B(A a) {
        this.a = a;
    }

    @Override
    public void run() {
        while(true){
            System.out.println("输入指令'Q'表示退出：");
            char c = scanner.next().toUpperCase().charAt(0);//接收控制台输入的字符'q'或'Q'
            if(c == 'Q'){
                a.setLoop(false);//将变量置为false,通知线程A退出
                break;
            }
        }

    }
}

输出：

输入指令'Q'表示退出：

80 79 77 25 58 63 97 47 39 99

2 34 44 73 79 87 98 q

Process finished with exit code 0

2.线程同步练习

/**
 * @author:程序员飞扬
 * @公众hao：程序员飞扬
 * @description:
 */
public class HomeWork02 {
    public static void main(String[] args) {
        DrawMoney drawMoney = new DrawMoney();
        Thread thread1 = new Thread(drawMoney);
        thread1.setName("t1");
        Thread thread2 = new Thread(drawMoney);
        thread2.setName("t2");
        thread1.start();
        thread2.start();
    }
}

class DrawMoney implements Runnable{
    private int money = 5000;
    @Override
    public void run() {
        System.out.println("当前一共有" + money);
        while(true){
            /**
             * 1. 使用synchronized实现线程同步
             * 2. 当多个线程执行到此处，就会去争夺this对象锁
             * 3. 哪个线程获取到this对象锁，就执行synchronized代码块，执行完成后，会释放this对象锁
             * 4.争夺不到this对象锁，就blocked,准备继续争夺
             * 5. this对象锁是非公平锁
             */
            synchronized (this){
                if(money < 1000){
                    System.out.println("余额不足");
                    break;
                }
                money -= 1000;
                System.out.println(Thread.currentThread().getName() + "取了1000元，当前余额" + money);
            }

            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

输出：

当前一共有5000

当前一共有5000

t1取了1000元，当前余额4000

t2取了1000元，当前余额3000

t2取了1000元，当前余额2000

t1取了1000元，当前余额1000

t1取了1000元，当前余额0

余额不足

余额不足

程序员飞扬
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
java 线程休眠 30秒_Java 多线程基础（七）线程休眠 sleep
weixin_35318343的博客
02-13 3604
Java 多线程基础(七)线程休眠 sleep一、线程休眠 sleepsleep() 方法定义在Thread.java中，是 static 修饰的静态方法。sleep() 的作用是让当前线程休眠，即当前线程会从“运行状态”进入到“休眠(阻塞)状态”。sleep()会指定休眠时间，线程休眠的时间会大于/等于该休眠时间；在线程重新被唤醒时，它会由“阻塞状态”变成“就绪状态”，从而等待cpu的调度执行。...
Thread.Sleep（）方法详细介绍
zjyfree的博客
12-02 3936
学习笔记
线程休眠,礼让
weixin_45970171的博客
11-02 730
线程休眠,礼让 线程休眠 sleep(时间)指定当前线程阻塞的毫米值 sleep存在异常InterruptedException; sleep时间达到后线程进入就绪状态 sleep可以模拟网络延迟（就是在run方法中加一个sleep方法就可以了），倒计时等 每一个对象都有一个锁，sleep不会释放锁； package com.Jinone.www; import java.text.SimpleDateFormat; import java.util.Date; public class TextS
Thread.sleep()【针对于当前线程的睡眠】
一个搬砖工人
11-11 2040
1 Thread.sleep() 使当前执行的线程在指定的毫秒数内休眠（暂时停止执行），这取决于系统计时器和调度程序的精度和准确性，线程不会丢失任何监视器的所有权。 public class TestThreadSleep { public static void main(String[] args) { System.out.println("Main thread begin time = " + System.currentTimeMillis()); MyT
Thread.sleep() vs. 对象的wait()：线程暂停的不同方式
赵KK的博客
09-27 697
方法和对象的wait()方法都可以让线程暂停执行，但它们有不同的用途和行为。选择哪种方式取决于你的需求和场景。希望本文能够帮助你更好地理解这两种方法的区别，以及如何在多线程编程中使用它们。
Java多线程-线程的生命周期
最新发布
01-27
线程生命周期的终点是死亡状态。线程在以下三种情况下结束：`run()`方法执行完毕、执行过程中抛出未捕获异常或错误，或者调用已过时的`stop()`方法。 6. 等待（Waiting）： 从JDK1.5开始，线程可以进入等待状态，这...
图解Java线程的生命周期
09-04
正确管理线程生命周期是防止死锁、资源浪费和提高程序效率的关键。合理设计线程间的协作，使用线程池来控制线程数量，以及正确处理异常，都是编写多线程程序时应考虑的重要因素。理解并掌握Java线程的生命周期转换有...
Java 线程的生命周期完整实例分析
08-25
Java 中的线程生命周期主要包括以下几个阶段：新建（New）、可运行（Runnable）、运行（Running）、等待（Waiting）、阻塞（Blocked）、死亡（Dead）。在 Java 中，我们可以通过使用 Thread 的生命周期来实现多线程...
JAVA并发编程实践-线程安全-学习笔记
07-20
而明确的不变约束则是指对象在创建后，其状态应满足的一系列条件，这些条件在整个对象生命周期内保持不变。 需要注意的是，完全由线程安全的类组成的程序并不一定线程安全，因为线程安全问题也可能出现在类之间的...
java多线程编程之线程的生命周期
09-04
Java多线程编程中，线程的生命周期包括四个主要阶段：新建、运行、阻塞和终止。理解这些状态以及如何通过Thread类中的方法控制它们至关重要。 1. **新建**： 当通过`new Thread()`创建一个新的线程对象时，线程...
关于多线程中的Thread.sleep方法以及面试相关
m0_47739580的博客
06-30 1889
多线程中sleep方法详解，以及与sleep有关的面试题
Java中关于Thread.sleep()与 线程对象.sleep()的思考
weixin_43114954的博客
02-02 2258
前言：java中Thread线程类中的sleep（）查看API文档如下： static void sleep(longmillis) 使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行），具体取决于系统定时器和调度程序的精度和准确性。 static void sleep(longmillis, intnanos) 导致正在执行的线程以指定的毫秒数加上指定的纳秒数来暂停（临时停止执行），这取决于系统定时器和调度器的精度和准确性。 得知该方法为静态方法，...
Thread.sleep()的简单用法
Wyh824的博客
06-19 2793
要用sleep的目的：为了暂停当前线程，减缓当前线程的执行。如果有调用其他接口进行操作，可避免被误认为是恶意攻击。
2020-09-16 Java 多线程及线程安全
0的博客
09-18 281
Java多线程 进程：一个程序的执行过程叫进程 线程：进程的一条执行路径 多线程：进程的多条执行路径 线程的五种状态 实现方式之一 声明一个类，继承Thread类，重写run()方法，调用类的实例对象的start()方法。 public class Test extends Thread{ @Override public void run (){ //线程执行代码块 } } //main方法 main(arg){ new Test().start(); //线程启动 ，如果调用的是r
Thread.sleep()方法
热门推荐
CheerForU
03-15 2万+
为什么要用sleep，主要是为了暂停当前线程，把cpu片段让出给其他线程，减缓当前线程的执行。 两种方式： 第一种方式是只调用sleep静态方法；第二种是获取对象后再调用sleep静态方法。第二种方式效率要低一些，因为多了一次函数调用，而且通过对象调用静态方法也不太符合“静态”的定义（静态成员最好通过类名直接访问），但功能上是一致的。当需要调用非静态方法时使用第二种方式，否则直接使用第一种方式...
Thread.sleep()控制两个线程执行顺序
Belle_Chou的博客
06-30 1822
import java.io.File; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; import java.io.InputStream; import java.io.Inp...
Thread.sleep的用法（搭配异步处理）
tcguoxing的博客
03-08 7956
Thread.sleep的用法 当我想延迟一段时间的时候呢，会不自觉的想到使用Thread.sleep函数，但我经常会忘记它会阻断主线程这回事，通俗来说就是用该函数阻止主线程200ms，那么后边的都得给我延迟200ms。而一些新手，比如我，经常忘了这回事。比如我们使用下边的方法 void main() { RunThread(); Console.writeLine(&quot;B&quot;); } void R...
Java线程生命周期与状态转换详解
本文主要探讨的是线程的生命周期及其状态控制，这对于理解和优化Java应用程序至关重要。 线程的生命周期通常包括以下几个阶段： 1. 新建状态（New）： 当我们使用`new`关键字创建了一个`Thread`对象时，线程就...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

程序员飞扬

赠人玫瑰，手有余香，感谢支持！

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值