需求背景

需要批量分配订单给人员，尽量保证分配到每个人的订单金额相近。可以按照金额平均分配，随机分配，指定数量分配。

思路分析

比如100个任务,每个任务ID和金额及号为(T100,100)…(T1,1)。第一轮分配先取最大的任务金额的分配给User1，即user1拥有T100，user2分配到T99，user3分配到T98。第二轮分配最小值，User1分配T1，User2分配T2，User3分配T3,第三轮分配最大值，即User1分配T97，User2分配T96，以此类推。

代码实现

• JDK必须是1.8及以上，代码中使用了1.8的特性，不多废话上代码

.

import java.io.*;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.stream.Collectors;

/**
 * @ClassName Allot
 * @Desc TODO
 * @Author chengp
 * @Date 2019/1/11 9:55
 * @Verion 1.0
 */
public class Allot {


    /**
     * 按金额分配
     *
     * @param users 人
     * @param tasks 任务
     * @return
     */
    public static Map<String, List<DemoTask>> allotOfAmount(List<DemoUser> users, List<DemoTask> tasks) {
        //Collections.shuffle(users);//随机排序
        Map<String, List<DemoTask>> allot = new ConcurrentHashMap<>(); //保存分配的信息
        if (users != null && users.size() > 0 && tasks != null && tasks.size() > 0) {
            List<DemoTask> copyTask = depCopy(tasks);//深拷贝,在处理过程中会删除已经分配的任务此处方便记录原始数据使用
            for (int n = 0; n < copyTask.size() + n; n++) {
                if (n % 2 == 0) {
                    copyTask = sortTask(copyTask, "desc");//正排
                } else {
                    copyTask = sortTask(copyTask, "asc");//倒排
                }
                for (int j = 0; j < users.size(); j++) {
                    if (copyTask.isEmpty()) break;
                    if (allot.containsKey(users.get(j).getUserId().toString())) {
                        List<DemoTask> list = allot.get(users.get(j).getUserId().toString());
                        list.add(copyTask.get(0));//每次取排序后的第一条
                        allot.put(users.get(j).getUserId().toString(), list);
                    } else {
                        List<DemoTask> list = new ArrayList<>();
                        list.add(copyTask.get(0));
                        allot.put(users.get(j).getUserId().toString(), list);
                    }
                    copyTask.remove(copyTask.get(0));//分配后删除

                }
            }
        }
        return allot;
    }

