多线程案例分析

最新推荐文章于 2024-08-10 16:13:20 发布
最新推荐文章于 2024-08-10 16:13:20 发布
阅读量249 收藏
点赞数 2
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_54698212/article/details/129897173
版权

目录

模拟多个线程实现取钱操作：

模拟多个线程实现售票操作：

模拟多个线程实现强抢红包操作：

生产者-消费者模式：

生产者-消费者模式（阻塞队列）：

模拟多个线程实现取钱操作：

    1.创建Account类
    2.创建自定义线程类实现取款操作
    3.创建多个线程实现取款，观察数据的变化

Account类

public class Account {
    private int deposit;//存款

    public Account() {
    }

    public Account(int deposit) {
        this.deposit = deposit;
    }

    public int getDeposit() {
        return deposit;
    }

    public void setDeposit(int deposit) {
        this.deposit = deposit;
    }

    public void withdraw(int num) {//取款
        synchronized (this) {
            if (this.deposit < num) {
                System.out.println("存款不够");
                System.exit(0);
            } else {
                //获取存款
                int before = this.deposit;
                //模拟取钱
                int after = before - num;
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    System.out.println(e.getMessage());
                }
                //修改存款
                this.deposit = after;
                System.out.println(Thread.currentThread().getName() + "取走" + num + "元，余额为：" + after);
            }
        }
    }
}

AccountThread类

public class AccountThread extends Thread{
    private Account account;

    public AccountThread(Account account) {
        this.account = account;
    }

    @Override
    public void run() {
        while(true) {
            account.withdraw(100);
        }
    }
}

Test类

public class Test {
    public static void main(String[] args) {
        //初始化
        Account account = new Account(1000);
        Thread thread1 = new AccountThread(account);
        thread1.setName("取款人1");
        thread1.start();
        Thread thread2 = new AccountThread(account);
        thread2.setName("取款人2");
        thread2.start();
    }
}

运行结果：

取款人1取走100元，余额为：900
取款人1取走100元，余额为：800
取款人1取走100元，余额为：700
取款人1取走100元，余额为：600
取款人1取走100元，余额为：500
取款人1取走100元，余额为：400
取款人1取走100元，余额为：300
取款人2取走100元，余额为：200
取款人2取走100元，余额为：100
取款人1取走100元，余额为：0
存款不够

模拟多个线程实现售票操作：

SellTicket类

public class SellTicket {
    private int ticket;

    public SellTicket() {
    }

    public SellTicket(int ticket) {
        this.ticket = ticket;
    }

    public int getTicket() {
        return ticket;
    }

    public void setTicket(int ticket) {
        this.ticket = ticket;
    }
    public void sellTicket() {
        synchronized (this) {
            if (ticket == 0) {
                System.out.println("没票了");
                System.exit(0);
            } else {
                try {
                    Thread.sleep(300);
                } catch (InterruptedException e) {
                    System.out.println(e.getMessage());
                }
                //一次卖一张票
                System.out.println(Thread.currentThread().getName() + "卖出一张票，余票为：" + ticket--);
            }
        }
    }
}

TicketThread类

public class TicketThread extends Thread{
    private SellTicket sellTicket;

    public TicketThread(SellTicket sellTicket) {
        this.sellTicket = sellTicket;
    }

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            sellTicket.sellTicket();
        }
    }
}

Test类

public class Test {
    public static void main(String[] args) {
        SellTicket sellTicket = new SellTicket(20);
        Thread thread1= new TicketThread(sellTicket);
        Thread thread2= new TicketThread(sellTicket);
        Thread thread3= new TicketThread(sellTicket);
        thread1.start();
        thread2.start();
        thread3.start();
    }
}

运行结果：

