第十七章 Java线程

已于 2024-05-27 10:44:12 修改
阅读量766 收藏 1
点赞数 2
分类专栏： javaSE 文章标签： 学习 java 前端
于 2022-11-26 22:09:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_18817831/article/details/127952264
版权

目录

在这里插入图片描述

1. 线程基本概念

1.1进程

  1. 进程是指运行中的程序，比如启动了QQ，就相当于启动了一个进程，操作系统会为该进程分配空间；当我们使用迅雷，就相当于又启动了一个进程，操作系统将为迅雷分配新的内存空间；
  2. 进程是程序的一次执行过程，或是正在运行的一个程序，是动态过程，有它自身的产生、存在、消亡的过程；
  3. Run代表启动了一个进程，会马上进入main方法，这时进程就开启了一个线程，即主线程；
    在这里插入图片描述
    这时再启用start()方法就会在主线程里面再启动一个子线程：Thread-0；
    子线程在执行的时候，主线程不会阻塞，会继续执行；
    在这里插入图片描述

1.2线程

  1. 线程由进程创建的，是进程的一个实体；
  2. 一个进程可以拥有多个线程；
  3. 单线程：在同一个时刻，只允许执行一个线程；
  4. 多线程：同一个时刻，可以执行多个线程。比如，一个qq进程，可以同时打开多个聊天窗口；一个迅雷进程，可以同时下载多个文件；

1.3 并发

(1)单核CPU实现多任务；(2)同一个CPU，在某个时刻，多个任务交替执行；CPU速度很快，造成“QQ”和“迅雷”貌似同时执行的错觉；
在这里插入图片描述

1.4 并行

(1)在同一个时刻多个任务同时执行，多核CPU可以实现并行；

在这里插入图片描述

获取当前电脑Cpu数量
在这里插入图片描述

3. 线程基本使用

在这里插入图片描述

3.1 继承Thread类

  1. 当一个类继承了Thread类，该类就可以当作线程使用；
  2. Thread类实现了Runnable接口的run方法
    在这里插入图片描述
  3. 重写run方法，实现自己的业务逻辑
    在这里插入图片描述
  4. 调用start()方法会调用run()方法
    在这里插入图片描述

3.1.1 子线程

  1. Run代表启动了一个进程，会马上进入main方法，这时进程就开启了一个线程，即主线程；
  2. 这时再启用start()方法就会在主线程里面再启动一个子线程：Thread-0；
  3. 子线程在执行的时候，主线程不会阻塞；
  4. 子线程、主线程会交替执行；
    在这里插入图片描述
  5. 主线程的名称是main，子线程的名称从Thread-0开始；
3.1.1.1 JConsole监控
  • 验证：使用JConsole监控线程执行情况：
    在这里插入图片描述
    在这里插入图片描述
3.1.1.2 直接run()方法
  1. 此时的run()方法只是个普通方法，直接调用并不会开启子线程，此时Thread.currentThread().getName()是main
  2. 直接调用run方法不会开启子线程，默认在主线程内执行；
    在这里插入图片描述
  3. 会把run()方法执行完毕，才向下执行，串行化地执行，程序会阻塞；
    在这里插入图片描述
3.1.1.2 调用start()方法
  • 真正实现多线程的效果，是start0()方法
  1. cat调用start()方法，进入到Thread类的start()方法，start()方法调用start0()方法；
    在这里插入图片描述
  2. 进入到Thread类中的start()方法；start0()是本地方法，JVM调用，用C/C++编写；
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

3.2 实现Runable接口

  1. 假如一个A类继承了B类，那么它就不能再继承Thread类，这个时候让A类实现Runable接口，同样能实现线程；
  2. Runable接口里没有start()方法，只有个run方法；
    在这里插入图片描述
    解决方案：dog对象赋给了Thread类中的target，thread.start()方法调用start0()方法，start0()方法调用本类的run方法，再调用target的run方法；在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

3.2.1 线程代理模式

