扛住100亿软呼吁?我们来试试一试

事例:计算数组中的平均数

 正常写法:

 图片 1

函数式编程:

 这样的代码是当叙而怎么,而无是怎么干

 图片 2

  我是如此解决的:利用NTP服务,同步所有的服务器时间,客户端应用时间戳来判断好之此时得发送小要。
  算法很轻实现:
  假设有100万用户,则用户id 为0-999999.要求的QPS为5万,
客户端得知QPS为5万,总用户数为100万,它计算
100万/5万=20,所有的用户应分为20组,如果 time() % 20 == 用户id %
20,那么这id的用户就是该于当下无异于秒发出请求,如此实现了大半客户端协同工作。每个客户端只待理解
总用户数和QPS 就能够自动准确发出请求了。
(扩展思考:如果QPS是3万
这样不能够让整除的数额,该如何处置?如何保证各级台客户端起的请数目尽量的户均呢?)

行之有效的内建函数

enumerate函数

# 对一个列表或数组既要遍历索引又要遍历元素时
l = [1,2,3]
for i in range (len(l)): 
    print i ,l[i]

 

0 1
1 2
2 3

 

# enumerate会将数组或列表组成一个索引序列。使我们再获取索引和索引内容的时候更加方便如下:
for index,text in enumerate(l): 
   print index ,text

 

0 1
1 2
2 3

末了,实践形成。

会合模块collections

  collections是Python内建的一个集模块,提供了过多中之集合类。

  deque是以快速落实插入和去操作的双向列表,适合用于队列和仓库。

  OrderedDict的Key会按照插入的顺序排列。
Counter是一个简易的计数器,也是dict的一个子类。

from collections import namedtuple
Point = namedtuple('Point', ['x', 'y'])
p = Point(1, 2)
print p.x
print p.y

 

from collections import deque
q = deque(['a', 'b', 'c'])
q.append('x')
q.appendleft('y')
print q

deque(['y', 'a', 'b', 'c', 'x'])

 

from collections import defaultdict
dd = defaultdict(lambda: 'N/A')
dd['key1'] = 'abc'
print dd['key1'] # key1存在
print dd['key2'] # key2不存在,返回默认值


abc
N/A

 

from collections import OrderedDict
d = dict([('a', 1), ('b', 2), ('c', 3)])
print d # dict的Key是无序的,{'a': 1, 'c': 3, 'b': 2}
od = OrderedDict([('a', 1), ('b', 2), ('c', 3)])
print od # OrderedDict的Key是有序的,OrderedDict([('a', 1), ('b', 2), ('c', 3)])


{'a': 1, 'c': 3, 'b': 2}
OrderedDict([('a', 1), ('b', 2), ('c', 3)])

 

from collections import Counter
c = Counter()
for ch in 'programming':
    c[ch] = c[ch] + 1
print c #Counter({'g': 2, 'm': 2, 'r': 2, 'a': 1, 'i': 1, 'o': 1, 'n': 1, 'p': 1})


Counter({'g': 2, 'm': 2, 'r': 2, 'a': 1, 'i': 1, 'o': 1, 'n': 1, 'p': 1})

 

 

察网络监控与监控端反馈,发现QPS 达到预期数量
网监督截图
3万qps

Hadoop Streaming & mrjob

 Hadoop有Java和Streaming两栽方法来修MapReduce任务。

   Java的亮点是测算效率高,并且配备好,直接从包改成一个jar文件就推行了。

   Hadoop
Streaming是Hadoop提供的一个编程工具,它同意用户使用其他可执行文件或者脚本文件作为Mapper和Reducer。

 图片 3

Streaming单机测试:

   cat input | mapper | sort | reducer > output

 mrjob实质上便是于Hadoop
Streaming的命执行及管了千篇一律重叠,有了统一之Python界面,无需而更去直接调用Hadoop
Streaming命令。

5.5)监控

要内容

Python多进程同大多线程

Python使用Hadoop分布式计算库mrjob

Python使用Spark分布式计算库PySpark

事例:分别下MapReduce和Spark实现wordcount

正则表达式简介

日子与日

常用内建模块: collections; itertools

3.4. 单机峰值QPS:
  文章被明显表示也1400万QPS.这个数值是杀大的,但是因起600尊服务器是,所以单机的QPS为
