1.java中a+=b和a =a+b背后实现的区别
较这两种运算符的区别,可以有以下两个方面的比较: 执行效率和类型转换。
首先说一下执行效率问题
就单纯的执行这两条语句,不考虑编译器的优化的话,a=a+b的执行效率是低于a+=b的,因为它多进行了一步中间变量的操作,而且会多占用一个变量的空间。而Java编译器默认对其进行了优化,优化之后两条语句都当做 a+=b来执行了,所以实际上是没有任何却别的。
其次说一下有关类型转换的区别。
相信大家都碰到过这种情况:
public class Test {
public static void main(String[] args){
int a = 2;
float b = 6;
a+=b; //right
// a=a+b; //error
a=(int) (a+b); //right
}
}
当使用a=a+b的时候,会抛出”Exception in thread "main" java.lang.Error: Unresolved compilation problem: Type mismatch: cannot convert from float to int“的异常,这是可以理解的,如果不使用(int)强制类型转换的话,float 是不能直接复值给int 变量的。我们将a=a+b注释掉,javac编译完之后,再使用反编译软件(例如XJad)打开Test.class文件,会发现源代码被解析成这样子:
即a+=b进行了强制类型转换,和 a=(int)((float)a+b)是等价的!
public class Test
{
public Test()
{
}
public static void main(String args[])
{
int a = 2;
float b = 6F;
a = (int)((float)a + b);
a = (int)((float)a + b);
}
}
到这里我们就明白了为什么a=a+b会抛出异常了。
原因:在Java中,在基本类型进行算术运算的时候,会发生小字节类型向大字节类型转换的现象。如图中 int 类型和float类型进行加法运算时会将 a 先转换为float类型,然后再和b相加。这样结果类型变成了float类型,如果这时候试图把float类型赋值给a时便会抛异常。
2.JDK和JRE
JRE: Java Runtime Environment
JDK:Java Development Kit
JRE顾名思义是java运行时环境,包含了java虚拟机,java基础类库。是使用java语言编写的程序运行所需要的软件环境,是提供给想运行java程序的用户使用的。
JDK顾名思义是java开发工具包,是程序员使用java语言编写java程序所需的开发工具包,是提供给程序员使用的。JDK包含了JRE,同时还包含了编译java源码的编译器javac,还包含了很多java程序调试和分析的工具:jconsole,jvisualvm等工具软件,还包含了java程序编写所需的文档和demo例子程序。
如果你需要运行java程序,只需安装JRE就可以了。如果你需要编写java程序,需要安装JDK。
3.JVM调优工具
jps:虚拟机进程状况工具
jstat:虚拟机统计信息监视工具
jinfo:Java配置信息工具
jmap:Java内存映像工具
jhat:虚拟机堆转储快照工具
jstack:Java堆栈跟踪工具
HSDIS:JIT生成代码反汇编
JConsole:Java监视与管理控制台
VIsualVm:多合一故障处理工具
4.OOM说一下?怎么排查?哪些会导致OOM?
1.java堆溢出:不断创建对象并且GC Roots到对象之间有可达路径避免垃圾回收机制清楚这些对象。用jhat+jmap进行分析, 确认内存中的对象是否是必要的,,也就是要先分清是内存溢出还是内存泄漏,如果是是内存泄漏就查看泄 漏对象到GC Roots的引用链,就能找到是通过怎样的路径关联导致无法自动回收,掌握了泄漏对象的类型信 息和引用链信息就能比较准确的定位泄漏代码的位置
如果不存在泄漏,就是有对象必须活着,就检查堆参数与机器物理内存对比看是否可以调大,代码上是否有 某些对象生命周期过长,持有状态时间过长,尝试减少运行内存的消耗
2.虚拟机栈和本地方法栈溢出:如果线程请求的栈深度大于虚拟机允许的最大深度抛出Stack OverflowError异常
如果虚拟机扩展栈时无法申请到足够的内存空间,抛出OutOfMemoryError异常
5.HTTP状态码
分类 | 分类描述 |
---|---|
1** | 信息,服务器收到请求,需要请求者继续执行操作 |
2** | 成功,操作被成功接收并处理 |
3** | 重定向,需要进一步的操作以完成请求 |
4** | 客户端错误,请求包含语法错误或无法完成请求 |
5** | 服务器错误,服务器在处理请求的过程中发生了错误 |
HTTP状态码列表:
状态码 | 状态码英文名称 | 中文描述 |
---|---|---|
100 | Continue | 继续。客户端应继续其请求 |
101 | Switching Protocols | 切换协议。服务器根据客户端的请求切换协议。只能切换到更高级的协议,例如,切换到HTTP的新版本协议 |
200 | OK | 请求成功。一般用于GET与POST请求 |
201 | Created | 已创建。成功请求并创建了新的资源 |
202 | Accepted | 已接受。已经接受请求,但未处理完成 |
203 | Non-Authoritative Information | 非授权信息。请求成功。但返回的meta信息不在原始的服务器,而是一个副本 |
204 | No Content | 无内容。服务器成功处理,但未返回内容。在未更新网页的情况下,可确保浏览器继续显示当前文档 |
205 | Reset Content | 重置内容。服务器处理成功,用户终端(例如:浏览器)应重置文档视图。可通过此返回码清除浏览器的表单域 |
206 | Partial Content | 部分内容。服务器成功处理了部分GET请求 |
300 | Multiple Choices | 多种选择。请求的资源可包括多个位置,相应可返回一个资源特征与地址的列表用于用户终端(例如:浏览器)选择 |
301 | Moved Permanently | 永久移动。请求的资源已被永久的移动到新URI,返回信息会包括新的URI,浏览器会自动定向到新URI。今后任何新的请求都应使用新的URI代替 |
302 | Found | 临时移动。与301类似。但资源只是临时被移动。客户端应继续使用原有URI |
303 | See Other | 查看其它地址。与301类似。使用GET和POST请求查看 |
304 | Not Modified | 未修改。所请求的资源未修改,服务器返回此状态码时,不会返回任何资源。客户端通常会缓存访问过的资源,通过提供一个头信息指出客户端希望只返回在指定日期之后修改的资源 |
305 | Use Proxy | 使用代理。所请求的资源必须通过代理访问 |
306 | Unused | 已经被废弃的HTTP状态码 |
307 | Temporary Redirect | 临时重定向。与302类似。使用GET请求重定向 |
400 | Bad Request | 客户端请求的语法错误,服务器无法理解 |
401 | Unauthorized | 请求要求用户的身份认证 |
402 | Payment Required | 保留,将来使用 |
403 | Forbidden | 服务器理解请求客户端的请求,但是拒绝执行此请求 |
404 | Not Found | 服务器无法根据客户端的请求找到资源(网页)。通过此代码,网站设计人员可设置"您所请求的资源无法找到"的个性页面 |
405 | Method Not Allowed | 客户端请求中的方法被禁止 |
406 | Not Acceptable | 服务器无法根据客户端请求的内容特性完成请求 |
407 | Proxy Authentication Required | 请求要求代理的身份认证,与401类似,但请求者应当使用代理进行授权 |
408 | Request Time-out | 服务器等待客户端发送的请求时间过长,超时 |
409 | Conflict | 服务器完成客户端的PUT请求是可能返回此代码,服务器处理请求时发生了冲突 |
410 | Gone | 客户端请求的资源已经不存在。410不同于404,如果资源以前有现在被永久删除了可使用410代码,网站设计人员可通过301代码指定资源的新位置 |
411 | Length Required | 服务器无法处理客户端发送的不带Content-Length的请求信息 |
412 | Precondition Failed | 客户端请求信息的先决条件错误 |
413 | Request Entity Too Large | 由于请求的实体过大,服务器无法处理,因此拒绝请求。为防止客户端的连续请求,服务器可能会关闭连接。如果只是服务器暂时无法处理,则会包含一个Retry-After的响应信息 |
414 | Request-URI Too Large | 请求的URI过长(URI通常为网址),服务器无法处理 |
415 | Unsupported Media Type | 服务器无法处理请求附带的媒体格式 |
416 | Requested range not satisfiable | 客户端请求的范围无效 |
417 | Expectation Failed | 服务器无法满足Expect的请求头信息 |
500 | Internal Server Error | 服务器内部错误,无法完成请求 |
501 | Not Implemented | 服务器不支持请求的功能,无法完成请求 |
502 | Bad Gateway | 充当网关或代理的服务器,从远端服务器接收到了一个无效的请求 |
503 | Service Unavailable | 由于超载或系统维护,服务器暂时的无法处理客户端的请求。延时的长度可包含在服务器的Retry-After头信息中 |
504 | Gateway Time-out | 充当网关或代理的服务器,未及时从远端服务器获取请求 |
505 | HTTP Version not supported | 服务器不支持请求的HTTP协议的版本,无法完成处理 |
6.线程池的种类
之前说过ThreadPoolExecutor的用法,jdkExecutors
包下还封装了一些其他类型的线程池。
newFixedThreadPool
public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>());
}
顾名思义,就是创建线程数量固定的线程池,线程池的corePoolSize
和maximumPoolSize
大小一样,并且keepAliveTime
为0,传入的队列LinkedBlockingQueue
为无界队列。在说ThreadPoolExecutor
的时候也说过,传入一个无界队列,maximumPoolSize
参数是不起作用的。
newSingleThreadExecutor
public static ExecutorService newSingleThreadExecutor() {
return new FinalizableDelegatedExecutorService
(new ThreadPoolExecutor(1, 1,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>()));
}
从代码中也能看得出来,corePoolSize
和maximumPoolSize
都是1,keepAliveTime
是0L, 传入的队列是无界队列。线程池中永远只要一个线程在工作。
newCachedThreadPool
public static ExecutorService newCachedThreadPool() {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
60L, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>());
}
可缓存线程池,说道缓存一般离不开过期时间,该线程池也是,corePoolSize
设置为0,maximumPoolSize
设置为int最大值,不同的是,线程池传入的队列是SynchronousQueue
,一个同步队列,该队列没有任何容量,每次插入新数据,必须等待消费完成。当有新任务到达时,线程池没有线程则创建线程处理,处理完成后该线程缓存60秒,过期后回收,线程过期前有新任务到达时,则使用缓存的线程来处理。
newScheduledThreadPool
public static ScheduledExecutorService newScheduledThreadPool(
int corePoolSize, ThreadFactory threadFactory) {
return new ScheduledThreadPoolExecutor(corePoolSize, threadFactory);
}
这个线程池使用了ScheduledThreadPoolExecutor
,该线程池继承自ThreadPoolExecutor
, 执行任务的时候可以指定延迟多少时间执行,或者周期性执行。
7.tomcat的系统架构和组件
https://www.ibm.com/developerworks/cn/java/j-lo-tomcat1/index.html
8.Linux的swap
http://www.cnblogs.com/kerrycode/p/5246383.html
9.10g文件,只有2g内存,怎么查找文件中指定的字符串出现位置。
MapReduce分割文件处理。
他说可以用cat | grep 管道处理。
10.linux常用命令
1. tar
创建一个新的tar文件
$ tar cvf archive_name.tar dirname/
解压tar文件
$ tar xvf archive_name.tar
查看tar文件
$ tar tvf archive_name.tar
更多示例:The Ultimate Tar Command Tutorial with 10 Practical Examples
2. grep
在文件中查找字符串(不区分大小写)
$ grep -i "the" demo_file
输出成功匹配的行,以及该行之后的三行
$ grep -A 3 -i "example" demo_text
在一个文件夹中递归查询包含指定字符串的文件
$ grep -r "ramesh" *
更多示例:Get a Grip on the Grep! – 15 Practical Grep Command Examples
3. find
查找指定文件名的文件(不区分大小写)
$ find -iname "MyProgram.c"
对找到的文件执行某个命令
$ find -iname "MyProgram.c" -exec md5sum {} \;
查找home目录下的所有空文件
$ find ~ -empty
更多示例:Mommy, I found it! — 15 Practical Linux Find Command Examples
4. ssh
登录到远程主机
$ ssh -l jsmith remotehost.example.com
调试ssh客户端
$ ssh -v -l jsmith remotehost.example.com
显示ssh客户端版本
$ ssh -V
更多示例:5 Basic Linux SSH Client Commands
5. sed
当你将Dos系统中的文件复制到Unix/Linux后,这个文件每行都会以\r\n结尾,sed可以轻易将其转换为Unix格式的文件,使用\n结尾的文件
$ sed 's/.$//' filename
反转文件内容并输出
$ sed -n '1!G; h; p' filename
为非空行添加行号
$ sed '/./=' thegeekstuff.txt | sed 'N; s/\n/ /'
更多示例:Advanced Sed Substitution Examples
6. awk
awk '{pattern + action}' {filenames}
尽管操作可能会很复杂,但语法总是这样,其中 pattern 表示 AWK 在数据中查找的内容,而 action 是在找到匹配内容时所执行的一系列命令。花括号({})不需要在程序中始终出现,但它们用于根据特定的模式对一系列指令进行分组。 pattern就是要表示的正则表达式,用斜杠括起来。
awk语言的最基本功能是在文件或者字符串中基于指定规则浏览和抽取信息,awk抽取信息后,才能进行其他文本操作。完整的awk脚本通常用来格式化文本文件中的信息。
通常,awk是以文件的一行为处理单位的。awk每接收文件的一行,然后执行相应的命令,来处理文本。
删除重复行
$ awk '!($0 in array) { array[$0]; print}' temp
打印/etc/passwd中所有包含同样的uid和gid的行
$ awk -F ':' '$3=$4' /etc/passwd
打印文件中的指定部分的字段
$ awk '{print $2,$5;}' employee.txt
更多示例:8 Powerful Awk Built-in Variables – FS, OFS, RS, ORS, NR, NF, FILENAME, FNR
7. vim
打开文件并跳到第10行
$ vim +10 filename.txt
打开文件跳到第一个匹配的行
$ vim +/search-term filename.txt
以只读模式打开文件
$ vim -R /etc/passwd
更多示例:How To Record and Play in Vim Editor
8. diff
比较的时候忽略空白符
$ diff -w name_list.txt name_list_new.txt
9. sort
以升序对文件内容排序
$ sort names.txt
以降序对文件内容排序
$ sort -r names.txt
以第三个字段对/etc/passwd的内容排序
$ sort -t: -k 3n /etc/passwd | more
10. export
输出跟字符串oracle匹配的环境变量
$ export | grep ORCALE
declare -x ORACLE_BASE="/u01/app/oracle"
declare -x ORACLE_HOME="/u01/app/oracle/product/10.2.0"
declare -x ORACLE_SID="med"
declare -x ORACLE_TERM="xterm"
设置全局环境变量
$ export ORACLE_HOME=/u01/app/oracle/product/10.2.0
11. xargs
将所有图片文件拷贝到外部驱动器
$ ls *.jpg | xargs -n1 -i cp {} /external-hard-drive/directory
将系统中所有jpd文件压缩打包
$ find / -name *.jpg -type f -print | xargs tar -cvzf images.tar.gz
下载文件中列出的所有url对应的页面
$ cat url-list.txt | xargs wget –c
12. ls
以易读的方式显示文件大小(显示为MB,GB...)
$ ls -lh
-rw-r----- 1 ramesh team-dev 8.9M Jun 12 15:27 arch-linux.txt.gz
以最后修改时间升序列出文件
$ ls -ltr
在文件名后面显示文件类型
$ ls -F
更多示例:Unix LS Command: 15 Practical Examples
13. pwd
输出当前工作目录
14. cd
cd -
可以在最近工作的两个目录间切换
使用shopt -s cdspell
可以设置自动对cd命令进行拼写检查
更多示例:6 Awesome Linux cd command Hacks
15. gzip
创建一个*.gz的压缩文件
$ gzip test.txt
解压*.gz文件
$ gzip -d test.txt.gz
显示压缩的比率
$ gzip -l *.gz
compressed uncompressed ratio uncompressed_name
23709 97975 75.8% asp-patch-rpms.txt
16. bzip2
创建*.bz2压缩文件
$ bzip2 test.txt
解压*.bz2文件
bzip2 -d test.txt.bz2
更多示例:BZ is Eazy! bzip2, bzgrep, bzcmp, bzdiff, bzcat, bzless, bzmore examples
17. uzip
解压*.zip文件
$ unzip test.zip
查看*.zip文件的内容
$ unzip -l jasper.zip
Archive: jasper.zip
Length Date Time Name
-------- ---- ---- ----
40995 11-30-98 23:50 META-INF/MANIFEST.MF
32169 08-25-98 21:07 classes_
15964 08-25-98 21:07 classes_names
10542 08-25-98 21:07 classes_ncomp
18. shutdown
关闭系统并立即关机
$ shutdown -h now
10分钟后关机
$ shutdown -h +10
重启
$ shutdown -r now
重启期间强制进行系统检查
$ shutdown -Fr now
19. ftp
ftp命令和sftp命令的用法基本相似连接ftp服务器并下载多个文件
$ ftp IP/hostname
ftp> mget *.html
显示远程主机上文件列表
ftp> mls *.html -
/ftptest/features.html
/ftptest/index.html
/ftptest/othertools.html
/ftptest/samplereport.html
/ftptest/usage.html
更多示例:FTP and SFTP Beginners Guide with 10 Examples
20. crontab
查看某个用户的crontab入口
$ crontab -u john -l
设置一个每十分钟执行一次的计划任务
*/10 * * * * /home/ramesh/check-disk-space
更多示例:Linux Crontab: 15 Awesome Cron Job Examples
21. service
service命令用于运行System V init脚本,这些脚本一般位于/etc/init.d文件下,这个命令可以直接运行这个文件夹里面的脚本,而不用加上路径
查看服务状态
$ service ssh status
查看所有服务状态
$ service --status-all
重启服务
$ service ssh restart
22. ps
ps命令用于显示正在运行中的进程的信息,ps命令有很多选项,这里只列出了几个
查看当前正在运行的所有进程
$ ps -ef | more
以树状结构显示当前正在运行的进程,H选项表示显示进程的层次结构
$ ps -efH | more
23. free
这个命令用于显示系统当前内存的使用情况,包括已用内存、可用内存和交换内存的情况
默认情况下free会以字节为单位输出内存的使用量
$ free
total used free shared buffers cached
Mem: 3566408 1580220 1986188 0 203988 902960
-/+ buffers/cache: 473272 3093136
Swap: 4000176 0 4000176
如果你想以其他单位输出内存的使用量,需要加一个选项,-g为GB,-m为MB,-k为KB,-b为字节
$ free -g
total used free shared buffers cached
Mem: 3 1 1 0 0 0
-/+ buffers/cache: 0 2
Swap: 3 0 3
如果你想查看所有内存的汇总,请使用-t选项,使用这个选项会在输出中加一个汇总行
ramesh@ramesh-laptop:~$ free -t
total used free shared buffers cached
Mem: 3566408 1592148 1974260 0 204260 912556
-/+ buffers/cache: 475332 3091076
Swap: 4000176 0 4000176
Total: 7566584 1592148 5974436
24. top
top命令会显示当前系统中占用资源最多的一些进程(默认以CPU占用率排序)如果你想改变排序方式,可以在结果列表中点击O(大写字母O)会显示所有可用于排序的列,这个时候你就可以选择你想排序的列
Current Sort Field: P for window 1:Def
Select sort field via field letter, type any other key to return
a: PID = Process Id v: nDRT = Dirty Pages count
d: UID = User Id y: WCHAN = Sleeping in Function
e: USER = User Name z: Flags = Task Flags
........
如果只想显示某个特定用户的进程,可以使用-u选项
$ top -u oracle
更多示例:Can You Top This? 15 Practical Linux Top Command Examples
25. df
显示文件系统的磁盘使用情况,默认情况下df -k
将以字节为单位输出磁盘的使用量
$ df -k
Filesystem 1K-blocks Used Available Use% Mounted on
/dev/sda1 29530400 3233104 24797232 12% /
/dev/sda2 120367992 50171596 64082060 44% /home
使用-h选项可以以更符合阅读习惯的方式显示磁盘使用量
$ df -h
Filesystem Size Used Avail Capacity iused ifree %iused Mounted on
/dev/disk0s2 232Gi 84Gi 148Gi 37% 21998562 38864868 36% /
devfs 187Ki 187Ki 0Bi 100% 648 0 100% /dev
map -hosts 0Bi 0Bi 0Bi 100% 0 0 100% /net
map auto_home 0Bi 0Bi 0Bi 100% 0 0 100% /home
/dev/disk0s4 466Gi 45Gi 421Gi 10% 112774 440997174 0% /Volumes/BOOTCAMP
//[email protected]/public 2.7Ti 1.3Ti 1.4Ti 48% 0 18446744073709551615 0% /Volumes/public
使用-T选项显示文件系统类型
$ df -T
Filesystem Type 1K-blocks Used Available Use% Mounted on
/dev/sda1 ext4 29530400 3233120 24797216 12% /
/dev/sda2 ext4 120367992 50171596 64082060 44% /home
26. kill
kill用于终止一个进程。一般我们会先用ps -ef
查找某个进程得到它的进程号,然后再使用kill -9 进程号
终止该进程。你还可以使用killall、pkill、xkill来终止进程
$ ps -ef | grep vim
ramesh 7243 7222 9 22:43 pts/2 00:00:00 vim
$ kill -9 7243
更多示例:4 Ways to Kill a Process – kill, killall, pkill, xkill
27. rm
删除文件前先确认
$ rm -i filename.txt
在文件名中使用shell的元字符会非常有用。删除文件前先打印文件名并进行确认
$ rm -i file*
递归删除文件夹下所有文件,并删除该文件夹
$ rm -r example
28. cp
拷贝文件1到文件2,并保持文件的权限、属主和时间戳
$ cp -p file1 file2
拷贝file1到file2,如果file2存在会提示是否覆盖
$ cp -i file1 file2
29. mv
将文件名file1重命名为file2,如果file2存在则提示是否覆盖
$ mv -i file1 file2
注意如果使用-f选项则不会进行提示
-v会输出重命名的过程,当文件名中包含通配符时,这个选项会非常方便
$ mv -v file1 file2
30. cat
你可以一次查看多个文件的内容,下面的命令会先打印file1的内容,然后打印file2的内容
$ cat file1 file2
-n命令可以在每行的前面加上行号
$ cat -n /etc/logrotate.conf
1 /var/log/btmp {
2 missingok
3 monthly
4 create 0660 root utmp
5 rotate 1
6 }
31. mount
如果要挂载一个文件系统,需要先创建一个目录,然后将这个文件系统挂载到这个目录上
# mkdir /u01
# mount /dev/sdb1 /u01
也可以把它添加到fstab中进行自动挂载,这样任何时候系统重启的时候,文件系统都会被加载
/dev/sdb1 /u01 ext2 defaults 0 2
32. chmod
chmod用于改变文件和目录的权限
给指定文件的属主和属组所有权限(包括读、写、执行)
$ chmod ug+rwx file.txt
删除指定文件的属组的所有权限
$ chmod g-rwx file.txt
修改目录的权限,以及递归修改目录下面所有文件和子目录的权限
$ chmod -R ug+rwx file.txt
更多示例:7 Chmod Command Examples for Beginners
33. chown
chown用于改变文件属主和属组
同时将某个文件的属主改为oracle,属组改为db
$ chown oracle:dba dbora.sh
使用-R选项对目录和目录下的文件进行递归修改
$ chown -R oracle:dba /home/oracle
34. passwd
passwd用于在命令行修改密码,使用这个命令会要求你先输入旧密码,然后输入新密码
$ passwd
超级用户可以用这个命令修改其他用户的密码,这个时候不需要输入用户的密码
# passwd USERNAME
passwd还可以删除某个用户的密码,这个命令只有root用户才能操作,删除密码后,这个用户不需要输入密码就可以登录到系统
# passwd -d USERNAME
35. mkdir
在home目录下创建一个名为temp的目录
$ mkdir ~/temp
使用-p选项可以创建一个路径上所有不存在的目录
$ mkdir -p dir1/dir2/dir3/dir4/
36. ifconfig
ifconfig用于查看和配置Linux系统的网络接口
查看所有网络接口及其状态
$ ifconfig -a
使用up和down命令启动或停止某个接口
$ ifconfig eth0 up
$ ifconfig eth0 down
更多示例:Ifconfig: 7 Examples To Configure Network Interface
37. uname
uname可以显示一些重要的系统信息,例如内核名称、主机名、内核版本号、处理器类型之类的信息
$ uname -a
Linux john-laptop 2.6.32-24-generic #41-Ubuntu SMP Thu Aug 19 01:12:52 UTC 2010 i686 GNU/Linux
38. whereis
当你不知道某个命令的位置时可以使用whereis命令,下面使用whereis查找ls的位置
$ whereis ls
ls: /bin/ls /usr/share/man/man1/ls.1.gz /usr/share/man/man1p/ls.1p.gz
当你想查找某个可执行程序的位置,但这个程序又不在whereis的默认目录下,你可以使用-B选项,并指定目录作为这个选项的参数。下面的命令在/tmp目录下查找lsmk命令
$ whereis -u -B /tmp -f lsmk
lsmk: /tmp/lsmk
39. whatis
wathis显示某个命令的描述信息
$ whatis ls
ls (1) - list directory contents
$ whatis ifconfig
ifconfig (8) - configure a network interface
40. locate
locate命名可以显示某个指定文件(或一组文件)的路径,它会使用由updatedb创建的数据库
下面的命令会显示系统中所有包含crontab字符串的文件
$ locate crontab
/etc/anacrontab
/etc/crontab
/usr/bin/crontab
/usr/share/doc/cron/examples/crontab2english.pl.gz
/usr/share/man/man1/crontab.1.gz
/usr/share/man/man5/anacrontab.5.gz
/usr/share/man/man5/crontab.5.gz
/usr/share/vim/vim72/syntax/crontab.vim
41. man
显示某个命令的man页面
$ man crontab
有些命令可能会有多个man页面,每个man页面对应一种命令类型
$ man SECTION-NUMBER commandname
man页面一般可以分为8种命令类型
- 用户命令
- 系统调用
- c库函数
- 设备与网络接口
- 文件格式
- 游戏与屏保
- 环境、表、宏
- 系统管理员命令和后台运行命令
例如,我们执行whatis crontab
,你可以看到crontab有两个命令类型1和5,所以我们可以通过下面的命令查看命令类型5的man页面
$ whatis crontab
crontab (1) - maintain crontab files for individual users (V3)
crontab (5) - tables for driving cron
$ man 5 crontab
42. tail
tail命令默认显示文件最后的10行文本
$ tail filename.txt
你可以使用-n选项指定要显示的行数
$ tail -n N filename.txt
你也可以使用-f选项进行实时查看,这个命令执行后会等待,如果有新行添加到文件尾部,它会继续输出新的行,在查看日志时这个选项会非常有用。你可以通过CTRL-C终止命令的执行
$ tail -f log-file
更多示例:3 Methods To View tail -f output of Multiple Log Files in One Terminal
43. less
这个命名可以在不加载整个文件的前提下显示文件内容,在查看大型日志文件的时候这个命令会非常有用
$ less huge-log-file.log
当你用less命令打开某个文件时,下面两个按键会给你带来很多帮助,他们用于向前和向后滚屏
CTRL+F – forward one window
CTRL+B – backward one window
更多示例:Unix Less Command: 10 Tips for Effective Navigation
44. su
su命令用于切换用户账号,超级用户使用这个命令可以切换到任何其他用户而不用输入密码
$ su - USERNAME
用另外一个用户名执行一个命令下面的示例中用户john使用raj用户名执行ls命令,执行完后返回john的账号
[john@dev-server]$ su - raj -c 'ls'
[john@dev-server]$
用指定用户登录,并且使用指定的shell程序,而不用默认的
$ su -s 'SHELLNAME' USERNAME
45. mysql
mysql可能是Linux上使用最广泛的数据库,即使你没有在你的服务器上安装mysql,你也可以使用mysql客户端连接到远程的mysql服务器
连接一个远程数据库,需要输入密码
$ mysql -u root -p -h 192.168.1.2
连接本地数据库
$ mysql -u root -p
你也可以在命令行中输入数据库密码,只需要在-p后面加上密码作为参数,可以直接写在p后面而不用加空格
46. yum
使用yum安装apache
$ yum install httpd
更新apache
$ yum update httpd
卸载/删除apache
$ yum remove httpd
47. rpm
使用rpm安装apache
# rpm -ivh httpd-2.2.3-22.0.1.el5.i386.rpm
更新apache
# rpm -uvh httpd-2.2.3-22.0.1.el5.i386.rpm
卸载/删除apache
# rpm -ev httpd
更多示例:RPM Command: 15 Examples to Install, Uninstall, Upgrade, Query RPM Packages
48. ping
ping一个远程主机,只发5个数据包
$ ping -c 5 gmail.com
更多示例:Ping Tutorial: 15 Effective Ping Command Examples
49. date
设置系统日期
# date -s "01/31/2010 23:59:53"
当你修改了系统时间,你需要同步硬件时间和系统时间
# hwclock –systohc
# hwclock --systohc –utc
50. wget
使用wget从网上下载软件、音乐、视频
$ wget http://prdownloads.sourceforge.net/sourceforge/nagios/nagios-3.2.1.tar.gz
下载文件并以指定的文件名保存文件
$ wget -O taglist.zip http://www.vim.org/scripts/download_script.php?src_id=7701
11.产生死锁的必要条件
从以上分析可见,如果在计算机系统中同时具备下面四个必要条件时,那麽会发生死锁。换句话说,只要下面四个条件有一个不具备,系统就不会出现死锁。
〈1〉互斥条件。即某个资源在一段时间内只能由一个进程占有,不能同时被两个或两个以上的进程占有。这种独占资源如CD-ROM驱动器,打印机等等,必须在占有该资源的进程主动释放它之后,其它进程才能占有该资源。这是由资源本身的属性所决定的。如独木桥就是一种独占资源,两方的人不能同时过桥。
〈2〉不可抢占条件。进程所获得的资源在未使用完毕之前,资源申请者不能强行地从资源占有者手中夺取资源,而只能由该资源的占有者进程自行释放。如过独木桥的人不能强迫对方后退,也不能非法地将对方推下桥,必须是桥上的人自己过桥后空出桥面(即主动释放占有资源),对方的人才能过桥。
〈3〉占有且申请条件。进程至少已经占有一个资源,但又申请新的资源;由于该资源已被另外进程占有,此时该进程阻塞;但是,它在等待新资源之时,仍继续占用已占有的资源。还以过独木桥为例,甲乙两人在桥上相遇。甲走过一段桥面(即占有了一些资源),还需要走其余的桥面(申请新的资源),但那部分桥面被乙占有(乙走过一段桥面)。甲过不去,前进不能,又不后退;乙也处于同样的状况。
〈4〉循环等待条件。存在一个进程等待序列{P1,P2,...,Pn},其中P1等待P2所占有的某一资源,P2等待P3所占有的某一源,......,而Pn等待P1所占有的的某一资源,形成一个进程循环等待环。就像前面的过独木桥问题,甲等待乙占有的桥面,而乙又等待甲占有的桥面,从而彼此循环等待。 上面我们提到的这四个条件在死锁时会同时发生。也就是说,只要有一个必要条件不满足,则死锁就可以排除。
12.字典树
https://blog.csdn.net/u013309870/article/details/71081393
13.dijkstra
https://www.cnblogs.com/biyeymyhjob/archive/2012/07/31/2615833.html
14.Linux大文件怎么查某一行的内容。
linux查找大文件特定内容 (超过整屏) linux有时候会遇到文件很大,关键字查找都要超过整屏,无法查看到所有内容。 这里可以利用以大划小思想,然后重定向。 比如一个非常大的日志文件info.log,我们要查看某段字符所有日志,可以同 cat info.log | grep ‘1711178968’ ,如果显示过多,此时可以加时间,行数控制。也可以通过 '>>'指令。 cat info.log | grep ‘1711178968’ >> temp.log 将中间结果暂存下来,通过more ,less等工具一页页查看temp.log文件
15.Redis和他的持久化方式
什么是持久化?
Redis的所有数据都保存在内存中,然后不定期的通过异步方式保存到磁盘上(这称为半持久化);也可以把每一次数据变化都写入到磁盘(这称为全持久化)。所谓持久化就是将内存数据转换为硬盘数据,内存模型到存储模型的转换,或者说是瞬时状态与持久状态的相互转换。
Redis有两种持久化方式,默认是snapshot方式,实现方法是定时将内存的快照持久化到硬盘,这种方式的缺点是持久化之后如果出现crash则会丢失一段数据。另外一种是aof方式,在写入内存数据的同时将操作命令保存到日志文件中。
快照方式:
这种快照方式和虚拟机的快照一样,保存某一时刻的完整数据。Redis在使用这种方式做持久化的时候,定期(默认5分钟)会先写入到一个临时文件,写入完成后,会用这个文件去替换上次的旧的文件。这种方式的好处是,任何一次的快照文件都是完整可用的。但是缺点是,它每隔一段时间(默认最快1分钟,最慢15分钟)做一次,所以会存在一段时间的数据丢失。
AOF方式:
这种方式就是把对Redis内存数据的的写指令记录下来,这些指令会被记录在AOF文件的末尾,然后每秒做一次fsync操作(默认每秒一次),把指令在后台在执行一次执行过程其实就是修改磁盘上的数据库内容。所以如果出现故障也只丢失1秒的数据。
上面这种方式就很类似于传统数据库服务器的事务日志。
如果遇到在追加日志的时候遇到意外,可以使用redis-check-aof工具进行日志修复。
因为采用了追加方式,所以AOF会越来越大(这一点又和传统数据库不一样,传统数据库事务日志文件都比较小),因此redis有另外一个机制就是AOF文件重写,当AOF文件达到一个设定的阈值后,会自动启动AOF文件压缩,只保留可以恢复数据的最小指令集。
通过上面的对AOF的描述,可以看到AOF是一个面向过程的,而RDB是面向对象的。
AOF方式的有点:
-
丢失数据最小
AOF方式的缺点:
-
同等数据量,AOF文件比RDB文件体积大
-
AOF恢复速度比RDB方式慢
16.秒杀系统设计
一、为什么难 秒杀系统难做的原因:库存只有一份,所有人会在集中的时间读和写这些数据。 例如小米手机每周二的秒杀,可能手机只有1万部,但瞬时进入的流量可能是几百几千万。 又例如12306抢票,亦与秒杀类似,瞬时流量更甚。
二、常见架构 流量到了亿级别,常见站点架构如上:
1)浏览器端,最上层,会执行到一些JS代码
2)站点层,这一层会访问后端数据,拼html页面返回给浏览器
3)服务层,向上游屏蔽底层数据细节
4)数据层,最终的库存是存在这里的,mysql是一个典型
三、优化方向
1)将请求尽量拦截在系统上游:传统秒杀系统之所以挂,请求都压倒了后端数据层,数据读写锁冲突严重,并发高响应慢,几乎所有请求都超时,流量虽大,下单成功的有效流量甚小【一趟火车其实只有2000张票,200w个人来买,基本没有人能买成功,请求有效率为0】
2)充分利用缓存:这是一个典型的读多写少的应用场景【一趟火车其实只有2000张票,200w个人来买,最多2000个人下单成功,其他人都是查询库存,写比例只有0.1%,读比例占99.9%】,非常适合使用缓存
四、优化细节
4.1)浏览器层请求拦截 点击了“查询”按钮之后,系统那个卡呀,进度条涨的慢呀,作为用户,我会不自觉的再去点击“查询”,继续点,继续点,点点点。。。有用么?平白无故的增加了系统负载(一个用户点5次,80%的请求是这么多出来的),怎么整?
a)产品层面,用户点击“查询”或者“购票”后,按钮置灰,禁止用户重复提交请求
b)JS层面,限制用户在x秒之内只能提交一次请求 如此限流,80%流量已拦。
4.2)站点层请求拦截与页面缓存 浏览器层的请求拦截,只能拦住小白用户(不过这是99%的用户哟),高端的程序员根本不吃这一套,写个for循环,直接调用你后端的http请求,怎么整?
a)同一个uid,限制访问频度,做页面缓存,x秒内到达站点层的请求,均返回同一页面
b)同一个item的查询,例如手机车次,做页面缓存,x秒内到达站点层的请求,均返回同一页面 如此限流,又有99%的流量会被拦截在站点层
4.3)服务层请求拦截与数据缓存 站点层的请求拦截,只能拦住普通程序员,高级黑客,假设他控制了10w台肉鸡(并且假设买票不需要实名认证),这下uid的限制不行了吧?怎么整?
a)大哥,我是服务层,我清楚的知道小米只有1万部手机,我清楚的知道一列火车只有2000张车票,我透10w个请求去数据库有什么意义呢?对于写请求,做请求队列,每次只透有限的写请求去数据层,如果均成功再放下一批,如果库存不够则队列里的写请求全部返回“已售完”
b)对于读请求,还要我说么?cache抗,不管是memcached还是redis,单机抗个每秒10w应该都是没什么问题的 如此限流,只有非常少的写请求,和非常少的读缓存mis的请求会透到数据层去,又有99.9%的请求被拦住了
4.4)数据层闲庭信步 到了数据这一层,几乎就没有什么请求了,单机也能扛得住,还是那句话,库存是有限的,小米的产能有限,透这么多请求来数据库没有意义。
五、总结 没什么总结了,上文应该描述的非常清楚了,对于秒杀系统,再次重复下笔者的两个架构优化思路:
1)尽量将请求拦截在系统上游 2)读多写少的常用多使用缓存
17.为什么要有timewait
可靠地实现了TCP全双工连接的终止 我们知道,TCP是比较可靠的。当TCP向另一端发送数据时,他要求对端返回一个确认(如同我们关闭时候的FIN和ACK)。如果没有收到确认,则会重发。 回忆一下我们最终的那个FIN与ACK,被动关闭方发送FIN,并等待主动关闭方返回的ACK。我们假设最终的ACK丢失,被动关闭方将需要重新发送它的最终那个FIN,主动关闭方必须维护状态信息(TIME_WAIT),以允许它重发最终的那个ACK。 如果没有了这个状态,当他第二次收到FIN时,会响应一个RST(也是一种类型的TCP分节),会被服务器解释成一个错误。 为了TCP打算执行必要的工作以彻底终止某个连接两个方向上的数据流(即全双工关闭),那么他必须要正确处理连接终止四个分节中任何一个分节丢失的情况。
18.TCP粘包问题分析和解决
https://blog.csdn.net/tiandijun/article/details/41961785
19.关于HTTP请求GET和POST的区别
1.GET提交,请求的数据会附在URL之后(就是把数据放置在HTTP协议头<request-line>中),以?分割URL和传输数据,多个参数用&连接;例如:login.action?name=hyddd&password=idontknow&verify=%E4%BD%A0 %E5%A5%BD。如果数据是英文字母/数字,原样发送,如果是空格,转换为+,如果是中文/其他字符,则直接把字符串用BASE64加密,得出如: %E4%BD%A0%E5%A5%BD,其中%XX中的XX为该符号以16进制表示的ASCII。
POST提交:把提交的数据放置在是HTTP包的包体<request-body>中。上文示例中红色字体标明的就是实际的传输数据
因此,GET提交的数据会在地址栏中显示出来,而POST提交,地址栏不会改变
2.传输数据的大小:
首先声明,HTTP协议没有对传输的数据大小进行限制,HTTP协议规范也没有对URL长度进行限制。 而在实际开发中存在的限制主要有:
GET:特定浏览器和服务器对URL长度有限制,例如IE对URL长度的限制是2083字节(2K+35)。对于其他浏览器,如Netscape、FireFox等,理论上没有长度限制,其限制取决于操作系统的支持。
因此对于GET提交时,传输数据就会受到URL长度的限制。
POST:由于不是通过URL传值,理论上数据不受限。但实际各个WEB服务器会规定对post提交数据大小进行限制,Apache、IIS6都有各自的配置。
3.安全性:
POST的安全性要比GET的安全性高。注意:这里所说的安全性和上面GET提到的“安全”不是同个概念。上面“安全”的含义仅仅是不作数据修改,而这里安全的含义是真正的Security的含义,比如:通过GET提交数据,用户名和密码将明文出现在URL上,因为(1)登录页面有可能被浏览器缓存, (2)其他人查看浏览器的历史纪录,那么别人就可以拿到你的账号和密码了
20.HTTP请求、响应报文格式
https://blog.csdn.net/a19881029/article/details/14002273
21.数据库缓存一致性模式
缓存是现在系统中必不可少的模块,并且已经成为了高并发高性能架构的一个关键组件。这篇博客我们来分析一下使用缓存的正确姿势。
缓存能解决的问题
-
提升性能
绝大多数情况下,select 是出现性能问题最大的地方。一方面,select 会有很多像 join、group、order、like 等这样丰富的语义,而这些语义是非常耗性能的;另一方面,大多数应用都是读多写少,所以加剧了慢查询的问题。
分布式系统中远程调用也会耗很多性能,因为有网络开销,会导致整体的响应时间下降。为了挽救这样的性能开销,在业务允许的情况(不需要太实时的数据)下,使用缓存是非常必要的事情。
-
缓解数据库压力
当用户请求增多时,数据库的压力将大大增加,通过缓存能够大大降低数据库的压力。
缓存的适用场景
-
对于数据实时性要求不高
对于一些经常访问但是很少改变的数据,读明显多于写,适用缓存就很有必要。比如一些网站配置项。
-
对于性能要求高
比如一些秒杀活动场景。
缓存三种模式
一般来说,缓存有以下三种模式:
-
Cache Aside 更新模式
-
Read/Write Through 更新模式
-
Write Behind Caching 更新模式
通俗一点来讲就是,同时更新缓存和数据库(Cache Aside 更新模式);先更新缓存,缓存负责同步更新数据库(Read/Write Through 更新模式);先更新缓存,缓存定时异步更新数据库(Write Behind Caching 更新模式)。这三种模式各有优劣,可以根据业务场景选择使用。
Cache Aside 更新模式
这是最常用的缓存模式了,具体的流程是:
- 失效:应用程序先从 cache 取数据,没有得到,则从数据库中取数据,成功后,放到缓存中。
- 命中:应用程序从 cache 中取数据,取到后返回。
- 更新:先把数据存到数据库中,成功后,再让缓存失效。
Cache Aside 更新模式流程图
注意我们上面所提到的,缓存更新时先更新数据库,然后在让缓存失效。那么为什么不是直接更新缓存呢?这里有一些缓存更新的坑,我们需要避免入坑。
避坑指南一
先更新数据库,再更新缓存。这种做法最大的问题就是两个并发的写操作导致脏数据。如下图(以Redis和Mysql为例),两个并发更新操作,数据库先更新的反而后更新缓存,数据库后更新的反而先更新缓存。这样就会造成数据库和缓存中的数据不一致,应用程序中读取的都是脏数据。
避坑指南二
先删除缓存,再更新数据库。这个逻辑是错误的,因为两个并发的读和写操作导致脏数据。如下图(以Redis和Mysql为例)。假设更新操作先删除了缓存,此时正好有一个并发的读操作,没有命中缓存后从数据库中取出老数据并且更新回缓存,这个时候更新操作也完成了数据库更新。此时,数据库和缓存中的数据不一致,应用程序中读取的都是原来的数据(脏数据)。
避坑指南三
先更新数据库,再删除缓存。这种做法其实不能算是坑,在实际的系统中也推荐使用这种方式。但是这种方式理论上还是可能存在问题。如下图(以Redis和Mysql为例),查询操作没有命中缓存,然后查询出数据库的老数据。此时有一个并发的更新操作,更新操作在读操作之后更新了数据库中的数据并且删除了缓存中的数据。然而读操作将从数据库中读取出的老数据更新回了缓存。这样就会造成数据库和缓存中的数据不一致,应用程序中读取的都是原来的数据(脏数据)。
但是,仔细想一想,这种并发的概率极低。因为这个条件需要发生在读缓存时缓存失效,而且有一个并发的写操作。实际上数据库的写操作会比读操作慢得多,而且还要加锁,而读操作必需在写操作前进入数据库操作,又要晚于写操作更新缓存,所有这些条件都具备的概率并不大。但是为了避免这种极端情况造成脏数据所产生的影响,我们还是要为缓存设置过期时间。
Read/Write Through 更新模式
在上面的 Cache Aside 更新模式中,应用代码需要维护两个数据存储,一个是缓存(Cache),一个是数据库(Repository)。而在Read/Write Through 更新模式中,应用程序只需要维护缓存,数据库的维护工作由缓存代理了。
Read/Write Through 更新模式流程图
Read Through
Read Through 模式就是在查询操作中更新缓存,也就是说,当缓存失效的时候,Cache Aside 模式是由调用方负责把数据加载入缓存,而 Read Through 则用缓存服务自己来加载。
Write Through
Write Through 模式和 Read Through 相仿,不过是在更新数据时发生。当有数据更新的时候,如果没有命中缓存,直接更新数据库,然后返回。如果命中了缓存,则更新缓存,然后由缓存自己更新数据库(这是一个同步操作)。
Write Behind Caching 更新模式
Write Behind Caching 更新模式就是在更新数据的时候,只更新缓存,不更新数据库,而我们的缓存会异步地批量更新数据库。这个设计的好处就是直接操作内存速度快。因为异步,Write Behind Caching 更新模式还可以合并对同一个数据的多次操作到数据库,所以性能的提高是相当可观的。
但其带来的问题是,数据不是强一致性的,而且可能会丢失。另外,Write Behind Caching 更新模式实现逻辑比较复杂,因为它需要确认有哪些数据是被更新了的,哪些数据需要刷到持久层上。只有在缓存需要失效的时候,才会把它真正持久起来。
Write Behind Caching 更新模式流程图
总结
三种缓存模式的优缺点:
- Cache Aside 更新模式实现起来比较简单,但是需要维护两个数据存储,一个是缓存(Cache),一个是数据库(Repository)。
- Read/Write Through 更新模式只需要维护一个数据存储(缓存),但是实现起来要复杂一些。
- Write Behind Caching 更新模式和Read/Write Through 更新模式类似,区别是Write Behind Caching 更新模式的数据持久化操作是异步的,但是Read/Write Through 更新模式的数据持久化操作是同步的。优点是直接操作内存速度快,多次操作可以合并持久化到数据库。缺点是数据可能会丢失,例如系统断电等。
缓存是通过牺牲强一致性来提高性能的。所以使用缓存提升性能,就是会有数据更新的延迟。这需要我们在设计时结合业务仔细思考是否适合用缓存。然后缓存一定要设置过期时间,这个时间太短太长都不好,太短的话请求可能会比较多的落到数据库上,这也意味着失去了缓存的优势。太长的话缓存中的脏数据会使系统长时间处于一个延迟的状态,而且系统中长时间没有人访问的数据一直存在内存中不过期,浪费内存。
22.查看本机ip
win:ipconfig/all Linux:ifconfig
23.如何查看网络延时
win:ping Linux:mtr
24.CPU负载
昨天查看Nagios警报信息,发现其中一台服务器CPU负载过重,机器为CentOS系统。信息如下:
- 2011-2-15 (星期二) 17:50
- WARNING - load average: 9.73, 10.67, 10.49
还有前两个小时发出的警报信息:
- 2011-2-15 (星期二) 16:50
- WARNING - load average: 10.52, 10.10, 10.06
- 2011-2-15 (星期二) 15:40
- WARNING - load average: 8.27, 9.23, 9.48
一、警报信息的三个参数到底是什么意思?
9.73、10.67、10.49分别代表前一分钟,五分钟,十五分钟的平均CPU负载,最重要的指标是最后一个数字,即前15分钟的平均CPU负载,这个数字越小越好。所谓CPU负载指的是一段时间内任务队列的长度,通俗的讲,就是一段时间内一共有多少任务在使用或等待使用CPU。
二、除了Nagios,还有哪些工具可以查看CPU负载?
可以使用top命令、uptime命令,特别是top命令,功能强大,不仅仅可以用来查看CPU负载。
三、CPU负载怎么理解?是不是CPU利用率?
这里要区别CPU负载和CPU利用率,它们是不同的两个概念,但它们的信息可以在同一个top命令中进行显示。CPU利用率显示的是程序在运行期间实时占用的CPU百分比,而CPU负载显示的是一段时间内正在使用和等待使用CPU的平均任务数。CPU利用率高,并不意味着负载就一定大。网上有篇文章举了一个有趣比喻,拿打电话来说明两者的区别,我按自己的理解阐述一下。
某公用电话亭,有一个人在打电话,四个人在等待,每人限定使用电话一分钟,若有人一分钟之内没有打完电话,只能挂掉电话去排队,等待下一轮。电话在这里就相当于CPU,而正在或等待打电话的人就相当于任务数。
在电话亭使用过程中,肯定会有人打完电话走掉,有人没有打完电话而选择重新排队,更会有新增的人在这儿排队,这个人数的变化就相当于任务数的增减。为了统计平均负载情况,我们5秒钟统计一次人数,并在第1、5、15分钟的时候对统计情况取平均值,从而形成第1、5、15分钟的平均负载。
有的人拿起电话就打,一直打完1分钟,而有的人可能前三十秒在找电话号码,或者在犹豫要不要打,后三十秒才真正在打电话。如果把电话看作CPU,人数看作任务,我们就说前一个人(任务)的CPU利用率高,后一个人(任务)的CPU利用率低。
当然, CPU并不会在前三十秒工作,后三十秒歇着,只是说,有的程序涉及到大量的计算,所以CPU利用率就高,而有的程序牵涉到计算的部分很少,CPU利用率自然就低。但无论CPU的利用率是高是低,跟后面有多少任务在排队没有必然关系。
25.cookies和session的区别,cookie是怎么传到前端的
1、Cookie 在客户端(浏览器),Session 在服务器端。
2、Cookie的安全性一般,他人可通过分析存放在本地的Cookie并进行Cookie欺骗。在安全性第一的前提下,选择Session更优。重要交互信息比如权限等就要放在Session中,一般的信息记录放Cookie就好了。
3、单个Cookie保存的数据不能超过4K,很多浏览器都限制一个站点最多保存20个Cookie。
4、Session 可以放在 文件、数据库或内存中,比如在使用Node时将Session保存在redis中。由于一定时间内它是保存在服务器上的,当访问增多时,会较大地占用服务器的性能。考虑到减轻服务器性能方面,应当适时使用Cookie。
5、Session 的运行依赖Session ID,而 Session ID 是存在 Cookie 中的,也就是说,如果浏览器禁用了 Cookie,Session 也会失效(但是可以通过其它方式实现,比如在 url 中传递 Session ID)。
6、用户验证这种场合一般会用 Session。因此,维持一个会话的核心就是客户端的唯一标识,即Session ID。
服务器通过发送一个名为 Set-Cookie
的HTTP头来创建一个cookie,作为 Response Headers 的一部分
26.SSL和TLS的差别
TLS与SSL连接过程无任何差异 SSL与TLS两者所使用的算法是不同的,SSL使用的是MAC哈希算法,TLS使用的是RFC-2104定义的HMAC算法,两者差异是在填充字节与密钥之间一个使用的是连接运算,一个使用的是异或运算,MAC和HMAC在取值范围也是不同的,但是安全度是相同的! SSL可以分为两个协议,SSL记录协议(SSL Record Protocol)为TCP协议在通信提交数据时提供数据封装、压缩、加密等基本操作! SSL握手协议(SSL Handshake Protocol)它建立在SSL记录协议之上,用于在实际的数据传输开始前,通讯双方进行身份认证、协商加密算法、交换加密密钥等。 TLS与SSL的两个协议工作方式与SSL一样! SSL所使用的版本为3.0,版本号也为3.0.x(x代表未知数因为SSL还在更新),而TLS版本为1.0,但版本号却为SSL3.1.0! TLS增加了许多新的报警代码,比如解密失败(decryption_failed)、记录溢出(record_overflow)、未知CA(unknown_ca)、拒绝访问(access_denied)等,但同时也支持SSL协议上所有的报警代码! TLS和SSL不能共用,因为在认证证书时TLS指定必须与TLS之间交换证书,因为TLS与SSL所使用的加密算法是不同的,所以不能把TLS与SSL一并使用! 在加密数据前会额外填充一部分在SSL中,填充后的数据长度要达到密文块长度的最小整数倍,而在TLS中,填充后的数据长度可以是密文块长度的任意整数倍(但填充的最大长度为255字节),并和公开密钥拼接,随后在跟着密文,这种方式可以防止基于对报文长度进行分析的攻击! TLS对随机数算法也进行了增强,TLS所使用的随机数算法是HMAC中定义的PRF来完成的,PRF使用两种散列算法保证其安全性。如果任一算法暴露了,只要第二种算法未暴露,则数据仍然是安全的,而SSL则使用的是MAC算法生成的随机只是用了一种散列算法!
27.单点登录的三种实现方式
单点登录SSO(Single Sign On)说得简单点就是在一个多系统共存的环境下,用户在一处登录后,就不用在其他系统中登录,也就是用户的一次登录能得到其他所有系统的信任。单点登录在大型网站里使用得非常频繁,例如像阿里巴巴这样的网站,在网站的背后是成百上千的子系统,用户一次操作或交易可能涉及到几十个子系统的协作,如果每个子系统都需要用户认证,不仅用户会疯掉,各子系统也会为这种重复认证授权的逻辑搞疯掉。实现单点登录说到底就是要解决如何产生和存储那个信任,再就是其他系统如何验证这个信任的有效性,因此要点也就以下两个:
- 存储信任
- 验证信任
如果一个系统做到了开头所讲的效果,也就算单点登录,单点登录有不同的实现方式,本文就罗列我开发中所遇见过的实现方式。
以Cookie作为凭证媒介
最简单的单点登录实现方式,是使用cookie作为媒介,存放用户凭证。 用户登录父应用之后,应用返回一个加密的cookie,当用户访问子应用的时候,携带上这个cookie,授权应用解密cookie并进行校验,校验通过则登录当前用户。
不难发现以上方式把信任存储在客户端的Cookie中,这种方式很容易令人质疑:
- Cookie不安全
- 不能跨域实现免登
对于第一个问题,通过加密Cookie可以保证安全性,当然这是在源代码不泄露的前提下。如果Cookie的加密算法泄露,攻击者通过伪造Cookie则可以伪造特定用户身份,这是很危险的。 对于第二个问题,更是硬伤。
通过JSONP实现
对于跨域问题,可以使用JSONP实现。 用户在父应用中登录后,跟Session匹配的Cookie会存到客户端中,当用户需要登录子应用的时候,授权应用访问父应用提供的JSONP接口,并在请求中带上父应用域名下的Cookie,父应用接收到请求,验证用户的登录状态,返回加密的信息,子应用通过解析返回来的加密信息来验证用户,如果通过验证则登录用户。
这种方式虽然能解决跨域问题,但是安全性其实跟把信任存储到Cookie是差不多的。如果一旦加密算法泄露了,攻击者可以在本地建立一个实现了登录接口的假冒父应用,通过绑定Host来把子应用发起的请求指向本地的假冒父应用,并作出回应。 因为攻击者完全可以按照加密算法来伪造响应请求,子应用接收到这个响应之后一样可以通过验证,并且登录特定用户。
通过页面重定向的方式
最后一种介绍的方式,是通过父应用和子应用来回重定向中进行通信,实现信息的安全传递。 父应用提供一个GET方式的登录接口,用户通过子应用重定向连接的方式访问这个接口,如果用户还没有登录,则返回一个的登录页面,用户输入账号密码进行登录。如果用户已经登录了,则生成加密的Token,并且重定向到子应用提供的验证Token的接口,通过解密和校验之后,子应用登录当前用户。
这种方式较前面两种方式,接解决了上面两种方法暴露出来的安全性问题和跨域的问题,但是并没有前面两种方式方便。 安全与方便,本来就是一对矛盾。
使用独立登录系统
一般说来,大型应用会把授权的逻辑与用户信息的相关逻辑独立成一个应用,称为用户中心。 用户中心不处理业务逻辑,只是处理用户信息的管理以及授权给第三方应用。第三方应用需要登录的时候,则把用户的登录请求转发给用户中心进行处理,用户处理完毕返回凭证,第三方应用验证凭证,通过后就登录用户。
28.红黑树
1.红黑树有哪些性质?
一般的,红黑树,满足以下性质,即只有满足以下全部性质的树,我们才称之为红黑树:
1)每个结点要么是红的,要么是黑的。
2)根结点是黑的。
3)每个叶结点(叶结点即指树尾端NIL指针或NULL结点)是黑的。
4)如果一个结点是红的,那么它的俩个儿子都是黑的。
5)对于任一结点而言,其到叶结点树尾端NIL指针的每一条路径都包含相同数目的黑结点。
2.红黑树和AVL树
首先红黑树是不符合AVL树的平衡条件的,即每个节点的左子树和右子树的高度最多差1的二叉查找树。但是提出了为节点增加颜色,红黑是用非严格的平衡来换取增删节点时候旋转次数的降低,任何不平衡都会在三次旋转之内解决,而AVL是严格平衡树,因此在增加或者删除节点的时候,根据不同情况,旋转的次数比红黑树要多。所以红黑树的插入效率更高
1 好处 及 用途
红黑树并不追求“完全平衡”——它只要求部分地达到平衡要求,降低了对旋转的要求,从而提高了性能。 红黑树能够以O(log2 n) 的时间复杂度进行搜索、插入、删除操作。此外,由于它的设计,任何不平衡都会在三次旋转之内解决。当然,还有一些更好的,但实现起来更复杂的数据结构 能够做到一步旋转之内达到平衡,但红黑树能够给我们一个比较“便宜”的解决方案。红黑树的算法时间复杂度和AVL相同,但统计性能比AVL树更高。
当然,红黑树并不适应所有应用树的领域。如果数据基本上是静态的,那么让他们待在他们能够插入,并且不影响平衡的地方会具有更好的性能。如果数据完全是静态的,例如,做一个哈希表,性能可能会更好一些。 在实际的系统中,例如,需要使用动态规则的防火墙系统,使用红黑树而不是散列表被实践证明具有更好的伸缩性。 典型的用途是实现关联数组
2 AVL树是最先发明的自平衡二叉查 找树。在AVL树中任何节点的两个儿子子树的高度最大差别为一,所以它也被称为高度平衡树。查找、插入和删除在平均和最坏情况下都是O(log n)。增加和删除可能需要通过一次或多次树旋转来重新平衡这个树。AVL树得名于它的发明者 G.M. Adelson-Velsky 和 E.M. Landis,他们在 1962 年的论文 "An algorithm for the organization of information" 中发表了它。
引入二叉树的目的是为了提高二叉树的搜索的效率,减少树的平均搜索长度.为此,就必须每向二叉树插入一个结点时调整树的结构,使得二叉树搜索保持平衡,从而可能降低树的高度,减少的平均树的搜索长度. AVL树的定义: 一棵AVL树满足以下的条件:
1>它的左子树和右子树都是AVL树
2>左子树和右子树的高度差不能超过1 从条件1可能看出是个递归定义,如GNU一样.
性质: 1>一棵n个结点的AVL树的其高度保持在0(log2(n)),不会超过3/2log2(n+1)
2>一棵n个结点的AVL树的平均搜索长度保持在0(log2(n)).
3>一棵n个结点的AVL树删除一个结点做平衡化旋转所需要的时间为0(log2(n)).
从1这点来看红黑树是牺牲了严格的高度平衡的优越条件为 代价红黑树能够以O(log2 n)的时间复杂度进行搜索、插入、删除操作。此外,由于它的设计,任何不平衡都会在三次旋转之内解决。当然,还有一些更好的,但实现起来更复杂的数据结构 能够做到一步旋转之内达到平衡,但红黑树能够给我们一个比较“便宜”的解决方案。红黑树的算法时间复杂度和AVL相同,但统计性能比AVL树更高.
https://blog.csdn.net/benpaobagzb/article/details/50805711
29.JVM调优参数
常见配置汇总
堆设置
-Xms:初始堆大小
-Xmx:最大堆大小
-XX:NewSize=n:设置年轻代大小
-XX:NewRatio=n:设置年轻代和年老代的比值。如:为3,表示年轻代与年老代比值为1:3,年轻代占整个年轻代年老代和的1/4
-XX:SurvivorRatio=n:年轻代中Eden区与两个Survivor区的比值。注意Survivor区有两个。如:3,表示Eden:Survivor=3:2,一个Survivor区占整个年轻代的1/5
-XX:MaxPermSize=n:设置持久代大小
收集器设置
-XX:+UseSerialGC:设置串行收集器
-XX:+UseParallelGC:设置并行收集器
-XX:+UseParalledlOldGC:设置并行年老代收集器
-XX:+UseConcMarkSweepGC:设置并发收集器
垃圾回收统计信息
-XX:+PrintGC
-XX:+PrintGCDetails
-XX:+PrintGCTimeStamps
-Xloggc:filename
并行收集器设置
-XX:ParallelGCThreads=n:设置并行收集器收集时使用的CPU数。并行收集线程数。
-XX:MaxGCPauseMillis=n:设置并行收集最大暂停时间
-XX:GCTimeRatio=n:设置垃圾回收时间占程序运行时间的百分比。公式为1/(1+n)
并发收集器设置
-XX:+CMSIncrementalMode:设置为增量模式。适用于单CPU情况。
-XX:ParallelGCThreads=n:设置并发收集器年轻代收集方式为并行收集时,使用的CPU数。并行收集线程数。
调优总结
年轻代大小选择
响应时间优先的应用:尽可能设大,直到接近系统的最低响应时间限制(根据实际情况选择)。在此种情况下,年轻代收集发生的频率也是最小的。同时,减少到达年老代的对象。
吞吐量优先的应用:尽可能的设置大,可能到达Gbit的程度。因为对响应时间没有要求,垃圾收集可以并行进行,一般适合8CPU以上的应用。
年老代大小选择
响应时间优先的应用:年老代使用并发收集器,所以其大小需要小心设置,一般要考虑并发会话率和会话持续时间等一些参数。如果堆设置小了,可以会造成内存碎片、高回收频率以及应用暂停而使用传统的标记清除方式;如果堆大了,则需要较长的收集时间。最优化的方案,一般需要参考以下数据获得:
并发垃圾收集信息
持久代并发收集次数
传统GC信息
花在年轻代和年老代回收上的时间比例
减少年轻代和年老代花费的时间,一般会提高应用的效率
吞吐量优先的应用:一般吞吐量优先的应用都有一个很大的年轻代和一个较小的年老代。原因是,这样可以尽可能回收掉大部分短期对象,减少中期的对象,而年老代尽存放长期存活对象。
较小堆引起的碎片问题
因为年老代的并发收集器使用标记、清除算法,所以不会对堆进行压缩。当收集器回收时,他会把相邻的空间进行合并,这样可以分配给较大的对象。但是,当堆空间较小时,运行一段时间以后,就会出现“碎片”,如果并发收集器找不到足够的空间,那么并发收集器将会停止,然后使用传统的标记、清除方式进行回收。如果出现“碎片”,可能需要进行如下配置:
-XX:+UseCMSCompactAtFullCollection:使用并发收集器时,开启对年老代的压缩。
-XX:CMSFullGCsBeforeCompaction=0:上面配置开启的情况下,这里设置多少次Full GC后,对年老代进行压缩
30.大端和小端
二、什么是大端和小端 Big-Endian和Little-Endian的定义如下:
1) Little-Endian就是低位字节排放在内存的低地址端,高位字节排放在内存的高地址端。
2) Big-Endian就是高位字节排放在内存的低地址端,低位字节排放在内存的高地址端。
31.二叉树的各种遍历
https://blog.csdn.net/zlp1992/article/details/51406067
32.新生代对象进入老年代的条件
新生代转移到老年代的触发条件:
1、长期存活的对象
2、大对象直接进入老年代
3、minor gc后,survivor仍然放不下
4、动态年龄判断 ,大于等于某个年龄的对象超过了survivor空间一半 ,大于等于某个年龄的对象直接进入老年代
33.多线程求和
https://blog.csdn.net/hagle_wang/article/details/78759725
34.tomcat类加载器
当应用需要到某个类时,则会按照下面的顺序进行类加载:
1 使用bootstrap引导类加载器加载
2 使用system系统类加载器加载
3 使用应用类加载器在WEB-INF/classes中加载
4 使用应用类加载器在WEB-INF/lib中加载
5 使用common类加载器在CATALINA_HOME/lib中加载
35.三种主流流媒体协议介绍
一、介绍
在流媒体协议中,常用的流媒体协议主要有 HTTP协议,RTSP协议和RTMP协议。
在国内视频网站多采用HTTP+MP4或者HTTP+FLV协议传输视频,而国外使用RTMP,RTSP等专门的流媒体格式。
二、协议介绍
1、HTTP协议:
HTTP的视频协议,主要是在互联网普及之后。在互联网上看视频的需求下形成的。
最初的HTTP视频协议,没有任何特别之处,就是通用的HTTP文件渐进式下载。本质就是下载视频文件,而利用视频文件本身的特点,就是存在头部信息,和部分视频帧数据,就完全可以解码播放了。显然这种方式需要将视频文件的头部信息放在文件的前面。有些例如faststart工具,就是专门做这个功能的。
但是最为原始的状态下,视频无法进行快进或者跳转播放到文件尚未被下载到的部分。这个时候对HTTP协议提出了range-request的要求。这个目前几乎所有HTTP的服务器都支持了。range-request,是请求文件的部分数据,指定偏移字节数。在视频客户端解析出视频文件的头部后,就可以判断后续视频相应的帧的位置了。或者根据码率等信息,计算相应的为位置。
优点:
HTTP Live Streaming 还有一个巨大优势:自适应码率流播(adaptive streaming)。效果就是客户端会根据网络状况自动选择不同码率的视频流,条件允许的情况下使用高码率,网络繁忙的时候使用低码率,并且自动在二者间随意切换。这对移动设备网络状况不稳定的情况下保障流畅播放非常有帮助。实现方法是服务器端提供多码率视频流,并且在列表文件中注明,播放器根据播放进度和下载速度自动调整。使用起来也非常简单。
缺点:
实时性相对较差,直播的时候延迟比较高。
2、RTSP协议:
用于Internet上针对多媒体数据流的一种传输协议,是TCP/IP协议体系中的一个应用层协议,RTSP在体系结构上位于RTP和RTCP之上,它使用TCP或UDP完成数据传输,该协议定义了一对多应用程序如何有效地通过IP网络传送多媒体数据。
本协议是最早的视频传输协议。其中RTSP协议用于视频点播的会话控制,例如发起点播请求的SETUP请求,进行具体播放操作的PLAY、PAUSE请求,视频的跳转也是通过PLAY请求的参数支持的。
优点:
RTSP协议族的优势,在于可以控制到视频帧,因此可以承载实时性很高的应用。这个优点是相对于HTTP方式的最大优点。H.323视频会议协议,底层一般采用RTSP协议。RTSP协议族的复杂度主要集中在服务器端,因为服务器端需要parse视频文件,seek到具体的视频帧,而且可能还需要进行倍速播放(就是老旧的DVD带的那种2倍速,4倍速播放的功能),倍速播放功能是RTSP协议独有的,其他视频协议都无法支持。
缺点:
就是服务器端的复杂度也比较高,实现起来也比较复杂。Ios端不支持该协议。
3、RTMP协议:
RTMP是Real Time Messaging Protocol(实时消息传输协议)的首字母缩写。RTMP(Real Time Messaging Protocol)实时消息传送协议是Adobe Systems公司为Flash播放器和服务器之间音频、视频和数据传输 开发的开放协议。该协议基于TCP,是一个协议族,包括RTMP基本协议及RTMPT/RTMPS/RTMPE等多种变种。RTMP是一种设计用来进行实时数据通信的网络协议,主要用来在Flash/AIR平台和支持RTMP协议的流媒体/交互服务器之间进行音视频和数据通信。支持该协议的软件包括Adobe Media Server/Ultrant Media Server/red5等。
优点:
支持直播、点播
缺点:
需要专用的服务器。
三、协议对比
关于三个RTMP,RTSP,HTTP的对比:
1.RTMP是adobe的,RTSP是 android native支持,http协议。
2.RTMP和HTTP有adaptive streaming的技术,RTSP没有
3.RTSP实时性是最好的,HTTP实时性比较差。
4.ios不支持rtsp,安卓支持。
41.mybatis的批量插入和分页
一.借助数组进行分页
原理:进行数据库查询操作时,获取到数据库中所有满足条件的记录,保存在应用的临时数组中,再通过List的subList方法,获取到满足条件的所有记录。
缺点:数据库查询并返回所有的数据,而我们需要的只是极少数符合要求的数据。当数据量少时,还可以接受。当数据库数据量过大时,每次查询对数据库和程序的性能都会产生极大的影响。
二.借助Sql语句进行分页
在了解到通过数组分页的缺陷后,我们发现不能每次都对数据库中的所有数据都检索。然后在程序中对获取到的大量数据进行二次操作,这样对空间和性能都是极大的损耗。所以我们希望能直接在数据库语言中只检索符合条件的记录,不需要在通过程序对其作处理。这时,Sql语句分页技术横空出世。
缺点:虽然这里实现了按需查找,每次检索得到的是指定的数据。但是每次在分页的时候都需要去编写limit语句,很冗余。而且不方便统一管理,维护性较差。所以我们希望能够有一种更方便的分页实现。
三.拦截器分页
上面提到的数组分页和sql语句分页都不是我们今天讲解的重点,今天需要实现的是利用拦截器达到分页的效果。自定义拦截器实现了拦截所有以ByPage结尾的查询语句,并且利用获取到的分页相关参数统一在sql语句后面加上limit分页的相关语句,一劳永逸。不再需要在每个语句中单独去配置分页相关的参数了。。
mapper.xml中批量插入方法的定义如下:
Xml代码
- <insert id="addTrainRecordBatch" useGeneratedKeys="true" parameterType="java.util.List">
- <selectKey resultType="long" keyProperty="id" order="AFTER">
- SELECT
- LAST_INSERT_ID()
- </selectKey>
- insert into t_train_record (add_time,emp_id,activity_id,flag)
- values
- <foreach collection="list" item="item" index="index" separator="," >
- (#{item.addTime},#{item.empId},#{item.activityId},#{item.flag})
- </foreach>
- </insert>
对于foreach标签的解释参考了网上的资料,具体如下:
foreach的主要用在构建in条件中,它可以在SQL语句中进行迭代一个集合。foreach元素的属性主要有 item,index,collection,open,separator,close。item表示集合中每一个元素进行迭代时的别名,index指 定一个名字,用于表示在迭代过程中,每次迭代到的位置,open表示该语句以什么开始,separator表示在每次进行迭代之间以什么符号作为分隔 符,close表示以什么结束,在使用foreach的时候最关键的也是最容易出错的就是collection属性,该属性是必须指定的,但是在不同情况 下,该属性的值是不一样的,主要有一下3种情况:
1.如果传入的是单参数且参数类型是一个List的时候,collection属性值为list
2.如果传入的是单参数且参数类型是一个array数组的时候,collection的属性值为array
3.如果传入的参数是多个的时候,我们就需要把它们封装成一个Map了,当然单参数也可以封装成map
关于foreach的具体例子在这里就先不举,以后有机会可以把每一种情况都举一个例子列出来。
42.大数据量表删除其中一部分
每次删除记录,数据库都要相应地更新索引,这是很慢的IO操作,而且后面索引碎片越来越多,就更慢,这就是为什么一开始只花1.5小时,后面要3小时才能删除400万条记录的原因。
删除之前,做个完整备份。
我在删除前先保存当前索引的DDL,然后删除其索引,
然后根据使用的删除条件建立一个临时的索引(这是提高速度的另外一个重要原因!)
开始删除操作,完成之后再重建之前的索引。
如果需要保留的数据比较少的话,可以把要保留的数据备份出来。在drop表。重新创建,先不要急着创建索引、主键,把数据导回去,然后在建索引、约束之类的。
记得在删除的时候不要在记录日志的模式下面,否则日志文件就要爆了。
2、在My SQL数据库使用中,有的表存储数据量比较大,达到每天三百万条记录左右,此表中建立了三个索引,这些索引都是必须的,其他程序要使用。
由于要求此表中的数据只保留当天的数据,所以每当在凌晨的某一时刻当其他程序处理完其中的数据后要删除该表中昨天以及以前的数据,使用delete删除表中的上百万条记录时,MySQL删除速度非常缓慢每一万条记录需要大概4分钟左右,这样删除所有无用数据要达到八个小时以上,这是难以接受的。
查询MySQL官方手册得知删除数据的速度和创建的索引数量是成正比的,于是删除掉其中的两个索引后测试,发现此时删除速度相当快,一百万条记录在一分钟多一些,可是这两个索引其他模块在每天一次的数据整理中还要使用,于是想到了一个折中的办法:
在删除数据之前删除这两个索引,此时需要三分钟多一些,然后删除其中无用数据,此过程需要不到两分钟,删除完成后重新创建索引,因为此时数据库中的数据相对较少,约三四十万条记录(此表中的数据每小时会增加约十万条),创建索引也非常快,约十分钟左右。这样整个删除过程只需要约15分钟。对比之前的八个小时,大大节省了时间。
43.MySQL主从复制
数据库的主从复制。
master and slave
主从设计可以让数据从一台服务器(Master)复制到多台独立的服务器(Slaves)。主从结构有很多好处,这已经成为后端标配的架构,在MYSQL中实现这一功能的术语叫 - Replication 。
注:配图并没有体现读写分离
主从设计的好处:
- 水平扩展,读写分离 - 在这种架构下,所有的增/删/改操作在Master上执行,所有的读操作在Slaves上执行,这样可以把并行压力分担到多个从库
- 数据安全 - 从库可以随时停下来备份数据,而不必考虑服务不可用的问题。
- 数据分析 - 在从库上分析数据,不会影响主库的性能
- 远程数据分配 - 可以通过从库创建数据提供给远端的网站使用,而不必暴露主库
目前MySQL支持两种方式的主从复制:
- 基于BinaryLog的比较传统的方式 这种方式log文件和文件中的同步位置
- 基于GlobalTransactionIdentifiers (GTIDs) 这种方式比较新,暂未研究