用代码模拟实现Runnable接口实现线程的机制；

  1. 把Proxy类当作Thread类
public class Thread02 {
    public static void main(String[] args) {
        Tiger tiger = new Tiger();//实现了Runnable接口
        ThreadProxy threadProxy = new ThreadProxy(tiger);
        threadProxy.start();
    }
}

实现步骤： 先创建一个Proxy类，继承Runnable

class ThreadProxy implements Runnable {//把Proxy类当作 ThreadProxy 线程代理

    private Runnable target = null;
    @Override
    public void run() {
        if (target != null) {
            target.run();//动态绑定（运行类型Tiger）
        }
    }

    public ThreadProxy(Runnable target) {
        this.target = target;
    }

    public void start() {
        start0();//真正实现多线程的方法
    }

    public void start0() {
        run();
    }
}
  1. 再创建一个普通类，实现Runnable接口；
class Tiger extends Animal implements Runnable{

    @Override
    public void run() {
        System.out.println("老虎发威~~");
    }
}

3.2.2 多线程机制

两个子线程会交替执行
在这里插入图片描述
在这里，主线程看不到
在这里插入图片描述
在这里插入图片描述

3.3 继承Thread Vs 实现Runnable接口

  1. 本质没有区别，因为Thread类本身就实现了Runnable接口的run()方法
  2. 但是实现Runnable接口的方式更加适合多个线程共享一个资源的情况，并且避免了单继承的限制；（建议使用Runnable接口）
  3. 继承Thread实现线程无法做到资源共享，并且受到单继承的限制；
    在这里插入图片描述

3.3.1 售票系统超卖问题

sleep()要在–tickets前面才能超卖

public class SellTicket {
    public static void main(String[] args) {
        /*SellTicket1 sellTicket1 = new SellTicket1();
        SellTicket1 sellTicket2 = new SellTicket1();
        SellTicket1 sellTicket3 = new SellTicket1();
        sellTicket1.start();
        sellTicket2.start();
        sellTicket3.start();*/
        SellTicket1 sellTicket1 = new SellTicket1();
        Thread thread1 = new Thread(sellTicket1);
        Thread thread2 = new Thread(sellTicket1);
        Thread thread3 = new Thread(sellTicket1);
        thread1.start();
        thread2.start();
        thread3.start();
    }
}

class SellTicket1 extends Thread {
    //private static int tickets = 100;
    private int tickets = 100;
    int count = 0;
    @Override
    public void run() {
        while (true) {
            if (tickets <= 0) {
                break;
            }
            System.out.println("窗台：" + Thread.currentThread().getName() +
                    "出售了" + (++count) + "张票,剩余票数：" + (--tickets));
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

3.3.2 线程终止

  1. 当线程完成任务后，会自动退出；
  2. 可以通过变量来控制run方法退出线程，即通知方式
3.3.2.1 通知线程退出

启动一个线程t，要求在main线程中去停止线程t
解决方案：在主线程中通过Setter方法将loop变量设置为false
在这里插入图片描述
在这里插入图片描述

3.3.3 线程基本方法

方法名作用
setName设置线程名称
getName获取线程名称
setPriority设置线程优先级
getPriority获取线程优先级
interrupt中断线程

在这里插入图片描述

3.3.3 线程中断

  1. interrupt中断线程，但并没有真正的结束线程，所以一般用于中断正在休眠的线程；（中断休眠，唤醒线程）
  2. sleep()，线程的静态方法，使当前线程休眠；
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());//获取线程名称

        //主线程打印5个hi，然后就中断子线程的休眠
        for (int i = 0; i < 5; i++) {
            Thread.sleep(1000);
            System.out.println("hi~~" + i);
        }
        System.out.println(t.getName() + "线程的优先级" + t.getPriority());
        t.interrupt();//执行到interrupt()方法时，中断线程的休眠
    }
}

