JavaStudy6(多线程基础)—B站韩顺平

已于 2022-09-16 12:29:44 修改
阅读量586 收藏 4
点赞数 4
文章标签： java 开发语言 后端 学习
于 2022-04-24 16:17:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/BLWY_1124/article/details/124385092
版权
本文详细介绍了Java中的多线程基础知识，包括线程的概念、创建线程的两种方式（继承Thread和实现Runnable）、并发与并行的区别、线程的生命周期状态以及线程同步机制。通过实例演示了线程的启动、终止、同步方法的使用，如synchronized关键字和互斥锁。同时，讨论了线程死锁问题，并提供了作业示例，展示了如何控制线程的执行和资源同步。
摘要由CSDN通过智能技术生成

JavaStudy6(多线程基础)—B站韩顺平

1 多线程基础

1.1线程相关概念

1.1.1 程序(program)

在这里插入图片描述

1.1.2 进程

在这里插入图片描述

1.1.3 什么是线程

在这里插入图片描述

1.1.4 其他相关概念
  1. 单线程：同一时刻，只允许执行一个线程
  2. 多线程：同一时刻，可以执行多个线程，比如一个qq进程，可以同时打开多个聊天窗口，一个迅雷进程，可以下载多个文件
  3. **并发：**同一时刻，多个任务交替执行，造成一种”貌似同时“的错觉，简单的说，单核cpu实现任务就是并发
  4. **并行：**同一时刻，多个任务同时执行。多核cpu可以实现并行。并发和并行。

在这里插入图片描述

在这里插入图片描述

1.2 线程基本使用

1.2.1 创建线程的两种方式

在这里插入图片描述

1.2.2 线程应用案例 1-继承 Thread 类

在这里插入图片描述

代码演示：

/**
 * @ClassName Thread01
 * @Author ：BLWY-1124
 * @Date ：2022/3/28 14:11
 * @Description： 演示通过继承 Thread 类创建线程
 * @Version: 1.0
 */
public class Thread01 {
    public static void main(String[] args) throws InterruptedException {
        //创建 Cat对象 可以当作线程使用
        Cat cat = new Cat();
        cat.start();;//启动线程-> 最终会执行 cat 的 run 方法

        //源码
        /*
        (1) public synchronized void start() {
        start0();
         }
         //start0() 是本地方法,是JVM调用，底层c/c++实现;
         //真正实现多线程的效果， 是 start0(), 而不是 run
         private native void start0();
         */

        //cat.run(); //run 方法就是一个普通的方法, 没有真正的启动一个线程，就会把 run 方法执行完毕，才向下执行
        //说明：当main线程启动一个子线程，Thread-0，主线程不会阻塞，会继续执行。
        //说明主线程和子线程是交替执行的，
        System.out.println("主线程继续执行" + "线程名：" + Thread.currentThread().getName());//名字main
        for (int i = 0; i < 60; i++) {
            System.out.println("主线程 = " + i);
            //让主线程休眠
            Thread.sleep(1000);
        }
    }
}
//老韩说明
// 1. 当一个类继承了 Thread 类， 该类就可以当做线程使用
// 2. 我们会重写 run 方法，写上自己的业务代码
// 3. run Thread 类 实现了 Runnable
/*
 @Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }
 */
class Cat extends Thread{
    int time = 0;
    @Override
    public void run() { //重写 run 方法，写上自己的业务逻辑
        while (true){
            // 该线程每隔 1 秒。在控制台输出 “喵喵, 我是小猫咪”
            System.out.println("喵喵，我是小猫咪"  + ++time + "线程名=" + Thread.currentThread().getName());//Thread-0
            //让该线程休眠 1 秒 ctrl+alt+t
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (time >=80){
                return;
            }
        }
    }
}

在这里插入图片描述

1.2.3 线程应用案例 2-实现 Runnable 接口

在这里插入图片描述

在这里插入图片描述

/**
 * @ClassName Thread02
 * @Author ：BLWY-1124
 * @Date ：2022/3/28 19:34
 * @Description： 通过实现接口 Runnable 来开发线程
 * @Version: 1.0
 */
public class Thread02 {
    public static void main(String[] args) {
//        Dog dog = new Dog();
//        //dog.start();这里不能调用 start
//        // 创建了 Thread 对象，把 dog 对象(实现 Runnable),放入 Thread
//        Thread thread = new Thread(dog);
//        thread.start();
        Tiger tiger = new Tiger();
        ThreadProxy threadProxy = new ThreadProxy(tiger);
        threadProxy.run();
    }
}
class Animal{

}
class Tiger extends Animal implements Runnable{

