双彩开奖结果:方块网络 - Welcome-广西快乐双彩官方网站 //www.y6mg.cn 一个关注网络的博客、记载生活与乐趣的网站 Sun, 27 May 2018 12:54:34 +0000 zh-CN hourly 1 https://wordpress.org/?v=4.8.7 最近折腾的总结 - Welcome-广西快乐双彩官方网站 //www.y6mg.cn/2545.html //www.y6mg.cn/2545.html#respond Sun, 27 May 2018 12:54:34 +0000 //www.y6mg.cn/?p=2545 前言:

最近折腾如下,很少时间在博客上分享了,除了有重大的东西折腾完成(比如gbdb)。

目前主要在知乎上更新:

C++ 从入门到放弃

这个专栏还没有生成完成,但是已经陆续开始更新自己的学习心得了。

go-linkedHashMap

最近还折腾了这个东西算是一个LRU的简单实现吧-用了一个数据结构,但是gbdb并没有用到,因为这单独实现了hash和link还有一些扩容桶的操作key只支持int型。

最近折腾的总结


方块网络 , 版权所有丨如未注明 , 均为原创丨本网站采用BY-NC-SA协议进行授权 , 转载请注明最近折腾的总结!
]]>
//www.y6mg.cn/2545.html/feed 0
关于最近折腾的总结 - Welcome-广西快乐双彩官方网站 //www.y6mg.cn/2528.html //www.y6mg.cn/2528.html#comments Sun, 04 Feb 2018 02:25:56 +0000 //www.y6mg.cn/?p=2528 前言:

看到我居然还有博友…昨天还有人要友链我…好吧,出来冒下泡吧。其实最近我只是死掉了而已。最近再看数据库相关的东西,买了4本mysql相关的书籍?!妒菘庀低呈迪帧贰秏ysql运维内参》《mysql Innodb引擎实现》《mysql从删库到跑路》。? 强烈推荐运维内参

关于最近折腾的总结

正文

基术方面:

实在没什么分享的,因为进度很吃紧,本来准备照着知乎大佬的数据库系统简单实现,因此还挖了自己的坑 gbDB(狗逼DB),好吧这只是个玩具,用go写了不到300行就从github上撤掉了,自己实现了frm文件结构后发现之后的是大坑。,因为再看知乎大佬的实现的时候发现大佬设计的真是精妙,抛出算法等问题,关于如何有效的规划整个项目的架构自己完全没有概念。再加上后来在盲目补充知识面的时候发现他是模仿sqllite的架构模式,我看的innodb相关的书,越来越绕进了哲学里….所以果断决定”放弃”,我是不会放弃的,如果要自己实现千万不要去看书,奈何我是处女座….

其实最近是没有什么进步的,在node方向,最近没有问公司的大佬问题,昨天由于我在v1版本的项目增加登陆统计没有加user索引导致服务器宕机2小时,mongodb直接挂了,由此第一次体验到了什么叫做千万数据不加索引导致的炸服。。 在v2版本里db层都加了索引过滤,其实是利用空集合的explain实现了一个黑盒检验,在进行查询时先检验下是否有匹配索引在进行真实查询。之前在做这个东西之前,db层都没有真实使用这个插件,想起之前问架构大佬的问题,大多数都是理所当然的想法,显然我们年轻的架构师非常优秀,再次流下了没有思维的泪水…。

公司加班严重,1周6天,学习时间本来就很少,加上效率实在不行,接下来还要严格控制。数据库这一块的东西很难啃,很多人都是大概知道,想深入了解有趣,却也艰难,最近要保持好心态,毕竟处于没有代码产量的尴尬境地,最近暂时转golang岗了,毕竟自己太菜语言玩法都不熟悉,也不想写一个简单的web去转岗,当然如果有合适的学习机会还会考虑的。

其实很好笑,最近折腾的东西在于我知道,别人不知道,并且我知道病还没什么卵用…..不过还好成就感还是有那么一点点的,但更多的是绝望,因为我必须坚持啃透,并且我没有援手。虽然李丹,鹏飞等大神早期给了我很多思路和帮助,但是本质上他们也不熟悉这些东西,所以最近也就没有再请教了。

为什么没有更新?因为我很尴尬啊….? 最近完全不知道自己在干啥…

生活方面:

生活无法自理,被网友基佬带去抄比特币赔了个血本无归,过年不仅没赚钱还欠了支付宝2千块钱,我真的是个极品,哈哈…? 不过还好,关注了另一个领域 【认知心理学】,看的是丹尼尔卡尼曼的《思考快与慢》,我习惯叫它《赌徒心理学》,《赌徒必备心灵鸡汤》 ,没错不赌不会接触到这个领域的,【认知心理学】很大程度上是参考了计算机的发展产生很多概念比如

思考与推理在人类大脑中的运作便像电脑软件在电脑里运作相似。认知心理学理论时常谈到输入、表征、计算或处理,以及输出等概念。

《思考快与慢》对2个系统的阐释颇为形象,还其中类似效用层叠,如何避免小概率事件演化为公共?;日陆谖掖蟾呕囟亮?2遍左右,里面很多理念在今天仍然受用,并且先进。

目前手中新书有《乌合之众》,《自卑与超越》等….只看了一点点,与上面说的那本差距很大,很难引起思考,而且很枯燥。

另外强烈推荐毁三观美剧 《黑镜》(black mirror) 对,是强烈推荐。

还有今年北京没下雪,我有了冬季部件雪的体验,有很多关于雪的记忆,搁笔了。

 


方块网络 , 版权所有丨如未注明 , 均为原创丨本网站采用BY-NC-SA协议进行授权 , 转载请注明关于最近折腾的总结!
]]>
//www.y6mg.cn/2528.html/feed 5
二叉树Morris遍历算法golang - Welcome-广西快乐双彩官方网站 //www.y6mg.cn/2464.html //www.y6mg.cn/2464.html#respond Mon, 13 Nov 2017 13:59:08 +0000 //www.y6mg.cn/?p=2464

前言:

自己写的不BB,思路差很多,这是golang实现版。 可以看一下博客园的图解,要冷静下来思考,还是很有趣的。

package tree

import (
	"container/list"
)

//二叉排序树树
type BSTree struct {
	root *BSTNode
	size int
}

//二叉树节点
type BSTNode struct {
	data   interface{}
	lchild *BSTNode
	rchild *BSTNode
	parent *BSTNode
}

//新建一个节点
func NewBSTNode(e interface{}) *BSTNode {
	return &BSTNode{data: e}
}

func NewBSTree() *BSTree {
	return &BSTree{}
}

// 插入节点
func (tree *BSTree) InsertNode(node *BSTNode) *BSTree {
	if tree.root == nil {
		tree.root = node
		return tree
	}
	thisNode := tree.root
	for {
		if thisNode.data.(int) < node.data.(int) {
			if thisNode.rchild == nil {
				thisNode.rchild = node
				node.parent = thisNode
				break
			} else {
				thisNode = thisNode.rchild
				continue
			}
		} else {
			if thisNode.lchild == nil {
				thisNode.lchild = node
				node.parent = thisNode
				break
			} else {
				thisNode = thisNode.lchild
				continue
			}
		}
	}
	return tree
}

// 中序遍历 morris
func (tree *BSTree) InOrderTraversal() *list.List {
	l := list.New()
	cur := tree.root
	for cur != nil {
		// 左节点为空直接输出
		if cur.lchild == nil {
			l.PushBack(cur.data)
			cur = cur.rchild
		} else {
			// find predecessor
			prev := cur.lchild
			for prev.rchild != nil && prev.rchild != cur {
				prev = prev.rchild
			}
			if prev.rchild == nil {
				prev.rchild = cur
				cur = cur.lchild
			} else {
				l.PushBack(cur.data)
				prev.rchild = nil
				cur = cur.rchild
			}
		}
	}
	return l
}

// 前序遍历 morris
func (tree *BSTree) PerOrderTraversal() *list.List {
	l := list.New()
	cur := tree.root
	for cur != nil {
		// 左节点为空直接输出
		if cur.lchild == nil {
			l.PushBack(cur.data)
			cur = cur.rchild
		} else {
			// find predecessor
			prev := cur.lchild
			for prev.rchild != nil && prev.rchild != cur {
				prev = prev.rchild
			}
			if prev.rchild == nil {
				l.PushBack(cur.data)
				prev.rchild = cur
				cur = cur.lchild
			} else {
				prev.rchild = nil
				cur = cur.rchild
			}
		}
	}
	return l
}