class T extends Thread {
    @Override
    public void run() {
        while (true) {
            for (int i = 0; i < 100; i++) {
                //获取当前线程的名称
                System.out.println(Thread.currentThread().getName() + " 吃包子～～" + i);
            }
            try {
                System.out.println(Thread.currentThread().getName() + " 正在休眠中～～");
                Thread.sleep(20 * 1000);
            } catch (InterruptedException e) {
                //当该线程执行到一个interrupt 方法时，就会catch 一个异常，可以加入自己的业务代码
                // InterruptedException捕获了一个中断异常
                System.out.println(Thread.currentThread().getName() + "被中断了");
            }
        }
    }
}

3.3.4 线程礼让

yield：线程的礼让，让出cpu，让其它线程执行，但礼让的时间不确定，所以不一定礼让成功；

3.3.5 线程插队

join：线程插队，一旦插入成功，则先执行完插入的线程的所有的任务；

public class Thread03 {
    public static void main(String[] args) throws InterruptedException {
        T t = new T();
        Thread thread = new Thread(t);
        thread.start();
        for (int i = 1; i <= 20; i++) {
            Thread.sleep(1000);
            System.out.println(Thread.currentThread().getName() + "(小弟)吃了" + i + "个");
            if (i == 10) {
                System.out.println("main线程(小弟)让子线程(大哥)先吃");
//                thread.join();//子线程(大哥)插队，大哥吃完小弟再吃
                Thread.yield();//main线程(小弟)礼让，不一定成功...
            }
        }
    }
}

class T implements Runnable {
    private int count = 0;
    private boolean loop = true;
    @Override
    public void run() {
        while (loop) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("子线程(老大)吃了" + (++count) + "个");
            if (count == 20) {//吃到20个结束
                System.out.println("子线程(大哥)吃完了，main线程(小弟)继续吃");
                break;
            }
        }
    }
    public void setLoop(boolean loop) {
        this.loop = loop;
    }
}
3.3.5.1 线程插队练习
public class ThreadMethodExercise {
    public static void main(String[] args) throws InterruptedException {
        T1 t1 = new T1();
        Thread thread = new Thread(t1);
        for (int i = 1; i <= 10; i++) {
            Thread.sleep(1000);
            System.out.println("main线程：hi " + i);
            if (i == 5) {
                thread.start();
                thread.join();//子线程启动后直接插队
            }
        }
    }
}

class T1 implements Runnable {
    private int count;
    @Override
    public void run() {
        while (true) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("子线程: hello " + (++count));
            if (count == 10) {
                break;
            }
        }
    }
}

3.3.6 守护线程

用户线程：也叫工作线程、当线程的任务执行完或通知方式结束；
守护线程：一般是为工作线程服务的，当所有的用户线程结束，守护线程自动结束；
常见的守护线程：垃圾回收机制；

主线程结束，子线程并不会结束；如果我们希望主线程结束时，子线程也结束，可以将子线程设置为守护线程；

