优惠券项目一

整体项目介绍 见 https://blog.csdn.net/wenjieyatou/article/details/80190886

分支一学习笔记：

分支1.1

1：解决优惠券编码重复问题，原先采用的是获取数据库所有的券，然后去比对是否重复，如果库数据量达百万的时候就会出现非常缓慢，而且会出现经常制券失败等，所以此版本舍弃原先采用随机数的模式，通过推特的雪花算法来保证唯一，但是依然保留优惠券前缀和后缀。
2：由原来的异步采用线程修改为线程池，以为高并发时候存在大量的线程占内存空间。
3：由原来制券采用for循环模式修改为批量制券，而且采用分配插入优惠券，一批次目前定为5000.

4：加入消息队列（采用rabbitMQ）对于某一批次添加失败，把失败的放入对列中，通过队列进行补救，已到达高可用。避免大批量优惠券来回重新导入消息队列对于异常信息拒绝解决并重返消息队列中，配置2个消费者以避免其中一个服务异常，消息处理出现死循环。

1，第一个问题，由于数据请求在百万级别数据库，所以可能造成查询十分缓慢甚至出现超时请求问题。所以直接生成唯一的优惠券值即可。具体代码如下：

import java.lang.reflect.Executable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class GenerateOnlyIdUtils {
    private final long twepoch = 1288834974657L;
    private final long workerIdBits = 5L;
    private final long datacenterIdBits = 5L;
    private final long maxWorkerId = -1L ^ (-1L << workerIdBits);
    private final long maxDatacenterId = -1L ^ (-1L << datacenterIdBits);
    private final long sequenceBits = 12L;
    private final long workerIdShift = sequenceBits;
    private final long datacenterIdShift = sequenceBits + workerIdBits;
    private final long timestampLeftShift = sequenceBits + workerIdBits + datacenterIdBits;
    private final long sequenceMask = -1L ^ (-1L << sequenceBits);

    private long workerId;
    private long datacenterId;
    private long sequence = 0L;
    private long lastTimestamp = -1L;

    public GenerateOnlyIdUtils(long workerId, long datacenterId) {
        if (workerId > maxWorkerId || workerId < 0) {
            throw new IllegalArgumentException(String.format("worker Id can't be greater than %d or less than 0", maxWorkerId));
        }
        if (datacenterId > maxDatacenterId || datacenterId < 0) {
            throw new IllegalArgumentException(String.format("datacenter Id can't be greater than %d or less than 0", maxDatacenterId));
        }
        this.workerId = workerId;
        this.datacenterId = datacenterId;
    }

    public synchronized long nextId() {
        long timestamp = timeGen();
        if (timestamp < lastTimestamp) {
            throw new RuntimeException(String.format("Clock moved backwards.  Refusing to generate id for %d milliseconds", lastTimestamp - timestamp));
        }
        //如果是同一时间序列 则时间序列内区别
        if (lastTimestamp == timestamp) {
            sequence = (sequence + 1) & sequenceMask;
            if (sequence == 0) {
                timestamp = tilNextMillis(lastTimestamp);
            }
        } else {
            sequence = 0L;
        }

        lastTimestamp = timestamp;

        return ((timestamp - twepoch) << timestampLeftShift) | (datacenterId << datacenterIdShift) | (workerId << workerIdShift) | sequence;
    }

    protected long tilNextMillis(long lastTimestamp) {
        long timestamp = timeGen();
        while (timestamp <= lastTimestamp) {
            timestamp = timeGen();
        }
        return timestamp;
    }

    protected long timeGen() {
        return System.currentTimeMillis();
    }

    public static void main(String args[]) {
        final GenerateOnlyIdUtils idGe = new GenerateOnlyIdUtils(1, 1);
        //线程池并行执行100次全局ID生成
        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0; i < 100; i++) {
            executorService.execute(new Runnable() {
                @Override
                public void run() {
                    long id = idGe.nextId();
                    System.out.println(id);
                }
            });
        }
        executorService.shutdown();
    }
}

2：由原来的异步采用线程修改为线程池，以为高并发时候存在大量的线程占内存空间。

线程池的自定义可以参考以下代码为：

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package org.springframework.scheduling.concurrent;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Future;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.RejectedExecutionException;
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurr