var、let、const区别
在javascript中有三种声明变量的方式：var、let、const。
var 声明全局变量，换句话理解就是，声明在for循环中的变量，跳出for循环同样可以使用。
for(var i=0;i<=1000;i++){
var sum=0;
sum+=i;
}
alert(sum);
声明在for循环内部的sum，跳出for循环一样可以使用，不会报错正常弹出结果
let：声明块级变量，即局部变量。
在上面的例子中，跳出for循环，再使用sum变量就会报错，有着严格的作用域，变量只作用域当前隶属的代码块，不可重复定义同一个变量，不可在声明之前调用，必须先定义再使用，会报错，循环体中可以用let
注意：必须声明’use strict’;后才能使用let声明变量否则浏览并不能显示结果,
const：用于声明常量，也具有块级作用域 ，也可声明块级。
const PI=3.14;
它和let一样，也不能重复定义同一个变量，const一旦定义，无法修改
Arthas真是好用，项目地址：https://github.com/alibaba/arthas ， 回想btrace时代真是辛苦。以下文字来自官方文档摘录。
Arthas 是Alibaba开源的Java诊断工具，深受开发者喜爱。
当你遇到以下类似问题而束手无策时，Arthas可以帮助你解决：
Arthas支持JDK 6+，支持Linux/Mac/Windows，采用命令行交互模式，同时提供丰富的 Tab 自动补全功能，进一步方便进行问题的定位和诊断。
下载arthas-boot.jar，然后用java -jar的方式启动：
wget https://alibaba.github.io/arthas/arthas-boot.jar
java -jar arthas-boot.jar
打印帮助信息：
java -jar arthas-boot.jar -h
Arthas 支持在 Linux/Unix/Mac 等平台上一键安装，请复制以下内容，并粘贴到命令行中，敲 回车 执行即可：
curl -L https://alibaba.github.io/arthas/install.sh | sh
上述命令会下载启动脚本文件 as.sh 到当前目录，你可以放在任何地方或将其加入到 $PATH 中。
直接在shell下面执行./as.sh，就会进入交互界面。
也可以执行./as.sh -h来获取更多参数信息。
|
|
wget https://alibaba.github.io/arthas/arthas-demo.jar
|
|
|
java -jar arthas-demo.jar
|
arthas-demo是一个简单的程序，每隔一秒生成一个随机数，再执行质因式分解，并打印出分解结果。
arthas-demo源代码：查看
在命令行下面执行（使用和目标进程一致的用户启动，否则可能attach失败）：
|
|
wget https://alibaba.github.io/arthas/arthas-boot.jar
|
|
|
java -jar arthas-boot.jar
|
选择应用java进程：
|
|
$ $ java -jar arthas-boot.jar
|
|
|
* [1]: 35542
|
|
|
[2]: 71560 arthas-demo.jar
|
Demo进程是第2个，则输入2，再输入回车/enter。Arthas会attach到目标进程上，并输出日志：
|
|
[INFO] Try to attach process 71560
|
|
|
[INFO] Attach process 71560 success.
|
|
|
[INFO] arthas-client connect 127.0.0.1 3658
|
|
|
,---. ,------. ,--------.,--. ,--. ,---. ,---.
|
|
|
/ O \ | .--. ''--. .--'| '--' | / O \ ' .-'
|
|
|
| .-. || '--'.' | | | .--. || .-. |`. `-.
|
|
|
| | | || |\ \ | | | | | || | | |.-' |
|
|
|
`--' `--'`--' '--' `--' `--' `--'`--' `--'`-----'
|
|
|
|
|
|
wiki: https://alibaba.github.io/arthas
|
|
|
version: 3.0.5.20181127201536
|
|
|
pid: 71560
|
|
|
time: 2018-11-28 19:16:24
|
|
|
|
|
|
$
|
输入dashboard，按enter/回车，会展示当前进程的信息，按ctrl+c可以中断执行。
|
|
$ dashboard
|
|
|
ID NAME GROUP PRIORI STATE %CPU TIME INTERRU DAEMON
|
|
|
17 pool-2-thread-1 system 5 WAITIN 67 0:0 false false
|
|
|
27 Timer-for-arthas-dashb system 10 RUNNAB 32 0:0 false true
|
|
|
11 AsyncAppender-Worker-a system 9 WAITIN 0 0:0 false true
|
|
|
9 Attach Listener system 9 RUNNAB 0 0:0 false true
|
|
|
3 Finalizer system 8 WAITIN 0 0:0 false true
|
|
|
2 Reference Handler system 10 WAITIN 0 0:0 false true
|
|
|
4 Signal Dispatcher system 9 RUNNAB 0 0:0 false true
|
|
|
26 as-command-execute-dae system 10 TIMED_ 0 0:0 false true
|
|
|
13 job-timeout system 9 TIMED_ 0 0:0 false true
|
|
|
1 main main 5 TIMED_ 0 0:0 false false
|
|
|
14 nioEventLoopGroup-2-1 system 10 RUNNAB 0 0:0 false false
|
|
|
18 nioEventLoopGroup-2-2 system 10 RUNNAB 0 0:0 false false
|
|
|
23 nioEventLoopGroup-2-3 system 10 RUNNAB 0 0:0 false false
|
|
|
15 nioEventLoopGroup-3-1 system 10 RUNNAB 0 0:0 false false
|
|
|
Memory used total max usage GC
|
|
|
heap 32M 155M 1820M 1.77% gc.ps_scavenge.count 4
|
|
|
ps_eden_space 14M 65M 672M 2.21% gc.ps_scavenge.time(m 166
|
|
|
ps_survivor_space 4M 5M 5M s)
|
|
|
ps_old_gen 12M 85M 1365M 0.91% gc.ps_marksweep.count 0
|
|
|
nonheap 20M 23M -1 gc.ps_marksweep.time( 0
|
|
|
code_cache 3M 5M 240M 1.32% ms)
|
|
|
Runtime
|
|
|
os.name Mac OS X
|
|
|
os.version 10.13.4
|
|
|
java.version 1.8.0_162
|
|
|
java.home /Library/Java/JavaVir
|
|
|
tualMachines/jdk1.8.0
|
|
|
_162.jdk/Contents/Hom
|
|
|
e/jre
|
thread 1会打印线程ID 1的栈，通常是main函数的线程。
|
|
$ thread 1 | grep 'main('
|
|
|
at demo.MathGame.main(MathGame.java:17)
|
|
|
$ jad demo.MathGame
|
|
|
|
|
|
ClassLoader:
|
|
|
+-sun.misc.Launcher$AppClassLoader@3d4eac69
|
|
|
+-sun.misc.Launcher$ExtClassLoader@66350f69
|
|
|
|
|
|
Location:
|
|
|
/tmp/arthas-demo.jar
|
|
|
|
|
|
/*
|
|
|
* Decompiled with CFR 0_132.
|
|
|
*/
|
|
|
package demo;
|
|
|
|
|
|
import java.io.PrintStream;
|
|
|
import java.util.ArrayList;
|
|
|
import java.util.Iterator;
|
|
|
import java.util.List;
|
|
|
import java.util.Random;
|
|
|
import java.util.concurrent.TimeUnit;
|
|
|
|
|
|
public class MathGame {
|
|
|
private static Random random = new Random();
|
|
|
private int illegalArgumentCount = 0;
|
|
|
|
|
|
public static void main(String[] args) throws InterruptedException {
|
|
|
MathGame game = new MathGame();
|
|
|
do {
|
|
|
game.run();
|
|
|
TimeUnit.SECONDS.sleep(1L);
|
|
|
} while (true);
|
|
|
}
|
|
|
|
|
|
public void run() throws InterruptedException {
|
|
|
try {
|
|
|
int number = random.nextInt();
|
|
|
List<Integer> primeFactors = this.primeFactors(number);
|
|
|
MathGame.print(number, primeFactors);
|
|
|
}
|
|
|
catch (Exception e) {
|
|
|
System.out.println(String.format("illegalArgumentCount:%3d, ", this.illegalArgumentCount) + e.getMessage());
|
|
|
}
|
|
|
}
|
|
|
|
|
|
public static void print(int number, List<Integer> primeFactors) {
|
|
|
StringBuffer sb = new StringBuffer("" + number + "=");
|
|
|
Iterator<Integer> iterator = primeFactors.iterator();
|
|
|
while (iterator.hasNext()) {
|
|
|
int factor = iterator.next();
|
|
|
sb.append(factor).append('*');
|
|
|
}
|
|
|
if (sb.charAt(sb.length() - 1) == '*') {
|
|
|
sb.deleteCharAt(sb.length() - 1);
|
|
|
}
|
|
|
System.out.println(sb);
|
|
|
}
|
|
|
|
|
|
public List<Integer> primeFactors(int number) {
|
|
|
if (number < 2) {
|
|
|
++this.illegalArgumentCount;
|
|
|
throw new IllegalArgumentException("number is: " + number + ", need >= 2");
|
|
|
}
|
|
|
ArrayList<Integer> result = new ArrayList<Integer>();
|
|
|
int i = 2;
|
|
|
while (i <= number) {
|
|
|
if (number % i == 0) {
|
|
|
result.add(i);
|
|
|
number /= i;
|
|
|
i = 2;
|
|
|
continue;
|
|
|
}
|
|
|
++i;
|
|
|
}
|
|
|
return result;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
Affect(row-cnt:1) cost in 970 ms.
|
常用命令举例：
通过watch命令来查看demo.MathGame#primeFactors函数的返回值：
|
|
$ watch demo.MathGame primeFactors returnObj
|
|
|
Press Ctrl+C to abort.
|
|
|
Affect(class-cnt:1 , method-cnt:1) cost in 107 ms.
|
|
|
ts=2018-11-28 19:22:30; [cost=1.715367ms] result=null
|
|
|
ts=2018-11-28 19:22:31; [cost=0.185203ms] result=null
|
|
|
ts=2018-11-28 19:22:32; [cost=19.012416ms] result=@ArrayList[
|
|
|
@Integer[5],
|
|
|
@Integer[47],
|
|
|
@Integer[2675531],
|
|
|
]
|
|
|
ts=2018-11-28 19:22:33; [cost=0.311395ms] result=@ArrayList[
|
|
|
@Integer[2],
|
|
|
@Integer[5],
|
|
|
@Integer[317],
|
|
|
@Integer[503],
|
|
|
@Integer[887],
|
|
|
]
|
|
|
ts=2018-11-28 19:22:34; [cost=10.136007ms] result=@ArrayList[
|
|
|
@Integer[2],
|
|
|
@Integer[2],
|
|
|
@Integer[3],
|
|
|
@Integer[3],
|
|
|
@Integer[31],
|
|
|
@Integer[717593],
|
|
|
]
|
|
|
ts=2018-11-28 19:22:35; [cost=29.969732ms] result=@ArrayList[
|
|
|
@Integer[5],
|
|
|
@Integer[29],
|
|
|
@Integer[7651739],
|
|
|
]
|
更多的功能可以查看进阶使用。
如果只是退出当前的连接，可以用quit或者exit命令。Attach到目标进程上的arthas还会继续运行，端口会保持开放，下次连接时可以直接连接上。
如果想完全退出arthas，可以执行shutdown命令。
方法执行数据观测
让你能方便的观察到指定方法的调用情况。能观察到的范围为：返回值、抛出异常、入参，通过编写 OGNL 表达式进行对应变量的查看。
watch 的参数比较多，主要是因为它能在 4 个不同的场景观察对象
| 参数名称 | 参数说明 |
|---|---|
| class-pattern | 类名表达式匹配 |
| method-pattern | 方法名表达式匹配 |
| express | 观察表达式 |
| condition-express | 条件表达式 |
| [b] | 在方法调用之前观察 |
| [e] | 在方法异常之后观察 |
| [s] | 在方法返回之后观察 |
| [f] | 在方法结束之后(正常返回和异常返回)观察 |
| [E] | 开启正则表达式匹配，默认为通配符匹配 |
| [x:] | 指定输出结果的属性遍历深度，默认为 1 |
这里重点要说明的是观察表达式，观察表达式的构成主要由 ognl 表达式组成，所以你可以这样写”{params,returnObj}”，只要是一个合法的 ognl 表达式，都能被正常支持。
观察的维度也比较多，主要体现在参数 advice 的数据结构上。Advice 参数最主要是封装了通知节点的所有信息。请参考表达式核心变量中关于该节点的描述。
特别说明：
启动快速入门里的arthas-demo。
|
|
$ watch demo.MathGame primeFactors "{params,returnObj}" -x 2
|
|
|
Press Ctrl+C to abort.
|
|
|
Affect(class-cnt:1 , method-cnt:1) cost in 44 ms.
|
|
|
ts=2018-12-03 19:16:51; [cost=1.280502ms] result=@ArrayList[
|
|
|
@Object[][
|
|
|
@Integer[535629513],
|
|
|
],
|
|
|
@ArrayList[
|
|
|
@Integer[3],
|
|
|
@Integer[19],
|
|
|
@Integer[191],
|
|
|
@Integer[49199],
|
|
|
],
|
|
|
]
|
|
|
$ watch demo.MathGame primeFactors "{params,returnObj}" -x 2 -b
|
|
|
Press Ctrl+C to abort.
|
|
|
Affect(class-cnt:1 , method-cnt:1) cost in 50 ms.
|
|
|
ts=2018-12-03 19:23:23; [cost=0.0353ms] result=@ArrayList[
|
|
|
@Object[][
|
|
|
@Integer[-1077465243],
|
|
|
],
|
|
|
null,
|
|
|
]
|
|
|
$ watch demo.MathGame primeFactors "{params,target,returnObj}" -x 2 -b -s -n 2
|
|
|
Press Ctrl+C to abort.
|
|
|
Affect(class-cnt:1 , method-cnt:1) cost in 46 ms.
|
|
|
ts=2018-12-03 19:29:54; [cost=0.01696ms] result=@ArrayList[
|
|
|
@Object[][
|
|
|
@Integer[1544665400],
|
|
|
],
|
|
|
@MathGame[
|
|
|
random=@Random[java.util.Random@522b408a],
|
|
|
illegalArgumentCount=@Integer[13038],
|
|
|
],
|
|
|
null,
|
|
|
]
|
|
|
ts=2018-12-03 19:29:54; [cost=4.277392ms] result=@ArrayList[
|
|
|
@Object[][
|
|
|
@Integer[1544665400],
|
|
|
],
|
|
|
@MathGame[
|
|
|
random=@Random[java.util.Random@522b408a],
|
|
|
illegalArgumentCount=@Integer[13038],
|
|
|
],
|
|
|
@ArrayList[
|
|
|
@Integer[2],
|
|
|
@Integer[2],
|
|
|
@Integer[2],
|
|
|
@Integer[5],
|
|
|
@Integer[5],
|
|
|
@Integer[73],
|
|
|
@Integer[241],
|
|
|
@Integer[439],
|
|
|
],
|
|
|
]
|
|
|
$ watch demo.MathGame primeFactors "{params,target}" -x 3
|
|
|
Press Ctrl+C to abort.
|
|
|
Affect(class-cnt:1 , method-cnt:1) cost in 58 ms.
|
|
|
ts=2018-12-03 19:34:19; [cost=0.587833ms] result=@ArrayList[
|
|
|
@Object[][
|
|
|
@Integer[47816758],
|
|
|
],
|
|
|
@MathGame[
|
|
|
random=@Random[
|
|
|
serialVersionUID=@Long[3905348978240129619],
|
|
|
seed=@AtomicLong[3133719055989],
|
|
|
multiplier=@Long[25214903917],
|
|
|
addend=@Long[11],
|
|
|
mask=@Long[281474976710655],
|
|
|
DOUBLE_UNIT=@Double[1.1102230246251565E-16],
|
|
|
BadBound=@String[bound must be positive],
|
|
|
BadRange=@String[bound must be greater than origin],
|
|
|
BadSize=@String[size must be non-negative],
|
|
|
seedUniquifier=@AtomicLong[-3282039941672302964],
|
|
|
nextNextGaussian=@Double[0.0],
|
|
|
haveNextNextGaussian=@Boolean[false],
|
|
|
serialPersistentFields=@ObjectStreamField[][isEmpty=false;size=3],
|
|
|
unsafe=@Unsafe[sun.misc.Unsafe@2eaa1027],
|
|
|
seedOffset=@Long[24],
|
|
|
],
|
|
|
illegalArgumentCount=@Integer[13159],
|
|
|
],
|
|
|
]
|
|
|
$ watch demo.MathGame primeFactors "{params[0],target}" "params[0]<0"
|
|
|
Press Ctrl+C to abort.
|
|
|
Affect(class-cnt:1 , method-cnt:1) cost in 68 ms.
|
|
|
ts=2018-12-03 19:36:04; [cost=0.530255ms] result=@ArrayList[
|
|
|
@Integer[-18178089],
|
|
|
@MathGame[demo.MathGame@41cf53f9],
|
|
|
]
|
|
|
$ watch demo.MathGame primeFactors "{params[0],throwExp}" -e -x 2
|
|
|
Press Ctrl+C to abort.
|
|
|
Affect(class-cnt:1 , method-cnt:1) cost in 62 ms.
|
|
|
ts=2018-12-03 19:38:00; [cost=1.414993ms] result=@ArrayList[
|
|
|
@Integer[-1120397038],
|
|
|
java.lang.IllegalArgumentException: number is: -1120397038, need >= 2
|
|
|
at demo.MathGame.primeFactors(MathGame.java:46)
|
|
|
at demo.MathGame.run(MathGame.java:24)
|
|
|
at demo.MathGame.main(MathGame.java:16)
|
|
|
,
|
|
|
]
|
|
|
$ watch demo.MathGame primeFactors '{params, returnObj}' '#cost>200' -x 2
|
|
|
Press Ctrl+C to abort.
|
|
|
Affect(class-cnt:1 , method-cnt:1) cost in 66 ms.
|
|
|
ts=2018-12-03 19:40:28; [cost=2112.168897ms] result=@ArrayList[
|
|
|
@Object[][
|
|
|
@Integer[2141897465],
|
|
|
],
|
|
|
@ArrayList[
|
|
|
@Integer[5],
|
|
|
@Integer[428379493],
|
|
|
],
|
|
|
]
|
如果想查看方法运行前后，当前对象中的属性，可以使用target关键字，代表当前对象
|
|
$ watch demo.MathGame primeFactors 'target'
|
|
|
Press Ctrl+C to abort.
|
|
|
Affect(class-cnt:1 , method-cnt:1) cost in 52 ms.
|
|
|
ts=2018-12-03 19:41:52; [cost=0.477882ms] result=@MathGame[
|
|
|
random=@Random[java.util.Random@522b408a],
|
|
|
illegalArgumentCount=@Integer[13355],
|
|
|
]
|
然后使用target.field_name访问当前对象的某个属性
|
|
$ watch demo.MathGame primeFactors 'target.illegalArgumentCount'
|
|
|
Press Ctrl+C to abort.
|
|
|
Affect(class-cnt:1 , method-cnt:1) cost in 67 ms.
|
|
|
ts=2018-12-03 20:04:34; [cost=131.303498ms] result=@Integer[8]
|
|
|
ts=2018-12-03 20:04:35; [cost=0.961441ms] result=@Integer[8]
|
springboot下使用redis非常方便：
Maven依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
<!– <artifactId>spring-boot-starter-redis</artifactId> –>
</dependency>
配置文件 application.properties添加
#redis的ip地址
spring.redis.hostName=127.0.0.1
#数据库，默认为0
spring.redis.database=1
#端口号
spring.redis.port=6379
#如果有密码
spring.redis.password=xxxxx
#客户端超时时间单位是毫秒 默认是2000
spring.redis.timeout=20000
StringRedisTemplate使用
stringRedisTemplate.opsForValue();//操作字符串
stringRedisTemplate.opsForHash();//操作hash
stringRedisTemplate.opsForList();//操作list
stringRedisTemplate.opsForSet();//操作set
stringRedisTemplate.opsForZSet();//操作有序set
示例
import
org.springframework.beans.factory.annotation.Autowired;
import
org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;
import java.util.concurrent.TimeUnit;
@Service
public class RedisService {
@Autowired
StringRedisTemplate stringRedisTemplate;
/**
*
stringRedisTemplate基本操作
*/
public void redis(){
stringRedisTemplate.opsForValue().set(“key”, “value”,60*10,
TimeUnit.SECONDS);//向redis里存入数据和设置缓存时间(10分钟)
stringRedisTemplate.boundValueOps(“key”).increment(1);//val做1操作
stringRedisTemplate.opsForValue().get(“key”);//根据key获取缓存中的val
stringRedisTemplate.boundValueOps(“key”).increment(1);//val +1
stringRedisTemplate.getExpire(“key”);//根据key获取过期时间
stringRedisTemplate.getExpire(“key”,TimeUnit.SECONDS);//根据key获取过期时间并换算成指定单位
stringRedisTemplate.delete(“key”);//根据key删除缓存
stringRedisTemplate.hasKey(“key”);//检查key是否存在，返回boolean值
stringRedisTemplate.opsForSet().add(“key”, “5”,”6″,”7″);//向指定key中存放set集合
stringRedisTemplate.expire(“key”,1000 ,
TimeUnit.MILLISECONDS);//设置过期时间
stringRedisTemplate.opsForSet().isMember(“key”, “1”);//根据key查看集合中是否存在指定数据
stringRedisTemplate.opsForSet().members(“key”);//根据key获取set集合
}
}
package 的导入语法，转自：https://blog.csdn.net/u010649766/article/details/79458004
写 Go 代码的时经常用到 import 这个命令用来导入包，参考如下：
import(
“fmt”
)
然后在代码里面可以通过如下的方式调用：
fmt.Println( “我爱北京天安门” )
fmt 是 Go 的标准库，它其实是去 GOROOT 下去加载该模块，当然 Go 的 import 还支持如下两种方式来加载自己写的模块：
相对路径
import “./model” // 当前文件同一目录的 model 目录，但是不建议这种方式 import
绝对路径
import “shorturl/model” // 加载 GOPATH/src/shorturl/model 模块
package 的导入的特殊用法
上面展示了一些 import 常用的几种方式，但是还有一些特殊的 import ，让很多新手很费解，下面是三种导入包的使用方法。
点操作
有时候会看到如下的方式导入包：
import(
. “fmt”
)
这个点操作的含义就是这个包导入之后在你调用这个包的函数时，你可以省略前缀的包名，也就是前面你调用的：
fmt.Println( “我爱北京天安门” )
可以省略的写成：
Println( “我爱北京天安门” )
别名操作
别名操作顾名思义可以把包命名成另一个用起来容易记忆的名字：
import(
f “fmt”
)
别名操作调用包函数时前缀变成了重命名的前缀，即：
f.Println( “我爱北京天安门” )
下划线操作
这个操作经常是让很多人费解的一个操作符，请看下面这个 import
import (
“database/sql”
_ “github.com/ziutek/mymysql/godrv”
)
下滑线 “_” 操作其实只是引入该包。当导入一个包时，它所有的 init() 函数就会被执行，但有些时候并非真的需要使用这些包，仅仅是希望它的 init() 函数被执行而已。这个时候就可以使用 “_” 操作引用该包了。即使用 “_” 操作引用包是无法通过包名来调用包中的导出函数，而是只是为了简单的调用其 init() 函数。
网上收集的ffmpeg常用使用场景及命令使用：
应用场景1：格式转换
我想把用iPhone拍的.MOV文件转成.avi文件。最简单了，可以执行下面的命令：
ffmpeg -i D:\Media\IMG_0873.MOV D:\Media\output.avi
意思是，把D:\Media目录下的源文件IMG_0873.MOV（视频：h.264，音频：aac）转换成output.avi（编码格式自动选择为：视频mpeg4，音频mp3），目标文件仍然保存到D:\Media目录下。问题来了：我想自己指定编码格式，怎么办呢？一种方法是，通过目标文件的扩展名（.flv、.mpg、.mp4、.wmv等）来控制，比如：
ffmpeg -i D:\Media\IMG_0873.MOV D:\Media\output2.flv
另一种方法是通过-c:v参数来控制，比如我想输出的视频格式是H.265（警告：编码时间会比较长哦）。命令行如下：
ffmpeg -i D:\Media\IMG_0873.MOV -c:v libx265 D:\Media\output265.avi
注：可以先用ffmpeg -encoders命令查看一下所有可选的编码格式。
不再深究了，我们继续。我发现源文件的图像帧尺寸是1920x 1080，我不需要这么大——能有720 x 480就够了。于是，就要用上-s参数了。为了保证图像缩放后的质量，最好加上码率参数-b:v。如下：
ffmpeg -i D:\Media\IMG_0873.MOV -s 720×480 -b:v 1500k D:\Media\output2.avi
还可以更简单一点，使用-target参数匹配行业标准，参数值可以是vcd、svcd、dvd、dv、dv50等，可能还需要加上电视制式作为前缀（pal-、ntsc-或film-）。如下：
ffmpeg -i D:\Media\IMG_0873.MOV -target pal-dvd D:\Media\output2dvd.avi
又来一个问题：我发现用手机拍的视频中，有些是颠倒的，我想让它顺时针旋转90度。这时候，可以使用-vf参数加入一个过滤器，如下：
ffmpeg -i D:\Media\IMG_0873.MOV -vf “rotate=90*PI/180” D:\Media\output3.avi
注：如果想逆时针旋转90度，90前面加个负号就可以了。
如果我只需要从源视频里截取一小段，怎么办呢？比如从第2秒的地方开始，往后截取10秒钟。命令行可以这样：
ffmpeg -ss 2 -t 10 -i D:\Media\IMG_0873.MOV D:\Media\output4.avi
注：这种情况下，-ss和-t参数必须放在-i前面，表示是限定后面跟着的输入文件的。
应用场景2：视频合成
我发现，用手机拍的视频有时候背景噪音比较大。怎么把噪音去掉，换成一段美妙的音乐呢？使用FFmpeg也能轻易做到。
第一步：把源文件里的音频去掉，生成一个临时文件tmp.mov
ffmpeg -i D:\Media\IMG_0873.MOV -vcodec copy -an D:\Media\tmp.mov
注：-vcodeccopy的意思是对源视频不解码，直接拷贝到目标文件；-an的意思是将源文件里的音频丢弃。
第二步：把这个无声的视频文件（tmp.mov）与一个音乐文件（music.mp3）合成，最终生成output.mov
ffmpeg -i D:\Media\tmp.mov -ss 30 -t 52 -i D:\Media\music.mp3 -vcodec copy D:\Media\output5.avi
为了保证良好的合成效果，音乐时长必须匹配视频时长。这里我们事先知道视频时长为52秒，于是截取music.mp3文件的第30秒往后的52秒与视频合成。另外，为了保证音频时长截取的准确性，我们这里没有使用-acodec copy，而是让音频重新转码。
还有一种情况：我们希望在一段视频上叠加一张图片。可以简单实现如下：
ffmpeg -i D:\Media\IMG_0873.MOV -i D:\Media\logo.png -filter_complex ‘overlay’ D:\Media\output6.avi
应用场景3：视频播放
格式转换或合成之后，我们需要试着播放一下。播放器的选择很多。这里顺手用ffplay工具也行：
ffplay -i D:\Media\output6.avi
应用场景4：获取视频信息
有时候，我只是想看看这个视频文件的格式信息。可以用ffprobe工具：
ffprobe -i D:\Media\IMG_0873.MOV
应用场景5: 截取视频片段转为GIF动画
可以简单地执行下面的命令行：
ffmpeg -ss 25 -t 10 -i D:\Media\bear.wmv -f gif D:\a.gif
意思是：将D:\Media目录下的源文件bear.wmv，从第25秒的位置开始，截取10秒长度的视频转成GIF文件，保存为D:\a.gif。
想要知道FFmpeg到底支持哪些格式吗？执行ffmpeg –formats即可。
问题来了，你的源文件可能是1080P的高清视频，帧率可能还比较高。为了便于网络分享，GIF文件最好小一点。于是，我们需要使用-s参数来进行图像的缩放，使用-r参数来限制目标文件的帧率。命令行如下：
ffmpeg -ss 25 -t 10 -i D:\Media\bear.wmv -s 320×240 -f gif -r 1 D:\b.gif
把b.gif拖进浏览器预览，结果发现：虽然帧率降到了1 fps（从源视频里每隔一秒抽取一帧图像输出到目标文件），整个动画播放还是持续了10秒钟，看着很揪心！能不能在源视频跳帧的情况下同时提高GIF的播放速率呢（比如说在2秒内播完）？查了一遍FFmpeg的说明文档，似乎没有哪个参数可以快速达到这样的目的。也罢，那就分两步走吧：
首先，执行ffmpeg -ss 25 -t 10 -i D:\Media\bear.wmv -r 1 -s 320×240 -f image2 D:\foo-%03d.jpeg，从源视频中每秒钟抽取一帧图像，保存为一系列JPEG文件。然后，再执行ffmpeg -f image2 -framerate 5 -i D:\foo-%03d.jpeg D:\c.gif，将这一系列JPEG图像合成为帧率5 fps的GIF文件。Bingo!
上面提到，把GIF文件拖进浏览器可以进行预览。当然，使用ffplay.exe工具也是可以的——命令行：ffplay D:\a.gif。
p.s. 附送一条指令：截取视频内任意时间点（比如第16.1秒处）的一帧图像保存为JPEG文件：ffmpeg -ss 16.1 -i D:\Media\bear.wmv -s 320×240 -vframes 1 -f image2 D:\d.jpeg
其他应用
FFmpeg的功能非常强大。关键是要理解各种参数的意义，并且巧妙搭配。必要的话，就把在线文档完整读一遍吧：http://www.ffmpeg.org/ffmpeg.html
================ffmpeg 常用基本命令=========================
1.分离视频音频流
ffmpeg -i input_file -vcodec copy -an output_file_video //分离视频流 ffmpeg -i input_file -acodec copy -vn output_file_audio //分离音频流
2.视频解复用
ffmpeg –i test.mp4 –vcodec copy –an –f m4v test.264ffmpeg –i test.avi –vcodec copy –an –f m4v test.264
3.视频转码
ffmpeg –i test.mp4 –vcodec h264 –s 352*278 –an –f m4v test.264 //转码为码流原始文件 ffmpeg –i test.mp4 –vcodec h264 –bf 0 –g 25 –s 352*278 –an –f m4v test.264 //转码为码流原始文件 ffmpeg –i test.avi -vcodec mpeg4 –vtag xvid –qsame test_xvid.avi //转码为封装文件//-bf B帧数目控制，-g 关键帧间隔控制，-s 分辨率控制
4.视频封装
ffmpeg –i video_file –i audio_file –vcodec copy –acodec copy output_file
5.视频剪切
ffmpeg –i test.avi –r 1 –f image2 image-%3d.jpeg //提取图片 ffmpeg -ss 0:1:30 -t 0:0:20 -i input.avi -vcodec copy -acodec copy output.avi //剪切视频//-r 提取图像的频率，-ss 开始时间，-t 持续时间
6.视频录制
ffmpeg –i rtsp://192.168.3.205:5555/test –vcodec copy out.avi
7.YUV序列播放
ffplay -f rawvideo -video_size 1920x1080 input.yuv
8.YUV序列转AVI
ffmpeg –s w*h –pix_fmt yuv420p –i input.yuv –vcodec mpeg4 output.avi
常用参数说明：
主要参数： -i 设定输入流 -f 设定输出格式 -ss 开始时间 视频参数： -b 设定视频流量，默认为200Kbit/s -r 设定帧速率，默认为25 -s 设定画面的宽与高 -aspect 设定画面的比例 -vn 不处理视频 -vcodec 设定视频编解码器，未设定时则使用与输入流相同的编解码器 音频参数： -ar 设定采样率 -ac 设定声音的Channel数 -acodec 设定声音编解码器，未设定时则使用与输入流相同的编解码器 -an 不处理音频
——————————————————————————————–
——————————————————————————————–
1、将文件当做直播送至live
ffmpeg -re -i localFile.mp4 -c copy -f flv rtmp://server/live/streamName
2、将直播媒体保存至本地文件
ffmpeg -i rtmp://server/live/streamName -c copy dump.flv
3、将其中一个直播流，视频改用h264压缩，音频不变，送至另外一个直播服务流
ffmpeg -i rtmp://server/live/originalStream -c:a copy -c:v libx264 -vpre slow -f flv rtmp://server/live/h264Stream
4、将其中一个直播流，视频改用h264压缩，音频改用faac压缩，送至另外一个直播服务流
ffmpeg -i rtmp://server/live/originalStream -c:a libfaac -ar 44100 -ab 48k -c:v libx264 -vpre slow -vpre baseline -f flv rtmp://server/live/h264Stream
5、将其中一个直播流，视频不变，音频改用faac压缩，送至另外一个直播服务流
ffmpeg -i rtmp://server/live/originalStream -acodec libfaac -ar 44100 -ab 48k -vcodec copy -f flv rtmp://server/live/h264_AAC_Stream
6、将一个高清流，复制为几个不同视频清晰度的流重新发布，其中音频不变
ffmpeg -re -i rtmp://server/live/high_FMLE_stream -acodec copy -vcodec x264lib -s 640×360 -b 500k -vpre medium -vpre baseline rtmp://server/live/baseline_500k -acodec copy -vcodec x264lib -s 480×272 -b 300k -vpre medium -vpre baseline rtmp://server/live/baseline_300k -acodec copy -vcodec x264lib -s 320×200 -b 150k -vpre medium -vpre baseline rtmp://server/live/baseline_150k -acodec libfaac -vn -ab 48k rtmp://server/live/audio_only_AAC_48k
7、功能一样，只是采用-x264opts选项
ffmpeg -re -i rtmp://server/live/high_FMLE_stream -c:a copy -c:v x264lib -s 640×360 -x264opts bitrate=500:profile=baseline:preset=slow rtmp://server/live/baseline_500k -c:a copy -c:v x264lib -s 480×272 -x264opts bitrate=300:profile=baseline:preset=slow rtmp://server/live/baseline_300k -c:a copy -c:v x264lib -s 320×200 -x264opts bitrate=150:profile=baseline:preset=slow rtmp://server/live/baseline_150k -c:a libfaac -vn -b:a 48k rtmp://server/live/audio_only_AAC_48k
8、将当前摄像头及音频通过DSSHOW采集，视频h264、音频faac压缩后发布
ffmpeg -r 25 -f dshow -s 640×480 -i video=”video source name”:audio=”audio source name” -vcodec libx264 -b 600k -vpre slow -acodec libfaac -ab 128k -f flv rtmp://server/application/stream_name
9、将一个JPG图片经过h264压缩循环输出为mp4视频
ffmpeg.exe -i INPUT.jpg -an -vcodec libx264 -coder 1 -flags +loop -cmp +chroma -subq 10 -qcomp 0.6 -qmin 10 -qmax 51 -qdiff 4 -flags2 +dct8x8 -trellis 2 -partitions +parti8x8+parti4x4 -crf 24 -threads 0 -r 25 -g 25 -y OUTPUT.mp4
10、将普通流视频改用h264压缩，音频不变，送至高清流服务(新版本FMS live=1)
ffmpeg -i rtmp://server/live/originalStream -c:a copy -c:v libx264 -vpre slow -f flv “rtmp://server/live/h264Stream live=1〃
————————————————————————
————————————————————————
1.采集usb摄像头视频命令：
ffmpeg -t 20 -f vfwcap -i 0 -r 8 -f mp4 cap1111.mp4
./ffmpeg -t 10 -f vfwcap -i 0 -r 8 -f mp4 cap.mp4
具体说明如下：我们采集10秒，采集设备为vfwcap类型设备，第0个vfwcap采集设备（如果系统有多个vfw的视频采集设备，可以通过-i num来选择），每秒8帧，输出方式为文件，格式为mp4。
2.最简单的抓屏：
ffmpeg -f gdigrab -i desktop out.mpg
3.从屏幕的（10,20）点处开始，抓取640×480的屏幕，设定帧率为5 ：
ffmpeg -f gdigrab -framerate 5 -offset_x 10 -offset_y 20 -video_size 640×480 -i desktop out.mpg
4.ffmpeg从视频中生成gif图片：
ffmpeg -i capx.mp4 -t 10 -s 320×240 -pix_fmt rgb24 jidu1.gif
5.ffmpeg将图片转换为视频：
http://blog.sina.com.cn/s/blog_40d73279010113c2.html
目前很多老mac pro用户都会有想着换个SSD硬盘已优化机器性能。
在使用时间机器备份完了老数据后，正常换好SSD硬盘，并在启动时使用 COMMAND + R 进入macOS实用程序界面，在正常格式话硬盘后，再使用“选择“从Time Machine备份恢复””，并选择对应的硬盘恢复时，可能会出现:
“将恢复系统添加到目的磁盘时发生错误”，重启系统再试还是一样的效果。
后来发现，对于想要完全恢复硬盘数据或着是空硬盘的，比如换SSD硬盘的情况，开机启动后的按键：
应该是COMMAND + OPTION + R 而不是 COMMAND + R,
加OPTION后启动将出现进度条，启动后工具的界面也稍有不同，至此一步步往下走，问题解决，GoodLuck!!
网上总结的4个方法，挺好的，分享下： https://blog.csdn.net/lmy86263/article/details/53150091
首先先定义一个测试实体类，如下：
public class User implements Serializable {
private Integer userId;
private String userName;
……
}
1. 通过XML映射文件中的resultMap
这种方式是最常见的，类似如下：
<mapper namespace=”data.UserMapper”>
<resultMap type=”data.User” id=”userResultMap”>
<!– 用id属性来映射主键字段 –>
<id property=”id” column=”user_id”/>
<!– 用result属性来映射非主键字段 –>
<result property=”userName” column=”user_name”/>
</resultMap>
</mapper>
通过里面的id标签和result标签来建立映射关系，由property和column分别指定实体类属性和数据表的列名。
2. 通过注解@Results和@Result
这两个注解是与XML文件中的标签相对应的：
@Results对应resultMap
@Result对应result
这两个注解是应用在方法的级别上的，也就是在mapper方法上，如下：
@Select(“select * from t_user where user_name = #{userName}”)
@Results(
@Result(property = “userId”, column = “user_id”),
@Result(property = “userName”, column = “user_name”)
)
User getUserByName(@Param(“userName”) String userName);
缺点：
由于注解是针对方法的，对于Mapper中的每个操作数据库的方法都必须有相同的注解完成映射关系的建立，导致很多的配置是重复的；
如果要避免配置重复的问题，可以采用在XML配置文件中配置这个resultMap，然后再@Result中通过id属性引用这个resultMap，
但是这样感觉很麻烦（由于使用了两种配置方式），不如直接使用基于XML的resultMap配置方式；
3. 通过属性配置完成映射
使用者最陌生的是通过配置属性来完成映射，Mybatis给我们提供了一种映射方式，如果属性的命名是遵从驼峰命名法的，数据列名遵从下划线命名，
那么可以使用这种方式，类似如下：
userName对应user_name;
userId对应user_id;
配置代码如下：
SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
Configuration configuration = new Configuration();
configuration.setMapUnderscoreToCamelCase(true);
sqlSessionFactoryBean.setConfiguration(configuration);
4. 通过使用在SQL语句中定义别名完成映射
这种方式最直接，直接在SQL语句中建立别名来完成映射，如下：
@Select(“select user_name as userName, user_id as userId from t_user where user_name = #{userName}”)
User getUserByName(@Param(“userName”) String userName);
navcat 使用root连接本地mysql，出现“client does not support authentication”
先使用命令行mysql -uroot -p连接mysql, 输入密码后进入
mysql>
然后运行以下命令如下：
1、mysql> use mysql;
2、mysql> alter user ‘root’@’localhost’ identified with mysql_native_password by ‘********’;
3、mysql> flush privileges;
mac下使用brew install mysql，安装pip install MySQL-python出现下面错误提示：
_mysql.c:44:10: fatal error: ‘my_config.h’ file not found
#include “my_config.h”
^~~~~~~~~~~~~
1 error generated.
error: command ‘cc’ failed with exit status 1
网上很多方法都无效，使用下面都步骤可解决
brew remove mysql brew install mysql@5.7 brew link --force mysql@5.7 pip install msyql-python (如权限不足，请使用sudo)
网上看到的３篇连载关于tornado异步的文章，写的很好，虽然有些内容有些老了，但不影响文章的借鉴意义，强烈推荐：
转自:https://www.jianshu.com/p/3cc234198567
HTTP通信中，client和server一问一答的方式。HTTP是基于TCP的应用层协议，通常在发送请求之前需要创建TCP连接，然后在收到响应之后会断开这个TCP连接。这就是常见的http短连接。既然有短连接，那么也有长连接。
HTTP协议最初的设计是无连接无状态的方式。为了维护状态，引入了cookie和session方式认证识别用户。早期的web开发中，为了给用户推送数据，通常使用所谓的长连接。那时的长连接还是基于短连接的方式实现，即通过client的轮询查询，在用户层面看起来连接并没有断开。随着技术的发展，又出现了Websockt和MQTT等通信协议。Websockt和MQTT则是全双工的通信协议。
相比全双工实现的长连接，我们还会在web开发中遇到伪长连接。即HTTP协议中的keepalive模式。因为HTTP设计是无连接设计，请求应答结束之后就关闭了TCP连接。在http通信中，就会有大量的新建和销毁tcp连接的过程，那怕是同一个用户同一个客户端。为了优化这种方式，HTTP提出了KeepAlive模式，即创建的tcp连接后，传输数据，server返回响应之后并不会关掉tcp连接，下一次http请求就能复用这个tcp连接。
这是一种协商式的连接，毕竟每次的http发送数据的时候，还是要单独为每个请求发送header之类的信息。相比全双工的websocket，一旦创建了连接，下一次就不需要再发送header，直接发送数据即可。因此描述http的keepalive应该是持久连接（HTTP persistent connection ）更准确。
HTTP的keepalive模式提供了HTTP通信的时候复用TCP连接的协商功能。http1.0默认是关闭的，只有在http的header加入Connection: Keep-Alive才能开启。而http1.1则正相反，默认就打开了，只有显示的在header里加入Connection: close才能关闭。现在的浏览器基本都是http1.1的协议，能否使用长连接，权看服务器的支持状况了。下图说明了开启keepalive模式的持久连接与短连接的通信示意图
当开启了持久连接，就不能使用返回EOF的方式来判断数据结尾了。对于静态和动态的数据，可以使用Conent-Lenght和Transfer-Encoding`来做应用层的区分。
了解了keeplive模式，接下来我们就来使用keepalive方式。服务器使用Tornado，tornado实现了keepalive的处理，客户端我们可以分别使用同步的requests和异步的AsyncHTTPClient。
先写一个简单的服务器：
micro-server.py
import tornado.httpserver
import tornado.ioloop
import tornado.web
class IndexHandler(tornado.web.RequestHandler):
def get(self, *args, **kwargs):
self.finish('It works')
app = tornado.web.Application(
handlers=[
('/', IndexHandler),
],
debug=True ) if __name__ == '__main__':
server = tornado.httpserver.HTTPServer(app)
server.listen(8000)
tornado.ioloop.IOLoop().instance().start()
requests 短连接
requests不愧是一个”for human” 的软件，实现一个http客户端非常简单。
import argparse
import requests
url = 'http://127.0.0.1:8000'
def short_connection():
resp = requests.get(url)
print(resp.text)
resp = requests.get(url)
print(resp.text)
def long_connection():
pass
if __name__ == '__main__':
ap = argparse.ArgumentParser()
ap.add_argument("-t", "--type", default="short")
args = ap.parse_args()
type_ = args.type if type_ == 'short':
short_connection() elif type_ == 'long':
long_connection()
运行keepalive python requests-cli.py –type=short，可以看见返回了数据，同时通过另外一个神器wireshark抓包如下：
requests 短连接
从抓包的情况来看，两次http请求，一共创建了两次tcp的握手连接和挥手断开。每次发送http数据都需要先创建tcp连接，然后就断开了连接。通常是客户端发起的断开连接。
requests 持久连接
requests的官网也说明了，基于urllib3的方式，requests百分比实现了keepalive方式，只需要创建一个客户端session即可，代码如下：
def long_connection(): s = requests.Session()
resp = s.get(url)
print(resp.text)
resp = s.get(url)
print(resp.text)
s.close()
再次通过抓包如下图：
requests 持久连接模式
可以看到，同样也是两次http请求，只创建了一次tcp的握手和挥手。两次http请求都基于一个tcp连接。再次查看包43，可以看到下图中的报文header指定了keepalive。
http请求的数据包
AsyncHTTPClient与持久连接
tornado是一个优秀高性能异步非阻塞（non-block）web框架。如果torando的handler中也需要请求别的三方资源，使用requests的同步网络IO，将会block住整个tornado的进程。因此tornado也实现了异步的http客户端AsyncHTTPClient。
短连接
使用AsyncHTTPClient也不难，但是想要使用其异步效果，就必须把其加入事件循环中，否则只有连接的创立，而没有数据的传输就退出了。
import tornado.httpclient
import tornado.ioloop
import time
url = 'http://127.0.0.1:8000'
def handle_response(response):
if response.error:
print("Error: %s" % response.error) else:
print(response.body)
http_client = tornado.httpclient.AsyncHTTPClient()
http_client.fetch(url, handle_response)
http_client.fetch(url, handle_response)
运行上述代码，将会看到wirshark中，创建了两次TCP连接和断开了连接，并没有发送http数据。为了发送http数据，还需要加入tornado的事件循环。即在最后一行加入tornado.ioloop.IOLoop.instance().start()
再次运行，客户端正常收到了数据，抓包如下：
async http client 短连接
抓包的结果咋一看像是持久连接，仔细一看却有两次握手和挥手的操作。的确，客户端发送异步http请求的时候，创建了两个端口49989和49990两个tcp连接。因为是异步的请求，因此先创建了两个连接，然后才发送数据，发送数据的时候都是基于所创建的端口进行的。也就是没有使用持久连接。
持久连接
AsyncHTTPClient使用持久连接也很简单。现在流行微服务架构。通常提供给客户端的服务称之为网关，网关从各种微服务中调用获取数据，通信的方式中，同步的有http和rpc，异步的有mq之类的。而http通常都是使用持久连接的方式。
下面我们介绍一下在tornado server的handler中使用async client请求微服务的资源。
再写一个简单server
#!/usr/bin/env python
# -*- coding:utf-8 -*-
import tornado.gen
import tornado.httpclient
import tornado.httpserver
import tornado.ioloop
import tornado.web
class AsyncKeepAliveHandler(tornado.web.RequestHandler):
@tornado.web.asynchronous
@tornado.gen.coroutine
def get(self, *args, **kwargs):
url = 'http://127.0.0.1:8000/'
http_client = tornado.httpclient.AsyncHTTPClient()
response = yield tornado.gen.Task(http_client.fetch, url)
print response.code print response.body
self.finish("It works")
app = tornado.web.Application(
handlers=[
('/async/keepalive', AsyncKeepAliveHandler)
],
debug=True )
if __name__ == '__main__':
server = tornado.httpserver.HTTPServer(app)
server.listen(5050)
tornado.httpclient.AsyncHTTPClient.configure("tornado.curl_httpclient.CurlAsyncHTTPClient")
tornado.ioloop.IOLoop().instance().start()
然后我们请求5050端口的服务，也连接发送两次http请求：
(venv)☁ keepalive curl http://127.0.0.1:5050/async/keepalive It works% (venv)☁ keepalive curl http://127.0.0.1:5050/async/keepalive It works%
再看我们的抓包情况：
tornado handler使用持久连接
从图中可以看到，即使是两个请求，最终都是复用了断开为50784的tcp连接。
因为asynchttpclient默认使用的是SimpleAsyncHTTPClient，实现持久连接只需要配置一下tornado.httpclient.AsyncHTTPClient.configure(“tornado.curl_httpclient.CurlAsyncHTTPClient”)即可。当然，这个需要tornado的版本4.2以上，当前的版本是4.5。
CurlAsyncHTTPClient依赖于pycurl。pycurl又依赖libcurl。在安装pycurl的时候，可能会出现link的问题。例如ImportError: pycurl: libcurl link-time version (7.37.1) is older than compile-time version (7.43.0) 。 解决了link问题，如果是mac系统，安装的时候可能出现error: Setup script exited with error: command ‘cc’ failed，多半是由于xcode做鬼，这里有一个解决说明
AsyncHTTPClient设置成为keepalive模式是全局性的，比较tornado是单进程单线程的，访问三方或者微服务，都是一个客户端，所有的模式都是持久连接。
短连接与持久连接的应用场景
持久连接可以减少tcp连接的创建和销毁，提升服务器的处理性能。但是并不是所有连接都得使用持久连接。长短连接都有其使用场景。
既然持久连接在于连接的持久，因此对于频繁通信，点对点的就可以使用。例如网关和微服务之间。如果创建了持久连接，就必须在意连接的存活状态。客户端一般不会主动关闭，因此服务端需要维护这个连接状态，对于一些长时间没有读写事件发生的连接，可以主动断开，节省资源。
对于一些用完就走的场景，也不需要使用持久连接。而另外一些需要全双工通信，例如推送和实时应用，则需要真正的长连接，比如MQTT实现推送和websocket实现实时应用等。
总结
微服务大行其道，从微观来看，增加了更多的网络IO。而IO又是最耗时的操作。相比之下，程式的计算速度就显得没那么紧要了。优化网络IO才是提升性能的关键。一些频繁通信的场景，使用持久连接或长连接更能优化大量TCP连接的创建和销毁。
就Python的而言，Tornado的诞生就是为了解决网络IO的瓶颈。并且很多tornado及其三方库的问题，都能在github和stackoverflow找到作者的参与和回答。可见作者对项目的负责。由于tornado单线程的特性，因此做任何IO操作，都需要考虑是否block。幸好有AsyncHTTPClinet，既可以提供异步IO，也可以实现持久连接，当然，tornado也支持websocket。