    /**
     * 平均分配&指定数量分配,多余的任务不予分配
     *
     * @param users 人
     * @param tasks 任务
     * @param count 每人指定分配数量
     * @return
     */
    public static Map<String, List<DemoTask>> allotOfAverage(List<DemoUser> users,   List<DemoTask> tasks, Integer count) {
        Collections.shuffle(users);//随机排序
        Collections.shuffle(tasks);
        Map<String, List<DemoTask>> allot = new ConcurrentHashMap<>(); //保存分配的信息
        if (users != null && users.size() > 0 && tasks != null && tasks.size() > 0) {
            for (int i = 0; i < tasks.size(); i++) {

                if (count != null && (i >= count * users.size())) {
                    break;
                }
                int j = i % users.size();
                if (allot.containsKey(users.get(j).getUserId().toString())) {
                    List<DemoTask> list = allot.get(users.get(j).getUserId().toString());
                    list.add(tasks.get(i));
                    allot.put(users.get(j).getUserId().toString(), list);
                } else {
                    List<DemoTask> list = new ArrayList<>();
                    list.add(tasks.get(i));
                    allot.put(users.get(j).getUserId().toString(), list);
                }
            }
        }
        return allot;
    }
    /**
     * 深拷贝
     *
     * @param srcList
     * @param <T>
     * @return
     */
    public static <T> List<T> depCopy(List<T> srcList) {
        ByteArrayOutputStream byteOut = new ByteArrayOutputStream();
        try {
            ObjectOutputStream out = new ObjectOutputStream(byteOut);
            out.writeObject(srcList);

            ByteArrayInputStream byteIn = new ByteArrayInputStream(byteOut.toByteArray());
            ObjectInputStream inStream = new ObjectInputStream(byteIn);
            List<T> destList = (List<T>) inStream.readObject();
            return destList;
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return null;
    }


    /**
     * 排序
     *
     * @param taskList
     * @param sort
     * @return
     */
    private static List<DemoTask> sortTask(List<DemoTask> taskList, String sort) {
        List<DemoTask> newList;
        if ("asc".equalsIgnoreCase(sort)) {//正序
            newList = taskList.stream().sorted(Comparator.comparing(DemoTask::getAmount))
                    .collect(Collectors.toList());
        } else if ("desc".equalsIgnoreCase(sort)) {//倒叙 reversed()即可
            newList = taskList.stream().sorted(Comparator.comparing(DemoTask::getAmount).reversed())
                    .collect(Collectors.toList());
        } else {
            newList = taskList;
        }
        return newList;
    }


    public static class  DemoUser{
        private Integer userId;
        private String userName;

        public Integer getUserId() {
            return userId;
        }

        public void setUserId(Integer userId) {
            this.userId = userId;
        }

        public String getUserName() {
            return userName;
        }

        public void setUserName(String userName) {
            this.userName = userName;
        }

        @Override
        public String toString() {
            return "DemoUser{" +
                    "userId=" + userId +
                    ", userName='" + userName + '\'' +
                    '}';
        }
    }


    public static class DemoTask implements Serializable{

        private Integer taskId;

        private BigDecimal amount;

        public Integer getTaskId() {
            return taskId;
        }

        public void setTaskId(Integer taskId) {
            this.taskId = taskId;
        }

        public BigDecimal getAmount() {
            return amount;
        }

        public void setAmount(BigDecimal amount) {
            this.amount = amount;
        }

        @Override
        public String toString() {
            return "DemoTask{" +
                    "taskId=" + taskId +
                    ", amount=" + amount +
                    '}'+'\n';
        }
    }
    public static void main(String[] args) {

        List<DemoUser> userList = new ArrayList<>();
        DemoUser entity = new DemoUser();
        entity.setUserId(1);
        userList.add(entity);
        DemoUser entity2 = new DemoUser();
        entity2.setUserId(2);
        userList.add(entity2);
        DemoUser entity3 = new DemoUser();
        entity3.setUserId(3);
        userList.add(entity3);

        List<DemoTask> taskList = new ArrayList<>();
        DemoTask apply1 = new DemoTask();
        apply1.setTaskId(1);
        apply1.setAmount(new BigDecimal(1000));
        taskList.add(apply1);
        DemoTask apply2 = new DemoTask();
        apply2.setTaskId(2);
        apply2.setAmount(new BigDecimal(1200));
        taskList.add(apply2);
        DemoTask apply3 = new DemoTask();
        apply3.setTaskId(3);
        apply3.setAmount(new BigDecimal(800));
        taskList.add(apply3);
        DemoTask apply4 = new DemoTask();
        apply4.setTaskId(5);
        apply4.setAmount(new BigDecimal(600));
        taskList.add(apply4);
        DemoTask apply5 = new DemoTask();
        apply5.setTaskId(5);
        apply5.setAmount(new BigDecimal(1600));
        taskList.add(apply5);
        DemoTask apply6 = new DemoTask();
        apply6.setTaskId(6);
        apply6.setAmount(new BigDecimal(2100));
        taskList.add(apply6);
        DemoTask apply7 = new DemoTask();
        apply7.setTaskId(7);
        apply7.setAmount(new BigDecimal(1210));
        taskList.add(apply7);

        DemoTask apply8 = new DemoTask();
        apply8.setTaskId(8);
        apply8.setAmount(new BigDecimal(1120));
        taskList.add(apply8);

        DemoTask apply9 = new DemoTask();
        apply9.setTaskId(9);
        apply9.setAmount(new BigDecimal(1310));
        taskList.add(apply9);

        DemoTask apply10 = new DemoTask();
        apply10.setTaskId(10);
        apply10.setAmount(new BigDecimal(1050));
        taskList.add(apply10);

        DemoTask apply11 = new DemoTask();
        apply11.setTaskId(11);
        apply11.setAmount(new BigDecimal(1500));
        taskList.add(apply11);
        List<DemoTask> copyTask = depCopy(taskList);

        Map<String, List<DemoTask>> map = allotOfAmount(userList,copyTask);

        System.out.println(map);
    }
}

执行结果：

结果分析：

根据结果看已经实现了我们要的效果了_！
www.aniba.cn

直接上代码，不啰嗦，复制可直接用

@Test
    public void test111() {
        //分配承接人
        List<String> nameList = new ArrayList<>();
        nameList.add("张三");
        nameList.add("王五");
        nameList.add("赵六");
        nameList.add("李四");
        //打乱list顺序,这样避免余数每次都分配到第一个人上面
        Collections.shuffle(nameList);
        //待分配人员
        List<String> clientList = new ArrayList<>();
        clientList.add("客户1");
        clientList.add("客户2");
        clientList.add("客户3");
        clientList.add("客户4");
        clientList.add("客户5");
        clientList.add("客户6");
        clientList.add("客户7");
        clientList.add("客户8");
        clientList.add("客户9");
//        clientList.add("客户10");
//        clientList.add("客户11");
//        clientList.add("客户12");
//        clientList.add("客户13");
//        clientList.add("客户14");
//        clientList.add("客户15");
//        clientList.add("客户16");

        //总客户数
        Integer clientCount = clientList.size();
        //总分配人数
        Integer userCount = nameList.size();
        //余数
        Integer remainderCount = clientCount % userCount;
        //每个人分配数
        Integer divideCount = clientCount / userCount;
        System.out.println("总客户数:" + clientCount + " 总销售数:" + userCount + " 余数:" + remainderCount + " 除数:" + divideCount);
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < userCount; i++) {
            for (int j = 0; j <= divideCount; j++) {
                sb.setLength(0);
                if (userCount * (j) + i <= clientList.size() - 1) {
                    sb.append(nameList.get(i)).append(clientList.get(userCount * (j) + i));
                    System.out.println(sb.toString());
                }
            }
        }
    }