    @Override
    public void run() {
        System.out.println("老虎嗷嗷叫");
    }

}
//线程代理类，模拟了一个极简的Thread类
class  ThreadProxy implements Runnable{
    private Runnable target;
    @Override
    public void run() {
        if (target != null){
            target.run();
        }
    }

    public ThreadProxy(Runnable target) {
        this.target = target;
    }
    public void start(){
        start0();//这个方法是真正实现多线程的方法
    }

    private void start0() {
        run();
    }

}
class Dog implements Runnable{ //通过实现 Runnable 接口，开发线程
        int count = 0;
    @Override
    public void run() {
        while (true){
            System.out.println("小狗汪汪叫.." + (++count) + Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (count >= 10){
                break;
            }
        }
    }
}
1.2.4 线程使用应用案例-多线程执行

在这里插入图片描述

代码演示：

/**
 * @ClassName Thread03
 * @Author ：BLWY-1124
 * @Date ：2022/3/28 23:07
 * @Description： main 线程启动两个子线程
 * @Version: 1.0
 */
public class Thread03 {
    public static void main(String[] args) {
        T1 t1 = new T1();
        T2 t2 = new T2();
        Thread thread1 = new Thread(t1);
        Thread thread2 = new Thread(t2);
        thread1.start();//启动第 1 个线程
        thread2.start();//启动第 2 个线程
    }
}
class T1 implements Runnable{
    int count = 0;
    @Override
    public void run() {
        while (true){
            //每隔 1 秒输出 “hello,world”,输出 10 次
            System.out.println("hello,world" + (++count));
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (count == 80 ){
                break;
            }
        }

    }
}
class T2 implements Runnable{
    int count = 0;
    @Override
    public void run() {
        while (true) {
            //每隔 1 秒输出 “hi”,输出 5 次
            System.out.println("hi" + (++count));
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (count == 60 ){
                break;
            }
        }
    }
1.2.5 线程如何理解

在这里插入图片描述
在这里插入图片描述

1.3 继承 Thread vs 实现 Runnable 的区别

在这里插入图片描述
在这里插入图片描述

代码演示：

/**
 * @ClassName SellTicket
 * @Author ：BLWY-1124
 * @Date ：2022/3/28 23:38
 * @Description： 使用多线程，模拟三个窗口同时售票 100 张
 * @Version: 1.0
 */
public class SellTicket {
    public static void main(String[] args) {
//        //测试
//        SellTicket01 sellTicket01 = new SellTicket01();
//        SellTicket01 sellTicket02 = new SellTicket01();
//        SellTicket01 sellTicket03 = new SellTicket01();
//        //这里我们会出现超卖.
//        sellTicket01.start();
//        sellTicket02.start();
//        sellTicket03.start();
        System.out.println("===使用实现接口方式来售票=====");

        SellTicket02 sellTicket02 = new SellTicket02();
        new Thread(sellTicket02).start();//第 1 个线程-窗口
        new Thread(sellTicket02).start();//第 2 个线程-窗口
        new Thread(sellTicket02).start();//第 3 个线程-窗口
    }
}
class SellTicket01 extends Thread{
    public static  int ticketNum =100;
    @Override
    public void run() {
        while (true){
            if (ticketNum <= 0){
                System.out.println("售票结束");
                break;
            }
            try {
                Thread.sleep(50); //休眠50毫秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("窗口 " + Thread.currentThread().getName() +
                    " 售出一张票" + " 剩余票数=" + (--ticketNum));
        }

    }
}

class SellTicket02 implements Runnable{
    public static  int ticketNum =100;
    @Override
    public void run() {
        while (true){
            if (ticketNum <= 0){
                System.out.println("售票结束");
                break;
            }
            try {
                Thread.sleep(50); //休眠50毫秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("窗口 " + Thread.currentThread().getName() +
                    " 售出一张票" + " 剩余票数=" + (--ticketNum));
        }
    }
}

1.4线程终止

1.4.1 基本说明

在这里插入图片描述

1.4.2 应用案例 ThreadExit_.java com.hspedu.exit

在这里插入图片描述

代码演示：

public class ThreadExit_ {
    public static void main(String[] args) throws InterruptedException {
        T t1 = new T();
        t1.start();

        //如果希望main线程去控制t1线程的终止，必须可以修改Loop
        //让t1退出run方法，从而终止t1线程->通知方式
        //让主线程休眠10秒 在通知T1线程退出
        System.out.println("主线程休眠10秒");
        Thread.sleep(10*1000);
        t1.setLoop(false);
    }
}

class T extends Thread {
    private int count = 0;
    //设置一个控制变量
    private boolean loop = true;

