连续三个交易日上证指数缩量收阳，扭扭捏捏，简单通过这五六个交易日上证和创业板的量价走势来看，近日如果不能放量上攻，还会有中阴线下杀探底，所以不应该急着乐观。倘若接下来有放量的阳线，则值得乐观。今天讲讲如何通过分时成交量判断后市涨跌。虽然讲的是分时量，但分时与K线的其实是一回事。只不过分时为即时走势，K线为事后走势，将K线周期无限降低，即为分时图。一、大盘分时量与后市预判看大盘的时候，想要预测接下来的涨跌，有一个比较简单的办法，总结一下就是：涨缩量，跌放量，看跌；涨放量，跌缩量，看涨。涨缩量，就是说大盘上涨的时候交易量减少，在大盘上看到的红柱越来越短(如下图)。有些分时量没有颜色，你可以设置出来。也可以看分时图上的红绿柱。下图是今天的上证分时图。当出现涨缩量这种情况的时候，说明并不是因为成交量导致价格上涨，极有可能是单笔高价交易导致的。这种上涨往往是虚涨。跌放量是说大盘下跌的时候交易量增加，在大盘分时图上看到的绿柱越来越长。说明大家在纷纷卖出手里的股票。这种下跌往往是实跌，如果涨缩量遇见跌放量，脚底抹油，趁早溜之大吉，因为后面大概率还有更大的跌幅。反之，涨放量(下图)就是大盘上涨的时候交易量增加，在大盘上看到红柱越来越长。同理，交易量带来的价格上涨往往是实涨。跌缩量则是在大盘下降的时候交易量减少，在大盘上看到绿柱越来越短，或许说明持有股票的人没有因为价格下就抛售，而是继续持有或持观望态度。当涨放量遇到了跌缩量，这种下跌往往是虚跌。也就是实涨之后是虚跌，在两者差别较大的情况下，基本后市大涨的概率很高。如果早盘有看好的股票，可以择机杀入，当天吃肉的概率大。不过大盘的起起伏伏情况太多，也有不少消息面的爆发和跳水。所以看的时候也要动动脑子哦。如果出现很长的绿柱，后市也不乐观，所以，不管是大盘还是个股，记住：涨放量，跌缩量，后市大概率是涨，相反后市大概率是跌！
还有就是，反弹时的成交量我们也称作为底量，有底量也就会有顶量。如果反弹时底量远远大于顶量，那反弹的高度一般都会比前高度高不少(见下图)
二、个股分时与后市预判这个方法也同样适合个股。以今天早盘的汉邦高科为例。10点钟开始的下跌是典型的放量下跌，而紧接着的反弹是无量反弹，是上不去的，最终受均价线压制，到收盘跌14个点。个股分时量还可以用两句话来概括：反弹有量，会继续冲高；反弹无量，会冲高回落。也就是说，当某只股票价格反弹的时候，如果交易量也配合上涨，那么这只股票后期仍然还有上涨空间。如果交易量没有配合上涨，那么这只股票很有可能要下跌。举个例子:今天早上这只票量价配合很好，竞价也很完美，我在今天早盘推荐，下午拉板，后市看高一线。

 

详解rsync算法--如何减少同步文件时的网络传输量


分类： 技术分享 算法 C/C++2012-02-28
 17:02 13504人阅读 评论(30) 收藏 举报

算法网络服务器server手机android


先看下图中的场景，客户端A和B，以及服务器server都保存了同一个文件，最初，A、B和server上的文件内容都是相同的（记为File.1）。某一时刻，B修改了文件内容，上传到SERVER上（记为File.2）。客户端A这时试图向服务器SERVER更新文件到最新内容，也就是File.1更新为File.2。




上面这个场景很常见，例如现在流行的网盘。假设我有一个文件a.txt在网盘上，上班时在公司的单位PC上更新了文件a.txt，下班后回到家里，家里PC硬盘上的a.txt就不是最新的内容，这时网盘就试图从服务器上去拿最新的a.txt了。




那么问题来了，如果在公司电脑上我只是更新了a.txt里很少的一部分内容，例如a.txt共有20M，我只更新了10个字节，难道家里的电脑上，网盘要从服务器上下载20M大小的文件？这明显很浪费带宽。

更有用的场景，假设我的手机android上也用了这个网盘（手机上网费贵得多），只改了几十字节的内容，就要下载20M的文件，得不偿失。或者我把这个文件共享给其他朋友，也有同样的问题：修改少量的内容，却同步完整的文件！