1400万/600= 约为2.3万QPS,
文章曾经提及系统可支撑4000万QPS,那么网的QPS 至少要到4000万/600 =
约为 6.6万,
这个数值大约是当下底3倍,短期来拘禁并无会见给硌。但是我深信不疑应该做了相应的压力测试。

 Mrjob实现wordcount

 

from mrjob.job import MRJob 
class MRWordFrequencyCount(MRJob): 
    def mapper(self, _, line): 
        yield "chars", len(line) 
        yield "words", len(line.split()) 
        yield "lines", 1 
    def reducer(self, key, values): 
        yield key, sum(values) 
if __name__ == '__main__': 
    MRWordFrequencyCount.run()

图片 4

总结:
  从单台服务器看.它需满足下面有准
  1. 支持至少100万连连用户
  2. 各级秒至少会处理2.3万的QPS,这里我们管对象定得重复胜一些
分别设定及了3万和6万。
  3.
摇红包:支持各国秒83只底速度下发给红包,也就是说每秒有2.3万次于摇红包的请,其中83单请求能摇到红包,其余的2.29万差呼吁会明白好从不摆到。当然客户端在接红包后,也要保证客户端以及服务器两度的红包数及红包外的金额要平等。因为从没开模块,所以我们呢把务求增强一倍增,达到200只红包每秒的分发速度
  4.
支持用户中作红包业务,确保收发两度的红包数量及红包外金额要一致。同样也设定200单红包每秒的散发速度也我们的对象。

Python中的lambda和map、 filter、 reduce

 map(function, sequence)
:对sequence中之item依次执行function(item),执行结果成一个List返回

 图片 5图片 6

 

 图片 7图片 8

图片 9

  客户端: esxi 5.0 虚拟机,配置也4核
5G内存。一共17大,每台与服务器建立6万只连。完成100万客户端模拟

过程与线程

经过:程序的同等不好实行(程序装载入内存,系统分配资源运行)

  每个过程来谈得来的内存空间、数据栈等,只能使用过程之中通讯,而不克直接共享信息

线程:所有线程运行于跟一个过程被,共享相同的运行条件

  每个独立的线程有一个程序运行的进口、顺序执行序列及次序的道

  线程的运作可以叫吞没(中断),或暂时吃吊起于(睡眠),让其它线程运行(让步)

  一个进程中的各个线程间共享同一片数据空间

架构图

迭代器itertools

  也接近序列对象提供了一个近似序列接口

  无限迭代器:

图片 10

  在最缺少输入序列终止之迭代器:

图片 11

  组合生成器:

图片 12

import itertools
for i in itertools.izip(itertools.count(1), ['a', 'b', 'c']):
    print i

(1, 'a')
(2, 'b')
(3, 'c')

 

参考:http://python.usyiyi.cn/python_278/library/itertools.html

则这原型简单地做到了预设的政工,但是它们跟诚的劳务会有怎么样区别吗?我摆了一下

Python中的lambda和map、 filter、 reduce

 filter(function,
sequence):对sequence中之item依次执行function(item),将实施结果吗

True的item组成一个List/String/Tuple(取决于sequence的种类)返回

 图片 13

与客户端的向对应之,服务器也存3独区间,和客户端的情形大类似。但是咱来看了在大概22:57分割,系统的处理能力就产生一个家喻户晓的骤降,随后而增长的尖状。这证明代码还需要优化。

 多进程与大多线程对比

 在形似景象下基本上单过程的内存资源是相互独立的,而大多线程可以协同享同一个历程遭到之内存资源

图片 14图片 15

  QPS: Queries per second 每秒的乞求数目

 RDD

 弹性分布式数据集Resilient Distributed Datasets:

  集群节点上不可变、已分区对象

  可序列化

  可以操纵存储级别(内存、磁盘等)来展开录取。

计量特性:

  血统lineage

  惰性计算lazy evaluation

浮动方式:

  文件读取

  来自父RDD

图片 16

  1. 基本功软件与硬件

Spark

 Spark是因map reduce算法实现之分布式计算框架:

  Spark的中级输出及结果输出可以保证存在内存中,从而不再用读写HDFS。

  Spark能重复好地用来数据挖掘与机具上等需要迭代的map reduce的算法中。

 图片 17

