Java学习笔记===》26.多线程综合练习

最新推荐文章于 2024-11-13 20:43:20 发布

kinbow_0923

最新推荐文章于 2024-11-13 20:43:20 发布

阅读量263

点赞数

分类专栏：学习笔记文章标签： java 学习笔记

本文链接：https://blog.csdn.net/m0_59318477/article/details/131368747

版权

学习笔记专栏收录该内容

30 篇文章 2 订阅

订阅专栏

多线程===》综合练习

1.需求：

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

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

package com_10MultiThreadTest.ThreadTest01;

public class MyThread extends Thread{

    static int ticket = 1000;


    @Override
    public void run() {
        while(true){
            synchronized (MyThread.class){
                if (method()) break;
            }
        }
    }

    private boolean method() {
        if (ticket == 0){
            System.out.println("票卖完了");
            return true;
        }else{
            try {
                Thread.sleep(30);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            ticket--;
            System.out.println(getName()+"正在卖票，还剩下，"+ticket+"张票");
        }
        return false;
    }
}
//测试类
package com_10MultiThreadTest.ThreadTest01;

public class Test {
    public static void main(String[] args) {
        /* 1.需求：
                 一共有1000张电影票，可以在两个窗口领取，假设每次领取的时间为3000毫秒，
                 请用多线程模拟卖票的过程并打印成语电影票的数量*/

        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();

        t1.setName("窗口1");
        t2.setName("窗口2");

        t1.start();
        t2.start();
    }
}

2.需求：

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

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

package com_10MultiThreadTest.ThreadTest02;

public class MyRunnable implements Runnable{
    static int number = 100;

    @Override
    public void run() {
        while(true){
            synchronized (MyRunnable.class){
                if (number < 10){
                    break;
                }else{
                    number--;
                    System.out.println(Thread.currentThread().getName()+"正在发放礼品，还剩"+number+"份礼品");
                }
            }
        }
    }
}
//测试类
package com_10MultiThreadTest.ThreadTest02;

public class Test {
    public static void main(String[] args) {
        /*### 2.需求：
                有100份礼品，两人同时发送，当剩下的礼品小于10份的时候不再送出
                利用多线程模拟该过程，并将线程的名字和礼物的剩余数量打印出来*/

        MyRunnable mr = new MyRunnable();

        Thread t1 = new Thread(mr,"小张");
        Thread t2 = new Thread(mr,"小明");


        t1.start();
        t2.start();
    }
}

3.需求：

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

要求：输出所有奇数

package com_10MultiThreadTest.ThreadTest03;

import com_09MultiThread._11ThreadSafe03.MyThread;

public class MyRunnable implements Runnable{

    int number = 1;

    @Override
    public void run() {
        while(true){
            synchronized (MyThread.class){
                if(number > 100){
                    break;
                }else{
                    try {
                        Thread.sleep(300);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    if (number % 2 == 1){
                        System.out.println(Thread.currentThread().getName()+"数字为"+number);
                    }
                    number++;
                }
            }
        }
    }
}
//测试类
package com_10MultiThreadTest.ThreadTest03;

public class Test {
    public static void main(String[] args) {
        /* 3.需求：
                同时开启两个线程，共同获取1-100之间的所有数字
                要求：输出所有奇数*/

        MyRunnable mr = new MyRunnable();

        Thread t1 = new Thread(mr,"线程1");
        Thread t2 = new Thread(mr,"线程2");

        t1.start();
        t2.start();

    }
}

4.需求：

微信中的抢红包也用到了多线程。
假设：100块，分成了3个包，现在有5个人去抢。
其中，红包是共享数据。
5个人是5条线程。
打印结果如下：
XXX抢到了XXX元
XXX抢到了XXX元
XXX抢到了XXX元
XXX没抢到
XXX没抢到

package com_10MultiThreadTest.ThreadTest04;

import java.util.Random;

public class MyThread extends Thread{
    static double money = 100;