Thread-0卖出一张票，余票为：20
Thread-0卖出一张票，余票为：19
Thread-0卖出一张票，余票为：18
Thread-2卖出一张票，余票为：17
Thread-2卖出一张票，余票为：16
Thread-2卖出一张票，余票为：15
Thread-2卖出一张票，余票为：14
Thread-2卖出一张票，余票为：13
Thread-2卖出一张票，余票为：12
Thread-2卖出一张票，余票为：11
Thread-2卖出一张票，余票为：10
Thread-2卖出一张票，余票为：9
Thread-2卖出一张票，余票为：8
Thread-1卖出一张票，余票为：7
Thread-1卖出一张票，余票为：6
Thread-1卖出一张票，余票为：5
Thread-1卖出一张票，余票为：4
Thread-1卖出一张票，余票为：3
Thread-1卖出一张票，余票为：2
Thread-1卖出一张票，余票为：1
没票了

模拟多个线程实现强抢红包操作：

RedPacket类

import java.util.Random;

public class RedPacket implements Runnable{
    /**
     *  抢红包：金额：money， 数量: count
     * 每轮次抢的金额 ( money元*100 )分
     * 金额随机数（范围）1-money*100-(count-1)*MIN
     * 最少钱数：MIN
     */
    private int money;//红包金额
    private int count;//红包数量
    private final int MIN = 1;//抢到的最少金额，1分

    public RedPacket() {
    }

    public RedPacket(int money, int count) {
        this.money = money*100;
        this.count = count;
    }


    @Override
    public void run() {
        synchronized (this) {
            if (count == 0) {
                System.out.println(Thread.currentThread().getName()+"手速过慢，红包已经没了");
                System.exit(0);
            } else {
                int num = 0;
                if (count == 1) {
                    num = this.money;//最后一次的红包为剩余的钱数
                }else{
                    Random random = new Random();
                    num = random.nextInt(this.money-(this.count-1)*MIN) + MIN; //每轮随机的钱数
                }
                System.out.println(Thread.currentThread().getName() + "抢到了" + num/100.0 + "元");
                this.money -= num;
                this.count--;
            }
        }
    }
}

 Test类

public class Test {
    public static void main(String[] args) {
        RedPacket redPacket = new RedPacket(10,5);
        while(true){
            new Thread(redPacket).start();
        }
    }
}

运行结果：

Thread-0抢到了3.12元
Thread-8抢到了3.4元
Thread-28抢到了1.82元
Thread-7抢到了0.39元
Thread-20抢到了1.27元
Thread-4手速过慢，红包已经没了

生产者-消费者模式：

Stock类：

public class Stock {
    private int count;//最大容量10
    public synchronized void push(){
        if(count<10){
            count++;
            this.notifyAll();
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                System.out.println(e.getMessage());
            }
            System.out.println(Thread.currentThread().getName()+"正在生产"+count);
        }else{
            try {
                this.wait();
            } catch (InterruptedException e) {
                System.out.println(e.getMessage());
            }
            System.out.println("仓库已满，停止生产");
        }
    }
    public synchronized void pop(){
        if(count>0){
            count--;
            this.notifyAll();
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                System.out.println(e.getMessage());
            }
            System.out.println(Thread.currentThread().getName()+"正在消费,库存还有"+count);
        }else{
            try {
                this.wait();
            } catch (InterruptedException e) {
                System.out.println(e.getMessage());
            }
            System.out.println("仓库已空，继续生产");
        }
    }
}

Produce类：

public class Produce extends Thread{
    private Stock stock;

    public Produce(Stock stock) {
        this.stock = stock;
    }

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            stock.push();
        }
    }
}

Consumer类：

public class Consumer extends Thread{
    private Stock stock;

    public Consumer(Stock stock) {
        this.stock = stock;
    }

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            stock.pop();
        }
    }
}

Test类：

public class Test1 {
    public static void main(String[] args) {
        Stock stock = new Stock();
        Produce thread1 = new Produce(stock);
        Consumer thread2 = new Consumer(stock);
        thread1.start();
        thread2.start();
    }
}

运行结果：

 Thread-0正在生产1
