• Java之多线程的综合练习二

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

    需求：

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

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

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

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

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

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

    解决方案一：

    1. public class MyThread extends Thread {
    2. ​
    3.     ArrayList list;
    4. ​
    5.     public MyThread(ArrayList list) {
    6.         this.list = list;
    7.     }
    8. ​
    9.     //线程一
    10.     static ArrayList list1 = new ArrayList<>();
    11.     //线程二
    12.     static ArrayList list2 = new ArrayList<>();
    13. ​
    14.     @Override
    15.     public void run() {
    16.         while (true) {
    17.             synchronized (MyThread.class) {
    18.                 if (list.size() == 0) {
    19.                     if("抽奖箱1".equals(getName())){
    20.                         System.out.println("抽奖箱1" + list1);
    21.                     }else {
    22.                         System.out.println("抽奖箱2" + list2);
    23.                     }
    24.                     break;
    25.                 } else {
    26.                     //继续抽奖
    27.                     Collections.shuffle(list);
    28.                     int prize = list.remove(0);
    29.                     if("抽奖箱1".equals(getName())){
    30.                         list1.add(prize);
    31.                     }else {
    32.                         list2.add(prize);
    33.                     }
    34.                 }
    35.             }
    36.             try {
    37.                 Thread.sleep(10);
    38.             } catch (InterruptedException e) {
    39.                 e.printStackTrace();
    40.             }
    41. ​
    42.         }
    43.     }
    44. }
    45. ​
    46. public class Test {
    47.     public static void main(String[] args) {
    48.         /*
    49.             有一个抽奖池,该抽奖池中存放了奖励的金额,该抽奖池中的奖项为 {10,5,20,50,100,200,500,800,2,80,300,700};
    50.             创建两个抽奖箱(线程)设置线程名称分别为“抽奖箱1”，“抽奖箱2”
    51.             随机从抽奖池中获取奖项元素并打印在控制台上,格式如下:
    52.             每次抽的过程中，不打印，抽完时一次性打印(随机)    在此次抽奖过程中，抽奖箱1总共产生了6个奖项。
    53.                 分别为：10,20,100,500,2,300最高奖项为300元，总计额为932元
    54.             在此次抽奖过程中，抽奖箱2总共产生了6个奖项。
    55.                 分别为：5,50,200,800,80,700最高奖项为800元，总计额为1835元
    56.         */
    57. ​
    58.         //创建奖池
    59.         ArrayList list = new ArrayList<>();
    60.         Collections.addAll(list,10,5,20,50,100,200,500,800,2,80,300,700);
    61. ​
    62.         //创建线程
    63.         MyThread t1 = new MyThread(list);
    64.         MyThread t2 = new MyThread(list);
    65. ​
    66.         //设置名字
    67.         t1.setName("抽奖箱1");
    68.         t2.setName("抽奖箱2");
    69. ​
    70.         //启动线程
    71.         t1.start();
    72.         t2.start();
    73.     }
    74. }
    75. ​

    解决方案二：

    1. public class MyThread extends Thread {
    2. ​
    3.     ArrayList list;
    4. ​
    5.     public MyThread(ArrayList list) {
    6.         this.list = list;
    7.     }
    8. ​
    9.     @Override
    10.     public void run() {
    11.         ArrayList boxList = new ArrayList<>();//1 //2
    12.         while (true) {
    13.             synchronized (MyThread.class) {
    14.                 if (list.size() == 0) {
    15.                     System.out.println(getName() + boxList);
    16.                     break;
    17.                 } else {
    18.                     //继续抽奖
    19.                     Collections.shuffle(list);
    20.                     int prize = list.remove(0);
    21.                     boxList.add(prize);
    22.                 }
    23.             }
    24.             try {
    25.                 Thread.sleep(10);
    26.             } catch (InterruptedException e) {
    27.                 e.printStackTrace();
    28.             }
    29. ​
    30.         }
    31.     }
    32. }
    33. ​
    34. public class Test {
    35.     public static void main(String[] args) {
    36.         /*
    37.             有一个抽奖池,该抽奖池中存放了奖励的金额,该抽奖池中的奖项为 {10,5,20,50,100,200,500,800,2,80,300,700};
    38.             创建两个抽奖箱(线程)设置线程名称分别为“抽奖箱1”，“抽奖箱2”
    39.             随机从抽奖池中获取奖项元素并打印在控制台上,格式如下:
    40.             每次抽的过程中，不打印，抽完时一次性打印(随机)    在此次抽奖过程中，抽奖箱1总共产生了6个奖项。
    41.                 分别为：10,20,100,500,2,300最高奖项为300元，总计额为932元
    42.             在此次抽奖过程中，抽奖箱2总共产生了6个奖项。
    43.                 分别为：5,50,200,800,80,700最高奖项为800元，总计额为1835元
    44.         */
    45. ​
    46.         //创建奖池
    47.         ArrayList list = new ArrayList<>();
    48.         Collections.addAll(list,10,5,20,50,100,200,500,800,2,80,300,700);
    49. ​
    50.         //创建线程
    51.         MyThread t1 = new MyThread(list);
    52.         MyThread t2 = new MyThread(list);
    53. ​
    54. ​
    55.         //设置名字
    56.         t1.setName("抽奖箱1");
    57.         t2.setName("抽奖箱2");
    58. ​
    59. ​
    60.         //启动线程
    61.         t1.start();
    62.         t2.start();
    63. ​
    64.     }
    65. }

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

    需求：

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

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

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

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

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

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

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

    1. public class MyCallable implements Callable {
    2. ​
    3.     ArrayList list;
    4. ​
    5.     public MyCallable(ArrayList list) {
    6.         this.list = list;
    7.     }
    8. ​
    9.     @Override
    10.     public Integer call() throws Exception {
    11.         ArrayList boxList = new ArrayList<>();//1 //2
    12.         while (true) {
    13.             synchronized (MyCallable.class) {
    14.                 if (list.size() == 0) {
    15.                     System.out.println(Thread.currentThread().getName() + boxList);
    16.                     break;
    17.                 } else {
    18.                     //继续抽奖
    19.                     Collections.shuffle(list);
    20.                     int prize = list.remove(0);
    21.                     boxList.add(prize);
    22.                 }
    23.             }
    24.             Thread.sleep(10);
    25.         }
    26.         //把集合中的最大值返回
    27.         if(boxList.size() == 0){
    28.             return null;
    29.         }else{
    30.             return Collections.max(boxList);
    31.         }
    32.     }
    33. }
    34. ​
    35. package com.itheima.test7;
    36. ​
    37. import java.util.ArrayList;
    38. import java.util.Collections;
    39. import java.util.concurrent.ExecutionException;
    40. import java.util.concurrent.FutureTask;
    41. ​
    42. public class Test {
    43.     public static void main(String[] args) throws ExecutionException, InterruptedException {
    44.         /*
    45.             有一个抽奖池,该抽奖池中存放了奖励的金额,该抽奖池中的奖项为 {10,5,20,50,100,200,500,800,2,80,300,700};
    46.             创建两个抽奖箱(线程)设置线程名称分别为    "抽奖箱1", "抽奖箱2"
    47.             随机从抽奖池中获取奖项元素并打印在控制台上,格式如下:
    48. ​
    49.             在此次抽奖过程中，抽奖箱1总共产生了6个奖项，分别为：10,20,100,500,2,300
    50.                 最高奖项为300元，总计额为932元
    51. ​
    52.             在此次抽奖过程中，抽奖箱2总共产生了6个奖项，分别为：5,50,200,800,80,700
    53.                 最高奖项为800元，总计额为1835元
    54. ​
    55.             在此次抽奖过程中,抽奖箱2中产生了最大奖项,该奖项金额为800元
    56.             核心逻辑：获取线程抽奖的最大值（看成是线程运行的结果）
    57. ​
    58. ​
    59.             以上打印效果只是数据模拟,实际代码运行的效果会有差异
    60.         */
    61. ​
    62.         //创建奖池
    63.         ArrayList list = new ArrayList<>();
    64.         Collections.addAll(list,10,5,20,50,100,200,500,800,2,80,300,700);
    65. ​
    66.         //创建多线程要运行的参数对象
    67.         MyCallable mc = new MyCallable(list);
    68. ​
    69.         //创建多线程运行结果的管理者对象
    70.         //线程一
    71.         FutureTask ft1 = new FutureTask<>(mc);
    72.         //线程二
    73.         FutureTask ft2 = new FutureTask<>(mc);
    74. ​
    75.         //创建线程对象
    76.         Thread t1 = new Thread(ft1);
    77.         Thread t2 = new Thread(ft2);
    78. ​
    79.         //设置名字
    80.         t1.setName("抽奖箱1");
    81.         t2.setName("抽奖箱2");
    82. ​
    83.         //开启线程
    84.         t1.start();
    85.         t2.start();
    86. ​
    87. ​
    88.         Integer max1 = ft1.get();
    89.         Integer max2 = ft2.get();
    90. ​
    91.         System.out.println(max1);
    92.         System.out.println(max2);
    93. ​
    94.         //在此次抽奖过程中,抽奖箱2中产生了最大奖项,该奖项金额为800元
    95.         if(max1 == null){
    96.             System.out.println("在此次抽奖过程中,抽奖箱2中产生了最大奖项,该奖项金额为"+max2+"元");
    97.         }else if(max2 == null){
    98.             System.out.println("在此次抽奖过程中,抽奖箱1中产生了最大奖项,该奖项金额为"+max1+"元");
    99.         }else if(max1 > max2){
    100.             System.out.println("在此次抽奖过程中,抽奖箱1中产生了最大奖项,该奖项金额为"+max1+"元");
    101.         }else if(max1 < max2){
    102.             System.out.println("在此次抽奖过程中,抽奖箱2中产生了最大奖项,该奖项金额为"+max2+"元");
    103.         }else{
    104.             System.out.println("两者的最大奖项是一样的");
    105.         }
    106.     }
    107. }
  • 相关阅读:
    使用 Set-Cookies HttpOnly & Secure标志保护 Tomcat
    K8S 实用工具之一 - 如何合并多个 kubeconfig？
    JDK的安装
    Visual Studio 2019光标变成灰色方块问题
    ▶《强化学习的数学原理》(2024春)_西湖大学赵世钰 Ch0 一张图讲完强化学习原理
    自媒体怎么入门？过来人的三点建议，快看看
    华为数通方向HCIP-DataCom H12-831题库(单选题：201-220）
    Ubuntu安装步骤
    Hadoop3教程（一）：Hadoop的定义、组成及全生态概览
    网络游戏协议:基于Protobuf的序列化与反序列化
  • 原文地址：https://blog.csdn.net/qq_69748833/article/details/133500735