• Java之多线程综合练习小题一

    2. 多线程综合练习

    练习一：售票

    需求：

    一共有1000张电影票,可以在两个窗口领取,假设每次领取的时间为3000毫秒,

    请用多线程模拟卖票过程并打印剩余电影票的数量

    代码示例：

    1. public class MyThread extends Thread {
    2. ​
    3.     //第一种方式实现多线程，测试类中MyThread会创建多次，所以需要加static
    4.     static int ticket = 1000;
    5. ​
    6.     @Override
    7.     public void run() {
    8.         //1.循环
    9.         while (true) {
    10.             //2.同步代码块
    11.             synchronized (MyThread.class) {
    12.                 //3.判断共享数据（已经到末尾）
    13.                 if (ticket == 0) {
    14.                     break;
    15.                 } else {
    16.                     //4.判断共享数据（没有到末尾）
    17.                     try {
    18.                         Thread.sleep(3000);
    19.                     } catch (InterruptedException e) {
    20.                         e.printStackTrace();
    21.                     }
    22.                     ticket--;
    23.                     System.out.println(getName() + "在卖票，还剩下" + ticket + "张票!!!");
    24.                 }
    25.             }
    26.         }
    27.     }
    28. }
    29. ​
    30. public class Test {
    31.     public static void main(String[] args) {
    32.        /*
    33.             一共有1000张电影票,可以在两个窗口领取,假设每次领取的时间为3000毫秒,
    34.             要求:请用多线程模拟卖票过程并打印剩余电影票的数量
    35.         */
    36. ​
    37.         //创建线程对象
    38.         MyThread t1 = new MyThread();
    39.         MyThread t2 = new MyThread();
    40. ​
    41.         //给线程设置名字
    42.         t1.setName("窗口1");
    43.         t2.setName("窗口2");
    44. ​
    45.         //开启线程
    46.         t1.start();
    47.         t2.start();
    48. ​
    49.     }
    50. }
    ​

    练习二：赠送礼物

    需求：

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

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

    1. public class MyRunable implements Runnable {
    2. ​
    3.     //第二种方式实现多线程，测试类中MyRunable只创建一次，所以不需要加static
    4.     int count = 100;
    5. ​
    6.     @Override
    7.     public void run() {
    8.         //1.循环
    9.         while (true) {
    10.             //2.同步代码块
    11.             synchronized (MyThread.class) {
    12.                 //3.判断共享数据（已经到末尾）
    13.                 if (count < 10) {
    14.                     System.out.println("礼物还剩下" + count + "不再赠送");
    15.                     break;
    16.                 } else {
    17.                     //4.判断共享数据（没有到末尾）
    18.                     count--;
    19.                     System.out.println(Thread.currentThread().getName() + "在赠送礼物，还剩下" + count + "个礼物!!!");
    20.                 }
    21.             }
    22.         }
    23.     }
    24. }
    25. ​
    26. ​
    27. public class Test {
    28.     public static void main(String[] args) {
    29.         /*
    30.             有100份礼品,两人同时发送，当剩下的礼品小于10份的时候则不再送出，
    31.             利用多线程模拟该过程并将线程的名字和礼物的剩余数量打印出来.
    32.         */
    33. ​
    34.         //创建参数对象
    35.         MyRunable mr = new MyRunable();
    36. ​
    37.         //创建线程对象
    38.         Thread t1 = new Thread(mr,"窗口1");
    39.         Thread t2 = new Thread(mr,"窗口2");
    40. ​
    41.         //启动线程
    42.         t1.start();
    43.         t2.start();
    44.     }
    45. }
    46. ​

    练习三：打印数字

    需求：

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

    将输出所有的奇数。

    1. public class MyRunable implements Runnable {
    2. ​
    3.     //第二种方式实现多线程，测试类中MyRunable只创建一次，所以不需要加static
    4.     int number = 1;
    5. ​
    6.     @Override
    7.     public void run() {
    8.         //1.循环
    9.         while (true) {
    10.             //2.同步代码块
    11.             synchronized (MyThread.class) {
    12.                 //3.判断共享数据（已经到末尾）
    13.                 if (number > 100) {
    14.                     break;
    15.                 } else {
    16.                     //4.判断共享数据（没有到末尾）
    17.                     if(number % 2 == 1){
    18.                         System.out.println(Thread.currentThread().getName() + "打印数字" + number);
    19.                     }
    20.                     number++;
    21.                 }
    22.             }
    23.         }
    24.     }
    25. }
    26. ​
    27. ​
    28. public class Test {
    29.     public static void main(String[] args) {
    30.         /*
    31.            同时开启两个线程，共同获取1-100之间的所有数字。
    32.            要求：将输出所有的奇数。
    33.         */
    34. ​
    35. ​
    36.         //创建参数对象
    37.         MyRunable mr = new MyRunable();
    38. ​
    39.         //创建线程对象
    40.         Thread t1 = new Thread(mr,"线程A");
    41.         Thread t2 = new Thread(mr,"线程B");
    42. ​
    43.         //启动线程
    44.         t1.start();
    45.         t2.start();
    46.     }
    47. }

    练习四：抢红包

    需求：

    抢红包也用到了多线程。

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

    其中，红包是共享数据。

    5个人是5条线程。

    打印结果如下：

    XXX抢到了XXX元

    XXX抢到了XXX元

    XXX抢到了XXX元

    XXX没抢到

    XXX没抢到

    解决方案一：

    1. public class MyThread extends Thread{
    2. ​
    3.     //共享数据
    4.     //100块，分成了3个包
    5.     static double money = 100;
    6.     static int count = 3;
    7. ​
    8.     //最小的中奖金额
    9.     static final double MIN = 0.01;
    10. ​
    11.     @Override
    12.     public void run() {
    13.         //同步代码块
    14.         synchronized (MyThread.class){
    15.             if(count == 0){
    16.                 //判断，共享数据是否到了末尾（已经到末尾）
    17.                 System.out.println(getName() + "没有抢到红包！");
    18.             }else{
    19.                 //判断，共享数据是否到了末尾（没有到末尾）
    20.                 //定义一个变量，表示中奖的金额
    21.                 double prize = 0;
    22.                 if(count == 1){
    23.                     //表示此时是最后一个红包
    24.                     //就无需随机，剩余所有的钱都是中奖金额
    25.                     prize = money;
    26.                 }else{
    27.                     //表示第一次，第二次（随机）
    28.                     Random r = new Random();
    29.                     //100 元   3个包
    30.                     //第一个红包：99.98
    31.                     //100 - (3-1) * 0.01
    32.                     double bounds = money - (count - 1) * MIN;
    33.                     prize = r.nextDouble(bounds);
    34.                     if(prize < MIN){
    35.                         prize = MIN;
    36.                     }
    37.                 }
    38.                 //从money当中，去掉当前中奖的金额
    39.                 money = money - prize;
    40.                 //红包的个数-1
    41.                 count--;
    42.                 //本次红包的信息进行打印
    43.                 System.out.println(getName() + "抢到了" + prize + "元");
    44.             }
    45.         }
    46.     }
    47. }
    48. public class Test {
    49.     public static void main(String[] args) {
    50.         /*
    51.             微信中的抢红包也用到了多线程。
    52.             假设：100块，分成了3个包，现在有5个人去抢。
    53.             其中，红包是共享数据。
    54.             5个人是5条线程。
    55.             打印结果如下：
    56.                 XXX抢到了XXX元
    57.                 XXX抢到了XXX元
    58.                 XXX抢到了XXX元
    59.                 XXX没抢到
    60.                 XXX没抢到
    61.         */
    62. ​
    63.         //创建线程的对象
    64.         MyThread t1 = new MyThread();
    65.         MyThread t2 = new MyThread();
    66.         MyThread t3 = new MyThread();
    67.         MyThread t4 = new MyThread();
    68.         MyThread t5 = new MyThread();
    69. ​
    70.         //给线程设置名字
    71.         t1.setName("小A");
    72.         t2.setName("小QQ");
    73.         t3.setName("小哈哈");
    74.         t4.setName("小诗诗");
    75.         t5.setName("小丹丹");
    76. ​
    77.         //启动线程
    78.         t1.start();
    79.         t2.start();
    80.         t3.start();
    81.         t4.start();
    82.         t5.start();
    83.     }
    84. }

    解决方案二：

    1. public class MyThread extends Thread{
    2. ​
    3.     //总金额
    4.     static BigDecimal money = BigDecimal.valueOf(100.0);
    5.     //个数
    6.     static int count = 3;
    7.     //最小抽奖金额
    8.     static final BigDecimal MIN = BigDecimal.valueOf(0.01);
    9. ​
    10.     @Override
    11.     public void run() {
    12.         synchronized (MyThread.class){
    13.             if(count == 0){
    14.                 System.out.println(getName() + "没有抢到红包！");
    15.             }else{
    16.                 //中奖金额
    17.                 BigDecimal prize;
    18.                 if(count == 1){
    19.                     prize = money;
    20.                 }else{
    21.                     //获取抽奖范围
    22.                     double bounds = money.subtract(BigDecimal.valueOf(count-1).multiply(MIN)).doubleValue();
    23.                     Random r = new Random();
    24.                     //抽奖金额
    25.                     prize = BigDecimal.valueOf(r.nextDouble(bounds));
    26.                 }
    27.                 //设置抽中红包，小数点保留两位，四舍五入
    28.                 prize = prize.setScale(2,RoundingMode.HALF_UP);
    29.                 //在总金额中去掉对应的钱
    30.                 money = money.subtract(prize);
    31.                 //红包少了一个
    32.                 count--;
    33.                 //输出红包信息
    34.                 System.out.println(getName() + "抽中了" + prize + "元");
    35.             }
    36.         }
    37.     }
    38. }
    39. ​
    40. public class Test {
    41.     public static void main(String[] args) {
    42.         /*
    43.             微信中的抢红包也用到了多线程。
    44.             假设：100块，分成了3个包，现在有5个人去抢。
    45.             其中，红包是共享数据。
    46.             5个人是5条线程。
    47.             打印结果如下：
    48.                 XXX抢到了XXX元
    49.                 XXX抢到了XXX元
    50.                 XXX抢到了XXX元
    51.                 XXX没抢到
    52.                 XXX没抢到
    53.         */
    54. ​
    55. ​
    56.         MyThread t1 = new MyThread();
    57.         MyThread t2 = new MyThread();
    58.         MyThread t3 = new MyThread();
    59.         MyThread t4 = new MyThread();
    60.         MyThread t5 = new MyThread();
    61. ​
    62.         t1.setName("小A");
    63.         t2.setName("小QQ");
    64.         t3.setName("小哈哈");
    65.         t4.setName("小诗诗");
    66.         t5.setName("小丹丹");
    67. ​
    68.         t1.start();
    69.         t2.start();
    70.         t3.start();
    71.         t4.start();
    72.         t5.start();
    73.     }
    74. }

    练习五：抽奖箱

    需求：

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

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

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

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

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

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

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

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

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

    .....

    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.         //1.循环
    12.         //2.同步代码块
    13.         //3.判断
    14.         //4.判断
    15. ​
    16.         while (true) {
    17.             synchronized (MyThread.class) {
    18.                 if (list.size() == 0) {
    19.                     break;
    20.                 } else {
    21.                     //继续抽奖
    22.                     Collections.shuffle(list);
    23.                     int prize = list.remove(0);
    24.                     System.out.println(getName() + "又产生了一个" + prize + "元大奖");
    25.                 }
    26.             }
    27.             try {
    28.                 Thread.sleep(10);
    29.             } catch (InterruptedException e) {
    30.                 e.printStackTrace();
    31.             }
    32. ​
    33.         }
    34.     }
    35. }
    36. ​
    37. ​
    38. ​
    39. public class Test {
    40.     public static void main(String[] args) {
    41.         /*
    42.             有一个抽奖池,该抽奖池中存放了奖励的金额,该抽奖池中的奖项为 {10,5,20,50,100,200,500,800,2,80,300,700};
    43.             创建两个抽奖箱(线程)设置线程名称分别为“抽奖箱1”，“抽奖箱2”
    44.             随机从抽奖池中获取奖项元素并打印在控制台上,格式如下:
    45.                              每次抽出一个奖项就打印一个(随机)
    46.                 抽奖箱1 又产生了一个 10 元大奖
    47.                 抽奖箱1 又产生了一个 100 元大奖
    48.                 抽奖箱1 又产生了一个 200 元大奖
    49.                 抽奖箱1 又产生了一个 800 元大奖
    50.                 抽奖箱2 又产生了一个 700 元大奖
    51.                 .....
    52.         */
    53. ​
    54.         //创建奖池
    55.         ArrayList list = new ArrayList<>();
    56.         Collections.addAll(list,10,5,20,50,100,200,500,800,2,80,300,700);
    57. ​
    58.         //创建线程
    59.         MyThread t1 = new MyThread(list);
    60.         MyThread t2 = new MyThread(list);
    61. ​
    62.         //设置名字
    63.         t1.setName("抽奖箱1");
    64.         t2.setName("抽奖箱2");
    65. ​
    66.         //启动线程
    67.         t1.start();
    68.         t2.start();
    69.     }
    70. }

  • 相关阅读:
    mysql性能优化之数据类型(持续更新)
    Java：修改Jar的源码，并上传Nexus私有仓库，替换jar版本
    CentOS7 设置固定IP地址
    Node学习二十 —— 构建和使用HTTP中间件
    centos7桌面版下载向日葵和todesk
    Rsync分布式应用
    Visio画图更改连接线的弧形和调整跨线
    java反射全面复习
    【中央任务调度系统—通信开发】
    进阶指针（三）--- qsort函数(快速排序)的使用和（用冒泡排序）模拟实现
  • 原文地址：https://blog.csdn.net/qq_69748833/article/details/133470575