多线程学习之多线程的案例

刺骨的言语ヽ痛彻心扉 2024-03-24 22:56 112阅读 0赞

## 练习一：赠送礼物 ##

需求：有100份礼品,两人同时发送，当剩下的礼品小于10份的时候则不再送出。利用多线程模拟该过程并将线程的名字和礼物的剩余数量打印出来.

示例：

public class MyRunable implements Runnable {
    
        //第二种方式实现多线程，测试类中MyRunable只创建一次，所以不需要加static
        int count = 100;
    
        @Override
        public void run() {
            //1.循环
            while (true) {
                //2.同步代码块
                synchronized (MyThread.class) {
                    //3.判断共享数据（已经到末尾）
                    if (count < 10) {
                        System.out.println("礼物还剩下" + count + "不再赠送");
                        break;
                    } else {
                        //4.判断共享数据（没有到末尾）
                        count--;
                        System.out.println(Thread.currentThread().getName() + "在赠送礼物，还剩下" + count + "个礼物!!!");
                    }
                }
            }
        }
    }
    
    
    public class Test {
        public static void main(String[] args) {
            /*
                有100份礼品,两人同时发送，当剩下的礼品小于10份的时候则不再送出，
                利用多线程模拟该过程并将线程的名字和礼物的剩余数量打印出来.
            */
    
            //创建参数对象
            MyRunable mr = new MyRunable();
    
            //创建线程对象
            Thread t1 = new Thread(mr,"窗口1");
            Thread t2 = new Thread(mr,"窗口2");
    
            //启动线程
            t1.start();
            t2.start();
        }
    }

##  ##

## 练习二：打印数字 ##

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

实例：

public class MyRunable implements Runnable {
    
        //第二种方式实现多线程，测试类中MyRunable只创建一次，所以不需要加static
        int number = 1;
    
        @Override
        public void run() {
            //1.循环
            while (true) {
                //2.同步代码块
                synchronized (MyThread.class) {
                    //3.判断共享数据（已经到末尾）
                    if (number > 100) {
                        break;
                    } else {
                        //4.判断共享数据（没有到末尾）
                        if(number % 2 == 1){
                            System.out.println(Thread.currentThread().getName() + "打印数字" + number);
                        }
                        number++;
                    }
                }
            }
        }
    }
    
    
    public class Test {
        public static void main(String[] args) {
        
            //创建参数对象
            MyRunable mr = new MyRunable();
    
            //创建线程对象
            Thread t1 = new Thread(mr,"线程A");
            Thread t2 = new Thread(mr,"线程B");
    
            //启动线程
            t1.start();
            t2.start();
        }
    }

## 练习三：抢红包 ##

需求：

抢红包也用到了多线程。

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

其中，红包是共享数据。

5个人是5条线程。

打印结果如下：

XXX抢到了XXX元

方案一：

public class MyThread extends Thread{
        public static double money = 100.0;
        public static int count = 3;
        //最小的中奖金额
        public static final double MIN = 0.01;
    
        @Override
        public void run(){
            //同步代码块
            synchronized (MyThread.class){
                if(count == 0){
                    //红包抢完了
                    System.out.println(Thread.currentThread().getName() + "没有抢到红包");
                }else{
                    //红包还有
                    //定义一个当前金额的变量
                    double price = 0;
                    if(count == 1){
                        //只有一个红包了 则无需随机直接赋值即可
                        price = money;
                    }else {
                        //是第一个和第二个红包 进行随机
                        Random random = new Random();
                        //100 元   3个包
                        //第一个红包：100 - (3-1) * 0.01 = 99.98  设置的是边界，这样random就会在这个范围内选取
                        int bounds  = money - (count-1) * MIN;
                        price = random.nextInt(bounds);
                        if(price < MIN){
                            price = MIN;
                        }
                    }
                    //从money当中，去掉当前中奖的金额
                    money = money - price;
                    //红包的个数-1
                    count--;
                    //本次红包的信息进行打印
                    System.out.println(getName() + "抢到了" + price + "元");
                }
            }
        }
    }
    
    
    
    public class Test {
        public static void main(String[] args) {
          
    
            //创建线程的对象
            MyThread t1 = new MyThread();
            MyThread t2 = new MyThread();
            MyThread t3 = new MyThread();
            MyThread t4 = new MyThread();
            MyThread t5 = new MyThread();
    
            //给线程设置名字
            t1.setName("kk");
            t2.setName("oneone");
            t3.setName("11");
            t4.setName("kunkun");
            t5.setName("ii");
    
            //启动线程
            t1.start();
            t2.start();
            t3.start();
            t4.start();
            t5.start();
        }
    }

