多线程练习

最新推荐文章于 2024-09-09 21:58:55 发布
最新推荐文章于 2024-09-09 21:58:55 发布
阅读量898 收藏 20
点赞数 14
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46977298/article/details/140619169
版权

练习一：售票

需求：一共有1000张电影票，可以在两个窗口领取，假设每次领取的时间为3000毫秒，请用多线程模拟卖票过程并打印剩余电影票的数量。

多个线程操作共享数据。

线程类：

public class ThreadDemo1 extends Thread{
    static int ticket = 1000;
    @Override
    public void run() {
        while (true) {
            synchronized (ThreadDemo1.class) {
                if (ticket == 0) {
                    break;
                }
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                ticket--;
                System.out.println("剩余" + ticket + "张电影票");
            }
        }
    }
}

 测试类：

public class Test1 {
    public static void main(String[] args) {
        ThreadDemo1 t1 = new ThreadDemo1();
        ThreadDemo1 t2 = new ThreadDemo1();
        t1.setName("窗口一");
        t2.setName("窗口二");
        t1.start();
        t2.start();
    }
}

练习二：赠送礼物

需求：有100份礼品，两人同时发送，当剩下的礼品小于10份的时候则不再送出。

利用多线程模拟该过程并将线程的名字和礼物的剩余数量打印出来。

线程类：

public class ThreadDemo2 extends Thread{
    static int ticket = 100;
    @Override
    public void run() {
        while (true)
            synchronized (ThreadDemo2.class) {
                if (ticket < 10) {
                    break;
                }
                ticket--;
                System.out.println(this.getName() + "：剩余" + ticket + "份礼物");
            }
    }
}

 测试类： 

public class Test2 {
    public static void main(String[] args) {
        ThreadDemo2 t1 = new ThreadDemo2();
        ThreadDemo2 t2 = new ThreadDemo2();
        t1.setName("小刘");
        t2.setName("小张");
        t1.start();
        t2.start();
    }
}

练习三：打印数字

需求：同时开启两个线程，共同获取1-100之间的所有数字。

将输出所有的奇数。

线程类：

public class ThreadDemo3 extends Thread{
    static int number = 1;

    @Override
    public void run() {
        while (true) {
            synchronized (ThreadDemo3.class) {
                if (number > 100) {
                    break;
                }
                if (number % 2 != 0) {
                    System.out.println(number);
                }
                number++;
            }
        }
    }
}

 测试类： 

public class Test3 {
    public static void main(String[] args) {
        ThreadDemo3 t1 = new ThreadDemo3();
        ThreadDemo3 t2 = new ThreadDemo3();
        t1.setName("线程1");
        t2.setName("线程2");
        t1.start();
        t2.start();
    }
}

练习四：抢红包

需求：

抢红包也用到了多线程。

假设：100块，分成了3个包，现在有5个人去抢。

其中，红包是共享数据。

5个人是5条线程。

打印结果如下：

XXX抢到了XXX元

XXX抢到了XXX元

XXX抢到了XXX元

XXX没抢到

XXX没抢到

线程类：

import java.util.Random;

public class ThreadDemo4 extends Thread {
    // 总钱数
    static int totalMoney = 100;
    // 3个人抢到红包
    static int count = 1;
    final int MIN = 1;

    @Override
    public void run() {
        synchronized (ThreadDemo4.class) {
            // 3个红包已抢完
            if (count == 4) {
                System.out.println(this.getName() + "没抢到");
            }
            // 第3个红包直接就是剩下的钱
            if (count == 3) {
                System.out.println(this.getName() + "抢了" + totalMoney + "元");
                count++;
            }
            if (count <= 2) {
                Random r = new Random();
                int money = r.nextInt(totalMoney - MIN * (3 - count)) + MIN;
                System.out.println(this.getName() + "抢了" + money + "元");
                totalMoney -= money;
                count++;
            }
        }
    }
}

关于此题，每个线程的run方法只执行一次，如何保证每个线程只抽一次？因为抽完线程就die了，不会再运行了。Java中线程的6个状态。

练习五：抽奖箱

需求：

有一个抽奖池，该抽奖池中存放了奖励的金额，该抽奖池中的奖项为 {10,5,20,50,100,200,500,800,2,80,300,700}；

创建两个抽奖箱(线程)设置线程名称分别为“抽奖箱1”，“抽奖箱2”。

随机从抽奖池中获取奖项元素并打印在控制台上，格式如下：

每次抽出一个奖项就打印一个(随机)

抽奖箱1 又产生了一个 10 元大奖

抽奖箱1 又产生了一个 100 元大奖

抽奖箱1 又产生了一个 200 元大奖

抽奖箱1 又产生了一个 800 元大奖  