// 后续遍历 morris
func (tree *BSTree) PostOrderTraversal() *list.List {
	l := list.New()
	assistNode := NewBSTNode(0)
	assistNode.lchild = tree.root
	cur := assistNode
	for cur != nil {
		if cur.lchild == nil {
			cur = cur.rchild
		} else {
			prev := cur.lchild
			for prev.rchild != nil && prev.rchild != cur {
				prev = prev.rchild
			}
			if prev.rchild == nil {
				prev.rchild = cur
				cur = cur.lchild
			} else {
				prev.rchild = nil
				getNodeIntoList(cur.lchild, prev, l)
				cur = cur.rchild
			}
		}
	}
	return l
}
func getReverseNodes(from *BSTNode, to *BSTNode) {

	if from == to {
		return
	}
	x := from
	y := from.rchild
	for true {
		z := y.rchild
		y.rchild = x
		x = y
		y = z
		if x == to {
			break
		}
	}
}
func getNodeIntoList(from *BSTNode, to *BSTNode, l *list.List) {
	getReverseNodes(from, to)
	for true {
		l.PushBack(to.data)
		if to == from {
			break
		}
		to = to.rchild
	}
	getReverseNodes(to, from)
}


方块网络 , 版权所有丨如未注明 , 均为原创丨本网站采用BY-NC-SA协议进行授权 , 转载请注明二叉树Morris遍历算法golang!
]]>
//www.y6mg.cn/2464.html/feed 0
怒钢DBA系列-mongo索引篇 - Welcome-广西快乐双彩官方网站 //www.y6mg.cn/2448.html //www.y6mg.cn/2448.html#comments Tue, 10 Oct 2017 18:58:16 +0000 //www.y6mg.cn/?p=2448

前言:

此话题说来话长,老大让写多个查询接口,尽量考虑索引使用,因为数据非常多,不使用索引查询很慢,于是乎,我写了一个通用查询接口,指定索引生成query对象。根据mongo权威指南的说法 建立复合索引 A_1_B_1_C_1 此时可用索引为 A-B-C |A-B| A? 三种, 跟DBA说了讨论了这个问题(PS:我也不想讨论但是已经写完了真的懒得改了),老大又说不能使用通用的DB层查询接口,索引也要为业务服务,于是乎我们3个人开始验证索引顺序对查询的影响,半小时被打N次脸,难道mongo权威指南是盗版书?? DBA 测试 A-B 和 B-A 都是用复合索引?A_1_B_1_C_1 且实际扫描文档数 和 返回文档树一致 2者相同。这就有点不科学了。但事实就摆在那里。。。一定有什么误会于是回家做实验了。

结论(PS 正文太长放结论先):

假设存在索引 A_1_B_1_C_1

AB与BA 都可以正常使用索引效率相同

AC 可使用索引效率较低

BC 不可使用索引 进入 COLLSCAN stage

AXBC 可使用索引与ABCX效率相同

A:{$exists:true}BC 可使用索引? KEEP_MUTATIONS stage? 需要复验后返回对性能有影响(很小)

SORT 情况

sort 情况顺序不可变,不可出现 AC 此时无法使用索引排序进入 SORT stage 是、排序效率降低。

即A存在在查询方面可无视对象排序,只排序时关注索引定义。prefix原则是只要存在index首字段即可并不需要考虑位置。

正文:

以公司的测试服务器的数据做实验 ,执行db.collection.getIndexes() 方法,此文档有大约27万数据。我们使用第8个复合索引作为测试索引

{
	"v" : 1,
	"key" : {
		"state" : 1,
		"user" : 1,
		"stock" : 1
	},
	"name" : "state_1_user_1_stock_1",
	"ns" : "mango_order.od_reservations",
	"background" : true
}

我们来看最佳 explain 即ABC db.od_reservations.find({state:1,user:32432424,stock:3243242}).explain(“executionStats”)

{
	"queryPlanner" : {
		"plannerVersion" : 1,
		"namespace" : "mango_order.od_reservations",
		"indexFilterSet" : false,
		"parsedQuery" : {
			"$and" : [
				{
					"state" : {
						"$eq" : 1
					}
				},
				{
					"stock" : {
						"$eq" : 3243242
					}
				}
			]
		},
		"winningPlan" : {
			"stage" : "FETCH",
			"inputStage" : {
				"stage" : "IXSCAN",
				"keyPattern" : {
					"state" : 1,
					"user" : 1,
					"stock" : 1
				},
				"indexName" : "state_1_user_1_stock_1",
				"isMultiKey" : false,
				"isUnique" : false,
				"isSparse" : false,
				"isPartial" : false,
				"indexVersion" : 1,
				"direction" : "forward",
				"indexBounds" : {
					"state" : [
						"[1.0, 1.0]"
					],
					"user" : [
						"[MinKey, MaxKey]"
					],
					"stock" : [
						"[3243242.0, 3243242.0]"
					]
				}
			}
		},
		"rejectedPlans" : [ ]
	},
	"executionStats" : {
		"executionSuccess" : true,
		"nReturned" : 0,
		"executionTimeMillis" : 157,
		"totalKeysExamined" : 29806,
		"totalDocsExamined" : 0,
		"executionStages" : {
			"stage" : "FETCH",
			"nReturned" : 0,
			"executionTimeMillisEstimate" : 160,
			"works" : 29806,
			"advanced" : 0,
			"needTime" : 29805,
			"needYield" : 0,
			"saveState" : 232,
			"restoreState" : 232,
			"isEOF" : 1,
			"invalidates" : 0,
			"docsExamined" : 0,
			"alreadyHasObj" : 0,
			"inputStage" : {
				"stage" : "IXSCAN",
				"nReturned" : 0,
				"executionTimeMillisEstimate" : 160,
				"works" : 29806,
				"advanced" : 0,
				"needTime" : 29805,
				"needYield" : 0,
				"saveState" : 232,
				"restoreState" : 232,
				"isEOF" : 1,
				"invalidates" : 0,
				"keyPattern" : {
					"state" : 1,
					"user" : 1,
					"stock" : 1
				},
				"indexName" : "state_1_user_1_stock_1",
				"isMultiKey" : false,
				"isUnique" : false,
				"isSparse" : false,
				"isPartial" : false,
				"indexVersion" : 1,
				"direction" : "forward",
				"indexBounds" : {
					"state" : [
						"[1.0, 1.0]"
					],
					"user" : [
						"[MinKey, MaxKey]"
					],
					"stock" : [
						"[3243242.0, 3243242.0]"
					]
				},
				"keysExamined" : 29806,
				"dupsTested" : 0,
				"dupsDropped" : 0,
				"seenInvalidated" : 0
			}
		}
	},
	"serverInfo" : {
		"host" : "mango",
		"port" : 27017,
		"version" : "3.2.8",
		"gitVersion" : "ed70e33130c977bda0024c125b56d159573dbaf0"
	},
	"ok" : 1
}

接下来尝试 A_C 检索 db.od_reservations.find({state:1,stock:3243242}).explain(“executionStats”) 证明 A_C 使用该复合索引

