cn12306的设计思路

cn12306的设计思路，不依赖数据库
=======

现在还有不少人在讨论12306的设计，在这里写一个简单的设计思路

1. 网站不是为了解决高峰期票少人多的问题，争论里总讨论这个话题没意义
2. 排队机制不能到处套用，拿网游的常规做法来处理web不是很合适，应该最大限度提升系统的响应速度
3. 最好的方式是开票后10分钟内热门车次票就被订光了，抢到票的高高兴兴去付钱，没抢到的骂骂咧咧想其他途径，早死早超生
4. 响应速度上去后，人们自然不用各种外挂、脚本来刷票了，对减轻网站压力也有好处
5. 交易量没有那么夸张，昨天上海热线微博发的消息：长假期间9月28日至10月1日4天网络预售票达到40万张，约占全部预售车票量的40%，建议旅客尽快换取纸质车票。据此可以估计总的交易规模
6. 12306一些纯配置数据的查询也很慢，比如车次、时刻表、票价等。说明设计确实做得比较渣
7. 静态内容处理好cdn、缓存是比较简单的，配置类数据可以缓存在各个服务节点，或者加一个配置服务，此类数据的查询web server自己就可以处理，都是基本的算法，放到nginx都行，再配合缓存，基本没大的压力
8. 发邮件，发短信之类的多弄几个队列发就是了
9. 查询时有余票，下订单时却没票属于合理情况，没必要回避

整个网站可以用varnish/nginx+redis+appservice

现在看看交易的主要部分：余票查询、订票和订单支付。只关注服务本身，不涉及http cache server、http proxy server等。

假设全国共5000车次（实际4000多，有一部分在12306还查不到），每个车次定员2000人（从网上资料看，很多车型定员不满1000），停靠站不超过64站（6245是62站，实际上超过30站的很少），预售12天车票。

如果这些票全通过网络预订，那么估计每天的交易量<1kw，实际上现在电话，窗口还是主要途径

可以用int来表示车次和日期，实际上int16就够了，用一个int64来表示每个座位的预订状态。每个车次/日期用组合用一个单独的队列来存储，预计占用的空间为定员数*size(int64)再加一些其他数据，可以算出这些数据全放到内存中也占不了多大的地。这样车票的查询和预订就可以全部在内存中计算。

车票预定后有45分钟的支付时间，可以用redis来存储这部分数据，因为存储的时间短，再优化一下存储结构，占不了多少空间。

支付后数据进入传统的RDMS，在查看订单，退票、取票时会用到。这些数据相对而言查询量应该不大，transaction的粒度小、好控制，分区策略比较容易制定。各大RDMS应付这个访问量都不成问题。

用golang写了一个数据结构的原型，没怎么用golang的特有功能比如chan，这样可以方便的移植到其他语言。

原先查询和预订放在一起的，后来为了设计一个简单的master/slave结构，把查询和预订分来了。数据持久化用redis，接口简单，吞吐量也有保证。

这样整个服务被划分成若干组service set，每一组service set由master\slave\redis组成，负责若干车次/日期的查询和预订

查询的流程如下:

1. 根据配置分析起点/终点，确定车次，根据车次/日期确定调用service的地址 (web)

2. 并发调用这些地址 (web)

3. 在对应的队列查询符合条件的票数，最多返回10 (slave)

4. 组合查询结果，输出到浏览器 (web)

查询逻辑基本上是没有锁的，而且全部内存中计算，响应速度很快(2000整数的位运算)。 web端可以缓存查询结果10-30秒, 对业务没什么影响。利用pipleline也可以提升浏览器的响应速度

预订的流程如下:

1. 根据配置分析起点/终点，确定车次，根据车次/日期确定调用service的地址（web）

2. 找到对应的队列，加锁 (master)

3. 找到可用的座位 (master)

4. 调用redis的HMSET修改状态 (master)

5. 修改内存中的数据，释放锁 (master)

6. 订单写入redis, 并返回web端 (master)

7. 同步座位状态 (slave)

还是有很大的优化空间的，比如悲观锁可以改成乐观锁，用cas保证数据同步; 优化座位扫描的起始点以减少扫描次数等。
只要网络部分处理的好，并发链接数和响应速度不是问题, 或者简单一点，直接用go.http提供rest接口性能也过得去

如果master挂了, slave可以在很短的时间内切换为master，同时再另起一个服务作为新的salve

订单支付的流程如下

1. 验证支付结果，写日志，写队列
2. 移除redis中的数据
3. 通过队列写RDMS、发邮件、发短信

预计10个靠谱的开发人员半年就可以做得很好，要是20个开发人员的话，估计火车上求艳遇的应用都可以做出来了

数据结构 https://files.cnblogs.com/buzzlight/main.zip

/*
 cn 12306 数据结构


*/
package main

import (
    "fmt"
    "strconv"
    "sync"
    "time"
)

var (
    serverId       int //服务编号    
    baseDate       int = int(time.Date(2012, 1, 0, 0, 0, 0, 0, time.UTC).Unix() / (60 * 60 * 24))
    maxSearchCount int = 10 //查询剩余车票返回的最大值
    maxLength      int = 62 //车次最多经停站数
)

