Quantcast
Channel: PayMoon贝明实验室
Viewing all 130 articles
Browse latest View live
↧

[TODO list]HTTPS的前生后世

September 9, 2015, 8:42 am
$
0
0
引言 刚才在群里，很多大拿在讨论DNS劫持，https的拦截机制，拦截后能做什么，百度为什么全部切换HTTPS，HTTPS如何用Proxy帮助调试 附：DNSPOD解决不了DNS劫持，用户本机或者路由器设置中的DNS以及上级DNS才是解决关键。只有运营商才能解决。 PS: 本文是一个todo list, 以后会完善。大纲如下 1 原理 2 在Java中如何应用 3 拦截原理 4 拦截的几种场景 5 防拦截 6 百度，google切换https的流程 7 页面和移动端的https改造 放几个链接 HTTPS - Wikipedia, the free encyclopedia https://en.wikipedia.org/wiki/HTTPS#Overview Qualys SSL Labs https://www.ssllabs.com/
↧
Search

Java递归文件读取文件内容并追加写到另一个文件中

September 10, 2015, 4:43 am
$
0
0
引言 需求如下，因为需要把相当一部分代码取出来并且粘贴到word中，因为量大，并不想手动做。于是写代码解决 正文 1 获取文件位置 2 递归遍历文件，识别文件内容 3 如果是文件，读取出来内容 4 写进另一个文件 代码先贴 [crayon-564208032c522073697725/]  
↧
↧

【线程九】Java内存模型是什么

September 16, 2015, 10:43 pm
$
0
0

Java内存模型规定和指引Java程序在不同的内存架构、CPU和操作系统间有确定性地行为。它在多线程的情况下尤其重要。Java内存模型对一个线程所做的变动能被其它线程可见提供了保证，它们之间是先行发生关系。这个关系定义了一些规则让程序员在并发编程时思路更清晰。比如，先行发生关系确保了：

      • 线程内的代码能够按先后顺序执行，这被称为程序次序规则。
      • 对于同一个锁，一个解锁操作一定要发生在时间上后发生的另一个锁定操作之前，也叫做管程锁定规则。
      • 前一个对volatile的写操作在后一个volatile的读操作之前，也叫volatile变量规则。
      • 一个线程内的任何操作必需在这个线程的start()调用之后，也叫作线程启动规则。
      • 一个线程的所有操作都会在线程终止之前，线程终止规则。
      • 一个对象的终结操作必需在这个对象构造完成之后，也叫对象终结规则。
      • 可传递性

我强烈建议大家阅读《Java并发编程实践》（电子书有需要请留言）第十六章来加深对Java内存模型的理解。

↧

PHP如何使用http curl 传输数据

September 16, 2015, 11:48 pm
$
0
0

引言

之前从未写过这门全世界最好的语言，这两天因业务所需，研究了下，感觉还好。 然后在使用过程中看到有人提问类似业务内容，索性写出来了。

搭建php环境

搭建httpd

搭建mysql

开始php第一个hello world

在/var/www/html中创建index.php 写上 [crayon-564208032bf51303526081/]

使用php进行curl 操作

数据格式就按照给定的 [crayon-564208032bf5a680702048/] 首先我们先要明白这到底是什么鬼 curl代表linux命令

Content-type: application/json：代表header

POST 提交方式

"http://xxx" 提交url

提交数据：

[crayon-564208032bf60182953242/]

然后又查php手册，看如何使用

首先要安装http 扩展

然后demo如下

[crayon-564208032bf65786544452/] 这个示例还是非常容易理解的 只不过他的header不同 转为自己所需要格式 照猫画虎写一个

整理如下

[crayon-564208032bf6a573587888/] 结果：成功！ 总结 这个例子一做下来，发现使用这货还可以做爬虫，包括一般爬取和提交表单爬数据。 并且在做的过程中真的写了一个小爬虫程序，有机会分享出来。真是又学了一招
↧

Eclipse Maven 错误 “Failure to transfer…”Failure to transfer org.apache.maven.plugins:maven-compiler-plugin:pom:2.0.2 from http://repo1.maven.org/maven2 was cached in the local repository, resolution will not be reattempted until the update interval of central has elapsed or updates are forced. Original error: Could not transfer artifact org.apache.maven.plugins:maven-compiler-plugin:pom:2.0.2 from/to central (http://repo1.maven.org/maven2): No response received after 60000 ExampleProject Unknown Maven Problem

September 24, 2015, 11:47 pm
$
0
0
报错日志 [crayon-564208032bae5689888058/]   这是因为没有下载完导致的，手动或者命令删除这些文件 对于Linux或者OSX: [crayon-564208032baef027753145/] 对于 windows: [crayon-564208032baf4218342386/] 然后在Project右键，选择 Maven->"Update Project ...", 选择OK就可以了.
↧
↧

Failed to read candidate component class包冲突解决方法

September 25, 2015, 2:55 am
$
0
0
一般是spring的包在Maven里面冲突了。 打开Eclipse的Denpendency Hierar视图，找里面的jar包，conflict关键字，就知道冲突来源了。 关于解决方法，请参考： Eclipse maven中jar依赖冲突解决exclude, pom exclude添加接触jar依赖 | PayMoon贝明实验室 http://www.paymoon.com/index.php/2015/06/10/eclipse-maven-exclude-pom-exclude-jar/
↧

Failed to connect to 127.0.0.1:27017 reason: errno:111 connection attempt failed at src/mongo/shell/mongo.js:146

October 10, 2015, 9:11 am
↧

如何使用httpclient4 发送json数据到hubspot hubapi

October 12, 2015, 12:56 am
$
0
0
1 首先使用httpclient4发送数据的方式 [crayon-564208032aa01229077033/]   2  在核心内容发送前，需要对数据处理 [crayon-564208032aa0f347156407/]     3 整理如下 [crayon-564208032aa15829786006/] FORK from GITHUB 4 其它类 metric [crayon-564208032aa1e614626384/] FORK FROM GITHUB 5 其它类二 [crayon-564208032aa24460360722/] FORK FROM GITHUB    
↧
Search

红色黄色黑色绿色十六进制颜色码