大高QPS系统压力测试    本系统压力测试
总是数    一般<1000 (几百坐内)    1000000 (1百万)
单连接吞吐量    非常大 每个连几十M字节吞吐    非常小
每个连每次几十独字节
需要的IO次数    不多    非常多

Python中的lambda和map、 filter、 reduce

  reduce(function, sequence,
starting_value):对sequence中之item顺序迭代调用function,

如果有starting_value,还可以用作初始值调用

 图片 18

阶段2:

逐条执行单线程与同时实行两独连发线程

图片 19

图片 20

join阻塞进程直到线程执行完毕

5.1) 单机实现100万用户连接

Python 多进程( multiprocessing)

 fork操作:

  调用一差,返回两差。因为操作系统自动把目前过程(称为大
  进程)复制了同样卖(称为子进程), 然后各自在大人进程和子进
  程内返回。子进程永远回回0,而父进程返回子进程的ID。子
  进程就需要调用getppid()就足以以到父亲进程的ID。

图片 21

图片 22

出于Windows没有fork调用,上面的代码在Windows上无法运转。

1, 客户端的摇红包请求消息

大局解释器锁GIL

GIL全称全局解释器锁Global Interpreter Lock, GIL并无
举凡Python的特征,它是于贯彻Python解析器(CPython)时
所引入的一个定义

GIL是同一拿全局排异锁,同一时刻才发一个线程在运转

  毫无疑问全局锁之留存会针对多线程的频率有无略影响。甚至就是差一点顶Python是独单线程的顺序。

  multiprocessing库的面世非常挺程度达到是以弥补thread库因为

  GIL而不行的缺点。它完全的复制了平等拟thread所提供的接口方

  便搬。唯一的异就是其使了差不多进程使未是多线程。每个

  进程有友好之单独的GIL,因此也无见面起过程中的GIL争快。

总体观察在3万QPS区间,服务器的QPS比较稳定,在6万QSP时候,服务器的拍卖就不平静了。我相信当下同自家之代码有关,如果持续优化的话,还应力所能及生出双重好之效益。

基于Linux管道的MapReducer

 

import sys
for line in sys.stdin:
    ls = line.split()
    for word in ls:
        if len(word.strip()) != 0:
            print word + ',' + str(1)

 

 

import sys
word_dict = {}
for line in sys.stdin:
    ls = line.split(',')
    word_dict.setdefault(ls[0], 0)
    word_dict[ls[0]] += int(ls[1])

for word in word_dict:
    print word, word_dict[word]

 $ cat wordcount.input | python mapper.py | python reducer.py | sort -k
2r

 Output:
  n world 3
  n hello 2
  n hi 1

图片 23

图片 24

2, 客户端的另信息 比如聊天 好友这同样看似

PySpark实现WordCount

图片 25

客户端QPS
  因为起100万并连续在服务器上,QPS为3万。这就是意味着每个连各个33秒,就待为劳动器发一个摇红包的求。因为单IP可以成立的连接数为6万横,
有17台服务器又拟客户端表现。我们如果举行的便保险在各一样秒都起这般多的恳求发朝服务器即可。
里头技术中心就是客户端协同。但是各个客户端的启航日,建立连接的日还不相同,还在网断开重连这样的情况,各个客户端如何判断何时自己待发送请求,各自该发送小要呢?

时光和日期

time模块和datetime模块

import time
print time.time()
print time.localtime()
for i in range(3):
    time.sleep(0.5)
    print "Tick!"

 

1479487832.06
time.struct_time(tm_year=2016, tm_mon=11, tm_mday=19, tm_hour=0, tm_min=50, tm_sec=32, tm_wday=5, tm_yday=324, tm_isdst=0)
Tick!
Tick!
Tick!

 

import datetime
print "today is: ", datetime.date.today()
print "now is: ", datetime.datetime.now()
print datetime.date(2016,6,4)
print datetime.time(14,00)

 

today is:  2016-11-19
now is:  2016-11-19 00:50:38.551905
2016-06-04
14:00:00

 

# 计算昨天和明天的日期
import datetime
today = datetime.date.today()
yesterday = today - datetime.timedelta(days=1)
tomorrow = today + datetime.timedelta(days=1)
print yesterday,today,tomorrow

 

2016-11-18 2016-11-19 2016-11-20

