订单号生成逻辑，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+"\t\r");
                     }
                     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+"\t\r");
                     }
                     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#基本是利用原子自增方式解决并发和效率问题