October 12, 2015, 10:09 pm
$
0
0
英文代码　       形像颜色　                HEX格式　     RGB格式
LightPink
浅粉色
#FFB6C1
255,182,193
Pink
粉红
#FFC0CB
255,192,203
Crimson
猩红
#DC143C
220,20,60
LavenderBlush
脸红的淡紫色
#FFF0F5
255,240,245
PaleVioletRed
苍白的紫罗兰红色
#DB7093
219,112,147
HotPink
热情的粉红
#FF69B4
255,105,180
DeepPink
深粉色
#FF1493
255,20,147
MediumVioletRed
适中的紫罗兰红色
#C71585
199,21,133
Orchid
兰花的紫色
#DA70D6
218,112,214
Thistle
蓟
#D8BFD8
216,191,216
plum
李子
#DDA0DD
221,160,221
Violet
紫罗兰
#EE82EE
238,130,238
Magenta
洋红
#FF00FF
255,0,255
Fuchsia
灯笼海棠（紫红色）
#FF00FF
255,0,255
DarkMagenta
深洋红色
#8B008B
139,0,139
Purple
紫色
#800080
128,0,128
MediumOrchid
适中的兰花紫
#BA55D3
186,85,211
DarkVoilet
深紫罗兰色
#9400D3
148,0,211
DarkOrchid
深兰花紫
#9932CC
153,50,204
Indigo
靛青
#4B0082
75,0,130
BlueViolet
深紫罗兰的蓝色
#8A2BE2
138,43,226
MediumPurple
适中的紫色
#9370DB
147,112,219
MediumSlateBlue
适中的板岩暗蓝灰色
#7B68EE
123,104,238
SlateBlue
板岩暗蓝灰色
#6A5ACD
106,90,205
DarkSlateBlue
深岩暗蓝灰色
#483D8B
72,61,139
Lavender
薰衣草花的淡紫色
#E6E6FA
230,230,250
GhostWhite
幽灵的白色
#F8F8FF
248,248,255
Blue
纯蓝
#0000FF
0,0,255
MediumBlue
适中的蓝色
#0000CD
0,0,205
MidnightBlue
午夜的蓝色
#191970
25,25,112
DarkBlue
深蓝色
#00008B
0,0,139
Navy
海军蓝
#000080
0,0,128
RoyalBlue
皇军蓝
#4169E1
65,105,225
CornflowerBlue
矢车菊的蓝色
#6495ED
100,149,237
LightSteelBlue
淡钢蓝
#B0C4DE
176,196,222
LightSlateGray
浅石板灰
#778899
119,136,153
SlateGray
石板灰
#708090
112,128,144
DoderBlue
道奇蓝
#1E90FF
30,144,255
AliceBlue
爱丽丝蓝
#F0F8FF
240,248,255
SteelBlue
钢蓝
#4682B4
70,130,180
LightSkyBlue
淡蓝色
#87CEFA
135,206,250
SkyBlue
天蓝色
#87CEEB
135,206,235
DeepSkyBlue
深天蓝
#00BFFF
0,191,255
LightBLue
淡蓝
#ADD8E6
173,216,230
PowDerBlue
火药蓝
#B0E0E6
176,224,230
CadetBlue
军校蓝
#5F9EA0
95,158,160
Azure
蔚蓝色
#F0FFFF
240,255,255
LightCyan
淡青色
#E1FFFF
225,255,255
PaleTurquoise
苍白的绿宝石
#AFEEEE
175,238,238
Cyan
青色
#00FFFF
0,255,255
Aqua
水绿色
#00FFFF
0,255,255
DarkTurquoise
深绿宝石
#00CED1
0,206,209
DarkSlateGray
深石板灰
#2F4F4F
47,79,79
DarkCyan
深青色
#008B8B
0,139,139
Teal
水鸭色
#008080
0,128,128
MediumTurquoise
适中的绿宝石
#48D1CC
72,209,204
LightSeaGreen
浅海洋绿
#20B2AA
32,178,170
Turquoise
绿宝石
#40E0D0
64,224,208
Auqamarin
绿玉\碧绿色
#7FFFAA
127,255,170
MediumAquamarine
适中的碧绿色
#00FA9A
0,250,154
MediumSpringGreen
适中的春天的绿色
#F5FFFA
245,255,250
MintCream
薄荷奶油
#00FF7F
0,255,127
SpringGreen
春天的绿色
#3CB371
60,179,113
SeaGreen
海洋绿
#2E8B57
46,139,87
Honeydew
蜂蜜
#F0FFF0
240,255,240
LightGreen
淡绿色
#90EE90
144,238,144
PaleGreen
苍白的绿色
#98FB98
152,251,152
DarkSeaGreen
深海洋绿
#8FBC8F
143,188,143
LimeGreen
酸橙绿
#32CD32
50,205,50
Lime
酸橙色
#00FF00
0,255,0
ForestGreen
森林绿
#228B22
34,139,34
Green
纯绿
#008000
0,128,0
DarkGreen
深绿色
#006400
0,100,0
Chartreuse
查特酒绿
#7FFF00
127,255,0
LawnGreen
草坪绿
#7CFC00
124,252,0
GreenYellow
绿黄色
#ADFF2F
173,255,47
OliveDrab
橄榄土褐色
#556B2F
85,107,47
Beige
米色（浅褐色）
#6B8E23
107,142,35
LightGoldenrodYellow
浅秋麒麟黄
#FAFAD2
250,250,210
Ivory
象牙色
#FFFFF0
255,255,240
LightYellow
浅黄色
#FFFFE0
255,255,224
Yellow
纯黄
#FFFF00
255,255,0
Olive
橄榄
#808000
128,128,0
DarkKhaki
深卡其布
#BDB76B
189,183,107
LemonChiffon
柠檬薄纱
#FFFACD
255,250,205
PaleGodenrod
灰秋麒麟
#EEE8AA
238,232,170
Khaki
卡其布
#F0E68C
240,230,140
Gold
金
#FFD700
255,215,0
Cornislk
玉米色
#FFF8DC
255,248,220
GoldEnrod
秋麒麟
#DAA520
218,165,32
FloralWhite
花的白色
#FFFAF0
255,250,240
OldLace
老饰带
#FDF5E6
253,245,230
Wheat
小麦色
#F5DEB3
245,222,179
Moccasin
鹿皮鞋
#FFE4B5
255,228,181
Orange
橙色
#FFA500
255,165,0
PapayaWhip
番木瓜
#FFEFD5
255,239,213
BlanchedAlmond
漂白的杏仁
#FFEBCD
255,235,205
NavajoWhite
Navajo白
#FFDEAD
255,222,173
AntiqueWhite
古代的白色
#FAEBD7
250,235,215
Tan
晒黑
#D2B48C
210,180,140
BrulyWood
结实的树
#DEB887
222,184,135
Bisque
（浓汤）乳脂，番茄等
#FFE4C4
255,228,196
DarkOrange
深橙色
#FF8C00
255,140,0
Linen
亚麻布
#FAF0E6
250,240,230
Peru
秘鲁
#CD853F
205,133,63
PeachPuff
桃色
#FFDAB9
255,218,185
SandyBrown
沙棕色
#F4A460
244,164,96
Chocolate
巧克力
#D2691E
210,105,30
SaddleBrown
马鞍棕色
#8B4513
139,69,19
SeaShell
海贝壳
#FFF5EE
255,245,238
Sienna
黄土赭色
#A0522D
160,82,45
LightSalmon
浅鲜肉（鲑鱼）色
#FFA07A
255,160,122
Coral
珊瑚
#FF7F50
255,127,80
OrangeRed
橙红色
#FF4500
255,69,0
DarkSalmon
深鲜肉（鲑鱼）色
#E9967A
233,150,122
Tomato
番茄
#FF6347
255,99,71
MistyRose
薄雾玫瑰
#FFE4E1
255,228,225
Salmon
鲜肉（鲑鱼）色
#FA8072
250,128,114
Snow
雪
#FFFAFA
255,250,250
LightCoral
淡珊瑚色
#F08080
240,128,128
RosyBrown
玫瑰棕色
#BC8F8F
188,143,143
IndianRed
印度红
#CD5C5C
205,92,92
Red
纯红
#FF0000
255,0,0
Brown
棕色
#A52A2A
165,42,42
FireBrick
耐火砖
#B22222
178,34,34
DarkRed
深红色
#8B0000
139,0,0
Maroon
栗色
#800000
128,0,0
White
纯白
#FFFFFF
255,255,255
WhiteSmoke
白烟
#F5F5F5
245,245,245
Gainsboro
Gainsboro
#DCDCDC
220,220,220
LightGrey
浅灰色
#D3D3D3
211,211,211
Silver
银白色
#C0C0C0
192,192,192
DarkGray
深灰色
#A9A9A9
169,169,169
Gray
灰色
#808080
128,128,128
DimGray
暗淡的灰色
#696969
105,105,105
Black
纯黑
#000000
0,0,0
↧
↧

Java 定时 quzrtz CronTrigger配置格式

