Java多线程实现抽奖池

多线程实现1：

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

//实现抽奖池的功能
public class MyThread extends Thread {
    ArrayList<Integer> list;

/*    //线程1使用的集合，不加上这个list1,只使用一个list的话，难以保证线程同步
    static ArrayList<Integer> list1 = new ArrayList<>();

    //线程2使用的集合
    static ArrayList<Integer> list2 = new ArrayList<>();*/
    //如果有100个线程，难道我写100个判断语句吗

    public MyThread(ArrayList<Integer> list) {
        this.list = list;//之所以在这里传入，不是直接在该类中定义，是因为该类中定义的话，会出现多个，不是一个集合
    }

    @Override
    public void run() {
        ArrayList<Integer> boxList = new ArrayList<>();
        //1.循环
        while (true) {
            //2.同步代码块
            synchronized (MyThread.class) {
                //3.判断共享数据是否已经到达末尾
                if (list.size() == 0) {
                    //奖抽完了,开始打印
                   /* if (Thread.currentThread().getName().equals("线程1")) {
                        System.out.print("线程1" + list1);
                        int[] arr = process(list1);
                        System.out.println("最大值是: " + arr[0] + " 总金额为： " + arr[1]);
                    } else {
                        System.out.print("线程2" + list2);
                        int[] arr = process(list2);
                        System.out.println("最大值是: " + arr[0] + " 总金额为： " + arr[1]);
                    }*/
                    System.out.print(getName() + boxList);
                    int[] arr = process(boxList);
                    System.out.println("最大值是: " + arr[0] + " 总金额为： " + arr[1]);
                    break;
                } else {
                    //4.判断共享数据没有到达末尾
                    //继续抽奖
                    Collections.shuffle(list);//洗牌，打乱
                    int prize = list.remove(0);
                  /*  if (Thread.currentThread().getName().equals("线程1"))
                        list1.add(prize);
                    else
                        list2.add(prize);*/
                    //   System.out.println(getName() + "又产生了一个 " + prize + " 元大奖");
                    boxList.add(prize);
                }
            }
            //加上下面这一段，使得可以尽量平均点，不然数据量太少，一个线程抢占cpu后，框框一顿打印，直接干没了
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }

    public static int[] process(ArrayList<Integer> list) {
        int max = -1;
        int sum = 0;
        for (Integer i : list) {
            sum += i;
            max = Math.max(max, i);
        }
        return new int[]{max, sum};
    }
}

上述没有返回结果，改进，使用多线程创建的第三种方式，callable+futuretask

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.循环
        while (true) {
            //2.同步代码块
            synchronized (MyThread.class) {
                //3.判断共享数据是否已经到达末尾
                if (list.size() == 0) {
                    System.out.println(Thread.currentThread().getName() + boxList);
                    int[] arr = process(boxList);
                    System.out.println("最大值是: " + arr[0] + " 总金额为： " + arr[1]);
                    break;
                } else {

                    Collections.shuffle(list);//洗牌，打乱
                    int prize = list.remove(0);
                    boxList.add(prize);
                }
            }
            //加上下面这一段，使得可以尽量平均点，不然数据量太少，一个线程抢占cpu后，框框一顿打印，直接干没了
            Thread.sleep(10);
        }
        //抽奖结束
        if (boxList.size() == 0)
            return null;

        return Collections.max(boxList);//我像一个小丑
    }

    public static int[] process(ArrayList<Integer> list) {
        int max = -1;
        int sum = 0;
        for (Integer i : list) {
            sum += i;
            max = Math.max(max, i);
        }
        return new int[]{max, sum};
    }
}

Main方法实现调试

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

public class Main {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //创建奖池
        ArrayList<Integer> list = new ArrayList<>();
        Collections.addAll(list, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 50, 100, 200, 300, 500, 700, 800);
        //创建线程
       /* MyThread t1=new MyThread(list);
        MyThread t2=new MyThread(list);
        MyThread t3=new MyThread(list);
        MyThread t4=new MyThread(list);
        MyThread t5=new MyThread(list);
        MyThread t6=new MyThread(list);
        MyThread t7=new MyThread(list);
        //设置线程名
        t1.setName("线程1");
        t2.setName("线程2");
        t3.setName("线程3");
        t4.setName("线程4");
        t5.setName("线程5");
        t6.setName("线程6");
        t7.setName("线程7");
        //开启线程
        t1.start();
        t2.start();
        t3.start();
        t4.start();
        t5.start();
        t6.start();
        t7.start();*/
        //创建多线程要运行的参数对象
        MyCallable mc = new MyCallable(list);
        //创建多线程运行结果的管理者对象
        FutureTask<Integer> ft1 = new FutureTask<>(mc);
        FutureTask<Integer> ft2 = new FutureTask<>(mc);
        FutureTask<Integer> ft3 = new FutureTask<>(mc);
        FutureTask<Integer> ft4 = new FutureTask<>(mc);
        FutureTask<Integer> ft5 = new FutureTask<>(mc);
        FutureTask<Integer> ft6 = new FutureTask<>(mc);
        FutureTask<Integer> ft7 = new FutureTask<>(mc);


        //创建线程对象
        Thread t1 = new Thread(ft1);
        Thread t2 = new Thread(ft2);
        Thread t3 = new Thread(ft3);
        Thread t4 = new Thread(ft4);
        Thread t5 = new Thread(ft5);
        Thread t6 = new Thread(ft6);
        Thread t7 = new Thread(ft7);
        t1.setName("线程1");
        t2.setName("线程2");
        t3.setName("线程3");
        t4.setName("线程4");
        t5.setName("线程5");
        t6.setName("线程6");
        t7.setName("线程7");
        t1.start();
        t2.start();
        t3.start();
        t4.start();
        t5.start();
        t6.start();
        t7.start();
        Integer max1 = ft1.get();
        Integer max2 = ft2.get();
        Integer max3 = ft3.get();
        Integer max4 = ft4.get();
        Integer max5 = ft5.get();
        Integer max6 = ft6.get();
        Integer max7 = ft7.get();
        List<Integer> maxList = new ArrayList<>();
        Collections.addAll(maxList, max1, max2, max3, max4, max5, max6, max7);
        Integer max = Collections.max(maxList);
        for (int i = 0; i < maxList.size(); i++)
            if (Objects.equals(maxList.get(i), max)) {
                System.out.println("线程" + (i + 1) + "抽得最大值");
                return;
            }
    }
}