    @Override
    public void run() {
        while (loop) {
            try {	
                Thread.sleep(50); //让当前线程休眠50ms
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("T 运行中" + count++);
        }
    }
    public void setLoop(boolean loop){
        this.loop = loop;
    }
}

1.5 线程常用方法

1.5.1 常用方法第一组

在这里插入图片描述

1.5.2 注意事项和细节

在这里插入图片描述

1.5.3 应用案例 ThreadMethod01.java

在这里插入图片描述

代码演示：

public class ThreadMethod {
    public static void main(String[] args) throws InterruptedException {
        T t = new T();
        t.setName("老韩");
        t.setPriority(Thread.MIN_PRIORITY);
        t.start();
        System.out.println("线程名：" + t.getName());
        for (int i = 0; i < 5; i++) {
            System.out.println("hi" + i);
            Thread.sleep(1000);
        }
        System.out.println(t.getName() + "线程优先级" + t.getPriority() );//1
        t.interrupt();//当执行到这里就会中断线程的休眠
    }
}
class T extends Thread{
    @Override
    public void run() {
        while (true){
        for (int i = 0; i < 100; i++) {
            //Thread.currentThread（）,getName（）获取当前线程的名称
            System.out.println(Thread.currentThread().getName() + "吃包子" + i);
        }
        try {
            System.out.println(Thread.currentThread().getName() + "休眠ing--");
            Thread.sleep(20000);
        } catch (InterruptedException e) {
            //当该线程执行到一个interrupt方法时，就会catch一个异常，可以加入自己的业务代码
            System.out.println(Thread.currentThread().getName() + "被interrupt了");
        }
    }
    }
}
1.5.4 常用方法第二组

在这里插入图片描述

1.5.5 应用案例

代码演示：

public class ThreadMethod02 {
    public static void main(String[] args) throws InterruptedException {
        T2 t2 = new T2();
        t2.start();

        for (int i = 1; i <= 20; i++) {
            Thread.sleep(1000);
            System.out.println("hi" + i);
            if (i == 5){
                System.out.println("子线程执行");
                //t2.join();
                Thread.yield();
                System.out.println("子线程执行完毕，主线程继续执行");
            }
            }
    }
}
class T2 extends Thread{