{
	"queryPlanner" : {
		"plannerVersion" : 1,
		"namespace" : "mango_order.od_reservations",
		"indexFilterSet" : false,
		"parsedQuery" : {
			"$and" : [
				{
					"state" : {
						"$eq" : 1
					}
				},
				{
					"stock" : {
						"$eq" : 3243242
					}
				}
			]
		},
		"winningPlan" : {
			"stage" : "FETCH",
			"inputStage" : {
				"stage" : "IXSCAN",
				"keyPattern" : {
					"state" : 1,
					"user" : 1,
					"stock" : 1
				},
				"indexName" : "state_1_user_1_stock_1",
				"isMultiKey" : false,
				"isUnique" : false,
				"isSparse" : false,
				"isPartial" : false,
				"indexVersion" : 1,
				"direction" : "forward",
				"indexBounds" : {
					"state" : [
						"[1.0, 1.0]"
					],
					"user" : [
						"[MinKey, MaxKey]"
					],
					"stock" : [
						"[3243242.0, 3243242.0]"
					]
				}
			}
		},
		"rejectedPlans" : [ ]
	},
	"executionStats" : {
		"executionSuccess" : true,
		"nReturned" : 0,
		"executionTimeMillis" : 157,
		"totalKeysExamined" : 29806,
		"totalDocsExamined" : 0,
		"executionStages" : {
			"stage" : "FETCH",
			"nReturned" : 0,
			"executionTimeMillisEstimate" : 160,
			"works" : 29806,
			"advanced" : 0,
			"needTime" : 29805,
			"needYield" : 0,
			"saveState" : 232,
			"restoreState" : 232,
			"isEOF" : 1,
			"invalidates" : 0,
			"docsExamined" : 0,
			"alreadyHasObj" : 0,
			"inputStage" : {
				"stage" : "IXSCAN",
				"nReturned" : 0,
				"executionTimeMillisEstimate" : 160,
				"works" : 29806,
				"advanced" : 0,
				"needTime" : 29805,
				"needYield" : 0,
				"saveState" : 232,
				"restoreState" : 232,
				"isEOF" : 1,
				"invalidates" : 0,
				"keyPattern" : {
					"state" : 1,
					"user" : 1,
					"stock" : 1
				},
				"indexName" : "state_1_user_1_stock_1",
				"isMultiKey" : false,
				"isUnique" : false,
				"isSparse" : false,
				"isPartial" : false,
				"indexVersion" : 1,
				"direction" : "forward",
				"indexBounds" : {
					"state" : [
						"[1.0, 1.0]"
					],
					"user" : [
						"[MinKey, MaxKey]"
					],
					"stock" : [
						"[3243242.0, 3243242.0]"
					]
				},
				"keysExamined" : 29806,
				"dupsTested" : 0,
				"dupsDropped" : 0,
				"seenInvalidated" : 0
			}
		}
	},
	"serverInfo" : {
		"host" : "mango",
		"port" : 27017,
		"version" : "3.2.8",
		"gitVersion" : "ed70e33130c977bda0024c125b56d159573dbaf0"
	},
	"ok" : 1
}

接下来验证 _BC db.od_reservations.find({user:32432424,stock:3243242}).explain(“executionStats”) 证明 _BC 不使用索引

{
	"queryPlanner" : {
		"plannerVersion" : 1,
		"namespace" : "mango_order.od_reservations",
		"indexFilterSet" : false,
		"parsedQuery" : {
			"$and" : [
				{
					"stock" : {
						"$eq" : 3243242
					}
				},
				{
					"user" : {
						"$eq" : 32432424
					}
				}
			]
		},
		"winningPlan" : {
			"stage" : "COLLSCAN",
			"filter" : {
				"$and" : [
					{
						"stock" : {
							"$eq" : 3243242
						}
					},
					{
						"user" : {
							"$eq" : 32432424
						}
					}
				]
			},
			"direction" : "forward"
		},
		"rejectedPlans" : [ ]
	},
	"executionStats" : {
		"executionSuccess" : true,
		"nReturned" : 0,
		"executionTimeMillis" : 92,
		"totalKeysExamined" : 0,
		"totalDocsExamined" : 277389,
		"executionStages" : {
			"stage" : "COLLSCAN",
			"filter" : {
				"$and" : [
					{
						"stock" : {
							"$eq" : 3243242
						}
					},
					{
						"user" : {
							"$eq" : 32432424
						}
					}
				]
			},
			"nReturned" : 0,
			"executionTimeMillisEstimate" : 80,
			"works" : 277401,
			"advanced" : 0,
			"needTime" : 277390,
			"needYield" : 10,
			"saveState" : 2171,
			"restoreState" : 2171,
			"isEOF" : 1,
			"invalidates" : 0,
			"direction" : "forward",
			"docsExamined" : 277389
		}
	},
	"serverInfo" : {
		"host" : "mango",
		"port" : 27017,
		"version" : "3.2.8",
		"gitVersion" : "ed70e33130c977bda0024c125b56d159573dbaf0"
	},
	"ok" : 1
}

接下来验证 BA 是否使用索引 db.od_reservations.find({user:32432424,state:1}).explain(“executionStats”) 证明DBA正确,此时使用了复合索引 我们接下来看看和AB是否有性能差距

{
	"queryPlanner" : {
		"plannerVersion" : 1,
		"namespace" : "mango_order.od_reservations",
		"indexFilterSet" : false,
		"parsedQuery" : {
			"$and" : [
				{
					"state" : {
						"$eq" : 1
					}
				},
				{
					"user" : {
						"$eq" : 32432424
					}
				}
			]
		},
		"winningPlan" : {
			"stage" : "FETCH",
			"inputStage" : {
				"stage" : "IXSCAN",
				"keyPattern" : {
					"state" : 1,
					"user" : 1,
					"stock" : 1
				},
				"indexName" : "state_1_user_1_stock_1",
				"isMultiKey" : false,
				"isUnique" : false,
				"isSparse" : false,
				"isPartial" : false,
				"indexVersion" : 1,
				"direction" : "forward",
				"indexBounds" : {
					"state" : [
						"[1.0, 1.0]"
					],
					"user" : [
						"[32432424.0, 32432424.0]"
					],
					"stock" : [
						"[MinKey, MaxKey]"
					]
				}
			}
		},
		"rejectedPlans" : [ ]
	},
	"executionStats" : {
		"executionSuccess" : true,
		"nReturned" : 0,
		"executionTimeMillis" : 0,
		"totalKeysExamined" : 0,
		"totalDocsExamined" : 0,
		"executionStages" : {
			"stage" : "FETCH",
			"nReturned" : 0,
			"executionTimeMillisEstimate" : 0,
			"works" : 1,
			"advanced" : 0,
			"needTime" : 0,
			"needYield" : 0,
			"saveState" : 0,
			"restoreState" : 0,
			"isEOF" : 1,
			"invalidates" : 0,
			"docsExamined" : 0,
			"alreadyHasObj" : 0,
			"inputStage" : {
				"stage" : "IXSCAN",
				"nReturned" : 0,
				"executionTimeMillisEstimate" : 0,
				"works" : 1,
				"advanced" : 0,
				"needTime" : 0,
				"needYield" : 0,
				"saveState" : 0,
				"restoreState" : 0,
				"isEOF" : 1,
				"invalidates" : 0,
				"keyPattern" : {
					"state" : 1,
					"user" : 1,
					"stock" : 1
				},
				"indexName" : "state_1_user_1_stock_1",
				"isMultiKey" : false,
				"isUnique" : false,
				"isSparse" : false,
				"isPartial" : false,
				"indexVersion" : 1,
				"direction" : "forward",
				"indexBounds" : {
					"state" : [
						"[1.0, 1.0]"
					],
					"user" : [
						"[32432424.0, 32432424.0]"
					],
					"stock" : [
						"[MinKey, MaxKey]"
					]
				},
				"keysExamined" : 0,
				"dupsTested" : 0,
				"dupsDropped" : 0,
				"seenInvalidated" : 0
			}
		}
	},
	"serverInfo" : {
		"host" : "mango",
		"port" : 27017,
		"version" : "3.2.8",
		"gitVersion" : "ed70e33130c977bda0024c125b56d159573dbaf0"
	},
	"ok" : 1
}

验证 AB db.od_reservations.find({state:1,user:32432424}).explain(“executionStats”) 证明 BA与AB索引效率相同,AB可高效使用索引而AC则不行。