public class ThreadMehod03 {
    public static void main(String[] args) {
        MyDaemonThread myDaemonThread = new MyDaemonThread();
        Thread thread = new Thread(myDaemonThread);
        thread.setDaemon(true);//将子线程设置为守护线程
        thread.start();
        for (int i = 1; i <= 10; i++) {
            System.out.println("主线程" + Thread.currentThread().getName() + i);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

class MyDaemonThread implements Runnable {
    @Override
    public void run() {
        for (; ; ) {
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("子线程" + Thread.currentThread().getName());
        }
    }
}

3.3.7 线程的声明周期

  1. JDK中用Thread.State枚举表示了线程的七种（六种）状态
    在这里插入图片描述
public class ThreadState_ {
    public static void main(String[] args) throws InterruptedException {
        T2 t2 = new T2();
        Thread thread = new Thread(t2);
        System.out.println(thread.getName() + "状态 " + thread.getState());//NEW
        thread.start();
        //子线程和主线程同时执行
        /*for (int i = 0; i < 10; i++) {
            Thread.sleep(1000);//主线程休眠、主线程输出
            System.out.println(thread.getName() + "状态 " + thread.getState());//RUNNABLE
        }*/
        while (Thread.State.TERMINATED != thread.getState()) {
            Thread.sleep(1000);
            System.out.println(thread.getName() + "状态 " + thread.getState());//RUNNABLE、TIMED_WAITING
        }
        System.out.println(thread.getName() + "状态 " + thread.getState());//TERMINATED
    }
}

class T2 implements Runnable {
    @Override
    public void run() {
        while (true) {
            for (int i = 0; i < 10; i++) {
                System.out.println(Thread.currentThread().getName() + " " + i);//子线程输出
                try {
                    Thread.sleep(1000);//子线程休眠
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            break;
        }
    }
}

3.3.8 线程同步机制

  1. 在多线程编程中，一些敏感数据不允许被多个线程同时访问，此时就使用同步访问技术，保证数据在任意一个时刻，最多有一个线程访问，以保证数据的完整性；
  2. 也可以这样理解：线程同步，即当有一个线程在对内存进行操作时，其它线程都不可以对这个内存地址进行操作，知道该线程完成操作后，其它线程才能对该内存地址进行操作；

3.3.9 互斥锁

  1. Java语言中，引入了对象互斥锁的概念，来保证共享数据操作的完整性；

  2. 每个对象都对应一个可称为“互斥锁”的标记，这个标记用来保证在任一时刻，只能有一个线程访问该对象；

  3. 关键字synchronized来与对象的互斥锁联系，当某个对象用synchronized修饰时，表明该对象在任一时刻只能由一个线程访问；

  4. 同步的局限性：会导致程序的执行效率降低；

  5. 同步方法(非静态的)的锁可以是this，也可以是其它对象(要求是同一个对象)
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

  6. 同步方法(静态的)的锁为当前类本身；

  7. 手段：方法上加锁、代码块上加锁；

  8. 执行了线程对象的wait()方法，当前线程暂停，释放锁；

  9. 同步方法如果没有使用static修饰，默认锁对象为this；

  10. 如果方法使用static修饰，默认锁对象：当前类.class; 如果想在静态方法中，实现一个同步代码块，写类本身；
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

3.4.0 死锁

public class DeadLock_ {
    public static void main(String[] args) {
        DeadLockDemo deadLockDemo = new DeadLockDemo(true);
        deadLockDemo.setName("A线程");
        deadLockDemo.start();
        DeadLockDemo deadLockDemo1 = new DeadLockDemo(false);
        deadLockDemo1.setName("B线程");
        deadLockDemo1.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为true，线程A 就会先得到/持有 o1对象锁，然后尝试去获取o2对象锁
        //(2)如果flag为true，线程A 就会先得到/持有 o1对象锁，然后尝试去获取o2对象锁
        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");
                }
            }
        }
    }
}

3.4.1 释放锁

  1. 同步方法中执行了线程对象的wait()方法，当前线程暂停，并释放锁；
  2. 同步方法中遇到break，return，不得不结束线程，释放锁；
  3. 同步方法中出现了未处理的error或者Exception，导致线程异常结束，释放锁；
3.4.1.1 不释放锁
  1. 程序调用Thread.sleep()、Thread.yield() 方法暂停当前线程的执行，但并不会释放锁；
  2. 线程执行同步代码块时，其它线程调用了该线程的suspend()方法将该线程挂起，而该线程不释放锁；
~ 小团子
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
java基础代码_java_输入输出流_接口_多线程_异常_
09-29
在校学习时编写的java代码以及思考笔记，涉及java多线程的实现与协调、输入输出流、接口、继承等内容，适合java新手编程入门
JAVA线程
互联网底层民工的博客
06-26 8426
虽然我们可以理解同步代码块和同步方法的锁对象问题，但是我们并没有直接看到在哪里加上了锁，在哪里释放了锁，为了更清晰的表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock，Lock是接口不能直接实例化，这里采用它的实现类ReentrantLock来实例化。
Java线程
sunyingboaini的博客
06-20 1万+
线程的使用
JAVA之多线程
maxu0808的博客
03-18 1005
一、什么是多线程 1. 线程与进程、并行与并发 进程：每个进程拥有自己的一整套变量。一个进程可以包含多个线程。 线程：线程属于进程，多个线程会存在共享数据的情况发生，也就是多个线程会共享同一块内存区域。 一个例子：打开word是一个进程，打开qq音乐又是另外一个进程，两进程之间不会互相影响（都有自己的一块内存区域）。但比如在qq音乐里一遍听歌，一遍又浏览排行榜，那就是在qq音乐这个进程里又有两个线程，它们之间会存在共享内存的情况。 并发：多线程就是并发的例子，一块CPU调度时会分为好多个时间片，每
Java基础核心技术：多线程(day16-day17)
05-11
本套Java视频完全针对初级学员，课堂实录，自发布以来，好评如潮！Java视频中注重与学生互动，讲授幽默诙谐、细致入微，覆盖Java基础所有核心知识点，同类Java视频中也是代码量大、案例多、实战性强的。同时，本Java视频教程注重技术原理剖析，深入JDK源码，辅以代码实战贯穿始终，用实践驱动理论，并辅以必要的代码练习。
Java线程系列详解
wang_yong_hui_1234的博客
04-15 3600
1）volatile本质是在告诉jvm当前变量在寄存器中的值是不确定的，需要从主存中读取，synchronized则是锁定当前变量，只有当前线程可以访问该变量，其他线程被阻塞住。2）volatile仅能使用在变量级别，synchronized则可以使用在变量，方法。3）volatile仅能实现变量的修改可见性，而synchronized则可以保证变量的修改可见性和原子性。4）volatile不会造成线程的阻塞，而synchronized可能会造成线程的阻塞。
Java 线程 基础知识总结
Zhangguohao666的博客
07-27 6227
文章目录线程基础生产消费者模型，synchronizedjoin方法+死锁（哲学家进餐问题）join和锁死锁有趣的Timer类Timer多线程的一个运行实例 初步认识下线程，线程怎么去实现（通过继承Thread或者实现Runnable接口） 线程基础 很不严谨的说，线程是什么？线程就是为了让很多个东东并发执行，大大的提高程序执行的效率啊 三个非常重要的概念： 程序：一组写好了的静态代码块（就我...
编程必备：JAVA多线程详解
拾一二的博客
06-14 7568
多线程已经成为一种常见的编程模式，广泛应用于各种不同类型的应用程序中。本篇博客文章中，我们将会探讨多线程编程的相关知识和技巧。通过代码示例和实际应用案例来深入了解多线程的具体实现和应用方法，帮助更好地掌握多线程编程技术，提高程序效率和性能。后期随学习深入还会补充修改。以上就是我对多线程的个人简介，后续会不断完善更新，与大家共勉。
Java多线程超详解
热门推荐
weixin_44797490的博客
06-11 14万+
引言 随着计算机的配置越来越高，我们需要将进程进一步优化，细分为线程，充分提高图形化界面的多线程的开发。这就要求对线程的掌握很彻底。 那么话不多说，今天本帅将记录自己线程的学习。 线程的相关API //获取当前线程的名字 Thread.currentThread().getName() 1.start():1.启动当前线程2.调用线程中的run方法 2.run():通常需要重写Thread类中的此...
全网最全JAVA面试八股文，终于整理完了
hahazz233的博客
06-24 1万+
又到一年金三银四面试跳槽季，你准备好了吗？今天为大家整理了目前互联网出现率最高的大厂面试题，所谓八股文也就是指文章的八个部分，文体有固定格式:由破题、承题、起讲、入题、起股、中股、后股、束股八部分组成，题目一律出自四书五经中的原文。而JAVA面试八股文也就是为了考验大家的JAVA基础功底，所以强烈建议背诵全文。（1） 原子性原子性指的是一个或者多个操作，要么全部执行并且在执行的过程中不被其他操作打断，要 么就全部都不执行。（2） 可见性可见性指多个线程操作一个共享变量时，其中一个线程对变量进行修改后，其他线
计算机后端-Java-Java核心基础-第20章 多线程 17. 线程通信：生产者消费者例题.avi
05-22
计算机后端-Java-Java核心基础-第20章 多线程 17. 线程通信：生产者消费者例题.avi
java人家\Java第三十七讲总结-线程.doc
11-11
小贝程序员生活\课件\java\java人家\Java第三十七讲总结-线程.doc 小贝程序员生活\课件\java\java人家\Java第三十七讲总结-线程.doc 小贝程序员生活\课件\java\java人家\Java第三十七讲总结-线程.doc
计算机后端-Java-Java核心基础-第19章 IDEA的使用与多线程 17. 线程优先级的设置.avi
05-22
计算机后端-Java-Java核心基础-第19章 IDEA的使用与多线程 17. 线程优先级的设置.avi
【IT十八掌徐培成】Java基础第17天-04.多线程复制-1avi.zip
08-07
【IT十八掌徐培成】Java基础第17天-04.多线程复制-1avi.zip
Java2实用教程提取码
04-28
Java是一种很优秀的编程语言，具有面向对象、与平台无关、安全、稳定和多线程等特点，是目前软件设计中极为健壮的编程语言。Java语言不仅可以用来开发大型的应用程序，而且特别适合于在...第17章 JavaSwing基础
Java创建线程的七种方法，全网最全面总结~
CYK_byte的博客
02-03 2万+
属于基础的面试问题，一定要能够回答全哦~
JAVA多线程详解（超详细）
最新发布
m0_74823434的博客
10-10 1万+
程序：开发写的代码称之为程序。程序就是一堆代码，一组数据和指令集，是一个静态的概念。进程(Process)：将程序运行起来，我们称之为进程。进程是执行程序的一次执行过程，它是动态的概念。进程存在生命周期，也就是说程序随着程序的终止而销毁。进程之间是通过TCP/IP端口实现交互的。线程(Thread)：线程是进程中的实际运作的单位，是进程的一条流水线，是程序的实际执行者，是最小的执行单位。通常在一个进程中可以包含若干个线程，当然一个进程中至少有一个线程。线程是CPU调度和执行的最小单位。注意。
一篇搞懂Java多线程（全网最细）
让优秀成为一种习惯！
07-22 8328
Java多线程是一种强大而有趣的编程概念。它允许程序同时执行多个任务，就像一个宏大的交响乐团。每个线程都是一个独立的执行路径，有自己的速度和优先级。那么，我们期待多线程能给我们带来什么呢？
Java基础学习——Java线程（一）多线程的发展史、线程的三种创建方式、线程的生命周期、线程的常用方法、线程的优先级
skx1102195517的博客
12-27 1150
一、什么是线程 1.概念 1）程序：为完成特定任务，用某种语言编写的一组指令的集合（程序是静态的） 2）进程：是程序的一次执行过程。进程作为分配资源的单位，在内存中为每个正在运行的进程分配不同的内存区域（进程是动态的），进程有生命周期。 3）线程： 一个进程同时执行多个线程，就是多线程。 2.单核CPU与多核CPU 对于在单核CPU上执行的多个线程，CPU按照时间片执行，一个时间片只能执行一个线程，但时间片时间特别短，造成了同时执行多个线程的假象。 多核CPU才真正实现了同一时间多个线程同时
使用java17使用lambda开启多个线程并用线程模拟买票的高并发线程问题
05-30
接下来，我们可以使用 Lambda 表达式来创建多个线程，并模拟买票的高并发线程问题。具体实现步骤如下： 1. 创建一个 Runnable 接口的实现类，用于模拟买票的操作。 ```java public class BuyTicket implements ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

~ 小团子

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

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

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

打赏作者

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

抵扣说明：

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

余额充值