November 4, 2015, 6:37 pm
$
0
0
CronTrigger配置格式: 格式: [秒] [分] [小时] [日] [月] [周] [年]
序号 说明 是否必填 允许填写的值 允许的通配符
1 秒 是 0-59 , - * /
2 分 是 0-59 , - * /
3 小时 是 0-23 , - * /
4 日 是 1-31 , - * ? / L W
5 月 是 1-12 or JAN-DEC , - * /
6 周 是 1-7 or SUN-SAT , - * ? / L #
7 年 否 empty 或 1970-2099 , - * /
通配符说明: * 表示所有值. 例如:在分的字段上设置 "*",表示每一分钟都会触发。 ? 表示不指定值。使用的场景为不需要关心当前设置这个字段的值。例如:要在每月的10号触发一个操作，但不关心是周几，所以需要周位置的那个字段设置为"?" 具体设置为 0 0 0 10 * ? - 表示区间。例如 在小时上设置 "10-12",表示 10,11,12点都会触发。 , 表示指定多个值，例如在周字段上设置 "MON,WED,FRI" 表示周一，周三和周五触发 / 用于递增触发。如在秒上面设置"5/15" 表示从5秒开始，每增15秒触发(5,20,35,50)。 在月字段上设置'1/3'所示每月1号开始，每隔三天触发一次。 L 表示最后的意思。在日字段设置上，表示当月的最后一天(依据当前月份，如果是二月还会依据是否是润年[leap]), 在周字段上表示星期六，相当于"7"或"SAT"。如果在"L"前加上数字，则表示该数据的最后一个。例如在周字段上设置"6L"这样的格式,则表示“本月最后一个星期五" W 表示离指定日期的最近那个工作日(周一至周五). 例如在日字段上设置"15W"，表示离每月15号最近的那个工作日触发。如果15号正好是周六，则找最近的周五(14号)触发, 如果15号是周未，则找最近的下周一(16号)触发.如果15号正好在工作日(周一至周五)，则就在该天触发。如果指定格式为 "1W",它则表示每月1号往后最近的工作日触发。如果1号正是周六，则将在3号下周一触发。(注，"W"前只能设置具体的数字,不允许区间"-").
小提示 'L'和 'W'可以一组合使用。如果在日字段上设置"LW",则表示在本月的最后一个工作日触发(一般指发工资 )
# 序号(表示每月的第几个周几)，例如在周字段上设置"6#3"表示在每月的第三个周六.注意如果指定"#5",正好第五周没有周六，则不会触发该配置(用在母亲节和父亲节再合适不过了)
小提示 周字段的设置，若使用英文字母是不区分大小写的 MON 与mon相同.
常用示例:
0 0 12 * * ? 每天12点触发
0 15 10 ? * * 每天10点15分触发
0 15 10 * * ? 每天10点15分触发
0 15 10 * * ? * 每天10点15分触发
0 15 10 * * ? 2005 2005年每天10点15分触发
0 * 14 * * ? 每天下午的 2点到2点59分每分触发
0 0/5 14 * * ? 每天下午的 2点到2点59分(整点开始，每隔5分触发)
0 0/5 14,18 * * ? 每天下午的 2点到2点59分(整点开始，每隔5分触发) 每天下午的 18点到18点59分(整点开始，每隔5分触发)
0 0-5 14 * * ? 每天下午的 2点到2点05分每分触发
0 10,44 14 ? 3 WED 3月分每周三下午的 2点10分和2点44分触发
0 15 10 ? * MON-FRI 从周一到周五每天上午的10点15分触发
0 15 10 15 * ? 每月15号上午10点15分触发
0 15 10 L * ? 每月最后一天的10点15分触发
0 15 10 ? * 6L 每月最后一周的星期五的10点15分触发
0 15 10 ? * 6L 2002-2005 从2002年到2005年每月最后一周的星期五的10点15分触发
0 15 10 ? * 6#3 每月的第三周的星期五开始触发
0 0 12 1/5 * ? 每月的第一个中午开始每隔5天触发一次
0 11 11 11 11 ? 每年的11月11号 11点11分触发(光棍节)
↧

【线程八•2】JAVA中COUNTDOWNLATCH使用demo

November 25, 2015, 4:58 am
$
0
0
1 其实http://www.itzhai.com/the-introduction-and-use-of-a-countdownlatch.html 已经讲的很好了。 为什么又要写一下呢？ 2 因为有一些没提到的，和新发现的。 2.1 CountDownLatch最重要的方法是countDown()和await()，前者主要是倒数一次，后者是等待倒数到0，如果没有到达0，就只有阻塞等待了。 2.2 [crayon-56579710323cb221120303/] 这个方法可以用起来，他是这么用的：

 end.await(1,TimeUnit.SECONDS);

如果执行后，1秒没有完成，他就等不及了，会直接宣布结束，但是后面的线程依然会执行

Game Start

No.7 arrived

Game Over

No.8 arrived

No.10 arrived

No.9 arrived

No.6 arrived

No.2 arrived

No.1 arrived

No.3 arrived

No.5 arrived

No.4 arrived

2.3. 关于2.2中TimeUnit的用法，可以点进去看API说明。有很多实用方法。

System.out.println(TimeUnit.SECONDS.convert(1, TimeUnit.MINUTES));

输出:1 分钟转60秒

System.out.println(TimeUnit.SECONDS.toMinutes(600));

输出：600秒转10Minutes

3 ExecutorService用法

3.1 Executors.newFixedThreadPool(10);

3.2 exec.submit(run);（与exec.execute(run);区别）

将Runnable的对象传递给ExecutorService的submit方法，则该run方法自动在一个线程上执行，并且会返回执行结果Future对象，但是在该Future对象上调用get方法，将返回null。

3.3 exec.shutdown();

4 源码解析

Java多线程系列--“JUC锁”09之 CountDownLatch原理和示例 - 如果天空不死 - 博客园 http://www.cnblogs.com/skywang12345/p/3533887.html

↧

Could not autowire field ResourceBundleMessageSource

November 25, 2015, 11:24 pm
$
0
0
org.springframework.beans.factory.BeanCreationException

Could not autowire field: org.springframework.context.support.ResourceBundleMessageSource

[crayon-5657971031eca310782153/] 错误说得明显。 找到xxx-context.xml，添加 [crayon-5657971031eda368573115/]  
↧

安装rabbitmq

November 26, 2015, 12:47 am
$
0
0
安装rabbitmq   1 yum install -y erlang   备注:
##如果装不上erlang wget -O /etc/yum.repos.d/erlang_solutions.repo  http://binaries.erlang-solutions.com/rpm/centos/erlang_solutions.repo 再装   rpm --import http://www.rabbitmq.com/rabbitmq-signing-key-public.asc
  2 wget http://www.rabbitmq.com/releases/rabbitmq-server/v3.4.2/rabbitmq-server-3.4.2-1.noarch.rpm   yum install -y rabbitmq-server-3.4.2-1.noarch.rpm   3 chkconfig rabbitmq-server on   4 service rabbitmq-server restart   5 rabbitmq-plugins enable rabbitmq_management （如发现RabbitMQ启动成功，但是Web不能访问到RabbitMQ控制台。则在dos窗口执行命令：rabbitmq-plugins.bat enable rabbitmq_management，然后再重启RabbitMQ即可通过Web访问到RabbitMQ控制台。）   6 rabbitmqctl change_password guest 123456  
  1. 添加外部访问
/etc/rabbitmq/rabbitmq.config  
[{rabbit, [{loopback_users, []}]}].
  然后 remoteIP:15672  
  1. 配置集群