var (
    trains map[int]*Train
    lock   sync.Mutex
)

// 车次+日期
type Train struct {
    snow      *snow        //Id生产器
    lock      sync.RWMutex //锁    
    train     int          //车次
    date      int          //日期    
    data      []uint64     //座位数据
    config    *TrainConfig //配置
    dbAddress string       //redis 的地址
    dbKey     string       //redis hashset的key
    dbConnect interface{}  //redis connection
}

func newTrain(train, date int) *Train {
    config := getTrainConfig(train)
    t := &Train{
        snow:      newSnow(train, serverId),
        train:     train,
        date:      date,
        data:      make([]uint64, config.length),
        config:    config,
        dbKey:     "hashset_" + strconv.Itoa((train<<16)|date),
        dbAddress: "db address",
        dbConnect: "db connection"}
    return t
}

// 车次一些配置数据
type TrainConfig struct {
    length int    //座位数
    _      string //其他
}

func getTrainConfig(train int) *TrainConfig {
    return &TrainConfig{length: maxLength}
}

// 订单
type Order struct {
    id    uint64 //订单编号
    user  int64  //用户编号
    index int    //座位编号
    train int    //车次
    date  int    //日期
    stamp int64  //时间戳
}

func init() {
    serverId = 123
    trains = make(map[int]*Train, 1000)

    fmt.Println("init", "server id", serverId, "baseDate", baseDate)
}

// 获取车次数据
func getTrain(train, date int) (*Train, bool) {
    key := (train << 16) | date
    t, ok := trains[key]
    return t, ok
}

// 一次只查询一个车次，可以很容易的扩展到查询多个车次
func search(train, date int, start, end uint8) (count int) {
    if t, ok := getTrain(train, date); ok {
        return t.search(start, end)
    }
    return 0
}

// 一次只预订一个座位，可以很容易扩展为预订多个
func order(user int64, train, date int, start, end uint8) (order Order, ok bool) {
    if t, ok := getTrain(train, date); ok {
        return t.order(user, start, end)
    }
    return
}

// 定时增加车次数据
func addTrain(train, date int) {
    key := (train << 16) | date

    lock.Lock()
    defer lock.Unlock()

    t := newTrain(train, date)
    trains[key] = t
}

// 查询是否有票
func (t *Train) search(start, end uint8) (count int) {
    data := t.data
    var mask uint64 = (1<<(end-start) - 1) << (start)
    for _, d := range data {
        if d&mask == 0 {
            count++
        }
        if count > maxSearchCount {
            break
        }
    }
    return count
}

// 预订
func (t *Train) order(user int64, start, end uint8) (order Order, ok bool) {

    var mask uint64 = (1<<(end-start) - 1) << (start)
    t.lock.Lock()
    defer t.lock.Unlock()

    data := t.data
    length := t.config.length
    for i := 0; i < length; i++ {
        if data[i]&mask != 0 {
            continue
        }

        //持久化,处理队列
        order = Order{id: t.snow.nextInt(), user: user, index: i, train: t.train, date: t.date, stamp: time.Now().Unix()}
        data[i] = data[i] | mask
        return order, true
    }
    return
}

// 将日期转化为整数
func formatDate(t time.Time) int {
    return int(t.Unix()/(60*60*24)) - baseDate
}

func main() {

    date := formatDate(time.Now())
    for i := 0; i < 1024; i++ {
        addTrain(i, date)
    }

    testSearch()

}

func testSearch() {
    total := 1000 * 1000
    date := formatDate(time.Now())

    start := time.Now()
    var count int
    for i := 0; i < total; i++ {
        count = search(total/1000, date, 3, 17)
    }
    end := time.Now()

    fmt.Println("start", start)
    fmt.Println("end", end)
    fmt.Println("duration", end.Sub(start).Nanoseconds()/1000000)
    fmt.Println("search result", count)
}

// id生成器
type snow struct {
    lock     sync.Mutex
    base     int64
    stamp    int64 //上次生成编号的时间戳，24位，分钟为单位
    train    int   //车次编号，13位 = 1024*8
    server   int   //服务编号，9位 = 512
    sequence int   //上次生成编号，18位 = 1024*256
    mask     int
}

func newSnow(train, server int) *snow {
    snow := &snow{
        train:  train,
        server: server,
        base:   time.Date(2012, 1, 0, 0, 0, 0, 0, time.UTC).Unix() / 60,
        mask:   -1 ^ (-1 << 18)}

    return snow
}

func (snow *snow) nextInt() uint64 {
    snow.lock.Lock()
    defer snow.lock.Unlock()

    ts := time.Now().Unix()/60 - snow.base
    if ts == snow.stamp {
        snow.sequence = (snow.sequence + 1) & snow.mask
        if snow.sequence == 0 {
            panic("error:overflow")
        }
    } else {
        snow.sequence = 0
    }
    snow.stamp = ts
    id := (uint64(snow.stamp) << (18 + 9 + 13)) | (uint64(snow.train) << (9 + 18)) |
        (uint64(snow.server) << 18) | (uint64(snow.sequence))
    return id
}