{
	"queryPlanner" : {
		"plannerVersion" : 1,
		"namespace" : "mango_order.od_reservations",
		"indexFilterSet" : false,
		"parsedQuery" : {
			"$and" : [
				{
					"state" : {
						"$eq" : "1703282329098"
					}
				},
				{
					"user" : {
						"$eq" : 32432424
					}
				}
			]
		},
		"winningPlan" : {
			"stage" : "FETCH",
			"inputStage" : {
				"stage" : "IXSCAN",
				"keyPattern" : {
					"state" : 1,
					"user" : 1,
					"stock" : 1
				},
				"indexName" : "state_1_user_1_stock_1",
				"isMultiKey" : false,
				"isUnique" : false,
				"isSparse" : false,
				"isPartial" : false,
				"indexVersion" : 1,
				"direction" : "forward",
				"indexBounds" : {
					"state" : [
						"[\"1703282329098\", \"1703282329098\"]"
					],
					"user" : [
						"[32432424.0, 32432424.0]"
					],
					"stock" : [
						"[MinKey, MaxKey]"
					]
				}
			}
		},
		"rejectedPlans" : [ ]
	},
	"executionStats" : {
		"executionSuccess" : true,
		"nReturned" : 0,
		"executionTimeMillis" : 0,
		"totalKeysExamined" : 0,
		"totalDocsExamined" : 0,
		"executionStages" : {
			"stage" : "FETCH",
			"nReturned" : 0,
			"executionTimeMillisEstimate" : 0,
			"works" : 1,
			"advanced" : 0,
			"needTime" : 0,
			"needYield" : 0,
			"saveState" : 0,
			"restoreState" : 0,
			"isEOF" : 1,
			"invalidates" : 0,
			"docsExamined" : 0,
			"alreadyHasObj" : 0,
			"inputStage" : {
				"stage" : "IXSCAN",
				"nReturned" : 0,
				"executionTimeMillisEstimate" : 0,
				"works" : 1,
				"advanced" : 0,
				"needTime" : 0,
				"needYield" : 0,
				"saveState" : 0,
				"restoreState" : 0,
				"isEOF" : 1,
				"invalidates" : 0,
				"keyPattern" : {
					"state" : 1,
					"user" : 1,
					"stock" : 1
				},
				"indexName" : "state_1_user_1_stock_1",
				"isMultiKey" : false,
				"isUnique" : false,
				"isSparse" : false,
				"isPartial" : false,
				"indexVersion" : 1,
				"direction" : "forward",
				"indexBounds" : {
					"state" : [
						"[\"1703282329098\", \"1703282329098\"]"
					],
					"user" : [
						"[32432424.0, 32432424.0]"
					],
					"stock" : [
						"[MinKey, MaxKey]"
					]
				},
				"keysExamined" : 0,
				"dupsTested" : 0,
				"dupsDropped" : 0,
				"seenInvalidated" : 0
			}
		}
	},
	"serverInfo" : {
		"host" : "mango",
		"port" : 27017,
		"version" : "3.2.8",
		"gitVersion" : "ed70e33130c977bda0024c125b56d159573dbaf0"
	},
	"ok" : 1
}

验证 $exists A:$exists—B db.od_reservations.find({state:{$exists: true},user:32432424}).explain(“executionStats”) 结论 $exites 返回多结果对性能有影响(
KEEP_UTATIONS stage 表示检索到结果后,在检索过程中的删除或者修改,会触发一个复验的过程,当复验成功文档将被返回

{
	"queryPlanner" : {
		"plannerVersion" : 1,
		"namespace" : "mango_order.od_reservations",
		"indexFilterSet" : false,
		"parsedQuery" : {
			"$and" : [
				{
					"user" : {
						"$eq" : 32432424
					}
				},
				{
					"state" : {
						"$exists" : true
					}
				}
			]
		},
		"winningPlan" : {
			"stage" : "KEEP_MUTATIONS",
			"inputStage" : {
				"stage" : "FETCH",
				"filter" : {
					"state" : {
						"$exists" : true
					}
				},
				"inputStage" : {
					"stage" : "IXSCAN",
					"keyPattern" : {
						"state" : 1,
						"user" : 1,
						"stock" : 1
					},
					"indexName" : "state_1_user_1_stock_1",
					"isMultiKey" : false,
					"isUnique" : false,
					"isSparse" : false,
					"isPartial" : false,
					"indexVersion" : 1,
					"direction" : "forward",
					"indexBounds" : {
						"state" : [
							"[MinKey, MaxKey]"
						],
						"user" : [
							"[32432424.0, 32432424.0]"
						],
						"stock" : [
							"[MinKey, MaxKey]"
						]
					}
				}
			}
		},
		"rejectedPlans" : [ ]
	},
	"executionStats" : {
		"executionSuccess" : true,
		"nReturned" : 0,
		"executionTimeMillis" : 0,
		"totalKeysExamined" : 3,
		"totalDocsExamined" : 0,
		"executionStages" : {
			"stage" : "KEEP_MUTATIONS",
			"nReturned" : 0,
			"executionTimeMillisEstimate" : 0,
			"works" : 4,
			"advanced" : 0,
			"needTime" : 3,
			"needYield" : 0,
			"saveState" : 0,
			"restoreState" : 0,
			"isEOF" : 1,
			"invalidates" : 0,
			"inputStage" : {
				"stage" : "FETCH",
				"filter" : {
					"state" : {
						"$exists" : true
					}
				},
				"nReturned" : 0,
				"executionTimeMillisEstimate" : 0,
				"works" : 4,
				"advanced" : 0,
				"needTime" : 3,
				"needYield" : 0,
				"saveState" : 0,
				"restoreState" : 0,
				"isEOF" : 1,
				"invalidates" : 0,
				"docsExamined" : 0,
				"alreadyHasObj" : 0,
				"inputStage" : {
					"stage" : "IXSCAN",
					"nReturned" : 0,
					"executionTimeMillisEstimate" : 0,
					"works" : 4,
					"advanced" : 0,
					"needTime" : 3,
					"needYield" : 0,
					"saveState" : 0,
					"restoreState" : 0,
					"isEOF" : 1,
					"invalidates" : 0,
					"keyPattern" : {
						"state" : 1,
						"user" : 1,
						"stock" : 1
					},
					"indexName" : "state_1_user_1_stock_1",
					"isMultiKey" : false,
					"isUnique" : false,
					"isSparse" : false,
					"isPartial" : false,
					"indexVersion" : 1,
					"direction" : "forward",
					"indexBounds" : {
						"state" : [
							"[MinKey, MaxKey]"
						],
						"user" : [
							"[32432424.0, 32432424.0]"
						],
						"stock" : [
							"[MinKey, MaxKey]"
						]
					},
					"keysExamined" : 3,
					"dupsTested" : 0,
					"dupsDropped" : 0,
					"seenInvalidated" : 0
				}
			}
		}
	},
	"serverInfo" : {
		"host" : "mango",
		"port" : 27017,
		"version" : "3.2.8",
		"gitVersion" : "ed70e33130c977bda0024c125b56d159573dbaf0"
	},
	"ok" : 1
}

sort情况 db.od_reservations.find({state:{$exists:true},user:{$exists:true},stock:{$exists:true}}).sort({ state:1, stock:1}).explain(“executionStats”)

进行多种测试证明 sort排序时不能使用 AC BC 等索引 属于 SORT stage

{
	"queryPlanner" : {
		"plannerVersion" : 1,
		"namespace" : "mango_order.od_reservations",
		"indexFilterSet" : false,
		"parsedQuery" : {
			"$and" : [
				{
					"state" : {
						"$exists" : true
					}
				},
				{
					"stock" : {
						"$exists" : true
					}
				},
				{
					"user" : {
						"$exists" : true
					}
				}
			]
		},
		"winningPlan" : {
			"stage" : "SORT",
			"sortPattern" : {
				"state" : 1,
				"stock" : 1
			},
			"inputStage" : {
				"stage" : "KEEP_MUTATIONS",
				"inputStage" : {
					"stage" : "SORT_KEY_GENERATOR",
					"inputStage" : {
						"stage" : "FETCH",
						"filter" : {
							"$and" : [
								{
									"state" : {
										"$exists" : true
									}
								},
								{
									"user" : {
										"$exists" : true
									}
								},
								{
									"stock" : {
										"$exists" : true
									}
								}
							]
						},
						"inputStage" : {
							"stage" : "IXSCAN",
							"keyPattern" : {
								"state" : 1,
								"user" : 1,
								"stock" : 1
							},
							"indexName" : "state_1_user_1_stock_1",
							"isMultiKey" : false,
							"isUnique" : false,
							"isSparse" : false,
							"isPartial" : false,
							"indexVersion" : 1,
							"direction" : "forward",
							"indexBounds" : {
								"state" : [
									"[MinKey, MaxKey]"
								],
								"user" : [
									"[MinKey, MaxKey]"
								],
								"stock" : [
									"[MinKey, MaxKey]"
								]
							}
						}
					}
				}
			}
		},
		"rejectedPlans" : [ ]
	},
	"executionStats" : {
		"executionSuccess" : false,
		"errorMessage" : "Exec error: OperationFailed: Sort operation used more than the maximum 33554432 bytes of RAM. Add an index, or specify a smaller limit., state: FAILURE",
		"errorCode" : 96,
		"nReturned" : 0,
		"executionTimeMillis" : 313,
		"totalKeysExamined" : 101140,
		"totalDocsExamined" : 101140,
		"executionStages" : {
			"stage" : "SORT",
			"nReturned" : 0,
			"executionTimeMillisEstimate" : 310,
			"works" : 101142,
			"advanced" : 0,
			"needTime" : 101141,
			"needYield" : 0,
			"saveState" : 790,
			"restoreState" : 790,
			"isEOF" : 0,
			"invalidates" : 0,
			"sortPattern" : {
				"state" : 1,
				"stock" : 1
			},
			"memUsage" : 33554524,
			"memLimit" : 33554432,
			"inputStage" : {
				"stage" : "KEEP_MUTATIONS",
				"nReturned" : 101140,
				"executionTimeMillisEstimate" : 260,
				"works" : 101141,
				"advanced" : 101140,
				"needTime" : 1,
				"needYield" : 0,
				"saveState" : 790,
				"restoreState" : 790,
				"isEOF" : 0,
				"invalidates" : 0,
				"inputStage" : {
					"stage" : "SORT_KEY_GENERATOR",
					"nReturned" : 0,
					"executionTimeMillisEstimate" : 260,
					"works" : 101141,
					"advanced" : 0,
					"needTime" : 1,
					"needYield" : 0,
					"saveState" : 790,
					"restoreState" : 790,
					"isEOF" : 0,
					"invalidates" : 0,
					"inputStage" : {
						"stage" : "FETCH",
						"filter" : {
							"$and" : [
								{
									"state" : {
										"$exists" : true
									}
								},
								{
									"user" : {
										"$exists" : true
									}
								},
								{
									"stock" : {
										"$exists" : true
									}
								}
							]
						},
						"nReturned" : 101140,
						"executionTimeMillisEstimate" : 200,
						"works" : 101140,
						"advanced" : 101140,
						"needTime" : 0,
						"needYield" : 0,
						"saveState" : 790,
						"restoreState" : 790,
						"isEOF" : 0,
						"invalidates" : 0,
						"docsExamined" : 101140,
						"alreadyHasObj" : 0,
						"inputStage" : {
							"stage" : "IXSCAN",
							"nReturned" : 101140,
							"executionTimeMillisEstimate" : 40,
							"works" : 101140,
							"advanced" : 101140,
							"needTime" : 0,
							"needYield" : 0,
							"saveState" : 790,
							"restoreState" : 790,
							"isEOF" : 0,
							"invalidates" : 0,
							"keyPattern" : {
								"state" : 1,
								"user" : 1,
								"stock" : 1
							},
							"indexName" : "state_1_user_1_stock_1",
							"isMultiKey" : false,
							"isUnique" : false,
							"isSparse" : false,
							"isPartial" : false,
							"indexVersion" : 1,
							"direction" : "forward",
							"indexBounds" : {
								"state" : [
									"[MinKey, MaxKey]"
								],
								"user" : [
									"[MinKey, MaxKey]"
								],
								"stock" : [
									"[MinKey, MaxKey]"
								]
							},
							"keysExamined" : 101140,
							"dupsTested" : 0,
							"dupsDropped" : 0,
							"seenInvalidated" : 0
						}
					}
				}
			}
		}
	},
	"serverInfo" : {
		"host" : "mango",
		"port" : 27017,
		"version" : "3.2.8",
		"gitVersion" : "ed70e33130c977bda0024c125b56d159573dbaf0"
	},
	"ok" : 1
}

 


方块网络 , 版权所有丨如未注明 , 均为原创丨本网站采用BY-NC-SA协议进行授权 , 转载请注明怒钢DBA系列-mongo索引篇!
]]>
//www.y6mg.cn/2448.html/feed 1
go 网上简单验证码的demo - Welcome-广西快乐双彩官方网站 //www.y6mg.cn/2445.html //www.y6mg.cn/2445.html#comments Sun, 03 Sep 2017 05:48:19 +0000 //www.y6mg.cn/?p=2445