方案二：

//总金额
        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 + "元");
                }
            }
        }

## 练习四：抽奖箱 ##

需求：

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

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

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

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

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

实例：

public class MyThread extends Thread {
    
        ArrayList<Integer> list;
    
        public MyThread(ArrayList<Integer> list) {
            this.list = list;
        }
    
        @Override
        public void run() {
            //1.循环
            //2.同步代码块
            //3.判断
            //4.判断
    
            while (true) {
                synchronized (MyThread.class) {
                    if (list.size() == 0) {
                        break;
                    } else {
                        //继续抽奖
                        Collections.shuffle(list);
                        int prize = list.remove(0);
                        System.out.println(getName() + "又产生了一个" + prize + "元大奖");
                    }
                }
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
    
            }
        }
    }
    
    
    
    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 元大奖
                	.....
            */
    
            //创建奖池
            ArrayList<Integer> list = new ArrayList<>();
            Collections.addAll(list,10,5,20,50,100,200,500,800,2,80,300,700);
    
            //创建线程
            MyThread t1 = new MyThread(list);
            MyThread t2 = new MyThread(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元

方案一：

public class MyThread extends Thread {
    
        ArrayList<Integer> list;
    
        public MyThread(ArrayList<Integer> list) {
            this.list = list;
        }
    
        //线程一
        static ArrayList<Integer> list1 = new ArrayList<>();
        //线程二
        static ArrayList<Integer> list2 = new ArrayList<>();
    
        @Override
        public void run() {
            while (true) {
                synchronized (MyThread.class) {
                    if (list.size() == 0) {
                        if("抽奖箱1".equals(getName())){
                            System.out.println("抽奖箱1" + list1);
                        }else {
                            System.out.println("抽奖箱2" + list2);
                        }
                        break;
                    } else {
                        //继续抽奖
                        Collections.shuffle(list);
                        int prize = list.remove(0);
                        if("抽奖箱1".equals(getName())){
                            list1.add(prize);
                        }else {
                            list2.add(prize);
                        }
                    }
                }
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
    
            }
        }
    }
    
    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元
            */
    
            //创建奖池
            ArrayList<Integer> list = new ArrayList<>();
            Collections.addAll(list,10,5,20,50,100,200,500,800,2,80,300,700);
    
            //创建线程
            MyThread t1 = new MyThread(list);
            MyThread t2 = new MyThread(list);
    
            //设置名字
            t1.setName("抽奖箱1");
            t2.setName("抽奖箱2");
    
            //启动线程
            t1.start();
            t2.start();
        }
    }

方案二：

public class MyThread extends Thread {
    
        ArrayList<Integer> list;
    
        public MyThread(ArrayList<Integer> list) {
            this.list = list;
        }
    
        @Override
        public void run() {
            ArrayList<Integer> boxList = new ArrayList<>();//1 //2
            while (true) {
                synchronized (MyThread.class) {
                    if (list.size() == 0) {
                        System.out.println(getName() + boxList);
                        break;
                    } else {
                        //继续抽奖
                        Collections.shuffle(list);
                        int prize = list.remove(0);
                        boxList.add(prize);
                    }
                }
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
    
            }
        }
    }
    
    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元
            */
    
            //创建奖池
            ArrayList<Integer> list = new ArrayList<>();
            Collections.addAll(list,10,5,20,50,100,200,500,800,2,80,300,700);
    
            //创建线程
            MyThread t1 = new MyThread(list);
            MyThread t2 = new MyThread(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元

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

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.itheima.test7;
    
    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元
                核心逻辑：获取线程抽奖的最大值（看成是线程运行的结果）
    
    
                以上打印效果只是数据模拟,实际代码运行的效果会有差异
            */
    
            //创建奖池
            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<Integer> ft1 = new FutureTask<>(mc);
            //线程二
            FutureTask<Integer> 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 = ft1.get();
            Integer max2 = ft2.get();
    
            System.out.println(max1);
            System.out.println(max2);
    
            //在此次抽奖过程中,抽奖箱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("两者的最大奖项是一样的");
            }
        }
    }