文章对https://blog.csdn.net/qq_44729754/article/details/108712747进行修改而得。

如有疑问还请各位大佬指点，谢谢！

闲来无事，突然想起来红包随机分配算法要怎么实现，经过一阵子思考，勉强用CAS操作和锁两种方式实现了该算法，但对于CAS实现的方式心里没底，我没办法证明算法的正确性，只能简单的重复执行该算法10000次这种恶劣的方式来验证。真心希望有这方面经验的朋友可以交流一下，互相学习。还有个问题是，我把两种算法分别执行10000次的记录耗时，结果发现锁方式比CAS快，这有点出乎意料之外。但事后又想想CAS方式在竞争比较大的情况下，不停尝试然后失败确实挺耗费时间的。

package test1.Test1;

import java.math.BigDecimal;
import java.util.Iterator;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;

/**
 * 红包随机分配算法，每一个红包必须大于最小值小于平均值的2倍
 *
 */
public class HongBaoAlgorithm {
	//每个红包的最小金额
	private static final double MIN = 0.01;
	
	class HongBao{
		//红包总金额
		private AtomicReference<BigDecimal> amount = new AtomicReference<BigDecimal>();
		//红包个数
		private AtomicInteger count;
		//红包总金额
		private BigDecimal hbAmount;
		private int hbCount;//红包个数
		//上面的两对参数分别对应CAS和锁操作
		public HongBao(double amount,int count){
			this.amount.set(new BigDecimal(amount));
			this.count = new AtomicInteger(count);
			this.hbAmount = new BigDecimal(amount);
			this.hbCount = count;
		}
		