    static int count = 3;

    static final double MIN =0.01;

    @Override
    public void run() {
        synchronized (MyThread.class){
            if(count == 0){
                System.out.println(getName()+"没有抢到红包");
            }else{
                double prize = 0;
                if (count == 1){
                    prize = money;
                }else {
                    Random r = new Random();
                    double bounds = money -(count -1) * 0.01;
                    prize = r.nextDouble(bounds);
                    if (prize < MIN){
                        prize = MIN;
                    }
                }
                money = money - prize;
                count--;
                System.out.println(getName()+"抢到了"+prize+"元");
            }
        }
    }
}
//测试类
package com_10MultiThreadTest.ThreadTest04;

public class Test {
    public static void main(String[] args) {
        /*
            微信中的抢红包也用到了多线程。
            假设：100块，分成了3个包，现在有5个人去抢。
            其中，红包是共享数据。
            5个人是5条线程。
            打印结果如下：
            	XXX抢到了XXX元
            	XXX抢到了XXX元
            	XXX抢到了XXX元
            	XXX没抢到
            	XXX没抢到
        */
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();
        MyThread t3 = new MyThread();
        MyThread t4 = new MyThread();
        MyThread t5 = new MyThread();

        t1.setName("小红");
        t2.setName("小李");
        t3.setName("小张");
        t4.setName("小宋");
        t5.setName("小明");

        t1.start();
        t2.start();
        t3.start();
        t4.start();
        t5.start();
    }
}

//使用BigDecimal对程序升级

package com_10MultiThreadTest.ThreadTest04case2;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.Random;

public class MyThread extends Thread{

    //总金额
    static BigDecimal money = BigDecimal.valueOf(100.0);
    //个数
    static int count = 3;
    //最小抽奖金额
    static final BigDecimal MIN = BigDecimal.valueOf(0.01);

    @Override
    public void run() {
        synchronized (MyThread.class){
            if(count == 0){
                System.out.println(getName() + "没有抢到红包！");
            }else{
                //中奖金额
                BigDecimal prize;
                if(count == 1){
                    prize = money;
                }else{
                    //获取抽奖范围
                    double bounds = money.subtract(BigDecimal.valueOf(count-1).multiply(MIN)).doubleValue();
                    Random r = new Random();
                    //抽奖金额
                    prize = BigDecimal.valueOf(r.nextDouble(bounds));
                }
                //设置抽中红包，小数点保留两位，四舍五入
                prize = prize.setScale(2,RoundingMode.HALF_UP);
                //在总金额中去掉对应的钱
                money = money.subtract(prize);
                //红包少了一个
                count--;
                //输出红包信息
                System.out.println(getName() + "抽中了" + prize + "元");
            }
        }
    }
}
//测试类
package com_10MultiThreadTest.ThreadTest04case2;

public class Test {
    public static void main(String[] args) {
         /*
            微信中的抢红包也用到了多线程。
            假设：100块，分成了3个包，现在有5个人去抢。
            其中，红包是共享数据。
            5个人是5条线程。
            打印结果如下：
            	XXX抢到了XXX元
            	XXX抢到了XXX元
            	XXX抢到了XXX元
            	XXX没抢到
            	XXX没抢到
        */


        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();
        MyThread t3 = new MyThread();
        MyThread t4 = new MyThread();
        MyThread t5 = new MyThread();

        t1.setName("小A");
        t2.setName("小QQ");
        t3.setName("小哈哈");
        t4.setName("小诗诗");
        t5.setName("小丹丹");

        t1.start();
        t2.start();
        t3.start();
        t4.start();
        t5.start();
    }
}

5.需求：

有一个抽奖池,该抽奖池中存放了奖励的金额,该抽奖池中的奖项为 {10,5,20,50,100,200,500,800,2,80,300,700};
创建两个抽奖箱(线程)设置线程名称分别为“抽奖箱1”，“抽奖箱2”
随机从抽奖池中获取奖项元素并打印在控制台上,格式如下:
每次抽出一个奖项就打印一个(随机)
抽奖箱1 又产生了一个 10 元大奖
抽奖箱1 又产生了一个 100 元大奖
抽奖箱1 又产生了一个 200 元大奖
抽奖箱1 又产生了一个 800 元大奖
抽奖箱2 又产生了一个 700 元大奖
…

package com_10MultiThreadTest.ThreadTest05;

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

public class MyRunnable implements Runnable{