web1机器: chmod 777  /var/lib/rabbitmq/.erlang.cookie scp root@web2:/var/lib/rabbitmq/.erlang.cookie . chmod 400 /var/lib/rabbitmq/.erlang.cookie   分别重启web1,web2 rabbitmq   停止rabbitmq，每个机器分别执行 rabbitmq-server -detached   查看状态，应该都是自己 rabbitmqctl cluster_status   web1执行 rabbitmqctl stop_app rabbitmqctl join_cluster --ram rabbit@web2 rabbitmqctl start_app   查看状态 rabbitmqctl cluster_status         Rabbit - Error: mnesia_unexpectedly_running解决 rabbitmqctl stop_app rabbitmqctl reset   配置haproxy yum install -y haproxy   vi /etc/haproxy/haproxy.cfg   listen rabbitmq_cluster 0.0.0.0:5672 mode tcp balance roundrobin server   web1 10.144.169.225:5672 check inter 2000 rise 2 fall 3 server   web2 10.161.47.79:5672 check inter 2000 rise 2 fall 3     cat /dev/null >         1.停止RabbitMQ应用，关闭节点 # rabbitmqctl stop 2.停止RabbitMQ应用 # rabbitmqctl stop_app 3.启动RabbitMQ应用 # rabbitmqctl start_app 4.显示RabbitMQ中间件各种信息 # rabbitmqctl status 5.重置RabbitMQ节点 # rabbitmqctl reset # rabbitmqctl force_reset  
↧
↧

【线程十】【翻译●中英双语】Java中的volatile 变量是什么