		/**
		 * 用CAS操作随机分配一个红包
		 * @return
		 */
		public double assignHongBao(){
			while(true){
				//如果红包个数为0，则表示红包也被抢完，返回0
				if(count.get()<=0){
					return 0.0;
				}
				//如果是最后一个红包则直接将剩余的金额返回
				if(count.get()==1){
					BigDecimal c = amount.get();
					if(amount.compareAndSet(c, new BigDecimal(0))){
						count.decrementAndGet();
						return c.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
					}else{//如果最后一个红包金额修改失败，则表示最后一个红包已被抢走，已没有剩余红包，直接返回0
						return 0.0;
					}
				}
				BigDecimal balanceAmount = amount.get();
				int balanceCount = count.get();
				if(balanceCount==0){
					return 0.0;
				}
				//求出剩余红包金额和个数的平均值
				double avg = balanceAmount.divide(new BigDecimal(balanceCount),8,BigDecimal.ROUND_HALF_UP).doubleValue();
				//随机获取一个MIN到2倍平均值之间的值
				double cur = getRandom(MIN, avg*2);
				//获取剩余金额和分配金额的差值
				double b = balanceAmount.add(new BigDecimal(-cur)).doubleValue();
				//由于每个红包至少是MIN这么大，此处获取剩余红包个数应该有的最小的红包金额，
				//比如MIN=0.01，那么如果这次分配之后还剩2个红包，则金额至少要剩下2分钱，不然不够分
				double c = new BigDecimal(balanceCount-1).multiply(new BigDecimal(MIN)).doubleValue();
				//分配之后剩余金额b  需大于等于   剩余的最小值c，如果不满足则重新分配红包大小，直到满足要求
				while(b < c){
					cur = getRandom(MIN, avg*2);
					b = balanceAmount.add(new BigDecimal(-cur)).doubleValue();
				}
				//如果是最后一个红包则直接将剩余的金额返回，
				//在返回结果之前再一次执行这个判断的目的是为了在多线程情况如果在返回结果之前已经被抢到只剩最后一个的时候
				//还是返回随机获得金额的话则会导致总金额不会被抢完
				if(count.get()==1){
					BigDecimal c1 = amount.get();
					if(amount.compareAndSet(c1, new BigDecimal(0))){
						count.decrementAndGet();
						return c1.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
					}else{//如果最后一个红包金额修改失败，则表示最后一个红包已被抢走，已没有剩余红包，直接返回0
						return 0.0;
					}
				}
				//CAS更新金额和个数同时成功，则返回随机分配的红包金额
				if(amount.compareAndSet(balanceAmount, balanceAmount.add(new BigDecimal(-cur)))){
					count.decrementAndGet();
					return cur;
				}
				
			}
			

		}
		
		
		/**
		 * 用锁控制
		 * @return
		 */
		public synchronized double assignHongBao2(){
				//如果红包个数为0，则表示红包也被抢完，返回0
				if(hbCount==0){
					return 0.0;
				}
				//如果是最后一个红包则直接将剩余的金额返回
				if(hbCount==1){
					hbCount--;
					return hbAmount.doubleValue();
				}
				//求出剩余红包金额和个数的平均值
				double avg = hbAmount.divide(new BigDecimal(hbCount),8,BigDecimal.ROUND_HALF_UP).doubleValue();
				//随机获取一个MIN到2倍平均值之间的值
				double cur = getRandom(MIN, avg*2);
				//获取剩余金额和分配金额的差值
				double b = hbAmount.add(new BigDecimal(-cur)).doubleValue();
				//由于每个红包至少是MIN这么大，此处获取剩余红包个数应该有的最小的红包金额，
				//比如MIN=0.01，那么如果这次分配之后还剩2个红包，则金额至少要剩下2分钱，不然不够分
				double c = new BigDecimal(hbCount-1).multiply(new BigDecimal(MIN)).doubleValue();
				//分配之后剩余金额b  需大于等于   剩余的最小值c，如果不满足则重新分配红包大小，直到满足要求
				while(b < c){
					cur = getRandom(MIN, avg*2);
					b = hbAmount.add(new BigDecimal(-cur)).doubleValue();
				}
				hbAmount = hbAmount.add(new BigDecimal(-cur));
				hbCount--;
				return cur;
		}
		
		/**
		 * 计算两个数之间的随机值，结果保留两位小数
		 * @param begin
		 * @param end
		 * @return
		 */
		private double getRandom(double begin,double end){
			   double random = Math.random();
			   double amount =  random*(end - begin)+begin;
			   BigDecimal bg = new BigDecimal(amount);
			   return bg.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
		}

	}
		
	
	private static void test(double hbAmount,int hbCount,int personCount) throws InterruptedException{
		HongBaoAlgorithm h = new HongBaoAlgorithm();
		final HongBao hb = h.new HongBao(hbAmount,hbCount);
		int THREAD_COUNT = personCount;
		ExecutorService pool = Executors.newFixedThreadPool(THREAD_COUNT);
		final ConcurrentLinkedQueue<Double> total = new ConcurrentLinkedQueue<Double>();
		final CountDownLatch latch = new CountDownLatch(THREAD_COUNT);
		for(int i=0;i<THREAD_COUNT;i++){
			pool.execute(new Runnable() {
				public void run() {
					double m = hb.assignHongBao();
					total.add(m);
//					if(m>0){
//						System.out.println(Thread.currentThread().getName()+"抢到:"+m);
//					}else{
//						System.out.println(Thread.currentThread().getName()+"没抢到红包");
//					}
					latch.countDown();
				}
			});
		}
		pool.shutdown();
		latch.await();
		double amount = 0.0;
		Iterator<Double> it = total.iterator();
		while(it.hasNext()){
			amount += it.next();
		}
		amount = new BigDecimal(amount).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
		//如果分配到的总金额和传入的总金额不相等
		if(amount!=hbAmount){
			System.out.println("amount:"+amount);
		}
		//计算抢到的红包总额来判断跟设定的金额是否一致，从而判断算法的正确性，很恶劣的方式
	}
	
	public static void main(String[] args) throws InterruptedException{
		long start = System.currentTimeMillis();
		//执行10000次，验证一下正确率
		for(int i=0;i<10000;i++){
			//9个红包，10个人抢
			test(100, 9, 10);
		}
		System.out.println("用时："+(System.currentTimeMillis()-start)+"ms");
	}

}