    @Override
    public void run() {
        for (int i = 1; i <= 20; i++) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("hello,join" + i);
        }

    }
}

t2.join();执行效果

join:线程的插队。插队的线程一旦插队成功，则肯定
先执行完插入的线程所有的任务

在这里插入图片描述

Thread.yield();执行效果

yield:线程的礼让。让出cpu,让其他线程执行，但礼
让的时间不确定，所以也不一定礼让成功

在这里插入图片描述

1.5.6 用户线程和守护线程

在这里插入图片描述

1.5.7 应用案例 ThreadMethod03.java

下面我们测试如何将一个线程设置成守护线程

在这里插入图片描述

代码演示：

public class ThreadMethod03 {
    public static void main(String[] args) throws InterruptedException {
        MyDaemonThread myDaemonThread = new MyDaemonThread();
        //如果我们希望main线程结束后，子线程自动结束
        //将子线程设为守护线程
        myDaemonThread.setDaemon(true);
        myDaemonThread.start();

        for (int i = 1; i <= 10; i++) {
            System.out.println("宝强在幸苦工作---");
            Thread.sleep(1000);
        }
    }
}
class MyDaemonThread extends Thread{
    @Override
    public void run() {
        for( ; ; ){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("马蓉和宋喆在聊天---");
        }
    }
}

运行结果：

在这里插入图片描述

1.6 线程的生命周期

1.6.1 JDK 中用 Thread.State 枚举表示了线程的几种状态

在这里插入图片描述

1.6.2 线程状态转换图

在这里插入图片描述

NEW: new了一个线程出来的时候的状态

RUNNABLE: 调用start()方法后进入RUNNABLE状态（可运行状态），RUNNABLE内细化还有两个状态：（Ready就绪状态 和 Running 运行状态）。

BLOCKED: 调用等待进入同步代码块锁，这时候就会阻塞，待获得钥匙后，就会回到RUNNABLE状态

WAITING: 在RUNNABLE状态调用了(.wait() 、.join()、LockSupport.park())方法时就会进入WAITING（等待）状态。等方法结束或者通过（.notify() 、.notifyAll() 、LockSupport.unpark() ）方法就会回到RUNNABLE（可运行状态）。

TIMED_WAITING（超时等待）: 在RUNNABLE状态时，调用（Thread.sleep(time); .wait(time) ）等方法，等待时间结束后，就会回到RUNNABLE（可运行状态）。

TERMTNATED: 线程结束。

1.6.3 写程序查看线程状态 ThreadState_.java
public class ThreadState_ {
    public static void main(String[] args) throws InterruptedException {
        T t = new T();
        System.out.println(t.getName() + "状态" + t.getState());
        t.start();
        while (Thread.State.TERMINATED != t.getState()){
            System.out.println(t.getName() + "状态" + t.getState());
                Thread.sleep(500);
        }
        System.out.println(t.getName() + "状态" + t.getState());
    }
}
class T extends Thread{
    @Override
    public void run() {
        while (true){
            for (int i = 0; i < 10; i++) {
                System.out.println("hi" + i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
            break;
        }
    }
}

结果：

在这里插入图片描述

1.7 线程的同步

1.7.1 Synchronized 线程同步机制

在这里插入图片描述

1.7.2 同步具体方法-Synchronized

在这里插入图片描述

代码演示：

以售票窗口来演示

/**
 * @ClassName SellTicket
 * @Author ：BLWY-1124
 * @Date ：2022/3/28 23:38
 * @Description： 使用多线程，synchronized  模拟三个窗口同时售票 100 张
 * @Version: 1.0
 */
public class SellTicket {
    public static void main(String[] args) {

        System.out.println("===使用实现接口方式来售票=====");

        //测试
        SellTicket03 sellTicket03 = new SellTicket03();
        new Thread(sellTicket03).start();//第 1 个线程-窗口
        new Thread(sellTicket03).start();//第 2 个线程-窗口
        new Thread(sellTicket03).start();//第 3 个线程-窗口
    }
}

class SellTicket01 extends Thread{
    public static  int ticketNum =100;
    @Override
    public void run() {
        while (true){
            if (ticketNum <= 0){
                System.out.println("售票结束");
                break;
            }
            try {
                Thread.sleep(50); //休眠50毫秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("窗口 " + Thread.currentThread().getName() +
                    " 售出一张票" + " 剩余票数=" + (--ticketNum));
        }

    }
}
//实现接口的方式，使用synchronized实现线程同步
class SellTicket03 implements Runnable{
    public static  int ticketNum =100; //让多个线程共享 ticketNum
    private boolean loop = true; //控制run方法的变量
    public synchronized void sell (){ //同步方法，在同一时刻只能有一个线程来执行sell方法
        if (ticketNum <= 0){
            System.out.println("售票结束");
            loop = false;
            return;
        }
        try {
            Thread.sleep(50); //休眠50毫秒
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("窗口 " + Thread.currentThread().getName() +
                " 售出一张票" + " 剩余票数=" + (--ticketNum));
    }
    @Override
    public  void run() {
        while (loop){
            sell(); //是一个同步方法
        }
    }
}
1.7.3 分析同步原理

在这里插入图片描述

1.8 互斥锁

1.8.1 基本介绍

在这里插入图片描述

/**
 * @ClassName SellTicket
 * @Author ：BLWY-1124
 * @Date ：2022/3/28 23:38
 * @Description： 使用多线程，synchronized 互斥锁 模拟三个窗口同时售票 100 张
 * @Version: 1.0
 */
public class SellTicket {
    public static void main(String[] args) {
        //不同对象 测试
        SellTicket01 sellTicket01 = new SellTicket01();
        SellTicket01 sellTicket02 = new SellTicket01();
        SellTicket01 sellTicket03 = new SellTicket01();
        //这里我们还是会出现超卖.
        sellTicket01.start();
        sellTicket02.start();
        sellTicket03.start(); //不同的对象在进入线程
        System.out.println("===使用实现接口方式来售票=====");

        //测试 传入同一对象
        SellTicket03 sellTicket04 = new SellTicket03();
        new Thread(sellTicket04).start();//第 1 个线程-窗口
        new Thread(sellTicket04).start();//第 2 个线程-窗口
        new Thread(sellTicket04).start();//第 3 个线程-窗口
    }
}

    class SellTicket01 extends Thread {
        public static int ticketNum = 120;

        @Override
        public synchronized void run() {
            synchronized (this){  //这里的this时不同的对象
                while (true) {
                    if (ticketNum <= 0) {
                        System.out.println("售票结束");
                        break;
                    }
                    try {
                        Thread.sleep(50); //休眠50毫秒
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("窗口 " + Thread.currentThread().getName() +
                            " 售出一张票" + " 剩余票数=" + (--ticketNum));
                }
            }

            }

        }

    //实现接口的方式，使用synchronized实现线程同步
    class SellTicket03 implements Runnable {
        public static int ticketNum = 100; //让多个线程共享 ticketNum
        private boolean loop = true; //控制run方法的变量
        Object object = new Object();


        public synchronized void sell() { //同步方法，在同一时刻只能有一个线程来执行sell方法
            synchronized (object) { //同一个对象
                if (ticketNum <= 0) {
                    System.out.println("售票结束");
                    loop = false;
                    return;
                }
                try {
                    Thread.sleep(50); //休眠50毫秒
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("窗口 " + Thread.currentThread().getName() +
                        " 售出一张票" + " 剩余票数=" + (--ticketNum));
            }
        }

        @Override
        public void run() {
            while (loop) {
                sell(); //是一个同步方法
            }
        }
    }
1.8.2 注意事项和细节

在这里插入图片描述

1.9 线程的死锁

1.9.1 基本介绍

在这里插入图片描述

应用案例

在这里插入图片描述

1.9.2 应用案例 DeadLock_.java
/**
 * @ClassName DeadLock_
 * @Author ：BLWY-1124
 * @Date ：2022/3/30 0:05
 * @Description： 模拟线程死锁
 * @Version: 1.0
 */
public class DeadLock_ {
    public static void main(String[] args) {
        //模拟死锁现象
        DeadLockDemo A = new DeadLockDemo(true);
        A.setName("A 线程");
        DeadLockDemo B = new DeadLockDemo(false);
        B.setName("B 线程");
        A.start();
        B.start();
    }
}

class DeadLockDemo extends Thread {
    static Object o1 = new Object();// 保证多线程，共享一个对象,这里使用 static
    static Object o2 = new Object();
    boolean flag;

    public DeadLockDemo(boolean flag) {//构造器
        this.flag = flag;

    }
    @Override
    public void run() {
//下面业务逻辑的分析
//1. 如果 flag 为 T, 线程 A 就会先得到/持有 o1 对象锁, 然后尝试去获取 o2 对象锁
//2. 如果线程 A 得不到 o2 对象锁，就会 Blocked
//3. 如果 flag 为 F, 线程 B 就会先得到/持有 o2 对象锁, 然后尝试去获取 o1 对象锁
//4. 如果线程 B 得不到 o1 对象锁，就会 Blocked
        if (flag) {
            synchronized (o1) {//对象互斥锁, 下面就是同步代码
                System.out.println(Thread.currentThread().getName() + " 进入 1");
                synchronized (o2) { // 这里获得 li 对象的监视权
                    System.out.println(Thread.currentThread().getName() + " 进入 2");
                }
            }
        } else {
            synchronized (o2) {
                System.out.println(Thread.currentThread().getName() + " 进入 3");
                synchronized (o1) { // 这里获得 li 对象的监视权
                    System.out.println(Thread.currentThread().getName() + " 进入 4");
                }
            }
        }
    }
}

在这里插入图片描述

1.10 释放锁

1.10.1 下面操作会释放锁

在这里插入图片描述

1.10.2 下面操作不会释放锁

在这里插入图片描述

1.11 本章作业

在这里插入图片描述

第一种方法:

/**
 * @ClassName HomeWork01
 * @Author ：BLWY-1124
 * @Date ：2022/3/30 11:28
 * @Description： 改变loop
 * @Version: 1.0
 */
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;

    @Override
    public void run() {

        while (loop) {
            System.out.println((int)(Math.random() * 100 + 1));
            //休眠
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    public void setLoop(boolean loop) {
        this.loop = loop;
    }
}

//知道第二个线程从键盘读取"Q"命令
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 key = scanner.next().toUpperCase().charAt(0);
            System.out.println("输出:" + key);
            if (key == 'Q') {
                //以通知的方式去结束A线程
                a.setLoop(false);
                System.out.println("b线程已退出");
                break;
            }
        }

    }
}

第二种方法:

/**
 * @ClassName HomeWork01
 * @Author ：BLWY-1124
 * @Date ：2022/3/30 11:28
 * @Description： 守护线程
 * @Version: 1.0
 */
public class HomeWork01_2 {
    public static void main(String[] args) {

        B b = new B();
        b.pretected();
        b.start();
    }
}

class A extends Thread {
    private boolean loop = true;

    @Override
    public void run() {

        while (loop) {
            System.out.println((int)(Math.random() * 100 + 1));
            //休眠
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

}

//直到第二个线程从键盘读取"Q"命令
class B extends Thread {
    private Scanner scanner = new Scanner(System.in);
    public void pretected(){
        A a = new A();
        a.setDaemon(true);
        a.start();
    }
    @Override
    public void run() {
        while (true){
            System.out.println("请输入你的指令(Q)表示退出:");
            char key = scanner.next().toUpperCase().charAt(0);
            System.out.println("输出:" + key);
            if (key == 'Q') {
                //以通知的方式去结束A线程
                //a.setLoop(false);
                System.out.println("b线程已退出");
                return;
            }
        }
    }
}

在这里插入图片描述

在这里插入图片描述

代码演示:

/**
 * @ClassName HomeWork02
 * @Author ：BLWY-1124
 * @Date ：2022/3/30 14:31
 * @Description： 同步代码块方法
 * @Version: 1.0
 */
public class HomeWork02 {
    public static void main(String[] args) {
        T t = new T();
        Thread thread1 =  new Thread(t);
        Thread thread2 =  new Thread(t);
        thread1.setName("thread1");
        thread2.setName("thread2");
        thread1.start();
        thread2.start();
    }
}
//解读
//1,这里使用synchronized实现了线程同步
//2,当多个线程执行到这里时，就会去争夺this对象锁
//3.哪个线程争夺到（获取）this对象锁，就执行synchronized代码块，执行完后，会释放this对象锁
//4,争夺不到this对象锁，就blocked,准备继续争夺
//5,this对象锁是非公平锁，
class T implements Runnable{
    int money = 10000;
     boolean loop = true;
    @Override
    public void run() {
        spend(); //synchronized
    }
    public /*synchronized*/ void spend(){
        while (loop){
            synchronized (this){
                if (money < 1000){
                    loop = false;
                    System.out.println("余额不足结束");
                    break;
                }
                money -=1000;
                System.out.println( Thread.currentThread().getName() + "已取钱1000===余额为" + money);
            }
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
                }
        }
    }
}

在这里插入图片描述

我亦无他,惟手熟尔

别来无恙blwy
关注
韩顺平Java自学笔记 网络多线程
m0_67946241的博客
08-18 812
自学笔记，自己的一些学习新的
韩顺平Java学习笔记_线程专题(基础)
m0_62661440的博客
03-11 500
韩顺平Java学习笔记_多线程基础专题
韩顺平 java课件
09-22
包括java基础知识、数据库相关知识，以及一些疑难问题解答
B站韩顺平java学习笔记（七）--面向对象编程（中级）章节
LW_20180806的博客
03-22 2821
一、IDEA使用 1、IDEA使用技巧和经验 （1）设置字体 菜单 file -> settings （2）字符编码设置 2、IDEA常用快捷键 （1）删除当前行，ctrl + y （2） （3） （4） 二、包 三、访问修饰符 四、OOP三大特征（封装，继承和多态） 五、Super关键字 六、方法重写（overwrite） 七、Object类详解，垃圾回收机制 ...
B站韩顺平java学习笔记（五）--数组、排序、查找章节
LW_20180806的博客
03-14 1815
一、数组 1、数组介绍 数组可以存放多个同一类型的数据。数组也是一种数据类型，是引用类型。即，数组是一组数据。 （1）数组的定义 ① 第一种 动态分配方式 语法：数据类型 数组名[ ] = new 数据类型[大小] //或者数据类型[ ] 数组名 = new 数据类型[大小] 例如：int a[ ] = new int[5] //创建了一个数组，名字a，存放了5个int型数据 ② 第二...
java多线程（韩顺平老师讲义）
weixin_44623449的博客
09-20 531
多线程（韩顺平） 进程：正在运行的程序 加载到内存里 线程是进程的实体，线程也可以由线程创建 单线程：同一时刻只能有一个线程 并发：同一时刻多个任务交替执行 1，继承Thread类（这个类也是实现runable接口 ） run()方法是普通方法，没有启动新的线程 接口是一个规范 我知道你的方法名， 我才知道找什么去调用什么 [1] native 本地方法start0() 底层C/C++实现 start0()==>线程可用，具体什么时候run。不知道等CPU调度。
韩顺平java学习笔记-多线程基础
jacknoe的博客
09-30 596
Java多线程基础
B站韩顺平老师Java学习路线
09-13
B站韩顺平老师Java学习路线
java入门韩顺平所有资源笔记等B站对应学习视频
04-25
2) 抛弃传统的以强灌知识点授课方式，每个阶段都有多个项目把知识点真正应用到项目中, 小伙伴在学习过程中有满满成就感，充分体会编程乐趣 3) 课程成完整体系，超全，超详细。 4) 充分考虑零基础小伙伴，通俗易懂 5)...
B站韩顺平QQ项目源代码
最新发布
04-19
【标题】"B站韩顺平QQ项目源代码"是一个基于Java编程语言的QQ聊天应用程序的源码实现，由知名讲师韩顺平在B站上分享。这个项目旨在教授Java编程技术，特别是网络编程和多线程应用，通过构建一个简易版的QQ客户端和...
韩顺平java从入门到精通的教学PPT
02-26
韩顺平java从入门到精通的教学PPT
韩顺平.循序渐进学.java.从入门到精通完整版PPT完整版笔记代码
02-03
完整版笔记代码，韩顺平.循序渐进学.java.从入门到精通完整版PPT完整版笔记代码
Java视频教程课件 郝斌107集全+韩顺平 第二版 百度云
03-07
1. Java视频教程程精彩课程 郝斌107集全 百度云 经典教程 2. 韩顺平 第二版 java视频教程 全套
韩顺平javase javaee 所有源代码和课件
12-28
韩顺平javase javaee 所有源代码和课件
韩顺平java笔记完整版
09-07
java课件PPT、java基础，适合初次接触java的朋友，可以下载看看，ppt。大家最好还要看视频教程学习，一起对着看就可以。
韩顺平 java 第38讲 线程
chen
10-12 1199
进程、线程的基本概念进程是指运行中的应用程序，每个进程都有自己独立的地址空间（内存空间）。比如用户点击ie浏览器，就启动了一个进程，操作系统就会为该进程分配独立的地址空间，当用户再次点击ie浏览器图标，就又启动了一个进程，操作系统将为新的进程分配新的独立的地址空间。线程是进程中的一个实体，是被系统独立调度和分派的基本单位，线程自己不拥有系统资源，只拥有一点在运行中必不可少的资源，但它可与同属一个进程
bilibili 韩顺平Java后端学习路线
China_HADES的博客
06-13 6451
java后端技术路线是一个相对完整的学习路线，所以大家不用把所有的都学完再去找工作，不用这样子，其实你只要学到第四个，第五个阶段，再做一些项目，再刷一些题，其实就可以开始准备找工作了 视频链接：https://www.bilibili.com/video/BV14K4y177Qk...
Java多线程（2）——多线程安全（传智播客毕老师视频讲解）
lx20012002的专栏
09-11 1064
有如下代码 public class RunnableDemo2 implements Runnable { int i=10; public void run() { for(;i>0;i--) System.out.println("...."+Thread.currentThread().getName()+"...."+i); } } public class Xi
Java_Study学习笔记（基础概念+运算符）
*ノ惯性呆萌￣︶￣的博客
06-04 121
Java学习的基础概念和java的相关运算符计算
"韩顺平Java零基础完整笔记word文档详细入门指南
韩顺平的《循序渐进学Java零基础》是一套针对Java编程新手的完整教程，内容全部由韩顺平老师编写并讲解。这套教程以Word文档形式发布，可以方便用户自行编辑和查阅学习。 第一章中，教程详细介绍了整个Java学习的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

别来无恙blwy

你的鼓励将是我创作的最大动力

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

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

打赏作者

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

抵扣说明：

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

余额充值