订单号生成逻辑，C#和JAVA双版

五年没写过博客了，倒是天天在看

转来转去，又转回技术

原来一直在使用微软爸爸的东西，最近一两年开始玩android，玩java，还有PostgreSQL

都有些应用了，倒是可以整理些随笔出来，这就是其中一篇吧

c#是java的优雅版本，java的linq就是一坨那啥，嗯！觉得不爽就别看了

订单号这个玩意我想有几点得保证

1，有顺序但不连续

2，不能太长，最好15位以内

3，最好全数字

目前来说谷歌和百度出来的感觉都达不到我要的这些要求，不是太长超过20位，就是会加上字母，再就是会连续，否则就没顺序，没有办法只有自己想

本来没想自己干的，这玩意绝对是个老问题，估计大家都有好办法，藏着了吧

开干，思路如下：

得有时间在里面，这样有顺序

不连续好办，加上随机尾数

不能太长也好办，取一部分时间戳，或者是当前时间减去过去一个固定时间的差值

OK，上代码，先JAVA

import java.io.*;
import java.util.UUID;
import java.util.concurrent.atomic.AtomicLong;

/**
 * Created by 黑曜石 on 2017/5/19.
 */
public class TradeNoGenerator {
    //基准时间截 (2017-01-01)
    private static final long initStamp=1483200000000L;
    //每秒基准容量1000个
    private static final int secondsSpace=1000;
    //基准容量扩容倍数
    private static final int secondsSpaceMulti=10;
    //多少秒不用，重新设定原子初始值
    private static final int secondsRefresh=60;
    //原子初始值
    private AtomicLong atomicLong=new AtomicLong((System.currentTimeMillis()-initStamp)*secondsSpaceMulti);

    private TradeNoGenerator() {
    }

    private static class TradeNoGeneratorHolder{
        private static TradeNoGenerator instance = new TradeNoGenerator();
    }

    public static TradeNoGenerator getInstance() {
        return TradeNoGeneratorHolder.instance;
    }