November 26, 2015, 2:18 am
$
0
0
volatile是一个特殊的修饰符，只有成员变量才能使用它。在Java并发程序缺少同步类的情况下，多线程对成员变量的操作对其它线程是透明的。volatile变量可以保证下一个读取操作会在前一个写操作之后发生，就是上一题的volatile变量规则。 前言： 在Java内存模型中，有main memory，每个线程也有自己的memory (例如寄存器)。为了性能，一个线程会在自己的memory中保持要访问的变量的副本。这样就会出现同一个变量在某个瞬间，在一个线程的memory中的值可能与另外一个线程memory中的值，或者main memory中的值不一致的情况。 volatile会保证变量只在main 中改变。并及时share给其它线程。 一个变量声明为volatile，就意味着这个变量是随时会被其他线程修改的，因此不能将它cache在线程memory中。 正文： How Volatile in Java works? Example of volatile keyword in Java How to use Volatile keyword in Java What is volatile variable in Java and when to use Volatile variable in Java is famous multi-threading interview question in Java interviews. Though many programmer knows what is a volatile variable but they fail on second part i.e. where to use volatile variable in Java as its not common to have clear understanding and hands-on on volatile in Java. In this tutorial we will address this gap by providing simple example of volatile variable in Java and discussing some when to use Volatile variable in Java. Any way Volatile keyword in Java is used as an indicator to Java compiler and Thread that do not cache value of this variable and always read it from main memory. So if you want to share any variable in which read and write operation is atomic by implementation e.g. read and write in int or boolean variable you can declare them as volatile variable. From Java 5 along with major changes like Autoboxing, Enum, Generics and Variable arguments , Java introduces some change in Java Memory Model (JMM), Which guarantees visibility of changes made by one thread to another also as "happens-before" which solves the problem of memory writes that happen in one thread can "leak through" and be seen by another thread. Java volatile keyword cannot be used with method or class and it can only be used with variable. Java volatile keyword also guarantees visibility and ordering , after Java 5 write to any volatile variable happens before any read into volatile variable. By the way use of volatile keyword also prevents compiler or JVM from reordering of code or moving away them from synchronization barrier.   YOL翻译 Java中的 volatile 变量是什么？何时使用volatile ？，在 Java 多线程的面试问题常见。 虽然很多程序员都知道什么是 volatile 变量，但他们对第二个问题就晕菜了，Java中也没有明确说明。在本教程中，我们将举例说明这个问题。 在 Java 中，Volatile在 Java 编译器和线程不缓存此变量的值，总是从主存读取它。所以如果你想要分享的任何原子的变量上的读和写操作，执行如读取和写入 int 或布尔值的变量，你可以将它们声明为 volatile 变量。从Java 5 开始，伴随着自动装箱、 枚举、 泛型和变量参数等主要的变化，Java介绍了一些 Java 内存模型 (JMM:http://ifeve.com/tag/jmm/)中的变化，它保证到另一个线程所做的更改可见性的一些变化也让其它线程有了偏序的问题（YOL注，请阅读JMM知识），这解决了发生在一个线程中的内存写入被泄漏，并被其它线程看见。Java volatile 关键字不能用于方法或类，它只可以用于变量。Java volatile 关键字也保证可视化和顺序性，Java 5 写入任何 volatile 变量后会发生以前任何读到 volatile 变量。顺便说一下使用 volatile 关键字还可以防止编译器或 JVM 中的代码重新排序或把他们从同步barrier中移除。     Volatile variable Example in Java To Understand example of volatile keyword in java let’s go back to Singleton pattern in Java and see double checked locking in Singleton with Volatile and without volatile keyword in java.   [crayon-56579710312ff802293948/]   If you look at the code carefully you will be able to figure out: 1) We are only creating instance one time 2) We are creating instance lazily at the time of first request comes.     If we do not make _instance variable volatile then Thread which is creating instance of Singleton is not able to communicate other thread, that instance has been created until it comes out of the Singleton block, so if Thread A is creating Singleton instance and just after creation lost the CPU, all other thread will not be able to see value of _instance as not null and they will believe its still null. Why? because reader threads are not doing any locking and until writer thread comes out of synchronized block, memory will not be synchronized and value of _instance will not be updated in main memory. With Volatile keyword in Java this is handled by Java himself and such updates will be visible by all reader threads.     So in Summary apart from synchronized keyword in Java, volatile keyword is also used to communicate content of memory between threads.         Let’s see another example of volatile keyword in Java most of the time while writing game we use a variable bExit to check whether user has pressed exit button or not, value of this variable is updated in event thread and checked in game thread , So if we don't use volatile keyword with this variable , Game Thread might miss update from event handler thread if its not synchronized in java already. volatile keyword in java guarantees that value of volatile variable will always be read from main memory and "happens-before" relationship in Java Memory model will ensure that content of memory will be communicated to different threads.   private boolean bExit; while(!bExit) { checkUserPosition(); updateUserPosition(); }   In this code example One Thread (Game Thread) can cache the value of "bExit" instead of getting it from main memory every time and if in between any other thread (Event handler Thread) changes the value; it would not be visible to this thread. Making boolean variable "bExit" as volatile in java ensures this will not happen.         When to use Volatile variable in Java One of the most important thing in learning of volatile keyword is understanding when to use volatile variable in Java. Many programmer knows what is volatile variable and How does it work but they never really used volatile for any practical purpose. Here are couple of example to demonstrate when to use Volatile keyword in Java:     1) You can use Volatile variable if you want to read and write long and double variable atomically. long and double both are 64 bit data type and by default writing of long and double is not atomic and platform dependence. Many platform perform write in long and double variable 2 step, writing 32 bit in each step, due to this its possible for a Thread to see 32 bit from two different write. You can avoid this issue by making long and double variable volatile in Java.     2) Volatile variable can be used as an alternative way of achieving synchronization in Java in some cases, like Visibility. with volatile variable its guaranteed that all reader thread will see updated value of volatile variable once write operation completed, without volatile keyword different reader thread may see different values.     3) volatile variable can be used to inform compiler that a particular field is subject to be accessed by multiple threads, which will prevent compiler from doing any reordering or any kind of optimization which is not desirable in multi-threaded environment. Without volatile variable compiler can re-order code, free to cache value of volatile variable instead of always reading from main memory. like following example without volatile variable may result in infinite loop   private boolean isActive = thread; public void printMessage(){ while(isActive){ System.out.println("Thread is Active"); } }   without volatile modifier its not guaranteed that one Thread see the updated value of isActive from other thread. compiler is also free to cache value of isActive instead of reading it from main memory in every iteration. By making isActive a volatile variable you avoid these issue.       4) Another place where volatile variable can be used is to fixing double checked locking in Singleton pattern. As we discussed in Why should you use Enum as Singleton that double checked locking was broken in Java 1.4 environment.             Important points on Volatile keyword in Java
  1. volatilekeyword in Java is only application to variable and using volatile keyword with class and method is illegal.
   
  1. volatilekeyword in Java guarantees that value of volatile variable will always be read from main memory and not from Thread's local cache.
   
  1. In Java reads and writes areatomicfor all variables declared using Java volatile keyword (including long and double variables).
   
  1. Using Volatilekeywordin Java on variables reduces the risk of memory consistency errors, because any write to a volatile variable in Java establishes a happens-before relationship with subsequent reads of that same variable.
   
  1. From Java 5 changes to a volatile variable are always visible to other threads. What’s more it also means that when a thread reads a volatile variable in Java, it sees not just the latest change to the volatile variable but also the side effects of the code that led up the change.
   
  1. Reads and writes are atomic for reference variables are for most primitive variables (all types except long and double) even without use of volatilekeywordin Java.
   
  1. An access to a volatile variable in Java never has chance to block, since we are only doing a simple read or write, so unlike a synchronized block we will never hold on to any lock or wait for anylock.
   
  1. Java volatile variable that is an object reference may be null.
   
  1. Java volatilekeyworddoesn't means atomic, its common misconception that after declaring volatile ++ will be atomic, to make the operation atomic you still need to ensure exclusive access using synchronized method or block in Java.
   
  1. If a variable is not shared between multiple threadsno need to use volatilekeyword with that variable.
        Difference between synchronized and volatile keyword in Java What is difference between volatile and synchronized is another popular core Java question asked in multi-threading and concurrency interviews. Remember volatile is not a replacement of synchronized keyword but can be used as an alternative in certain cases. Here are few differences between volatile and synchronized keyword in Java.    
  1. Volatile keyword in Java is a field modifier, while synchronized modifies code blocks and methods.
   
  1. Synchronized obtains and releases lock on monitor’s Java volatile keyword doesn't require that.
   
  1. Threads in Java can be blocked for waiting any monitor in case of synchronized, that is not the case with volatile keyword in Java.
   
  1. Synchronized method affects performance more than volatile keyword in Java.
   
  1. Since volatile keyword in Java only synchronizes the value of one variable between Thread memory and"main"memory while synchronized synchronizes the value of all variable between thread memory and "main" memory and locks and releases a monitor to boot. Due to this reason synchronized keyword in Java is likely to have more overhead than volatile.
   
  1. You can not synchronize on null object but your volatile variable in java could be null.
   
  1. From Java 5 Writing into a volatile field has the same memory effect as a monitor release, and reading from a volatile field has the same memory effect as a monitor acquire
    In Summary volatile keyword in Java is not a replacement of synchronized block or method but in some situation is very handy and can save performance overhead which comes with use of synchronization in Java     if you like to know more about volatile I would also suggest to go thorough FAQ on Java Memory Model here which explains happens-before operations quite well. 中文相关： java中关键字volatile的作用 http://sakyone.iteye.com/blog/668091
↧

[待翻译]Apache Mesos and Jenkins – elastic build slaves | CloudBees

November 30, 2015, 7:12 pm
$
0
0
The Mesos project is a cluster management tool for building your own elastic clouds. (see more at mesosphere.io). Here I will take you through setting up Jenkins to make use of Mesos as an elastic cloud of build slaves. Mesos is fast changing project and one to watch.
来源： Apache Mesos and Jenkins - elastic build slaves | CloudBees
↧
Search

解决MISCONF Redis is configured to save RDB snapshots, but is currently not able to persist on disk

December 1, 2015, 6:50 pm
$
0
0
报错如下： [crayon-56618f8267db1918584961/] 操作如下： [crayon-56618f8267dc1893236825/]   解决办法： [crayon-56618f8267dc8886100804/]          
↧

java 7 创建文件并分配读写权限

December 8, 2015, 12:17 am
$
0
0
好像大家都还没用这一块功能？今天看书刷到这一节，有心在网上搜索了下，哪都木有。 [crayon-5676fa4ebfad3652916534/]  
↧
↧

Maven : NoClassDefFoundError Xms256m

December 26, 2015, 1:12 am
$
0
0
ERR1: Maven : NoClassDefFoundError Xms256m while running Maven Command ERR2: Error: Could not find or load main class Xms256m. 是因为环境变量 [crayon-568056d2ac732561194447/] 而不是 [crayon-568056d2ac73b328651576/]  
↧

anthelion使用Ant工具编译运行失败

December 26, 2015, 2:34 am
$
0
0
雅虎开源其爬虫anthelion，我试了一把，编译了40分钟，结果失败。猜测是有些包缺少。yahoo/anthelion https://github.com/yahoo/anthelion [crayon-568056d2ab9cc657444372/]          
↧

如何查找MySQL中查询慢的SQL语句

April 6, 2016, 10:45 pm
$
0
0
如何在mysql查找效率慢的SQL语句呢？这可能是困然很多人的一个问题，MySQL通过慢查询日志定位那些执行效率较低的SQL 语句，用--log-slow-queries[=file_name]选项启动时，mysqld 会写一个包含所有执行时间超过long_query_time 秒的SQL语句的日志文件，通过查看这个日志文件定位效率较低的SQL 。下面介绍MySQL中如何查询慢的SQL语句 一、MySQL数据库有几个配置选项可以帮助我们及时捕获低效SQL语句   1，slow_query_log 这个参数设置为ON，可以捕获执行时间超过一定数值的SQL语句。   2，long_query_time 当SQL语句执行时间超过此数值时，就会被记录到日志中，建议设置为1或者更短。   3，slow_query_log_file 记录日志的文件名。   4，log_queries_not_using_indexes 这个参数设置为ON，可以捕获到所有未使用索引的SQL语句，尽管这个SQL语句有可能执行得挺快。   二、检测mysql中sql语句的效率的方法   1、通过查询日志 （1）、Windows下开启MySQL慢查询 MySQL在Windows系统中的配置文件一般是是my.ini找到[mysqld]下面加上 代码如下 log-slow-queries = F:/MySQL/log/mysqlslowquery。log long_query_time = 2 （2）、Linux下启用MySQL慢查询 MySQL在Windows系统中的配置文件一般是是my.cnf找到[mysqld]下面加上 代码如下 log-slow-queries=/data/mysqldata/slowquery。log long_query_time=2 说明 log-slow-queries = F:/MySQL/log/mysqlslowquery。 为慢查询日志存放的位置，一般这个目录要有MySQL的运行帐号的可写权限，一般都将这个目录设置为MySQL的数据存放目录； long_query_time=2中的2表示查询超过两秒才记录；   2.show processlist 命令   SHOW PROCESSLIST显示哪些线程正在运行。您也可以使用mysqladmin processlist语句得到此信息。 各列的含义和用途： ID列 一个标识，你要kill一个语句的时候很有用，用命令杀掉此查询 /*/mysqladmin kill 进程号。 user列 显示单前用户，如果不是root，这个命令就只显示你权限范围内的sql语句。 host列 显示这个语句是从哪个ip的哪个端口上发出的。用于追踪出问题语句的用户。 db列 显示这个进程目前连接的是哪个数据库。 command列 显示当前连接的执行的命令，一般就是休眠（sleep），查询（query），连接（connect）。 time列 此这个状态持续的时间，单位是秒。 state列 显示使用当前连接的sql语句的状态，很重要的列，后续会有所有的状态的描述，请注意，state只是语句执行中的某一个状态，一个 sql语句，以查询为例，可能需要经过copying to tmp table，Sorting result，Sending data等状态才可以完成 info列 显示这个sql语句，因为长度有限，所以长的sql语句就显示不全，但是一个判断问题语句的重要依据。   这个命令中最关键的就是state列，mysql列出的状态主要有以下几种： Checking table 正在检查数据表（这是自动的）。 Closing tables 正在将表中修改的数据刷新到磁盘中，同时正在关闭已经用完的表。这是一个很快的操作，如果不是这样的话，就应该确认磁盘空间是否已经满了或者磁盘是否正处于重负中。 Connect Out 复制从服务器正在连接主服务器。 Copying to tmp table on disk 由于临时结果集大于tmp_table_size，正在将临时表从内存存储转为磁盘存储以此节省内存。 Creating tmp table 正在创建临时表以存放部分查询结果。 deleting from main table 服务器正在执行多表删除中的第一部分，刚删除第一个表。 deleting from reference tables 服务器正在执行多表删除中的第二部分，正在删除其他表的记录。 Flushing tables 正在执行FLUSH TABLES，等待其他线程关闭数据表。 Killed 发送了一个kill请求给某线程，那么这个线程将会检查kill标志位，同时会放弃下一个kill请求。MySQL会在每次的主循环中检查kill标志位，不过有些情况下该线程可能会过一小段才能死掉。如果该线程程被其他线程锁住了，那么kill请求会在锁释放时马上生效。 Locked 被其他查询锁住了。 Sending data 正在处理SELECT查询的记录，同时正在把结果发送给客户端。 Sorting for group 正在为GROUP BY做排序。 Sorting for order 正在为ORDER BY做排序。 Opening tables 这个过程应该会很快，除非受到其他因素的干扰。例如，在执ALTER TABLE或LOCK TABLE语句行完以前，数据表无法被其他线程打开。正尝试打开一个表。 Removing duplicates 正在执行一个SELECT DISTINCT方式的查询，但是MySQL无法在前一个阶段优化掉那些重复的记录。因此，MySQL需要再次去掉重复的记录，然后再把结果发送给客户端。 Reopen table 获得了对一个表的锁，但是必须在表结构修改之后才能获得这个锁。已经释放锁，关闭数据表，正尝试重新打开数据表。 Repair by sorting 修复指令正在排序以创建索引。 Repair with keycache 修复指令正在利用索引缓存一个一个地创建新索引。它会比Repair by sorting慢些。 Searching rows for update 正在讲符合条件的记录找出来以备更新。它必须在UPDATE要修改相关的记录之前就完成了。 Sleeping 正在等待客户端发送新请求. System lock 正在等待取得一个外部的系统锁。如果当前没有运行多个mysqld服务器同时请求同一个表，那么可以通过增加--skip-external-locking参数来禁止外部系统锁。 Upgrading lock INSERT DELAYED正在尝试取得一个锁表以插入新记录。 Updating 正在搜索匹配的记录，并且修改它们。 User Lock 正在等待GET_LOCK()。 Waiting for tables 该线程得到通知，数据表结构已经被修改了，需要重新打开数据表以取得新的结构。然后，为了能的重新打开数据表，必须等到所有其他线程关闭这个表。以下几种情况下会产生这个通知：FLUSH TABLES tbl_name, ALTER TABLE, RENAME TABLE, REPAIR TABLE, ANALYZE TABLE,或OPTIMIZE TABLE。 waiting for handler insert INSERT DELAYED已经处理完了所有待处理的插入操作，正在等待新的请求。 大部分状态对应很快的操作，只要有一个线程保持同一个状态好几秒钟，那么可能是有问题发生了，需要检查一下。 还有其他的状态没在上面中列出来，不过它们大部分只是在查看服务器是否有存在错误是才用得着。   例如如图：     3、explain来了解SQL执行的状态 explain显示了mysql如何使用索引来处理select语句以及连接表。可以帮助选择更好的索引和写出更优化的查询语句。

使用方法，在select语句前加上explain就可以了：

例如：

explain select surname,first_name form a,b where a.id=b.id

结果如图

EXPLAIN列的解释

table 显示这一行的数据是关于哪张表的 type 这是重要的列，显示连接使用了何种类型。从最好到最差的连接类型为const、eq_reg、ref、range、indexhe和ALL possible_keys 显示可能应用在这张表中的索引。如果为空，没有可能的索引。可以为相关的域从WHERE语句中选择一个合适的语句 key 实际使用的索引。如果为NULL，则没有使用索引。很少的情况下，MYSQL会选择优化不足的索引。这种情况下，可以在SELECT语句 中使用USE INDEX（indexname）来强制使用一个索引或者用IGNORE INDEX（indexname）来强制MYSQL忽略索引 key_len 使用的索引的长度。在不损失精确性的情况下，长度越短越好 ref 显示索引的哪一列被使用了，如果可能的话，是一个常数 rows MYSQL认为必须检查的用来返回请求数据的行数 Extra 关于MYSQL如何解析查询的额外信息。将在表4.3中讨论，但这里可以看到的坏的例子是Using temporary和Using filesort，意思MYSQL根本不能使用索引，结果是检索会很慢   extra列返回的描述的意义 Distinct 一旦MYSQL找到了与行相联合匹配的行，就不再搜索了 Not exists MYSQL优化了LEFT JOIN，一旦它找到了匹配LEFT JOIN标准的行，就不再搜索了 Range checked for each Record（index map:#） 没有找到理想的索引，因此对于从前面表中来的每一个行组合，MYSQL检查使用哪个索引，并用它来从表中返回行。这是使用索引的最慢的连接之一 Using filesort 看到这个的时候，查询就需要优化了。MYSQL需要进行额外的步骤来发现如何对返回的行排序。它根据连接类型以及存储排序键值和匹配条件的全部行的行指针来排序全部行 Using index 列数据是从仅仅使用了索引中的信息而没有读取实际的行动的表返回的，这发生在对表的全部的请求列都是同一个索引的部分的时候 Using temporary 看到这个的时候，查询需要优化了。这里，MYSQL需要创建一个临时表来存储结果，这通常发生在对不同的列集进行ORDER BY上，而不是GROUP BY上 Where used 使用了WHERE从句来限制哪些行将与下一张表匹配或者是返回给用户。如果不想返回表中的全部行，并且连接类型ALL或index，这就会发生，或者是查询有问题不同连接类型的解释（按照效率高低的顺序排序） const 表中的一个记录的最大值能够匹配这个查询（索引可以是主键或惟一索引）。因为只有一行，这个值实际就是常数，因为MYSQL先读这个值然后把它当做常数来对待 eq_ref 在连接中，MYSQL在查询时，从前面的表中，对每一个记录的联合都从表中读取一个记录，它在查询使用了索引为主键或惟一键的全部时使用 ref 这个连接类型只有在查询使用了不是惟一或主键的键或者是这些类型的部分（比如，利用最左边前缀）时发生。对于之前的表的每一个行联合，全部记录都将从表中读出。这个类型严重依赖于根据索引匹配的记录多少—越少越好 range 这个连接类型使用索引返回一个范围中的行，比如使用>或<查找东西时发生的情况 index 这个连接类型对前面的表中的每一个记录联合进行完全扫描（比ALL更好，因为索引一般小于表数据） ALL 这个连接类型对于前面的每一个记录联合进行完全扫描，这一般比较糟糕，应该尽量避免      

MySQL - 查看慢SQL

查看MySQL是否启用了查看慢SQL的日志文件 （1） 查看慢SQL日志是否启用 mysql> show variables like 'log_slow_queries'; +------------------+-------+ | Variable_name    | Value | +------------------+-------+ | log_slow_queries | ON    | +------------------+-------+ 1 row in set (0.00 sec) （2） 查看执行慢于多少秒的SQL会记录到日志文件中 mysql> show variables like 'long_query_time'; +-----------------+-------+ | Variable_name   | Value | +-----------------+-------+ | long_query_time | 1     | +-----------------+-------+ 1 row in set (0.00 sec) 这里value=1， 表示1秒   2. 配置my.ini文件（inux下文件名为my.cnf）， 查找到[mysqld]区段，增加日志的配置，如下示例： [mysqld] log="C:/temp/mysql.log" log_slow_queries="C:/temp/mysql_slow.log" long_query_time=1 log指示日志文件存放目录； log_slow_queries指示记录执行时间长的sql日志目录； long_query_time指示多长时间算是执行时间长，单位s。 Linux下这些配置项应该已经存在，只是被注释掉了，可以去掉注释。但直接添加配置项也OK啦。     查询到效率低的 SQL 语句 后，可以通过 EXPLAIN 或者 DESC 命令获取 MySQL 如何执行 SELECT 语句的信息，包括在 SELECT 语句执行过程中表如何连接和连接的顺序，比如我们想计算 2006 年所有公司的销售额，需要关联 sales 表和 company 表，并且对 profit 字段做求和（ sum ）操作，相应 SQL 的执行计划如下： mysql> explain select sum(profit) from sales a,company b where a.company_id = b.id and a.year = 2006\G; *************************** 1. row *************************** id: 1 select_type: SIMPLE table: a type: ALL possible_keys: NULL key: NULL key_len: NULL ref: NULL rows: 12 Extra: Using where *************************** 2. row *************************** id: 1 select_type: SIMPLE table: b type: ALL possible_keys: NULL key: NULL key_len: NULL ref: NULL rows: 12 Extra: Using where 2 rows in set (0.00 sec) 每个列的解释如下： •select_type ：表示 SELECT 的 类型，常见的取值有 SIMPLE （简单表，即不使用表连接或者子查询）、 PRIMARY （主查询，即外层的查询）、 UNION （ UNION 中的第二个或者后面的查询语句）、 SUBQUERY （子查询中的第一个 SELECT ）等。 •table ：输出结果集的表。 •type ：表示表的连接类型，性能由好到差的连接类型为 system （表中仅有一行，即常量表）、 const （单表中最多有一个匹配行，例如 primary key 或者 unique index ）、 eq_ref （对于前面的每一行，在此表中只查询一条记录，简单来说，就是多表连接中使用 primary key 或者 unique index ）、 ref （与 eq_ref 类似，区别在于不是使用 primary key 或者 unique index ，而是使用普通的索引）、 ref_or_null （ 与 ref 类似，区别在于条件中包含对 NULL 的查询 ） 、 index_merge ( 索引合并优化 ) 、 unique_subquery （ in 的后面是一个查询主键字段的子查询）、 index_subquery （ 与 unique_subquery 类似，区别在于 in 的后面是查询非唯一索引字段的子查询）、 range （单表中的范围查询）、 index （对于前面的每一行，都通过查询索引来得到数据）、 all （对于前面的每一行，都通过全表扫描来得到数据）。 •possible_keys ：表示查询时，可能使用的索引。 •key ：表示实际使用的索引。 •key_len ：索引字段的长度。 •rows ：扫描行的数量。 •Extra ：执行情况的说明和描述。 在上面的例子中，已经可以确认是 对 a 表的全表扫描导致效率的不理想，那么 对 a 表的 year 字段创建索引，具体如下： mysql> create index idx_sales_year on sales(year); Query OK, 12 rows affected (0.01 sec) Records: 12 Duplicates: 0 Warnings: 0 创建索引后，这条语句的执行计划如下： mysql> explain select sum(profit) from sales a,company b where a.company_id = b.id and a.year = 2006\G; *************************** 1. row *************************** id: 1 select_type: SIMPLE table: a type: ref possible_keys: idx_sales_year key: idx_sales_year key_len: 4 ref: const rows: 3 Extra: *************************** 2. row *************************** id: 1 select_type: SIMPLE table: b type: ALL possible_keys: NULL key: NULL key_len: NULL ref: NULL rows: 12 Extra: Using where 2 rows in set (0.00 sec) 可以发现建立索引后对 a 表需要扫描的行数明显减少（从全表扫描减少到 3 行），可见索引的使用可以大大提高数据库的访问速度，尤其在表很庞大的时候这种优势更为明显，使用索引优化 sql 是优化问题 sql 的一种常用基本方法，在后面的章节中我们会具体介绍如何使索引来优化 sql 。         本文主要介绍的是MySQL慢查询分析方法，前一段日子，我曾经设置了一次记录在MySQL数据库中对慢于1秒钟的SQL语句进行查询。想起来有几个十分设置的方法，有几个参数的名称死活回忆不起来了，于是重新整理一下，自己做个笔记。 对于排查问题找出性能瓶颈来说，最容易发现并解决的问题就是MySQL慢查询以及没有得用索引的查询。 OK，开始找出MySQL中执行起来不“爽”的SQL语句吧。 MySQL慢查询分析方法一： 这个方法我正在用，呵呵，比较喜欢这种即时性的。 MySQL5.0以上的版本可以支持将执行比较慢的SQL语句记录下来。 MySQL> show variables like 'long%'; 注：这个long_query_time是用来定义慢于多少秒的才算“慢查询” +-----------------+-----------+ | Variable_name | Value | +-----------------+-----------+ | long_query_time | 10.000000 | +-----------------+-----------+ 1 row in set (0.00 sec) MySQL> set long_query_time=1; 注： 我设置了1, 也就是执行时间超过1秒的都算慢查询。 Query OK, 0 rows affected (0.00 sec) MySQL> show variables like 'slow%'; +---------------------+---------------+ | Variable_name | Value | +---------------------+---------------+ | slow_launch_time | 2 | | slow_query_log | ON | 注：是否打开日志记录 | slow_query_log_file | /tmp/slow.log | 注： 设置到什么位置 +---------------------+---------------+ 3 rows in set (0.00 sec) MySQL> set global slow_query_log='ON' 注：打开日志记录 一旦slow_query_log变量被设置为ON，MySQL会立即开始记录。 /etc/my.cnf 里面可以设置上面MySQL全局变量的初始值。 long_query_time=1 slow_query_log_file=/tmp/slow.log MySQL慢查询分析方法二: MySQLdumpslow命令 /path/MySQLdumpslow -s c -t 10 /tmp/slow-log 这会输出记录次数最多的10条SQL语句，其中： -s, 是表示按照何种方式排序，c、t、l、r分别是按照记录次数、时间、查询时间、返回的记录数来排序，ac、at、al、ar，表示相应的倒叙; -t, 是top n的意思，即为返回前面多少条的数据; -g, 后边可以写一个正则匹配模式，大小写不敏感的; 比如 /path/MySQLdumpslow -s r -t 10 /tmp/slow-log 得到返回记录集最多的10个查询。 /path/MySQLdumpslow -s t -t 10 -g “left join” /tmp/slow-log 得到按照时间排序的前10条里面含有左连接的查询语句。   简单点的方法： 打开 my.ini ,找到 [mysqld] 在其下面添加   long_query_time = 2 log-slow-queries = D:/mysql/logs/slow.log #设置把日志写在那里，可以为空，系统会给一个缺省的文件 #log-slow-queries = /var/youpath/slow.log linux下host_name-slow.log log-queries-not-using-indexes   long_query_time 是指执行超过多长时间（单位是秒）的sql会被记录下来，这里设置的是2秒。 以下是mysqldumpslow常用参数说明，详细的可应用mysqldumpslow -help查询。   -s，是表示按照何种方式排序，c、t、l、r分别是按照记录次数、时间、查询时间、返回的记录数来排序（从大到小），ac、at、al、ar表示相应的倒叙。   -t，是top n的意思，即为返回前面多少条数据。 www.2cto.com  -g，后边可以写一个正则匹配模式，大小写不敏感。   接下来就是用mysql自带的慢查询工具mysqldumpslow分析了（mysql的bin目录下 ），我这里的日志文件名字是host-slow.log。   列出记录次数最多的10个sql语句   mysqldumpslow -s c -t 10 host-slow.log   列出返回记录集最多的10个sql语句  mysqldumpslow -s r -t 10 host-slow.log   按照时间返回前10条里面含有左连接的sql语句   mysqldumpslow -s t -t 10 -g "left join" host-slow.log   使用mysqldumpslow命令可以非常明确的得到各种我们需要的查询语句，对MySQL查询语句的监控、分析、优化起到非常大的帮助       在日常开发当中，经常会遇到页面打开速度极慢的情况，通过排除，确定了，是数据库的影响，为了迅速查找具体的SQL，可以通过Mysql的日志记录方法。 -- 打开sql执行记录功能 set global log_output='TABLE'; -- 输出到表 set global log=ON; -- 打开所有命令执行记录功能general_log, 所有语句: 成功和未成功的. set global log_slow_queries=ON; -- 打开慢查询sql记录slow_log, 执行成功的: 慢查询语句和未使用索引的语句 set global long_query_time=0.1; -- 慢查询时间限制(秒) set global log_queries_not_using_indexes=ON; -- 记录未使用索引的sql语句 -- 查询sql执行记录 select * from mysql.slow_log order by 1; -- 执行成功的：慢查询语句,和未使用索引的语句 select * from mysql.general_log order by 1; -- 所有语句： 成功和未成功的. -- 关闭sql执行记录 set global log=OFF; set global log_slow_queries=OFF; -- long_query_time参数说明 -- v4.0, 4.1, 5.0, v5.1 到 5.1.20(包括):不支持毫秒级别的慢查询分析(支持精度为1-10秒); -- 5.1.21及以后版本 :支持毫秒级别的慢查询分析, 如0.1; -- 6.0 到 6.0.3: 不支持毫秒级别的慢查询分析(支持精度为1-10秒); -- 6.0.4及以后:支持毫秒级别的慢查询分析; 通过日志中记录的Sql，迅速定位到具体的文件，优化sql看一下，是否速度提升了呢？         本文针对MySQL数据库服务器查询逐渐变慢的问题， 进行分析，并提出相应的解决办法，具体的分析解决办法如下：会经常发现开发人员查一下没用索引的语句或者没有limit n的语句，这些没语句会对数据库造成很大的影...       本文针对MySQL数据库服务器查询逐渐变慢的问题， 进行分析，并提出相应的解决办法，具体的分析解决办法如下： 会经常发现开发人员查一下没用索引的语句或者没有limit n的语句，这些没语句会对数据库造成很大的影响，例如一个几千万条记录的大表要全部扫描，或者是不停的做filesort，对数据库和服务器造成io影响等。这是镜像库上面的情况。 而到了线上库，除了出现没有索引的语句，没有用limit的语句，还多了一个情况,mysql连接数过多的问题。说到这里，先来看看以前我们的监控做法 1. 部署zabbix等开源分布式监控系统，获取每天的数据库的io，cpu，连接数 2. 部署每周性能统计，包含数据增加量，iostat，vmstat，datasize的情况 3. Mysql slowlog收集，列出top 10 以前以为做了这些监控已经是很完美了，现在部署了mysql节点进程监控之后，才发现很多弊端 第一种做法的弊端: zabbix太庞大，而且不是在mysql内部做的监控，很多数据不是非常准备，现在一般都是用来查阅历史的数据情况 第二种做法的弊端：因为是每周只跑一次，很多情况没法发现和报警 第三种做法的弊端: 当节点的slowlog非常多的时候，top10就变得没意义了，而且很多时候会给出那些是一定要跑的定期任务语句给你。。参考的价值不大 那么我们怎么来解决和查询这些问题呢 对于排查问题找出性能瓶颈来说，最容易发现并解决的问题就是MYSQL的慢查询以及没有得用索引的查询。 OK，开始找出mysql中执行起来不“爽”的SQL语句吧。 方法一： 这个方法我正在用，呵呵，比较喜欢这种即时性的。
01 Mysql5.0以上的版本可以支持将执行比较慢的SQL语句记录下来。
02 mysql> show variables like 'long%'; 注：这个long_query_time是用来定义慢于多少秒的才算“慢查询”
03 +-----------------+-----------+
04 | Variable_name | Value |
05 +-----------------+-----------+
06 | long_query_time | 10.000000 |
07 +-----------------+-----------+
08 1 row in set (0.00 sec)
09 mysql> set long_query_time=1; 注： 我设置了1, 也就是执行时间超过1秒的都算慢查询。
10 Query OK, 0 rows affected (0.00 sec)
11 mysql> show variables like 'slow%';
12 +---------------------+---------------+
13 | Variable_name | Value |
14 +---------------------+---------------+
15 | slow_launch_time | 2 |
16 | slow_query_log | ON | 注：是否打开日志记录
17 | slow_query_log_file | /tmp/slow.log | 注： 设置到什么位置
18 +---------------------+---------------+
19 3 rows in set (0.00 sec)
20 mysql> set global slow_query_log='ON' 注：打开日志记录
21 一旦slow_query_log变量被设置为ON，mysql会立即开始记录。
22 /etc/my.cnf 里面可以设置上面MYSQL全局变量的初始值。
23 long_query_time=1
24 slow_query_log_file=/tmp/slow.log
方法二:mysqldumpslow命令
01 /path/mysqldumpslow -s c -t 10 /tmp/slow-log
02 这会输出记录次数最多的10条SQL语句，其中：
03 -s, 是表示按照何种方式排序，c、t、l、r分别是按照记录次数、时间、查询时间、返回的记录数来排序，ac、at、al、ar，表示相应的倒叙；
04 -t, 是top n的意思，即为返回前面多少条的数据；
05 -g, 后边可以写一个正则匹配模式，大小写不敏感的；
06 比如
07 /path/mysqldumpslow -s r -t 10 /tmp/slow-log
08 得到返回记录集最多的10个查询。
09 /path/mysqldumpslow -s t -t 10 -g “left join” /tmp/slow-log
10 得到按照时间排序的前10条里面含有左连接的查询语句。
最后总结一下节点监控的好处 1． 轻量级的监控，而且是实时的，还可以根据实际的情况来定制和修改 2． 设置了过滤程序，可以对那些一定要跑的语句进行过滤 3． 及时发现那些没有用索引，或者是不合法的查询，虽然这很耗时去处理那些慢语句，但这样可以避免数据库挂掉，还是值得的 4. 在数据库出现连接数过多的时候，程序会自动保存当前数据库的processlist，DBA进行原因查找的时候这可是利器 5. 使用mysqlbinlog 来分析的时候，可以得到明确的数据库状态异常的时间段 有些人会建义我们来做mysql配置文件设置 调节tmp_table_size 的时候发现另外一些参数 Qcache_queries_in_cache 在缓存中已注册的查询数目 Qcache_inserts 被加入到缓存中的查询数目 Qcache_hits 缓存采样数数目 Qcache_lowmem_prunes 因为缺少内存而被从缓存中删除的查询数目 Qcache_not_cached 没有被缓存的查询数目 (不能被缓存的，或由于 QUERY_CACHE_TYPE) Qcache_free_memory 查询缓存的空闲内存总数 Qcache_free_blocks 查询缓存中的空闲内存块的数目 Qcache_total_blocks 查询缓存中的块的总数目 Qcache_free_memory 可以缓存一些常用的查询,如果是常用的sql会被装载到内存。那样会增加数据库访问速度
↧
Viewing all 130 articles
Browse latest View live
Search