前言:

搭go学习web架子的时候看需要验证码看了网上一种实现。

正文:

其实就是绘制点, 网上的demo都有一个字符对应的过程生成256标准的字符对应表喵??搞了半天也不知道为什么这么做,我还以为要增加随机性(防止机器人模拟随机??)网上问了很多人,也看了所谓的这段代码的注释详解。最后我特么才发现 ——他这复制的uniuri的源码,其实根本无卵用。我靠,那些强行解释的难道没发现。。,然后直接替换成随机数字拼接在一起就好了。个人以为他要拼接出uuid类似的东西是为了用字符短暂标识数字验证码但是后面又转回去了根本没什么意义不知道在搞毛。 (难道还是我太弱智?感觉最初的也不是原创……)

然后那个方法的

io.ReadFull(crand.Reader, r)

现在的的crand.read()内部已经使用了io.ReadFull ?方法,所以可以不用这样写来读取字节缓存了,关于io.ReadFull :

读取正好len(buf)长度的字节。如果字节数不是指定长度,则返回错误信息和正确的字节数。当没有字节能被读时,返回EOF错误。如果读了一些,但是没读完产生EOF错误时,返回ErrUnexpectedEOF错误。

所以不需要那样写了,看到uniuri已经直接使用crand.read方法了。

实现就是绘制点,绘制干扰线(偏移),干扰点

package main

import (
	"fmt"
	"image"
	"image/color"
	"image/png"
	"io"
	"math/rand"
	"net/http"
	"time"
)

const (
	stdWidth  = 100
	stdHeight = 40
	maxSkew   = 2
)

const (
	fontWidth  = 5
	fontHeight = 8
	blackChar  = 1
)

var captcha = []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
var font = [][]byte{
	{ // 0
		0, 1, 1, 1, 0,
		1, 0, 0, 0, 1,
		1, 0, 0, 0, 1,
		1, 0, 0, 0, 1,
		1, 0, 0, 0, 1,
		1, 0, 0, 0, 1,
		1, 0, 0, 0, 1,
		0, 1, 1, 1, 0,
	},
	{ // 1
		0, 0, 1, 0, 0,
		0, 1, 1, 0, 0,
		1, 0, 1, 0, 0,
		0, 0, 1, 0, 0,
		0, 0, 1, 0, 0,
		0, 0, 1, 0, 0,
		0, 0, 1, 0, 0,
		1, 1, 1, 1, 1,
	},
	{ // 2
		0, 1, 1, 1, 0,
		1, 0, 0, 0, 1,
		0, 0, 0, 0, 1,
		0, 0, 0, 1, 1,
		0, 1, 1, 0, 0,
		1, 0, 0, 0, 0,
		1, 0, 0, 0, 0,
		1, 1, 1, 1, 1,
	},
	{ // 3
		1, 1, 1, 1, 0,
		0, 0, 0, 0, 1,
		0, 0, 0, 1, 0,
		0, 1, 1, 1, 0,
		0, 0, 0, 1, 0,
		0, 0, 0, 0, 1,
		0, 0, 0, 0, 1,
		1, 1, 1, 1, 0,
	},
	{ // 4
		1, 0, 0, 1, 0,
		1, 0, 0, 1, 0,
		1, 0, 0, 1, 0,
		1, 0, 0, 1, 0,
		1, 1, 1, 1, 1,
		0, 0, 0, 1, 0,
		0, 0, 0, 1, 0,
		0, 0, 0, 1, 0,
	},
	{ // 5
		1, 1, 1, 1, 1,
		1, 0, 0, 0, 0,
		1, 0, 0, 0, 0,
		1, 1, 1, 1, 0,
		0, 0, 0, 0, 1,
		0, 0, 0, 0, 1,
		0, 0, 0, 0, 1,
		1, 1, 1, 1, 0,
	},
	{ // 6
		0, 0, 1, 1, 1,
		0, 1, 0, 0, 0,
		1, 0, 0, 0, 0,
		1, 1, 1, 1, 0,
		1, 0, 0, 0, 1,
		1, 0, 0, 0, 1,
		1, 0, 0, 0, 1,
		0, 1, 1, 1, 0,
	},
	{ // 7
		1, 1, 1, 1, 1,
		0, 0, 0, 0, 1,
		0, 0, 0, 0, 1,
		0, 0, 0, 1, 0,
		0, 0, 1, 0, 0,
		0, 1, 0, 0, 0,
		0, 1, 0, 0, 0,
		0, 1, 0, 0, 0,
	},
	{ // 8
		0, 1, 1, 1, 0,
		1, 0, 0, 0, 1,
		1, 0, 0, 0, 1,
		0, 1, 1, 1, 0,
		1, 0, 0, 0, 1,
		1, 0, 0, 0, 1,
		1, 0, 0, 0, 1,
		0, 1, 1, 1, 0,
	},
	{ // 9
		0, 1, 1, 1, 0,
		1, 0, 0, 0, 1,
		1, 0, 0, 0, 1,
		1, 1, 0, 0, 1,
		0, 1, 1, 1, 1,
		0, 0, 0, 0, 1,
		0, 0, 0, 0, 1,
		1, 1, 1, 1, 0,
	},
}