作业2:计算日期里的工作日

  摇红包的事体非常简单,首先服务器按照一定的速生产红包。红包没有为得走吧,就堆放在里面。服务器收到一个客户端的求,如果服务器里现在发生红包就会见报告客户端有,否则就是提示无红包。
  因为单机每秒有3万底恳求,所以大部分的呼吁会砸。只需要处理好锁的题目即可。
  我为了削减竞争,将有所的用户分在了不同之桶里。这样可以减去对锁的竞争。如果后还有复强之性要求,还可使用
高性能队列——Disruptor来进一步提高性能。

正则表达式

点滴栽模式匹配:搜索search()和匹配match()

图片 26图片 27

看清一个字符串是否是合法的Email地址

 图片 28

作业1:电话号码正则匹配

例子:

+008613112345678

+861795101023231212

+8608715432231

01023459764

06346046499

010120

摇红包

multiprocessing

multiprocessing是越平台版本的大都进程模块,它提供了
一个Process类来代表一个经过对象,下面是现身说法代码:

图片 29

其一顺序一旦用单进程写虽然需实施10秒以上的流年,而因此几近进程则启动10个过程并行执行,只需要用1秒多之日。

独家启动服务器端和监控端,然后挨家挨户启动17令客户端,让她建立由100万的链接。在服务器端,利用ss
命令 统计有每个客户端以及服务器建立了有些连接。
令如下:
 Alias ss2=Ss –ant | grep 1025 | grep EST | awk –F: “{print \$8}” |
sort | uniq –c’

函数式编程

其三特别特点:

  immutable data 不可变数据

  first class functions:函数像变量一样采用

  尾递归优化:每次递归都用stack

好处:

  parallelization 并行

  lazy evaluation 惰性求值

  determinism 确定性

函数式编程http://coolshell.cn/articles/10822.html

  实现的靶子: 单机支持100万连续,模拟了摇红包和发红包过程,单机峰值QPS
6万,平稳支持了政工。

经过中通信Queue

Queue是大半进程安全之行,可以利用Queue实现多进程中的数码传递

图片 30图片 31

7实践

进程池Pool

用来批量创建子进程,可以活控制子进程的多少

图片 32

图片 33

  发红包:产生一个红包里包含一定金额,红包指定数只用户,每个用户会收到红包信息,用户可以发送拆红包的呼吁,获取其中的有些金额。

函数式编程技术

技术:

  map & reduce

  pipeline

  recursing 递归

  currying

  higher order function 高阶函数

图片 34

  最后
我们得同法监督系统来打听系统的光景,我假了自己任何一个品类(https://github.com/xiaojiaqi/fakewechat)
里的部分代码完成了此监控模块,利用是监控,服务器和客户端会把目前之计数器内容作于监理,监控需要拿各个客户端的数目做一个结缘和显示。同时还会见把日志记录下来,给以后的辨析提供原始数据。
线上系统又多下opentsdb这样的时序数据库,这里资源有限,所以用了一个原本的方案

Python中的lambda和map、 filter、 reduce

lambda:快速定义单行的不过小函数, inline的匿名函数

图片 35

  服务端: dell R2950。
8核物理机,非独占有其他业务在劳作,16G内存。这大硬件大概是7年前的产品,性能应无是异常高要求。
  服务器硬件版本:
machine
  服务器CPU信息:
cpu

MapReducer

思:任务之讲和结果的汇总

 图片 36

抵交具有红包下发完成后,再起步一个作红包的服务,这个服务系统会变动2万独红包,每秒为是200个,每个红包随机指定3各用户,并通往这3只用户有消息,客户端会自动来拿红包,最后有的红包都于将走。

Spark与Hadoop结合

Spark可以直接对HDFS进行多少的读写,同样支撑Spark on
YARN。Spark可以跟MapReduce运行为同集众多中,共享存储资源与计量。

  本地模式

  Standalone模式

  Mesoes模式

  yarn模式

5.4) 发红包业务

Hadoop

 Hadoop是Apache开源组织的一个分布式计算开源框架。

   核心的计划虽是: MapReduce和HDFS( HadoopDistributed File System)

 图片 37