Thread-0正在生产2
Thread-0正在生产3
Thread-0正在生产4
Thread-0正在生产5
Thread-0正在生产6
Thread-0正在生产7
Thread-0正在生产8
Thread-0正在生产9
Thread-1正在消费,库存还有8
Thread-0正在生产9
Thread-1正在消费,库存还有8
Thread-1正在消费,库存还有7
Thread-1正在消费,库存还有6
Thread-1正在消费,库存还有5
Thread-1正在消费,库存还有4
Thread-1正在消费,库存还有3
Thread-1正在消费,库存还有2
Thread-1正在消费,库存还有1
Thread-1正在消费,库存还有0

生产者-消费者模式（阻塞队列）：

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

public class Test1 {
    public static void main(String[] args) {
        BlockingQueue queue = new ArrayBlockingQueue(10);
        Thread produce = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 20; i++) {
                    try {
                        queue.put(i);
                        Thread.sleep(100);
                        System.out.println(Thread.currentThread().getName()+"正在生产"+i);
                    } catch (InterruptedException e) {
                        System.out.println(e.getMessage());
                    }
                }
            }
        });
        produce.start();
        Thread consumer = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 20; i++) {
                    try {
                        Object value = queue.take();
                        Thread.sleep(100);
                        System.out.println(Thread.currentThread().getName()+"正在消费"+value);
                    } catch (InterruptedException e) {
                        System.out.println(e.getMessage());
                    }
                }
            }
        });
        consumer.start();
    }
}

运行结果：

 Thread-0正在生产0
Thread-1正在消费0
Thread-0正在生产1
Thread-1正在消费1
Thread-0正在生产2
Thread-0正在生产3
Thread-1正在消费2
Thread-0正在生产4
Thread-1正在消费3
Thread-0正在生产5
Thread-0正在生产6
Thread-1正在消费4
Thread-0正在生产7
Thread-1正在消费5
Thread-0正在生产8
Thread-0正在生产9
Thread-1正在消费6
Thread-1正在消费7
Thread-1正在消费8
Thread-1正在消费9

那蓝桉
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
若依实现文件多线程批量上传案例
猿小白的博客
12-11 4074
若依实现文件多线程批量上传案例
python多线程接口案例
12-21
在这个特定的“python多线程接口案例”中，我们看到一个脚本被设计用来模拟50个或更多的用户并发访问某个内控公司的业务接口，并生成Excel报告记录结果。以下是对整个脚本的详细解析： 1. **获取Cookie**： 通过...
ruoyi-vue版本（三）AsyncManager 实现异步线程池的逻辑操作
一天不写代码难受的博客
01-17 1669
若依
SpringBoot 配置定时任务多线程异步执行
爱码猿的博客
08-26 2642
SpringBoot使用==@scheduled==执行定时任务是是单线程执行的，如果某个任务阻塞或者执行时间过长，会影响其他定时任务的执行。一般在项目内都需要进行相应的配置来允许定时任务并行执行
Socket与多线程案例
10-02
在这个“Socket与多线程案例”中，我们将会探讨如何在矿山定位系统这样的背景下，利用这两种技术实现高效的数据通信。 首先，让我们了解一下Socket。Socket是网络通信的基本单元，可以理解为网络上的应用程序之间...
多线程弹球代码案例
03-11
通过阅读和分析这个代码，我们可以进一步了解线程如何被创建、启动、同步以及通信，从而加深对多线程编程的理解。 总的来说，"多线程弹球代码案例"是一个很好的教学工具，它将抽象的线程概念与直观的游戏场景相结合...
java多线程案例——未完成
08-21
在这个未完成的案例中，我们可能正在探讨如何在Java中创建和管理线程，以及处理多线程环境下的并发问题。下面是对Java多线程基础知识的详细解释： 1. **线程的创建方式**： - 继承`Thread`类：自定义一个新的类，...
java多线程经典案例
01-15
通过分析并实践`threadTest`案例，我们可以深入理解Java多线程的原理和使用技巧，为编写高效并发程序打下坚实基础。同时，也要注意多线程编程中的死锁、活锁和饥饿等问题，合理设计线程间的交互，避免出现不可预期的...
C++ - 函数重载
jiaowenjie的专栏
08-06 324
/打印的是第二个函数的地址。//打印的是第一个函数的地址。-> 重载函数在本质上是相互独立的不同函数。-> 函数返回值不能作为函数重载的依据。-> 重载函数的函数类型不同。**3.函数默认参数和函数重载****函数重载的注意事项：****4.函数重载的本质**
Spring事务
c1tenj2的博客
08-07 434
以银行转账为例，一次转账操作伴随着一个账户的扣钱和另一个账户的加钱，这个流程是一个原子操作，要么同时发生，一气呵成，要么都不做。AccountServiceImpl实现AccountService接口，里面只有一个转账方法AccountMapper以及其映射文件account数据库测试代码用1/0模拟程序运行时出现异常的情况由于没有开启事务，出现了莫名其妙少了100块钱的情况，说明这个事务不是连续的。
反射和注解
supercool7的博客
08-08 253
反射的基本步骤包括获取Class对象、获取类的信息（构造函数、方法、字段等），然后通过Constructor、Method、Field等类的实例进行具体的操作。注解以@符号开头，通常紧跟着一个标识符，后面可以跟一些参数，用于给类、方法、字段等添加元数据信息，这些信息可以在编译时、运行时被读取和处理。通过Class类，可以获取类的构造函数、方法、字段等信息，而不需要在编译时确定这些信息。Spring、SpringBoot、Mybatis等框架中都大量使用了反射机制。此外，开发者还可以定义自己的注解，通过。
Java：继承，this，super
最新发布
m0_75257168的博客
08-10 274
可以同名，但参数列表不能相同（有参无参构造）
安卓Android & JAVA校招/实习面试合集:多线程、强软弱虚引用、进程、内存管理、Activity、Fragment......
qq_41915623的博客
08-10 270
安卓Android、java面试资料合集：内存管理、多线程、进程、强软弱虚应用、Activity
JVM 加载阶段 Class对象加载位置是在 堆中还是方法区？
萧曳丶
08-06 371
Class对象的加载位置：Class对象本身是加载到堆区中的。类的类型信息加载位置：类的类型信息（元数据）是加载到方法区（或元空间）中的。因此，对于问题“jvm 加载阶段 Class加载到堆中还是方法区”，答案是：Class对象加载到堆中，而类的类型信息加载到方法区（或元空间）中。这两个区域在JVM的类加载过程中都扮演着重要的角色，共同支持着Java程序的运行。
Spring一个强大便捷的代理工厂类
330553352的专栏
08-10 195
但如果你需要一种更加灵活和可配置性，那么Spring还提供了一个非常方便强大的ProxyFactoryBean类，该类特别适合那些需要更多自定义和控制的场景，例如当你需要为特定的Bean创建代理，或者需要在不修改原始代码的情况下为现有类添加额外的功能时。在Spring框架中，AOP（面向切面编程）是一种强大的编程范式，它允许开发者在不修改原有代码的情况下，为程序添加额外的功能，如日志记录、事务管理、安全控制等。在上面配置拦截器时，我们都是指定的具体拦截器，其实我们还可以使用通配符，指定拦截器。
dynamic-datasource+Mybatis多数据源使用
tiantiantbtb的博客
08-06 895
严格匹配数据源,默认false. true未匹配到指定数据源时抛异常,false使用默认数据源。#设置默认的数据源或者数据源组,默认值即为master。#去掉默认使用HikariCP。
javaImageIo实现图片内容动态修改
zhangzeshan
08-07 158
在指定坐标绘制水印文字
Leetcode JAVA刷刷站（10）正则表达式匹配
m0_73399576的博客
08-10 509
Leetcode JAVA刷刷站——字符串转换整数篇
多核编程实践：.NET多线程TCP服务案例
"这篇文档是关于基于多核编程的案例分析，主要探讨如何在多核架构下进行程序设计，特别是针对.NET环境下的多线程TCP服务。案例中涉及了C/S模式下的多媒体socket通信，以及如何在Intel处理器平台下利用多核优势优化...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值