type Image struct {
	*image.NRGBA
	color   *color.NRGBA
	width   int //a digit width
	height  int //a digit height
	dotsize int
}

func init() {
	rand.Seed(time.Now().UnixNano())
}

func NewImage(digits []byte, width, height int) *Image {
	img := new(Image)
	r := image.Rect(img.width, img.height, stdWidth, stdHeight)
	img.NRGBA = image.NewNRGBA(r)

	img.color = &color.NRGBA{
		uint8(rand.Intn(129)),
		uint8(rand.Intn(129)),
		uint8(rand.Intn(129)),
		0xFF,
	}
	// Draw background (10 random circles of random brightness)
	img.calculateSizes(width, height, len(digits))
	// img.fillWithCircles(10, img.dotsize)

	maxx := width - (img.width+img.dotsize)*len(digits) - img.dotsize
	maxy := height - img.height - img.dotsize*2

	x := rnd(img.dotsize*2, maxx)
	y := rnd(img.dotsize*2, maxy)

	// Draw digits.
	for _, n := range digits {
		img.drawDigit(font[n], x, y)
		x += img.width + img.dotsize
	}

	// Draw strike-through line.
	// img.strikeThrough()
	return img
}

func (img *Image) WriteTo(w io.Writer) (int64, error) {
	return 0, png.Encode(w, img)
}

func (img *Image) calculateSizes(width, height, ncount int) {

	// Goal: fit all digits inside the image.
	var border int
	if width > height {
		border = height / 5
	} else {
		border = width / 5
	}
	//保证绘制位置在内部
	// Convert everything to floats for calculations.
	w := float64(width - border*2)  //268
	h := float64(height - border*2) //48
	// fw takes into account 1-dot spacing between digits.
	//间隔
	fw := float64(fontWidth) + 1 //6

	fh := float64(fontHeight) //8
	nc := float64(ncount)     //7

	// Calculate the width of a single digit taking into account only the
	// width of the image.
	nw := w / nc //38
	// Calculate the height of a digit from this width.
	nh := nw * fh / fw //51

	// Digit too high?

	if nh > h {
		// Fit digits based on height.
		nh = h //nh = 44
		nw = fw / fh * nh
	}
	// Calculate dot size.
	img.dotsize = int(nh / fh)
	// Save everything, making the actual width smaller by 1 dot to account
	// for spacing between digits.
	img.width = int(nw)
	img.height = int(nh) - img.dotsize
}

func (img *Image) fillWithCircles(n, maxradius int) {
	color := img.color
	maxx := img.Bounds().Max.X
	maxy := img.Bounds().Max.Y
	for i := 0; i < n; i++ {
		setRandomBrightness(color, 255)
		r := rnd(1, maxradius)
		img.drawCircle(color, rnd(r, maxx-r), rnd(r, maxy-r), r)
	}
}

func (img *Image) drawHorizLine(color color.Color, fromX, toX, y int) {
	for x := fromX; x <= toX; x++ {
		img.Set(x, y, color)
	}
}

func (img *Image) drawCircle(color color.Color, x, y, radius int) {
	f := 1 - radius
	dfx := 1
	dfy := -2 * radius
	xx := 0
	yy := radius

	img.Set(x, y+radius, color)
	img.Set(x, y-radius, color)
	img.drawHorizLine(color, x-radius, x+radius, y)

	for xx < yy { if f >= 0 {
			yy--
			dfy += 2
			f += dfy
		}
		xx++
		dfx += 2
		f += dfx
		img.drawHorizLine(color, x-xx, x+xx, y+yy)
		img.drawHorizLine(color, x-xx, x+xx, y-yy)
		img.drawHorizLine(color, x-yy, x+yy, y+xx)
		img.drawHorizLine(color, x-yy, x+yy, y-xx)
	}
}

func (img *Image) strikeThrough() {
	r := 0
	maxx := img.Bounds().Max.X
	maxy := img.Bounds().Max.Y
	y := rnd(maxy/3, maxy-maxy/3)
	for x := 0; x < maxx; x += r {
		r = rnd(1, img.dotsize/3)
		y += rnd(-img.dotsize/2, img.dotsize/2)
		if y <= 0 || y >= maxy {
			y = rnd(maxy/3, maxy-maxy/3)
		}
		img.drawCircle(img.color, x, y, r)
	}
}

func (img *Image) drawDigit(digit []byte, x, y int) {
	skf := rand.Float64() * float64(rnd(-maxSkew, maxSkew))
	xs := float64(x)
	minr := img.dotsize / 2               // minumum radius
	maxr := img.dotsize/2 + img.dotsize/4 // maximum radius
	y += rnd(-minr, minr)
	for yy := 0; yy < fontHeight; yy++ {
		for xx := 0; xx < fontWidth; xx++ { if digit[yy*fontWidth+xx] != blackChar { continue } // Introduce random variations. or := rnd(minr, maxr) ox := x + (xx * img.dotsize) + rnd(0, or/2) oy := y + (yy * img.dotsize) + rnd(0, or/2) img.drawCircle(img.color, ox, oy, or) } xs += skf x = int(xs) } } func setRandomBrightness(c *color.NRGBA, max uint8) { minc := min3(c.R, c.G, c.B) maxc := max3(c.R, c.G, c.B) //超过边界退出 if maxc > max {
		return
	}

	n := rand.Intn(int(max-maxc)) - int(minc)
	c.R = uint8(int(c.R) + n)
	c.G = uint8(int(c.G) + n)
	c.B = uint8(int(c.B) + n)
}

func min3(x, y, z uint8) (o uint8) {
	o = x
	if y < o {
		o = y
	}
	if z < o { o = z } return } func max3(x, y, z uint8) (o uint8) { o = x if y > o {
		o = y
	}
	if z > o {
		o = z
	}
	return
}
func getLen(i int) ([]byte, error) {
	rand.Seed(time.Now().UnixNano())
	var capCode []byte
	for n := 0; n < i; n++ {
		capCode = append(capCode, byte(rand.Intn(len(captcha)-1)))
	}
	return capCode, nil
}

// rnd returns a random number in range [from, to].
func rnd(from, to int) int {
	//println(to+1-from)
	return rand.Intn(to+1-from) + from
}

func pic(w http.ResponseWriter, req *http.Request) {
	d, _ := getLen(4)
	w.Header().Set("Content-Type", "image/png")
	NewImage(d, 100, 40).WriteTo(w)
	fmt.Print(d)
}

func index(w http.ResponseWriter, req *http.Request) {
	str :="<img src="\"/pic\"" alt="\"图片验证码\"" border="\"1\"" />"
	w.Header().Set("Content-Type", "text/html")
	w.Write([]byte(str))
}

func main() {
	http.HandleFunc("/pic", pic)
	http.HandleFunc("/", index)
	s := &http.Server{
		Addr:           ":8080",
		ReadTimeout:    30 * time.Second,
		WriteTimeout:   30 * time.Second,
		MaxHeaderBytes: 1 << 20,
	}
	s.ListenAndServe()
}



方块网络 , 版权所有丨如未注明 , 均为原创丨本网站采用BY-NC-SA协议进行授权 , 转载请注明go 网上简单验证码的demo!
]]>
//www.y6mg.cn/2445.html/feed 2
会鸽项目上的一些坑 - Welcome-广西快乐双彩官方网站 //www.y6mg.cn/2432.html //www.y6mg.cn/2432.html#comments Sun, 20 Aug 2017 03:41:50 +0000 //www.y6mg.cn/?p=2432