抽奖箱2 又产生了一个 700 元大奖

将奖项放在集合中。随机获取索引，而集合中有一个remove方法在依据索引删除元素时会将删除的元素进行返回。或者利用工具类Collections的shuffle方法打乱元素，然后也是利用remove删除0索引处的元素并进行返回。

线程类：

import java.util.ArrayList;
import java.util.Random;

public class ThreadDemo5 extends Thread {
    ArrayList<String> list;

    public ThreadDemo5(ArrayList<String> list) {
        this.list = list;
    }

    @Override
    public void run() {
        while (true) {
            synchronized (ThreadDemo5.class) {
                int length = list.size();
                if (length == 0) {
                    break;
                }
                Random r = new Random();
                int index = r.nextInt(length);
                System.out.println(this.getName() + "又产生了一个"+list.remove(index)+"元大奖");
            }
        }
    }
}

public class Test5 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list, "10", "5", "20", "50", "100", "200", "500", "800", "2", "80", "300", "700");
        ThreadDemo5 t1 = new ThreadDemo5(list);
        ThreadDemo5 t2 = new ThreadDemo5(list);
        t1.setName("抽奖箱1");
        t2.setName("抽奖箱2");
        t1.start();
        t2.start();
    }
}

练习六：多线程统计并求最大值

需求：

在上一题基础上继续完成如下需求：

每次抽的过程中，不打印，抽完时一次性打印(随机)

在此次抽奖过程中，抽奖箱1总共产生了6个奖项。

分别为：10,20,100,500,2,300，最高奖项为300元，总计额为932元。

在此次抽奖过程中，抽奖箱2总共产生了6个奖项。

分别为：5,50,200,800,80,700最高奖项为800元，总计额为1835元。

为每个线程单独定义一个集合存自己抽到的奖。 

线程类： 

import java.util.ArrayList;
import java.util.Random;

public class ThreadDemo6 extends Thread {
    ArrayList<Integer> list;

    public ThreadDemo6(ArrayList<Integer> list) {
        this.list = list;
    }

    @Override
    public void run() {
        ArrayList<Integer> list1 = new ArrayList<>();
        while (true) {
            synchronized (ThreadDemo6.class) {
                int length = list.size();
                if (length == 0) {
                    int max = 0, sum = 0;
                    for (Integer prize : list1) {
                        sum += prize;
                        if (prize > max) {
                            max = prize;
                        }
                    }
                    System.out.println("此次抽奖过程中，" + this.getName() + "总共产生了" + list1.size() + "个奖项。");
                    System.out.print("分别为：");
                    for (Integer i : list1) {
                        System.out.print(i + ",");
                    }
                    System.out.println("最高奖项为" + max + "元，总计金额为" + sum + "元");
                    break;
                }
                Random r = new Random();
                int index = r.nextInt(length);
                list1.add(list.remove(index));
            }
        }
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }
}

 测试类：

import java.util.ArrayList;
import java.util.Collections;

public class Test6 {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        Collections.addAll(list, 10,5,20,50,100,200,500,800,2,80,300,700);
        ThreadDemo6 t1 = new ThreadDemo6(list);
        ThreadDemo6 t2 = new ThreadDemo6(list);
        t1.setName("抽奖箱1");
        t2.setName("抽奖箱2");
        t1.start();
        t2.start();
    }
}

练习七：多线程之间的比较

需求：

在上一题基础上继续完成如下需求：

在此次抽奖过程中，抽奖箱1总共产生了6个奖项，分别为：10,20,100,500,2,300

最高奖项为300元，总计额为932元。

在此次抽奖过程中，抽奖箱2总共产生了6个奖项，分别为：5,50,200,800,80,700

最高奖项为800元，总计额为1835元。

在此次抽奖过程中,抽奖箱2中产生了最大奖项,该奖项金额为800元

以上打印效果只是数据模拟,实际代码运行的效果会有差异

在测试类中将最大奖项获取出来再传递给每一个线程，当每一个线程抽取结束之后，将自己抽的最大值与最大奖项的值进行比较，如果相等则进行输出。

import java.util.ArrayList;
import java.util.Random;

public class ThreadDemo7 extends Thread {
    ArrayList<Integer> list;
    int maxPrize;

    public ThreadDemo7(ArrayList<Integer> list, int maxPrize) {
        this.list = list;
        this.maxPrize = maxPrize;
    }