rsync算法就是用来解决上述问题的。client A发送它所保存的旧文件File.1少量的rsync摘要，server拿到后对比本地的File.2内容，得到File.2相对于File.1的变化，然后通过仅发送这个变化来代替发送完整的File.2内容，这样大大减少了网络传输数据。client A收到这个变化后，更新本地的File.1到最新的File.2。就是这么简单。下面详述rsync算法的步骤。




rsync首先需要客户端与服务器之间约定一个块大小，例如1K。然后把File.1等分成多个1K大小的字符串块，每块各计算出MD5摘要和Alder32校验和，如下图。




这里简单介绍下MD5和校验和。MD5是种哈希算法，用于把任意长度的字符串转化为固定为128位的定长字符串，这里可以保证，相同的字符串不可能计算出不同的MD5值。MD5的碰撞率是有的，就是说，两个不同的字符串有可能计算出相同的MD5值，但是这个机率非常小，这里我们忽略不计。例如，在rsync算法里，同一个文件按1K切分成多块，每块都有一个MD5值，如果两块字符串的MD5值相同，则我们认为这两块数据完全相同。

校验和是把上述1K块数据映射为32位大小整型数字上，我们采用Alder32算法，这里同样可以保证，相同的字符串不可能计算出不同的Alder32值。Alder32有两个优点：1、计算非常快，比MD5快多了，成本小；2、当我们有了从0-1024长度的校验和后，计算出1-1025或者2-1026等其他校验和非常方便，只要少量运算即可。当然，它的缺点也很明显，就是碰撞率比MD5高多了，所以，我们要把每个rynsc块同时计算出Alder32校验和与MD5值。Alder32算法我会在本文最后解释。




客户端按1K大小划分File.1文件为许多块，并对每块计算出MD5、Alder32校验和。最后不满1K的数据不做计算。之后，客户端把这些MD5、Alder32校验和依序通过网络传输给服务器，最后不满1K的数据直接发给服务器。那么，服务器收到数据后怎么处理呢？看下图。




首先重申，计算Alder32校验和非常快！

所以，服务器先把最新文件File.2从0字节开始，按1K切分成许多块，每块计算出Alder32校验和，然后与客户端发来的File.1切分出来的Alder32校验和相比，如果alder32值都不一样，毫无疑问，文件内容是不相同的。接着，把File.2从1字节开始，按1K切分成许多块，每块计算出Alder32校验和，再与客户端的校验和比。如此循环下去，直到某个校验和相同了，那么把这段字符串再计算出MD5值，再与客户端过来的对应的MD5值相比（还记得吧？客户端对每个块既计算出Alder32又计算出MD5值），如果不同，则继续往后移1字节，继续比Alder32、MD5值。如果相同，则认为这1K数据，服务器与客户端保存的一致，忽略这块数据（例如1K字节），继续向下看。




全部处理完后，按File.2的文件顺序，向客户端发送以下数据：对于不能够在客户端File.1数据块中找到相同块的字符串，直接列上发出；如果可以找到，则写上MD5和Alder32值，代替原来1024字节的数据块。同样，最后不足1K大小的部分直接列上发出。




纯理论读起来会有些吃力，我再把它简化了举个例子吧。假设客户端与服务器间约定的字符块大小不是1K，而是4个字节。客户端的文件内容是：

taohuiissoman

而服务器的文件内容是：

itaohuiamsoman

现在我们来看看，rsync算法是怎么运作的。




首先，客户端开始分块并计算出MD5和Alder32值。




如上图，像taoh是一块，对taoh分别计算出MD5和alder32值。以此类推，最后一个n字母不足4位保留。于是，客户端把计算出的MD5和alder32按顺序发出，最后发出字符n。




服务器收到后，先把自己保存的File.2的内容按4字节划分。




划分出itao、huia、msom、an，当然，这些串的Alder32值肯定无法从File.1里划分出的：taoh、uiis、soma、n找出相同的。于是向后移一个字节，从t开始继续按4字节划分。




从taoh上找到了alder32相同的块，接着再比较MD5值，也相同！于是记下来，跳过taoh这4个字符，看uiam，又找不到File.1上相同的块了。继续向后跳1个字节从i开始看。还是没有找到Alder32相同，继续向后移，以此类推。




到了soma，又找到相同的块了。




重复上面的步骤，直到File.2文件结束。




那么，最终客户端与服务器间传输的数据如下图所示。




上面这个例子很简单，可由此推导出复杂的情况，包括File.2对File.1在任意位置上做了增、改、删，都能够完成。

如果这是个大文本文件，应用rsync算法就非常有意义，例如20M的文件，实际可能只传输1M的数据量！这样用户体验会好很多，特别是网速慢的场景。