前言:

公司转栈,已是前端….

正文:

项目的坑如下 巨坑 rethinkdb 真的是学到了,之前都不知道还有这个东西,在并行10做map操作的时候,对一个表进行多次扫描导致连接不能释放cpu压力250%爆炸,对集合进行比较复杂的聚合操作加上并行直接GG 此数据库在集合层面还不能保证原子性,可以说是项目重构的主要原因。 rethinkdb插入查询性能都还可以 1ms以内,复杂聚合需要125ms加上并行扫表聚合和数据集合的庞大(60字段)CPU和内存爆掉。。

并行转串行,串行转并行。在数据库扫表的时候出现一个问题,因为不能保证原子性,要先查再做更改,而扫表的监听操作是不确定的这时候需要放到一个栈里面,然后java架构说不靠谱,挂了岂不是数据就丢失了,好吧,后来设计成redis锁+队列。rabbitmq要设置basic.qos信令 prefetch_count,让消费者一次接受1个,当存在锁的时候使用nack回到队列不标记此消费者失败,也就是当锁阻塞多个消费者的时候,消息之后还可以通过这几个消费者,而不是reject后GG只能走第一个抢占的.

const key                       = "audit-lock-execute";
const ttl                       = 4;
exports.consumeTransactionAudit = async function (message, _channel) {
    try {
        let payloadStr = message.content.toString();
        let unlock     = await  __executeLock(ttl, key);
        if (unlock === 1) {
            return _channel.nack(message, false);// 如果锁被占用,nack回消息
        }

        await exports.auditTransaction(JSON.parse(payloadStr).audit);
        _channel.ack(message);
        unlock();
    } catch (err) {
        logger.error('消费consumeTransactionAudit...出错了,错误信息是', err);
        _channel.reject(message, true);
    }
};

生产者锁保证生产状态意外结束其他进程起来负责生产(只能监听一个扫表行为防止重复)

exports.audit = function () {
    setInterval(function () {
        try {
            alive();
        } catch (err) {
            logger.error('task/audit ', err);
        }
    }, 1000);
};

let status = false;// 进程锁,默认为false代表未锁住
// 更新生存周期,60秒判定失去进程
async function alive(_status) {
    if (status === false) {
        let result = await redisClinet.get('active-audit-lock');
        if (result === null) {
            __processLock();
        }
    }
    if (arguments.length !== 0 || status === true) {
        if (_status === true) {
            status = _status;
        }
        if (status === true) {
            // logger.info(`${process.pid}获得进程锁,锁定60秒...`);
            await redisClinet.set('active-audit-lock', `1`, 'EX', 60);
        }
    }
}

function __processLock() {

    logger.info(`${process.pid}准备争取进程锁...`);

    let key = 'audit-lock';
    let ttl = 61;
    warlock.lock(key, ttl, function (err, unlock) {

        if (err) {
            // Something went wrong and we weren't able to set a lock
            return;
        }

        if (typeof unlock === 'function') {
            if (status === false) {
                require("./process/audit.js");
            }
            alive(true);
        }

    });
}

还有一个电子票的部分,用pantomjs生成的pdf 需要4S左右,用golang纯线条画0.5S都不用还可以并行。而node的并行并状态维护太麻烦。

项目最终用java重构,虽然不是node的锅但还是被甩锅了,java架构问我写不写java,我大概就表示了下java垃圾就像黑我们node一样GG。现在安排在公司写前端,准备放弃,寻找下一个公司。他说了一句话node是前端的东西,尴尬了,从此对java转黑在java这种工业级语言面前我们都是菜鸡….

另外纠正下对JWT的误解,jwt在多个终端时可以保证状态不易被更改,jwt鉴权也学到许多。


方块网络 , 版权所有丨如未注明 , 均为原创丨本网站采用BY-NC-SA协议进行授权 , 转载请注明会鸽项目上的一些坑!
]]>
//www.y6mg.cn/2432.html/feed 1
密码?;ぃ阂怀∈О艿氖质?,一次高考的失利,一个不再在乎的人 - Welcome-广西快乐双彩官方网站 //www.y6mg.cn/2427.html //www.y6mg.cn/2427.html#comments Sun, 13 Aug 2017 09:08:44 +0000 //www.y6mg.cn/?p=2427

这是一篇受密码?;さ奈恼?,您需要提供访问密码:


方块网络 , 版权所有丨如未注明 , 均为原创丨本网站采用BY-NC-SA协议进行授权 , 转载请注明密码?;ぃ阂怀∈О艿氖质?,一次高考的失利,一个不再在乎的人!
]]>
//www.y6mg.cn/2427.html/feed 1
我为什么选择锤黑 - Welcome-广西快乐双彩官方网站 //www.y6mg.cn/2410.html //www.y6mg.cn/2410.html#comments Tue, 13 Jun 2017 11:05:04 +0000 //www.y6mg.cn/?p=2410 前言:

大概有一年没写博文了吧,今天开荤了。

第一次知晓锤子和罗永浩来自基佬的口述,然后在网上看了些视频,包括砸冰箱,舌战自如,我的奋斗….(但没有买罗的书)?;八堤焐景?,我乔布斯的我都不看为什么看那种书。我一开始是罗粉,当然有很多粉转黑的经历。但是我真的曾经是罗粉。

正文:

关于罗粉:先说下我接触的跟锤子有关的人——。

A君:高某翔(基佬,罗粉,锤粉,锤子T1,坚果,坚果pro用户),锤子的忠实用户,罗粉max+,买书的那种

B君:杨雪某韩 (罗粉,锤粉,倾家荡产买坚果pro),锤子的忠实用户,罗粉 死忠党。

C君: ?姜块(基佬,罗粉,当初给我传道的,资深手机用户) ? 手机党,买手机前都问他,还算比较专业??春美下?锤子。

D君: 张某龙 (基佬,锤子m1用户) 我心中的高端商务手机用户 。

先搬出一个理论: ?想要打败锤粉,就问他除了锤子有没有用过别的手机。 ?这句话有点太过了,比锤子好的手机吧。A没,B:oppo,步步高(蓝绿小王子) C 用过没买过锤子 D 用过

为什么转锤黑呢?

例1:锤子京东刷单的事情(铁证了),A,B君说刷单是友商干的,(凡是不利的都是有利的)

本人观点 :的确不能排除友商干的,但是小米团队刷单也是有智商的,讲究一个图文比混合。A君观点:“为了黑锤子”

例2: 坚果pro后屏碎裂问题 ?罗:“售后说了是摔的”

本人观点:虽然没亲眼目睹(自然碎裂视频过程已经曝出),也没有亲手摔过,但是个人愚见,摔出个放射状的不太容易吧。 A君观点:”你以为的就是你以为的” B君观点:“反正老子的没碎”。

例3:坚果屏幕公差问题

本人观点 :是手机就有公差但是锤粉连这个都不承认。。。让我怎么办,怎么不转黑。

例4:掉色问题

本人观点:也不需要什么观点了,拿来自己磨磨就知道了,不行去论坛看看,当然你也可以叫他们锤黑和水军。

再说一点科技美学对坚果pro的点评:关掉弹幕会发现坚果pro还是蛮好的。