    @Override
    public void run() {
        ArrayList<Integer> list1 = new ArrayList<>();
        while (true) {
            synchronized (ThreadDemo7.class) {
                int length = list.size();
                if (length == 0) {
                    int max = 0, sum = 0;
                    for (Integer prize : list1) {
                        sum += prize;
                        if (prize > max) {
                            max = prize;
                        }
                    }
                    System.out.println("此次抽奖过程中，" + this.getName() + "总共产生了" + list1.size() + "个奖项。");
                    System.out.print("分别为：");
                    for (Integer i : list1) {
                        System.out.print(i + ",");
                    }
                    System.out.println("最高奖项为" + max + "元，总计金额为" + sum + "元");
                    if (max == maxPrize) {
                        System.out.println("在此次抽奖过程中，" + this.getName() + "中产生了最大奖项，该奖项金额为" +max +"元");
                    }
                    break;
                }
                Random r = new Random();
                int index = r.nextInt(length);
                list1.add(list.remove(index));
            }
        }
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }
}

测试类：

import java.util.ArrayList;
import java.util.Collections;

public class Test7 {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        Collections.addAll(list, 10, 5, 20, 50, 100, 200, 500, 800, 2, 80, 300, 700);
        int maxPrize = 0;
        for (Integer i : list) {
            if (i > maxPrize) {
                maxPrize = i;
            }
        }
        ThreadDemo7 t1 = new ThreadDemo7(list, maxPrize);
        ThreadDemo7 t2 = new ThreadDemo7(list,maxPrize);
        t1.setName("抽奖箱1");
        t2.setName("抽奖箱2");
        t1.start();
        t2.start();
    }
}

还可以利用线程的抵第3种创建方式，将结果进行返回。

public class MyCallable implements Callable<Integer> {

    ArrayList<Integer> list;

    public MyCallable(ArrayList<Integer> list) {
        this.list = list;
    }

    @Override
    public Integer call() throws Exception {
        ArrayList<Integer> boxList = new ArrayList<>();//1 //2
        while (true) {
            synchronized (MyCallable.class) {
                if (list.size() == 0) {
                    System.out.println(Thread.currentThread().getName() + boxList);
                    break;
                } else {
                    //继续抽奖
                    Collections.shuffle(list);
                    int prize = list.remove(0);
                    boxList.add(prize);
                }
            }
            Thread.sleep(10);
        }
        //把集合中的最大值返回
        if(boxList.size() == 0){
            return null;
        }else{
            return Collections.max(boxList);
        }
    }
}