    //线程安全
    /**
     * 用这个，用这个
     * @return
     * 生成结果例：11983017246298
     * 由三段组成，11983017，2462，98
     * 第一段11983017，位数会随着时间增长增加，计算方式为与initStamp相加，结果为到秒的时间戳
     * 第二段，2462，看容量决定位数，容量=secondsSpace*secondsSpaceMulti，原子增长字段
     * 第三段98，固定2位，随机数
     */
    public synchronized String getNo(){
        long no=atomicLong.getAndIncrement();
        //当前秒时间戳与基准时间戳秒级数量
        long currentSecond = (System.currentTimeMillis()-initStamp) / 1000;
        //计数超过60秒未使用过，则重新给定初始值
        if (currentSecond-no/(secondsSpace*secondsSpaceMulti)>=secondsRefresh){
            //重置原子计数原始值
            atomicLong=new AtomicLong((System.currentTimeMillis()-initStamp)*secondsSpaceMulti);
            no=atomicLong.getAndIncrement();
        }
        //计算容量是否超出
        if (no-currentSecond*secondsSpace*secondsSpaceMulti>=secondsSpace*secondsSpaceMulti){
            //超出则等待下一秒的到来，这里计算到下一整数秒的微秒差
            long millisWithinSecond = System.currentTimeMillis() % 1000;
            try {
                Thread.sleep(1000 - millisWithinSecond);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println(">>> new second . "+no +" "+Thread.currentThread().getName());

            //重置原子计数原始值
            atomicLong=new AtomicLong((System.currentTimeMillis()-initStamp)*secondsSpaceMulti);
            no=atomicLong.getAndIncrement();
        }

        int hashCode= UUID.randomUUID().hashCode();
        hashCode=hashCode<0?-hashCode:hashCode;
        String randomStr=String.valueOf(hashCode).substring(0,2);
        return no+randomStr;
    }

    /**
     * 获取时间戳
     * @param tradeNo
     * @return
     */
    public long getTimestamp(String tradeNo){
        int spaceLen = String.valueOf(secondsSpace*secondsSpaceMulti).length()-1;
        int stampLen=tradeNo.length()-spaceLen-2;
        String stampStr=tradeNo.substring(0,stampLen);
        //右侧补齐微秒
        long stamp=Long.parseLong(stampStr+String.format("%1$03d",0));
        stamp+=initStamp;
        return stamp;
    }

    public static void main(String[] args) {

        File file=new File("e:/tradeno1.txt");
        if (file.exists()){
            file.delete();
        }
        try {
            file.createNewFile();
        } catch (IOException e) {
            e.printStackTrace();
        }
        file=new File("e:/tradeno2.txt");
        if (file.exists()){
            file.delete();
        }
        try {
            file.createNewFile();
        } catch (IOException e) {
            e.printStackTrace();
        }

        new Thread(new Runnable() {
            @Override
            public void run() {

                try {
                    Writer w=new FileWriter("e:/tradeno1.txt");
                    BufferedWriter buffWriter=new BufferedWriter(w);

                    TimeMark timeMark=new TimeMark();
                    for (int i = 0; i < 12000; i++) {
                        String x=getInstance().getNo();
                        //System.out.println(x);
                        buffWriter.write(x+"	
");
                    }
                    System.out.println("]]]");
                    timeMark.simplePrint();

                    buffWriter.close();
                    w.close();
                    System.out.println("写入成功！");

                } catch (FileNotFoundException e) {
                    System.out.println("要读取的文件不存在："+e.getMessage());
                } catch (IOException e) {
                    System.out.println("文件读取错误："+e.getMessage());
                }
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Writer w=new FileWriter("e:/tradeno2.txt");
                    BufferedWriter buffWriter=new BufferedWriter(w);

                    TimeMark timeMark=new TimeMark();
                    for (int i = 0; i < 24000; i++) {
                        String x=getInstance().getNo();
                        //System.out.println(x);
                        buffWriter.write(x+"	
");
                    }
                    System.out.println("]]]");
                    timeMark.simplePrint();

                    buffWriter.close();
                    w.close();
                    System.out.println("写入成功！");

                } catch (FileNotFoundException e) {
                    System.out.println("要读取的文件不存在："+e.getMessage());
                } catch (IOException e) {
                    System.out.println("文件读取错误："+e.getMessage());
                }
            }
        }).start();
    }
}

接下来是C#

public class TradeNoGenerator
    {
        //基准时间截 (2017-01-01)
        private static DateTime initDateTime = new DateTime(2017, 1, 1);
        //每秒基准容量1000个
        private static int secondsSpace = 1000;
        //基准容量扩容倍数
        private static int secondsSpaceMulti = 10;
        //多少秒不用，重新设定原子初始值
        private static int secondsRefresh = 60;
        //原子初始值
        private static long initStamp = (long)DateTime.UtcNow.Subtract(initDateTime).TotalSeconds * secondsSpace * secondsSpaceMulti;

        static TradeNoGenerator __TradeNoGenerator;
        private TradeNoGenerator()
        {
        }

        public static TradeNoGenerator GetInstance()
        {
            if (__TradeNoGenerator == null)
            {
                __TradeNoGenerator = new TradeNoGenerator();
            }
            return __TradeNoGenerator;
        }

        //线程安全
        /**
         * 用这个，用这个
         * @return
         * 生成结果例：11983017246298
         * 由三段组成，11983017，2462，98
         * 第一段11983017，位数会随着时间增长增加，计算方式为与initStamp相加，结果为到秒的时间戳
         * 第二段，2462，看容量决定位数，容量=secondsSpace*secondsSpaceMulti，原子增长字段
         * 第三段98，固定2位，随机数
         */
        public String GetNo()
        {
            long no = Interlocked.Increment(ref initStamp);
            //当前秒时间戳与基准时间戳秒级数量
            double currentSecond = DateTime.UtcNow.Subtract(initDateTime).TotalSeconds;
            //计数超过60秒未使用过，则重新给定初始值
            if (currentSecond - no / (secondsSpace * secondsSpaceMulti) >= secondsRefresh)
            {
                //重置原子计数原始值
                initStamp= (long)DateTime.UtcNow.Subtract(initDateTime).TotalSeconds * secondsSpace * secondsSpaceMulti;
                no = Interlocked.Increment(ref initStamp);
            }
            //计算容量是否超出
            if (no - currentSecond * secondsSpace * secondsSpaceMulti >= secondsSpace * secondsSpaceMulti)
            {
                //超出则等待下一秒的到来，这里计算到下一整数秒的微秒差
                int millisWithinSecond = DateTime.UtcNow.Millisecond % 1000;
                try
                {
                    Thread.Sleep(1000 - millisWithinSecond);
                }
                catch (Exception ex)
                {
                    
                }

                //重置原子计数原始值
                initStamp = (long)DateTime.UtcNow.Subtract(initDateTime).TotalSeconds * secondsSpace * secondsSpaceMulti;
                no = Interlocked.Increment(ref initStamp);
            }

            int hashCode = Guid.NewGuid().GetHashCode();
            hashCode = hashCode < 0 ? -hashCode : hashCode;
            String randomStr = hashCode.ToString().Substring(0, 2);
            return no + randomStr;
        }
    }

注释写得很清楚啦

1秒基准容量是1000个，可以以10的倍数来扩大（只能是10的倍数），一般扩大10倍，1秒容量到10000个，可以解决很多问题啦

速度你们可以自己测试，一秒内的速度是毫秒级别的

超出秒容量的话，那就得等待下一秒的到来

还有个问题就是当前不支持分布式

无论是JAVA还是C#基本是利用原子自增方式解决并发和效率问题