单机百万之尽
https://github.com/xiaojiaqi/C1000kPracticeGuide
争以AWS上拓展100万用户压力测试
https://github.com/xiaojiaqi/fakewechat/wiki/Stress-Testing-in-the-Cloud
构建一个君协调的类微信系统
https://github.com/xiaojiaqi/fakewechat/wiki/Design
http://djt.qq.com/article/view/1356
http://techblog.cloudperf.net/2016/05/2-million-packets-per-second-on-public.html
http://datacratic.com/site/blog/1m-qps-nginx-and-ubuntu-1204-ec2
@火丁笔记
http://huoding.com/2013/10/30/296
https://gobyexample.com/non-blocking-channel-operations

发红包

监控显示日志大概这样
监理日志

  1. 代码实现同分析

于服务器端启动一个发红包的劳务,这个服务会以200只每秒的快慢发出红包,总共4万独。此时考察客户端在监控及的日志,会意识差不多以200只每秒的速获得到红包。

  对于红包来服务,它的做事特别粗略,只需要按照顺序以更替当每个SET的红包闹对列里放至红包对象就是可了。这样可管每个SET里还是公平的,其次它的做事强度大没有,可以保工作稳定。

  前几天,偶然见到了
《扛住100亿不好呼吁——如何做一个“有把握”的春晚红包系统”》(url)一和,看了之后,感慨良多,收益很多。正所谓他山之石,可以攻玉,虽然此文发表于2015年,我顾时已是2016年最终,但是中间的思想依然是可以吗广大晚端平设计借鉴,。同时作为一个工程师,看罢以后又会盘算,学习了这么的篇章以后,是否能够给协调之做事带来一些其实的经验吗?所谓纸上得来算觉浅,绝知此事要躬行,能否自己履一下100亿破红包请求呢?否则读了事后脑子里能够剩下的事物
不了就是是100亿 1400万QPS整流
这样的字眼,剩下的篇章以显示作者是怎是过程为对象,在当地环境之模拟了这个过程。

末尾是golang 自带的pprof 信息,其中有gc 时间越了10ms,
考虑到当下是一个7年前之硬件,而且不仅仅占模式,所以还是可以接受。
pprof

  注意,在自己的测试环境里是少支付是基本服务之,所以实现的难度是大妈的减轻了。另外提供平等组数字:2016年淘宝的双料11底市峰值仅仅为12万/秒,微信红包分发速度是5万/秒,要完成这点是坏困难的。(http://mt.sohu.com/20161111/n472951708.shtml)

当好多goroutine 同时运行的上,依靠sleep
定时连无纯粹,发生了摇。我觉着这是golang本身调度导致的。当然如果cpu比较强,这个状况会磨。
以网络的影响,客户端在倡导连接时,可能发延迟,导致在前头1秒没成功连接。
服务器负荷较充分时,1000M网都面世了抛弃包现象,可以通过ifconfig
命令观察到者场景,所以会见出QPS的不定。
次张是 服务器处理的QPS图
服务器qps

  注:本文以及作者有情节,仅表示个人了解和推行,过程与微信团队没有其它关联,真正的线及系统为差,只是于一些技术点进行了推行,请读者进行区分。因作者水平有限,有任何问题还是作者的义务,有问题要联系
ppmsn2005#gmail.com. 全文内容 扛住100亿赖呼吁?我们来试试一试

应用客户端的http接口,将有的客户端QPS 调整至3万,让客户端发出3W
QPS强度的要。
运转如下命令:
启航脚本

  PPS:Packets per second 每秒数包数目

8 解析数据

第一摆是 客户端的QPS发送数据
客户端qps
即张图的横坐标是时,单位凡秒,纵坐标是QPS,表示这天天有所客户端发送的请求的QPS。
祈求的率先距离,几只小之峰值,是100万客户端起连接的,
图的第二距离是3万QPS 区间,我们得以视数据
比较稳定的保以3万者间隔。最后是6万QPS区间。但是自从整张图可以观看QPS不是无微不至地保障在我们愿意之直线上。这主要是以下几独由促成的

阶段1:

那个之安居。

  最后整体的圈一下
100亿浅摇红包这个要求,假而它是咸匀地发生在新春佳节联欢晚会的4独小时里,那么服务器的QPS
应该是10000000000/600/3600/4.0=1157.
乎不怕是单机每秒1000多不好,这个数值其实并无愈。如果完全是因为峰值速度1400万消化
10000000000/(1400*10000) =
714秒,也就是说只需要峰值坚持11分钟,就好好有着的请求。可见互联网产品的一个特色就是峰值非常强,持续时间并无见面非常丰富。

  在全体系统开始以前,我们当干懂我们的体系以形成后,应该来一个怎么的载重能力。

  服务器端的QPS相对简单,它才需要处理客户端的呼吁即可。但是以客观了解拍卖情况,我们尚待举行2宗工作。
  第一: 需要记录每秒处理的请求数目,这需要在代码里挂入计数器。
  第二:
我们要监控网络,因为网络的吞吐情况,可以成立的反映出QPS的实在数据。为是,我动用python脚本
结合ethtool
工具编写了一个略的工具,通过其我们得以直观的监及网络的数额包通过情况怎样。它好成立的显得出我们的纱有这般多之数据传在闹。
工具截图: 工具截图

结果如下:  100万接连起

6wqps

总结:
  按照计划目标,我们学与统筹了一个支撑100万用户,并且每秒至少得支持3万QPS,最多6万QPS的网,简单模拟了微信的摇红包和作红包的过程。可以说达了预想的目的。
倘600台主机每台主机可以支撑6万QPS,只待7分钟就可以成功
100亿糟摇红包请求。

  摇红包:客户端有一个摇红包的乞求,如果系统来红包就会见回到,用户得到红包

这是红包生成多少的状态变化图
变红包

假如法炮制,在劳动器端,启动一个闹红包的劳动,这个服务会以200独每秒的快慢发出红包。总共4万个。此时观察客户端在监督及之日记,会发现多以200独每秒的快获得到红包。
抵及拥有红包下发完成后,再起步一个作红包的服务,这个服务体系会转移2万只红包,每秒为是200个,每个红包随机指定3各项用户,并往当时3单用户产生消息,客户端会自动来将红包,最后有的红包都给以走。

骨干是适合的,这也认证系统是切合预期设计之。

当时是客户端每秒获取之摇红包状态
得红包

采用客户端的http接口,将有所的客户端QPS 调整至6万,让客户端有6W
QPS强度的要。

5.3) 摇红包业务

  这或多或少吧相对简便易行,笔者在几乎年前纵早好了单机百万用户之开支及操作。现代之服务器都可支撑百万用户。相关内容可以查
  github代码以及相关文档。