Yes_LiuSir
关注
  • 14
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java多线程练习源代码
01-11
本资源“Java多线程练习源代码”提供了一系列的示例，旨在帮助开发者深入理解和熟练掌握Java多线程的运用。 1. **线程的概念与创建** 线程是程序执行的最小单元，一个进程可以有多个线程同时执行任务。在Java中，...
多线程demo/java多线程练习
05-17
本项目"多线程demo/java多线程练习"旨在通过实际操作来深入理解和掌握多线程技术，同时模拟数据库操作，这在现代应用程序开发中至关重要。 1. **线程基础** - **创建线程**：Java提供了两种创建线程的方式，分别是...
java多线程之赛马程序实验8多线程练习下载进度
05-19
本实验"java多线程之赛马程序实验8多线程练习下载进度"聚焦于如何利用多线程来模拟实际场景中的下载进度显示。在这一过程中，我们将探讨Thread类的`run`和`start`方法，以及如何通过进度条来可视化表示下载过程。 ...
多线程练习题java
11-09
java多线程初学者练习题目，供初学者练习使用
java多线程练习demo 基本的线程使用方式 生产者消费者练习 龟兔赛跑练习.zip
11-02
java多线程练习demo 基本的线程使用方式 生产者消费者练习 龟兔赛跑练习
spring事务详细讲解-深入浅出
小电玩
09-08 325
Spring 事务是本身就是对数据库的事务的支持，没有数据库的事务 Spring 是本身无法实现事务的。Spring只提供了统一事务管理接口，具体的实现还是由各数据库自己实现。在使用 Spring 事务时，可以通过注解或编程方式将需要进行事务管理的方法和代码块标记为事务性操作，当这些操作被执行时，Spring 会负责开启时根据当前环境中设置的隔离级别，调整数据库隔离级别。
Java多线程：深入探索与详细解析
m0_63550220的博客
09-08 1322
作为Java中的基本执行单元，线程是轻量级的进程，由线程ID、程序计数器、Java虚拟机栈、本地方法栈、和线程私有内存等部分组成。每个线程都有独立的执行路径，但共享进程的资源（如内存）。：进程是系统资源分配的基本单位，它包含了一个或多个线程以及这些线程运行所需的资源。在Java中，JVM（Java虚拟机）就是一个进程，而运行在JVM上的多个线程则共享JVM的内存空间。：并发指的是多个任务在同一时间段内交替执行，而并行则指的是多个任务在同一时刻真正同时执行。
JAVA基础：数据类型、命名规范
weixin_53755148的博客
09-05 1306
变量类型就是用来指定变量中存储数据的类型。也称为数据类型。
自定义Stater
m0_63624484的博客
09-07 654
我们平时在导入依赖的时候，大部分导入的都是xxx-spring-boot-stater。那是因为它们都基于spring的规则将写好的框架定义成一个stater，这样方便springboot引用它们写好的功能。那我们为什么也要自定义stater呢？
基于JavaWeb开发的JavaSpringboot+Vue实现前后端分离房屋租赁系统
央顺科技官方博客
09-05 515
2021年处于信息科技高速发展的大背景之下。在今天，缺少手机和电脑几乎已经成为不可能的事情，人们生活中已经难以离开手机和电脑。针对增加的成本管理和操作,各大商家非常有必要建立自己的网上房屋租赁平台系统，这既可以让更多的人体验到网络所带来的方便，也有助于提高房屋的租赁。在经过几十年的高速发展后，互联网已成为最流行、最普及的媒体，每天的信息流量甚至能比得上过去十年。其以便捷的信息交换、快速的沟通速度，悄然地改变着会员的消费方式。
MyBatis面试
Tony_yitao的博客
09-09 410
MyBatis面试
SpringBoot总结
2302_77073236的博客
09-06 191
都做成图了，方便理解和掌握全局关系。
Web安全之文件上传漏洞和案例示范
最新发布
weixin_39996520的博客
09-09 623
在Web应用程序中，文件上传功能广泛应用，特别是在电商交易系统中，用户上传商品图片、订单文件等操作十分常见。然而，文件上传功能若未被妥善处理，将成为攻击者利用的突破口。本文将以电商交易系统为例，深入分析文件上传过程中的常见安全漏洞，提供相应的解决方案。
【计算机毕业设计】高校课堂教学管理系统
weixin_47772925的博客
09-04 1130
2.1Java是由SUN公司推出，该公司于2010年被oracle公司收购。Java本是印度尼西亚的一个叫做爪洼岛的英文名称，也因此得来java是一杯正冒着热气咖啡的标识。Java语言在移动互联网的大背景下具备了显著的优势和广阔的前景，它是面向对象的，分布式的，动态的，具有平台无关性、安全性、健壮性。Java语言的基本语句语法和C++一样，但是它面向对象的技术更加彻底，因为Java要求将所有的内容都必须封装成类，把类作为程序的基本单位。由于不允许类外有变量、方法。
从内存层面分析Java 参数传递机制
weixin_54574094的博客
09-06 874
基本数据类型的参数传递是值传递，修改方法内部的值不会影响外部变量，因为每个方法调用都有自己的栈帧。引用数据类型的参数传递是引用传递，修改方法内部的对象内容会影响外部变量，因为它们指向同一个对象。栈帧中的引用指向相同的对象内存地址。String类型是不可变的，对String对象的修改会创建一个新的对象，原始对象保持不变，这与对象的可变性相关。
Java中项目名、包名、类名、接口名、方法名、类名命名规范（简单示范）
weixin_70495659的博客
09-08 231
【代码】Java中项目名、包名、类名、接口名、方法名、类名命名规范（简单示范）
Spring事务和事务传播机制（下）
2202_76101487的博客
09-05 363
本文主要写了事务的隔离机制和传播机制；
Android 源码中jni项目 加载so目录小结
wenzhi的博客
09-06 915
如何实现把so放到Android设备目录system/lib64下面，系统应用apk就能自动获取里面的so？如果实现了这个功能，后续修改了jni具体功能实现，就不用修改这个apk的代码，只要替换这个so就可以完成不同的实现了。其实这个功能不难，只要是系统源码编译的应用就可以；具体如何编译可以看本文最后的介绍。本文主要介绍一下，系统源码应用编译后，load so的顺序：顺序就是优先apk目录下的 lib/arm64/，然后 system/lib64/，有的还会加载 vendor/lib64/
log4j日志封装说明—slf4j对于log4j的日志封装-正确获取调用堆栈
CoderCoding的博客
09-05 303
日志是项目中必用的东西，日志产品里最普及应该就是log4j了。(logback这里暂不讨论。) 先看一下常用的log4j的用法，一般来说log4j都会配合slf4j或者common-logging使用，这里已slf4j为例。最直接的用法就是在每个需要记录日志的类里，构造一个属于自己类的log实例，实际上很多著名的开源项目也是这么做的。
java多线程练习题
09-22
引用中的代码是一个Java多线程练习题，其中实现了三个线程A、B、C，每个线程依次输出字母和数字的组合。这里使用了原子计数器和公平锁来确保输出的顺序正确。 引用中的代码是另一个Java多线程练习题，其中实现了一...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值