同时增加的消耗，就是在PC上计算的MD5值和Alder32校验和，这只消耗少量的CPU和内存而已。




最后列下Alder32的算法：





[cpp] view
 plaincopy





A = 1 + D1 + D2 + ... + Dn (mod 65521)  

B = (1 + D1) + (1 + D1 + D2) + ... + (1 + D1 + D2 + ... + Dn) (mod 65521)  

  = n×D1 + (n−1)×D2 + (n−2)×D3 + ... + Dn + n (mod 65521)  

  

Adler-32(D) = B × 65536 + A  


D1到Dn就是待计算的字符串块，所有位上的ASC字符。它的C代码实现为：







[cpp] view
 plaincopy





const int MOD_ADLER = 65521;  

   

unsigned long adler32(unsigned char *data, int len) /* where data is the location of the data in physical memory and  

                                                       len is the length of the data in bytes */  

{  

    unsigned long a = 1, b = 0;  

    int index;  

   

    /* Process each byte of the data in order */  

    for (index = 0; index < len; ++index)  

    {  

        a = (a + data[index]) % MOD_ADLER;  

        b = (b + a) % MOD_ADLER;  

    }  

   

    return (b << 16) | a;  

}  

数据库怎么分库分表，垂直？水平？

一、数据库瓶颈

不管是IO瓶颈，还是CPU瓶颈，最终都会导致数据库的活跃连接数增加，进而逼近甚至达到数据库可承载活跃连接数的阈值。在业务Service来看就是，可用数据库连接少甚至无连接可用。接下来就可以想象了吧（并发量、吞吐量、崩溃）。

1、IO瓶颈

第一种：磁盘读IO瓶颈，热点数据太多，数据库缓存放不下，每次查询时会产生大量的IO，降低查询速度 -> 分库和垂直分表。

第二种：网络IO瓶颈，请求的数据太多，网络带宽不够 -> 分库。

2、CPU瓶颈

第一种：SQL问题，如SQL中包含join，group by，order by，非索引字段条件查询等，增加CPU运算的操作 -> SQL优化，建立合适的索引，在业务Service层进行业务计算。

第二种：单表数据量太大，查询时扫描的行太多，SQL效率低，增加CPU运算的操作 -> 水平分表。

二、分库分表

1、水平分库



 

1、概念：以字段为依据，按照一定策略（hash、range等），将一个库中的数据拆分到多个库中。

2、结果：


	
每个库的结构都一样；
	
	

	
每个库的数据都不一样，没有交集；
	
	

	
所有库的并集是全量数据；
	
3、场景：系统绝对并发量上来了，分表难以根本上解决问题，并且还没有明显的业务归属来垂直分库。

4、分析：库多了，io和cpu的压力自然可以成倍缓解。

2、水平分表



 

1、概念：以字段为依据，按照一定策略（hash、range等），将一个表中的数据拆分到多个表中。

2、结果：


	
每个表的结构都一样；
	
	

	
每个表的数据都不一样，没有交集；
	
	

	
所有表的并集是全量数据；

	
 
	
3、场景：系统绝对并发量并没有上来，只是单表的数据量太多，影响了SQL效率，加重了CPU负担，以至于成为瓶颈。

4、分析：表的数据量少了，单次SQL执行效率高，自然减轻了CPU的负担。

3、垂直分库



 

1、概念：以表为依据，按照业务归属不同，将不同的表拆分到不同的库中。

2、结果：


	
每个库的结构都不一样；
	
	

	
每个库的数据也不一样，没有交集；
	
	

	
所有库的并集是全量数据；
	
3、场景：系统绝对并发量上来了，并且可以抽象出单独的业务模块。

4、分析：到这一步，基本上就可以服务化了。例如，随着业务的发展一些公用的配置表、字典表等越来越多，这时可以将这些表拆到单独的库中，甚至可以服务化。再有，随着业务的发展孵化出了一套业务模式，这时可以将相关的表拆到单独的库中，甚至可以服务化。

4、垂直分表



 

1、概念：以字段为依据，按照字段的活跃性，将表中字段拆到不同的表（主表和扩展表）中。

2、结果：

2.1、每个表的结构都不一样；

2.2、每个表的数据也不一样，一般来说，每个表的字段至少有一列交集，一般是主键，用于关联数据；

2.3、所有表的并集是全量数据；

3、场景：系统绝对并发量并没有上来，表的记录并不多，但是字段多，并且热点数据和非热点数据在一起，单行数据所需的存储空间较大。以至于数据库缓存的数据行减少，查询时会去读磁盘数据产生大量的随机读IO，产生IO瓶颈。