老实人吴德周说「科学家」们分析的是不对的,罗永浩说你这是黑人家,人家叫知友?!蹩蒲Ъ椅侍?,那一阵子知乎被黑的很惨。。怎么说呢突然多了很多没有头像的专业人士…. ?当时那个点赞不到1000的帖子,只是来讨论为什么坚果会裂,然后知乎用户就被套上了科学家的帽子,还好,科学家们提出了新的思路https://www.zhihu.com/question/60157912?rf=60173119?,还有的科学家认为老罗的实验不是很格?https://www.zhihu.com/question/60181823? 还有一些哲学家提出了些看法?哲学思考:若5年前砸冰箱的罗永浩穿越今天买了坚果pro后盖碎裂,又看了斗鱼上“没问题”直播,他会怎样?

幸运的是这些锤粉的答案由于没有人肯定(甚至他们自己都不知道互赞)而沉入帖海,科学家们,还在科学家的岗位上。。。。现在觉得科技美学那么委婉,可能也是怕被锤粉们骂。

我可能接触了这种锤粉,有证据——伪证,有第三方——友商黑,有人赞同——水军,打赌测试(实验)——不想参加。

有一天,一群锤粉和一个锤黑一起坐飞机,在起飞前,乘务员开心的说:“这架飞机是由锤子科技制造的!”。 锤粉们听了之后各种喝彩,但不知为何都由于各种原因下了飞机退了票,只有锤黑还坐在飞机上,他跟乘务员说:我就赌这飞机根本飞不起来。然而,飞机刚启动就爆炸了,他低估了我罗的实力。
———老段子

作者:匿名用户
链接:https://www.zhihu.com/question/59470638/answer/165921981
来源:知乎
著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。

我想引用上面一个段子…

对于从不炒作的老罗他可能说过:“我爱日本!”“没有日本的话,亚洲是不值一提的?!薄敖康蔚蔚拿褡迕挥形蠢矗ㄖ泄说拿褡迩楦幸脖让拦谌嘶挂康蔚我煌虮叮薄爸侨瞬缓煤醚а?,光跳脚骂娘是没用的……”

但是作为朝鲜人,要卖给支那人,最好不要让让支那人看到….

还有你那些情怀,就你罗永浩做手机难。别人都是妥协,别人都是业界潜规则,就你一个是赔钱卖的好不好?

再谈下知乎,知乎相比网易等肯定喷子少了很多,但是还是有我这样的喷子。先看看罗老师话题下的评论。?这么正常,知乎真的是素质高的社会啊,等一等,我

想骂一句….罗玉龙…看最新评论果然。

 

 

我为什么选择锤黑

我为什么选择锤黑 我为什么选择锤黑

 


方块网络 , 版权所有丨如未注明 , 均为原创丨本网站采用BY-NC-SA协议进行授权 , 转载请注明我为什么选择锤黑!
]]>
//www.y6mg.cn/2410.html/feed 1
JsonWebToken 折腾相关 - Welcome-广西快乐双彩官方网站 //www.y6mg.cn/2395.html //www.y6mg.cn/2395.html#comments Thu, 18 May 2017 08:15:50 +0000 //www.y6mg.cn/?p=2395

前言:

最近折腾相关。

走了个流程,写了个快捷点的,定义个骨架那种,只完成了验证和签发,用了不到一天半时间。

https://github.com/fangker/n-jwtproxy

JWT无法避免重放攻击,每15-30分钟重新签发一次,jti可以解决上面问题,每次更新ID,token相比于session更能够胜任分布式…完全是扯淡。。每次更新ID还要用到redis,再者明文秘钥不安全,正确的姿势是每次根据用户名+某规则生成JTI然后存redis生成随机秘钥,每次用用户的随机秘钥来验证用户自己。。且jwt payload部分明文不能带有敏感信息。。这样来说还不如用session来的实在。。因为你不可能以这种方式来进行减压,会导致服务器客户端状态不同(而且并没有减少一次查核的操作-靠这东西来区分权限)。目前jwt在单点登录和移动设备上有的一玩(无法举出反例没接触)。

补充: 关于TOKEN防止CSRF攻击的情况,早上恶补了知识,答案是没有session你搞毛。CSRF 可以看下csrf这个???https://github.com/pillarjs/csrf/blob/master/index.js? 采用的方式是uid+秘钥验证的方式,表单附加 随机token,代码很清晰 还是需要redis来存key。其实也可以对cookie进行签名用单一key的话,当然知识单纯对于跨站来说。

总结一句话:比较弱鸡。。。。

es6的代理:

代理使用示例 来自 //www.oschina.net/translate/use-cases-for-es6-proxies

试用了几发,实用性一般,但是某些时候也有用处 反射那一块也挺有意思(恍恍惚惚在略拾)。

//?Define?a?validator?that?takes?custom?validators?and?returns?a?proxy
function?createValidator(target,?validator)?{??
??return?new?Proxy(target,?{
????_validator:?validator,
????set(target,?key,?value,?proxy)?{
??????if?(target.hasOwnProperty(key))?{
????????let?validator?=?this._validator[key];
????????if?(!!validator(value))?{
??????????return?Reflect.set(target,?key,?value,?proxy);
????????}?else?{
??????????throw?Error(`Cannot?set?${key}?to?${value}.?Invalid.`);
????????}
??????}?else?{
????????//?prevent?setting?a?property?that?isn't?explicitly?defined?in?the?validator
????????throw?Error(`${key}?is?not?a?valid?property`)
??????}
????}
??});
}
//?Now,?just?define?validators?for?each?property
const?personValidators?=?{??
??name(val)?{
????return?typeof?val?===?'string';
??},
??age(val)?{
????return?typeof?age?===?'number'?&&?age?>?18;
??}
}
class?Person?{??
??constructor(name,?age)?{
????this.name?=?name;
????this.age?=?age;
????return?createValidator(this,?personValidators);
??}
}
const?bill?=?new?Person('Bill',?25);
//?all?of?these?throw?an?error
bill.name?=?0;??
bill.age?=?'Bill';??
bill.age?=?15;

方块网络 , 版权所有丨如未注明 , 均为原创丨本网站采用BY-NC-SA协议进行授权 , 转载请注明JsonWebToken 折腾相关!
]]>
//www.y6mg.cn/2395.html/feed 4
瞎折腾气到肺炸 mqtt - Welcome-广西快乐双彩官方网站 //www.y6mg.cn/2386.html //www.y6mg.cn/2386.html#comments Thu, 04 May 2017 09:38:29 +0000 //www.y6mg.cn/?p=2386

前言:

mqtt(Message Queuing Telemetry Transport),pomelo不是支持了么,闲来没事看到有中文文档想撸一发,没想到活活被气死。。。

正文:

传送门?https://mcxiaoke.gitbooks.io/mqtt-cn/content/mqtt/0301-CONNECT.html

const net = require('net');

let server = net.createServer();

server.on('connection', function(sock) {
sock.on('data', function(data) {
    console.log(data.toString())
    let index=0
    let frame={
        packetType: (data[index]>>4)&0xF,
        flags:(data[index++]&0x2<<4)&0xF,
        remaining:getRemain(),
        variableHeader:{
            protocolName:(data.slice(index+2,index+6).toString()),
            protocolLevel:(data[index+7]),
            connectFlags:data[index+8]&&0xff,
            keepAlive:data.slice(index+9,index+13)
    }
    }
    function getRemain() {
        let byteLength=1;
        let value=0;
        do{
            value+=byteLength*(data[index]&0x7f)
            index++
            byteLength *= 128
        } while ((data[index]&0x80)==0x80)
        if(byteLength>Math.pow(128,3)){
            throw Error("剩余长度字段异常")
        }
        return value
    }
console.log(frame,index)
    const array=[];
    array.push('0X20','0X2')
    const buf=Buffer.from(array)

});
});

server.listen(1883);
//打印
 { protocolName: 'MQTT',
 protocolLevel: 194,
 connectFlags: 0,
 keepAlive: <Buffer 3c 00 10 61> } }

protocolLevel,和connectFlags匹配不上,直接炸了。协议版本匹配不上最奇葩,已经疯了找不到bug,准备自杀。

瞎折腾气到肺炸 mqtt


方块网络 , 版权所有丨如未注明 , 均为原创丨本网站采用广西快乐双彩官方网站协议进行授权 , 转载请注明瞎折腾气到肺炸 mqtt!
]]>
//www.y6mg.cn/2386.html/feed 3
  • 纪念人民日报创刊70周年 重温历史动人瞬间 2018-08-12