https://github.com/xiaojiaqi/C1000kPracticeGuide
  系统布局与优化文档:
https://github.com/xiaojiaqi/C1000kPracticeGuide/tree/master/docs/cn

3.3 单机需要支持之负载数:
  每令服务器支持的用户数:5.4亿/600 =
90万。也就算是平均单机支持90万用户。如果真实情况比90万再次多,则模仿的图景或会见出病,但是自己道QPS在斯实验中另行要。

作者:ppmsn2005#gmail.com
项目: https://github.com/xiaojiaqi/10billionhongbaos
wiki:
https://github.com/xiaojiaqi/10billionhongbaos/wiki/扛住100亿次请求?我们来试一试

4.1软件:
  Golang 1.8r3 , shell, python (开发尚未用c++ 而是使了golang,
是因为用golang 的早期原型达到了网要求。虽然golang
还在必然的题材,但是同出效率比较,这点损失可以领)
  服务器操作系统:
  Ubuntu 12.04
  客户端操作系统:
  debian 5.0

  1. 背景知识
  1. 前言

  发红包的事情好粗略,系统随机产生部分红包,并且随机选择部分用户,系统为这些用户提示有红包。这些用户仅待来拆红包的伸手,系统就是好肆意从红包中拆分来有金额,分给用户,完成这工作。同样这里也从未支付此核心服务。

可以窥见3万QPS区间,客户端每秒获取之红包数基本以200左右,在6万QPS的下,以及并发重的震动,不可知管在200斯数值了。我认为重点是6万QPS时候,网络的颠簸加剧了,造成了红包数量也以抖动。

3.2. 服务器数量:
  一共来638台服务器,按照正规运维设计,我深信所有服务器不见面了达到线,会有一定之硬件冗余,来严防突发硬件故障。假设一共来600高接入服务器。

以实践进程遭到,服务器和客户端都将自己内部的计数器记录发朝监控端,成为了日志。我们利用简易python
脚本和gnuplt 绘图工具,将履行的历程可视化,由此来说明运行过程。