    ArrayList<Integer> list;

    //新写构造方法
    public MyRunnable(ArrayList<Integer> list){
        this.list = list;
    }

    @Override
    public void run() {
        while(true){
            synchronized (MyRunnable.class){
                //抽奖结束
                if (list.size() == 0){
                    break;
                }else{
                    //继续抽奖
                    Collections.shuffle(list);
                    int prize = list.remove(0);
                    System.out.println(Thread.currentThread().getName()+"又产生了"+prize+"元大奖");
                }
            }

            //为了让线程更加均匀一点，
            //写在锁的外面的原因：，线程1执行完循环，会进入睡眠，这个时候线程2会大概率抢到执行权
            //同理当线程2执行完循环后会睡眠，那么线程1会大概率抢到执行权
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}
//测试类
package com_10MultiThreadTest.ThreadTest05;

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

public class Test {
    public static void main(String[] args) {
        /*
            有一个抽奖池,该抽奖池中存放了奖励的金额,该抽奖池中的奖项为 {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.创建奖池
        ArrayList<Integer> list = new ArrayList<>();
        Collections.addAll(list,10,5,20,50,100,200,500,800,2,80,300,700);
        MyRunnable mr = new MyRunnable(list);

        //2.创建线程
        Thread t1 = new Thread(mr,"抽奖箱1");
        Thread t2 = new Thread(mr,"抽奖箱2");

        //3.启动线程
        t1.start();
        t2.start();

    }
}

6.需求：

有一个抽奖池,该抽奖池中存放了奖励的金额,该抽奖池中的奖项为 {10,5,20,50,100,200,500,800,2,80,300,700};
创建两个抽奖箱(线程)设置线程名称分别为“抽奖箱1”，“抽奖箱2”
随机从抽奖池中获取奖项元素并打印在控制台上,格式如下:
每次抽的过程中，不打印，抽完时一次性打印(随机) 在此次抽奖过程中，抽奖箱1总共产生了6个奖项。
分别为：10,20,100,500,2,300最高奖项为300元，总计额为932元
在此次抽奖过程中，抽奖箱2总共产生了6个奖项。
分别为：5,50,200,800,80,700最高奖项为800元，总计额为1835元

package com_10MultiThreadTest.ThreadTest06;

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

public class MyRunnable implements Runnable{

    ArrayList<Integer> list;


    //新写构造方法
    public MyRunnable(ArrayList<Integer> list){
        this.list = list;
    }

    ArrayList<Integer> list1 = new ArrayList<>();
    ArrayList<Integer> list2 = new ArrayList<>();

    @Override
    public void run() {
        while(true){
            synchronized (MyRunnable.class){
                //抽奖结束
                if (list.size() == 0){
                    if ("抽奖箱1".equals(Thread.currentThread().getName())){
                        int sum = 0;
                        for (Integer integer : list1) {
                            sum += integer;
                        }
                        System.out.println("抽奖箱1"+list1+",最大奖项为"+Collections.max(list1)+"总计金额为："+sum);
                    }else{
                        int sum = 0;
                        for (Integer integer : list2) {
                            sum += integer;
                        }
                        System.out.println("抽奖箱1"+list2+",最大奖项为"+Collections.max(list2)+"总计金额为："+sum);
                    }
                    break;
                }else{
                    //继续抽奖
                    Collections.shuffle(list);
                    int prize = list.remove(0);
                    if ("抽奖箱1".equals(Thread.currentThread().getName())){
                        list1.add(prize);
                    }else{
                        list2.add(prize);
                    }
                }
            }

            //为了让线程更加均匀一点，
            //写在锁的外面的原因：，线程1执行完循环，会进入睡眠，这个时候线程2会大概率抢到执行权
            //同理当线程2执行完循环后会睡眠，那么线程1会大概率抢到执行权
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}
//测试类
package com_10MultiThreadTest.ThreadTest06;

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

public class Test {
    public static void main(String[] args) {
        /*
            有一个抽奖池,该抽奖池中存放了奖励的金额,该抽奖池中的奖项为 {10,5,20,50,100,200,500,800,2,80,300,700};
            创建两个抽奖箱(线程)设置线程名称分别为“抽奖箱1”，“抽奖箱2”
            随机从抽奖池中获取奖项元素并打印在控制台上,格式如下:
            每次抽的过程中，不打印，抽完时一次性打印(随机)    在此次抽奖过程中，抽奖箱1总共产生了6个奖项。
                分别为：10,20,100,500,2,300最高奖项为300元，总计额为932元
            在此次抽奖过程中，抽奖箱2总共产生了6个奖项。
                分别为：5,50,200,800,80,700最高奖项为800元，总计额为1835元
        */
        //1.创建奖池
        ArrayList<Integer> list = new ArrayList<>();
        Collections.addAll(list,10,5,20,50,100,200,500,800,2,80,300,700);
        com_10MultiThreadTest.ThreadTest06.MyRunnable mr = new com_10MultiThreadTest.ThreadTest06.MyRunnable(list);

        //2.创建线程
        Thread t1 = new Thread(mr,"抽奖箱1");
        Thread t2 = new Thread(mr,"抽奖箱2");

        //3.启动线程
        t1.start();
        t2.start();
    }
}

第二种方法，在成员位置定义集合效率太低，因为线程越多，创建的集合就越多，而在底层，每个线程都有自己的栈空间，而栈空间指甲剪又是相互独立的，所以只需要在成员方法里面定义一个公共集合，在启动线程的时候，每个线程会创建属于自己的集合，操作是相互独立的

package com_10MultiThreadTest.ThreadTest06case2;

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

public class MyRunnable implements Runnable{

    ArrayList<Integer> list;

    //新写构造方法
    public MyRunnable(ArrayList<Integer> list){
        this.list = list;
    }

    @Override
    public void run() {
        ArrayList<Integer> boxList = new ArrayList<>();
        while(true){
            synchronized (MyRunnable.class){
                //抽奖结束
                if (list.size() == 0){
                    int sum = 0;
                    for (Integer integer : boxList) {
                        sum += integer;
                    }
                    System.out.println(Thread.currentThread().getName()+boxList+",最大奖项为"+Collections.max(boxList)+"总计金额为："+sum);
                    break;
                }else{
                    //继续抽奖
                    Collections.shuffle(list);
                    int prize = list.remove(0);
                    boxList.add(prize);
                }
            }

            //为了让线程更加均匀一点，
            //写在锁的外面的原因：，线程1执行完循环，会进入睡眠，这个时候线程2会大概率抢到执行权
            //同理当线程2执行完循环后会睡眠，那么线程1会大概率抢到执行权
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}
//测试类
package com_10MultiThreadTest.ThreadTest06case2;

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

public class Test {
    public static void main(String[] args) {
        /*
            有一个抽奖池,该抽奖池中存放了奖励的金额,该抽奖池中的奖项为 {10,5,20,50,100,200,500,800,2,80,300,700};
            创建两个抽奖箱(线程)设置线程名称分别为“抽奖箱1”，“抽奖箱2”
            随机从抽奖池中获取奖项元素并打印在控制台上,格式如下:
            每次抽的过程中，不打印，抽完时一次性打印(随机)    在此次抽奖过程中，抽奖箱1总共产生了6个奖项。
                分别为：10,20,100,500,2,300最高奖项为300元，总计额为932元
            在此次抽奖过程中，抽奖箱2总共产生了6个奖项。
                分别为：5,50,200,800,80,700最高奖项为800元，总计额为1835元
        */
        //1.创建奖池
        ArrayList<Integer> list = new ArrayList<>();
        Collections.addAll(list,10,5,20,50,100,200,500,800,2,80,300,700);
        MyRunnable mr = new MyRunnable(list);

        //2.创建线程
        Thread t1 = new Thread(mr,"抽奖箱1");
        Thread t2 = new Thread(mr,"抽奖箱2");

        //3.启动线程
        t1.start();
        t2.start();
    }
}

7.需求

有一个抽奖池,该抽奖池中存放了奖励的金额,该抽奖池中的奖项为 {10,5,20,50,100,200,500,800,2,80,300,700};
创建两个抽奖箱(线程)设置线程名称分别为 “抽奖箱1”, “抽奖箱2”
随机从抽奖池中获取奖项元素并打印在控制台上,格式如下:

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

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

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

在此次抽奖过程中,抽奖箱2中产生了最大奖项,该奖项金额为800元
核心逻辑：获取线程抽奖的最大值（看成是线程运行的结果）

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

package com_10MultiThreadTest.ThreadTest07;

import java.util.ArrayList;
import java.util.Collections;
import java.util.concurrent.Callable;

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);
        }
    }
}
//测试类
package com_10MultiThreadTest.ThreadTest07;

import java.util.ArrayList;
import java.util.Collections;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class Test {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        /*
            有一个抽奖池,该抽奖池中存放了奖励的金额,该抽奖池中的奖项为 {10,5,20,50,100,200,500,800,2,80,300,700};
            创建两个抽奖箱(线程)设置线程名称分别为    "抽奖箱1", "抽奖箱2"
            随机从抽奖池中获取奖项元素并打印在控制台上,格式如下:

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

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

            在此次抽奖过程中,抽奖箱2中产生了最大奖项,该奖项金额为800元
            核心逻辑：获取线程抽奖的最大值（看成是线程运行的结果）


            以上打印效果只是数据模拟,实际代码运行的效果会有差异
        */
        //1.创建奖池
        ArrayList<Integer> list = new ArrayList<>();
        Collections.addAll(list, 10, 5, 20, 50, 100, 200, 500, 800, 2, 80, 300, 700);

        MyCallable mc = new MyCallable(list);

        FutureTask ft1 = new FutureTask<>(mc);
        FutureTask ft2 = new FutureTask<>(mc);

        Thread t1 = new Thread(ft1);
        Thread t2 = new Thread(ft2);

        t1.setName("抽奖箱1");
        t2.setName("抽奖箱2");

        t1.start();
        t2.start();

        Integer max1 = (Integer) ft1.get();
        Integer max2 = (Integer) ft2.get();

        //在此次抽奖过程中,抽奖箱2中产生了最大奖项,该奖项金额为800元
        if(max1 == null){
            System.out.println("在此次抽奖过程中,抽奖箱2中产生了最大奖项,该奖项金额为"+max2+"元");
        }else if(max2 == null){
            System.out.println("在此次抽奖过程中,抽奖箱1中产生了最大奖项,该奖项金额为"+max1+"元");
        }else if(max1 > max2){
            System.out.println("在此次抽奖过程中,抽奖箱1中产生了最大奖项,该奖项金额为"+max1+"元");
        }else if(max1 < max2){
            System.out.println("在此次抽奖过程中,抽奖箱2中产生了最大奖项,该奖项金额为"+max2+"元");
        }else{
            System.out.println("两者的最大奖项是一样的");
        }
    }
}