4、分析：可以用列表页和详情页来帮助理解。垂直分表的拆分原则是将热点数据（可能会冗余经常一起查询的数据）放在一起作为主表，非热点数据放在一起作为扩展表。这样更多的热点数据就能被缓存下来，进而减少了随机读IO。拆了之后，要想获得全部数据就需要关联两个表来取数据。

但记住，千万别用join，因为join不仅会增加CPU负担并且会讲两个表耦合在一起（必须在一个数据库实例上）。关联数据，应该在业务Service层做文章，分别获取主表和扩展表数据然后用关联字段关联得到全部数据。

三、分库分表工具

1、sharding-sphere：jar，前身是sharding-jdbc；2、TDDL：jar，Taobao Distribute Data Layer；3、Mycat：中间件。

注：工具的利弊，请自行调研，官网和社区优先。

四、分库分表步骤

根据容量（当前容量和增长量）评估分库或分表个数 -> 选key（均匀）-> 分表规则（hash或range等）-> 执行（一般双写）-> 扩容问题（尽量减少数据的移动）。

五、分库分表问题

1、非partition key的查询问题（水平分库分表，拆分策略为常用的hash法）

1、端上除了partition key只有一个非partition key作为条件查询



 



 

注：写入时，基因法生成userid，如图。关于xbit基因，例如要分8张表，23=8，故x取3，即3bit基因。根据userid查询时可直接取模路由到对应的分库或分表。根据username查询时，先通过usernamecode生成函数生成username_code再对其取模路由到对应的分库或分表。id生成常用snowflake算法。分布式ID生成器的解决方案总结，推荐看下这篇。

2、端上除了partition key不止一个非partition key作为条件查询



 



 

注：按照orderid或buyerid查询时路由到dbobuyer库中，按照sellerid查询时路由到dbo_seller库中。感觉有点本末倒置！有其他好的办法吗？改变技术栈呢？

3、后台除了partition key还有各种非partition key组合条件查询



 



 

2、非partition key跨库跨表分页查询问题（水平分库分表，拆分策略为常用的hash法）

注：用NoSQL法解决（ES等）。

3、扩容问题（水平分库分表，拆分策略为常用的hash法）

1、水平扩容库（升级从库法）



 

注：扩容是成倍的。

2、水平扩容表（双写迁移法）

 

第一步：（同步双写）应用配置双写，部署；

第二步：（同步双写）将老库中的老数据复制到新库中；

第三步：（同步双写）以老库为准校对新库中的老数据；第四步：（同步双写）应用去掉双写，部署；

注：双写是通用方案。

六、分库分表总结

1、分库分表，首先得知道瓶颈在哪里，然后才能合理地拆分（分库还是分表？水平还是垂直？分几个？）。且不可为了分库分表而拆分。

2、选key很重要，既要考虑到拆分均匀，也要考虑到非partition key的查询。

3、只要能满足需求，拆分规则越简单越好。

 　　１、缩量。缩量是指市场成交极为清淡,大部分人对市场后期走势十分认同。这里面又分两种情况：一是看淡后市,造成只有人卖,没有人买；二是看好后市,只有人买,没有人卖。缩量一般发生在趋势的中期,碰到下跌缩量应坚决出局,等量缩到一定程度,开始放量上攻时再买入。碰到上涨缩量则可坚决买进,等股价上冲乏力,有巨量放出的时候再卖出。 
 　　２、放量。放量一般发生在市场趋势发生转折的转折点处,市场各方力量对后市分歧逐渐加大,一些人纷纷把家底甩出,另一部分人却在大手笔吸纳。相对于缩量来说,放量有很大的虚假成分,控盘主力利用手中的筹码大手笔对敲放出天量是非常简单的事,但我们也没有必要因噎废食,只要分析透了主力的用意,也就可以将计就计“咬他一大口”。 
 　　３、堆量。主力意欲拉升时,常把成交量做得非常漂亮,几日或几周以来,成交量缓慢放大,股价慢慢推高,成交量在近期的Ｋ线图上形成一个状似土堆的形态,堆得越漂亮,就越可能产生大行情。相反,在高位的堆量表明主力已不想玩了,在大举出货,这种情况下我们要坚决退出,不要幻想再有巨利获取了。 
 　　４、量不规则性放大缩小。这种情况一般是没有突发利好或大盘基本稳定的前提下的妖庄所为,风平浪静时突然放出历史巨量,随后又复归平静,一般是实力不强的庄家在吸引市场关注,以便出货。 　　股市资金的运动才是股价变化的本质，成交量的分析异常重要。