见代码
https://github.com/xiaojiaqi/10billionhongbaos

5.2) 3万QPS

4.2硬件环境

以2摆设图合并起来 qps

  这个题目要分2个组成部分来拘禁客户端方面和服务器方面。

  和现有系统区分:
  和多数高QPS测试的不同,本系统的侧重点有所不同。我本着2者做了有的对待。

阶段3

  想圆模拟整个系统实际太为难矣,首先需要海量的服务器,其次要上亿的仿客户端。这对自我吧是处置不交,但是出几许方可确定,整个系统是可以水平扩展的,所以我们得套100万客户端,在法一大服务器
那么就算好了1/600底模拟。

  1. 技术分析及兑现

3.5. 发给红包:
  文中提到系统为5万只每秒的发出速度,那么单机每秒下发速度50000/600
=83个/秒,也不怕是单机系统应该保证每秒为83只底快慢发出即可。
  最后设想到系统的真人真事,还至少有用户登录的动作,拿红包这样的事务。真实的系统还见面包括聊天这样的服务业务。

  在代码方面,使用到的艺实在不多,主要是计划思想与golang本身的一对题材用考虑。
率先golang的goroutine
的多少控制,因为至少发生100万之上的连年,所以照日常的设计方案,至少要200万还是300万的goroutine在办事。这会促成系统自的负责非常重复。
下就是是100万单连续的军事管制,无论是连接要政工都见面促成一部分心智的当。
自之规划是这般的:

3, 服务器端对客户端音的对
  对于 第1种信息 客户端的摇红包请求消息
是如此处理的,从客户端将到摇红包请求消息,试图打SET的红包队列里
获取一个红包,如果以到了不畏将红包信息
返回给客户端,否则构造一个没摇到的音讯,返回给相应之客户端。
  对于第2种信息 客户端的别样信息 比如聊天
好友这无异于像样,只需要简地从队列里用走消息,转发让后端的闲聊服务班即可,其他服务会把信转发出来。
  对于第3种植信息 服务器端对客户端音的回复。SET
只待基于信里的用户id,找到SET里保存的用户连接对象,发回便可以了。

3.1 用户总数:
  通过文章我们可了解及接入服务器638雅, 服务上限约是14.3亿用户,
所以单机负载的用户上限约是14.3亿/638华=228万用户/台。但是时中国终将不会见来14亿用户同时在线,参考
http://qiye.qianzhan.com/show/detail/160818-b8d1c700.html
的布道,2016年Q2 微信用户约是8亿,月在在5.4
亿横。所以当2015年新年次,虽然使的用户会成千上万,但是同时在线肯定不顶5.4亿。

尽的历程分成3单等级

  1. 确定目标

  首先以100万连续分成多单不等之SET,每个SET是一个单独,平行的靶子。每个SET
只管理几千个连,如果单个SET
工作正常,我单待添加SET就能增长系统处理能力。
  其次谨慎的计划了每个SET里多少结构的大小,保证每个SET的下压力不见面极其怪,不会见油然而生信息之积聚。
  再次减少了gcroutine的数码,每个连只以一个goroutine,发送信息在一个SET里单独发一个gcroutine负责,这样节约了100万独goroutine。这样一切系统只待保留
100万散几百个gcroutine就可知形成业务。大量底节约了cpu 和内存
  系统的劳作流程大概如下:
  每个客户端连接成功后,系统会分配一个goroutine读取客户端的信,当消息读取完成,将她转化为信对象放至在SET的接受信息队列,然后回到获取下一个信
  在SET内部,有一个做事goroutine,它只有开非常简单而快捷之政工,它做的工作如下,检查SET的收受信息,它会接到3类消息

服务器QPS

分别    真正服务    本次模拟
事务复杂    更复杂    非常简单
协和    Protobuf 以及加密    简单的商议
支付    复杂    无
日志    复杂    无
性能    更高    无
用户分布    用户id分散在不同服务器,需要hash以后集合, 复杂。    用户id
连续,很多优化使代码简单 非常便捷
安全控制    复杂    无
热更新及版本控制    复杂    无
监控    细致    简单
Refers:

发表评论

电子邮件地址不会被公开。 必填项已用*标注