Daniel Hu的技术生活博客

Algorithm

Algorithm of the Week: Insertion Sort

LINUX

Linux系统内存相关信息获取

/proc/meminfo 每个字段的意思

ulimit

ulimit用于shell启动进程所占用的资源

cat /proc/<tomcat pid>/limits

How do I Find Out Linux CPU Utilization?

sar -u 2 5

Report CPU utilization. The following values are displayed:

• %user: Percentage of CPU utilization that occurred while executing at the user level (application).
• %nice: Percentage of CPU utilization that occurred while executing at the user level with nice priority.
• %system: Percentage of CPU utilization that occurred while executing at the system level (kernel).
• %iowait: Percentage of time that the CPU or CPUs were idle during which the system had an outstanding disk I/O request.
• %idle: Percentage of time that the CPU or CPUs were idle and the system did not have an outstanding disk I/O request.

Programming

QPS

QPS每秒查询率(Query Per Second)

每秒查询率QPS是对一个特定的查询服务器在规定时间内所处理流量多少的衡量标准，在因特网上，作为域名系统服务器的机器的性能经常用每秒查询率来衡量。

对应fetches/sec，即每秒的响应请求数，也即是最大吞吐能力。

Context Switches

You can determine whether context switching is excessive by comparing it with the value of Processor\% Privileged Time. If this counter is at 40 percent or more and the context-switching rate is high, then you can investigate the cause for high rates of context switches.

线程

轻量级锁

偏向锁

多线程的优劣/性能/系统开销

1.进入内核模式；
2.将CPU的寄存器保存到当前正在执行的线程的内核对象中。
注明：X86架构下CPU寄存器占了大约700字节(Byte)的空间，X64架构下CPU寄存器大约占了1024(Byte)的空间，IA64架构下CPU寄存器占了大约2500Byte的空间。
3.需要一个自旋锁(spin lock)，确定下一次调度那一个线程，然后再释放该自旋锁。
如果下一次调度的线程属于同一个进程，哪么此处开销更大，因为OS必须先切换虚拟地址空间。
4.把即将要运行的线程的内核对象的地址加载到CPU寄存器中。
5.退出内核模式。

There are three principles of package cohesion

• (REP) The ReuseReleaseEquivalencePrinciple
• (CCP) The CommonClosurePrinciple
• (CRP) The CommonReusePrinciple

There are three principles of package coupling

• (ADP) The AcyclicDependenciesPrinciple
• (SDP) The StableDependenciesPrinciple
• (SAP) The StableAbstractionsPrinciple

Java

理解HotSpot的CMS GC

Java Anti-Patterns

Jboss调优——最佳线程数

一个GC频繁的Case

Java轻量级锁原理详解(Lcightweight Locking)

Java轻量级锁原理详解(Lightweight Locking)

正确使用 Volatile 变量

Java 语言中的 volatile 变量可以被看作是一种 “程度较轻的 synchronized”；与 synchronized 块相比，volatile 变量所需的编码较少，并且运行时开销也较少，但是它所能实现的功能也仅是 synchronized 的一部分

锁提供了两种主要特性：互斥（mutual exclusion） 和可见性（visibility）。

Volatile 变量具有 synchronized 的可见性特性，但是不具备原子特性。这就是说线程能够自动发现 volatile 变量的最新值。Volatile 变量可用于提供线程安全，但是只能应用于非常有限的一组用例：多个变量之间或者某个变量的当前值与修改后值之间没有约束。因此，单独使用 volatile 还不足以实现计数器、互斥锁或任何具有与多个变量相关的不变式（Invariants）的类（例如 “start <=end”）。 c

Java生成UUID

String s = UUID.randomUUID().toString()

Guidelines for Java Testable Design

Avoid complex private methods
Avoid final methods
Avoid static methods
Use “new” with care
Avoid logic in constructors
Avoid the Singleton
Favor composition over inheritance
Wrap external libraries
Avoid service lookups

Ways to create objects in java example . Use static factory methods to create instance of a class in java

1. Use new keyword and call to constructor
2.Use public static factory methods
3.getInstance()
4.Reflective methods for creating instances of classes :
5.Objects creation using Deserialisation :
6.Using Clone method to copy / clone objects of an exisiting object

Architecture

Event Collaboration

Message Bus a.k.a. Event Bus

Message Bus

一些知名的架构师的问与答，无论是问题还是答案都值得学习

架构师接龙：岳旭强 VS. 杨卫华

JDK 7给Web带来了什么？协程在老系统上的应用，有哪些挑战？怎么解决？

类似Twitter、新浪微博这样的应用，针对第三方开放API接口，如何避免少数应用程序因为用户量激增而对系统带来冲击？对请求数做限制之外有没有更为折衷的办法？

Web应用的性能、扩展性是业界比较关注的，但是可用性显然更重要，有什么关键措施和经验可以提高系统的可用性？

 

架构师接龙：腾讯高级工程师邝宇恒VS. 百度架构师侯震宇

你的团队会对所有代码进行代码评审吗？具体如何实施？如何评价代码评审的作用？

架构师接龙 飞信孙朝晖VS.139说客李祎

你们做灰度发布和A/B测试吗？如果做的话，在架构上是如何支持的？

目前你的组织内是否具备了根据性能需求动态伸缩的应用部署基础架构？如果有的话，是怎样建设的？如果还没有，你怎样看待这个问题？

在你们的系统中，是否在设计与开发阶段就预留功能降级的接口，以应对突发故障？请举例说明设计的原则和实施方法。

架构师接龙：黄冬&邓毅

大量的用户使用行为记录需要留存，而留存下的数据量非常大，对于相关的数据也要进行频繁和复杂的业务计算，对于这样的存储有什么解决方案吗？对于这样的分析型计算有什么有效的架构 ？

架构师接龙：盛国军&栾义来

我们知道缓存能够提升性能，但缓存有个致命的问题，就是对事实数据的改变不敏感。如何保持和协调缓存数据和事实数据的一致性？

架构师接龙 岑文初VS. 杨海朝

模块化来降低耦合性时如何把握模块划分的粒度？如何权衡复用性与粒度过细导致依赖复杂的矛盾？

如何处理高并发系统中缓存失效的场景？

目前是如何做好应用的依赖监控的？例如依赖缓存，是否知道缓存的命中率情况、使用率等；依赖外部服务，是否知道外部服务的消耗时间、成功失败情况等。

对于不同系统之间的耦合如何处理？比如前端系统要求快速响应大量的用户请求，但是依赖于后端的服务体系，而服务系统的瓶颈可能在数据库读写上，如何协同这样需求差异化系统工作？

对于系统优化，平时如何查找瓶颈，最后又如何确定优化后是有效的？

架构师接龙 杨海朝VS. 孙立

在错综复杂的庞大系统中，如何避免多条线频繁地发布新代码对线上业务的影响？

在设计一个大规模伸缩性服务时需要做好哪些准备？是否会考虑分区、故障、自动化、异步等方面的问题？

在架构设计中如何应对不断出现的超过预估的数据量和访问量？

架构师接龙 孙立VS. 孙朝晖

你如何看待横向扩展（Scale Out）和纵向扩展（Scale Up）？

大型网站往往会将多种语言进行融合使用，关于这方面，你有什么经验分享？

对于大型系统的突发性故障，如何在架构层面帮助快速定位故障的原因？

架构师接龙：林昊&黄冬

随着数据量的不断增长以及前端应用的不断水平扩充，数据库的压力会成为明显的问题，这个时候常用的方案是数据拆分，在数据拆分时有些什么较好的拆分方式，以及如何能够做到数据拆分后对已有程序不产生影响或产生很小的影响？

数据拆分只是解决数据量增长后带来的问题的一种解决方案，请问是否还有一些其他的方式来解决数据量增长带来的问题呢，以及如何来实现这些方式呢？

对于大型网站而言，经常要面对不可预知的热点事件带来的高流量，如何能够做到避免这样突发的高流量造成网站的不可用呢？

高度可伸缩是互联网追求的目标，基于您的经验，请提供一些构建高度可伸缩系统的最佳实践？

架构师接龙：盛大许式伟VS. 金山张宴

作为系统架构师，您一般会从哪些方面来保证网站的高可用性（降低故障时间）？

您在任务切分上，有什么经验分享？您通过哪些手段保证任务的独立性？

这些讨论中有很多直接学习和借鉴的内容，下面是我感兴趣的几个话题

1. JDK7的新特性，包括GC和并发框架
2. 如何进行代码Review
3. 功能降级，以及如何不断出现的超过预估的数据量和访问量
4. 如何保持和协调缓存数据和事实数据的一致性，以及如何解决缓存失效的问题
5. 通过模块化来降低耦合度
6. 分层接口化和组件化
7. 服务化
8. 应用监测
9. 做好应用的依赖监控，例如依赖缓存，是否知道缓存的命中率情况、使用率等；依赖外部服务，是否知道外部服务的消耗时间、成功失败情况等。
10. 系统之间耦合的处理
11. 异步化、线程池化、事件驱动

Java

Java Socket实战之一 单线程通信

Java Socket实战之二 多线程通信

Java Socket实战之三 传输对象

Java Socket实战之四 传输压缩对象

JVM伪共享

disruptor – Concurrent Programming Framework 并发编程框架

How to Analyze Java Thread Dumps

Architecture

The LMAX Architecture

The LMAX Architecture（中文）

Tumblr架构 – 页面浏览量150亿/月并且比Twitter更难拓展

Pipe Comet

Servlet 3以前，一次http请求就由一个容器线程完成全部处理，容器线程的生命周期取决于整个业务处理的时间（如果后端有依赖系统，例如DB，集中式缓存，外部系统service），由此可见，并发处理请求的数量在容器线程池有限的条件下，直接用容器线程数量/rt（响应时间）即可得到。而容器线程是否真的需要有那么久的生命周期?在整个事务处理过程中是否可以被回收，等到需要时在申请?

ebay_architecture.pdf(2006)

eBay 的Scalability最佳实践

水平切分
避免分布式事务
虚拟化所有层次
Cache

再谈 eBay 的扩展性最佳实践

1）水平切分 Partition Everything

2）异步处理Asynchrony Everywhere

3）自动Automate Everything

4) 故障检测与回溯(Remember Everything Fails)

5）拥抱不一致(Embrace Inconsistency)

Web服务请求异步化介绍

SOA

SOA@eBay读后

SOA @ eBay : How is it a hit

LINUX

linux中的inode简单介绍

Linux会为每一个文件分配一个唯一的inode节点。在linux中，文件的文件名、文件属性、文件内容是分别存储的：文件名存放在目录项（即 dentry）中，文件属性存放在inode中，文件内容存放在block中。Linux在查找文件时，首先先读取dentry，dentry中存储的文 件名和inode编号的一个映射表， 根据这个表找到inode编号，再根据inode找到磁盘中的文件。

Understand UNIX / Linux Inodes Basics with Examples

An Inode number points to an Inode. An Inode is a data structure that stores the following information about a file :

• Size of file
• Device ID
• User ID of the file
• Group ID of the file
• The file mode information and access privileges for owner, group and others
• File protection flags
• The timestamps for file creation, modification etc
• link counter to determine the number of hard links
• Pointers to the blocks storing file’s contents

 

$ stat DW.txt 

File: `DW.txt’
Size: 24908         Blocks: 56         IO Block: 4096   regular file
Device: ca01h/51713d    Inode: 15696241    Links: 1
Access: (0664/-rw-rw-r–)  Uid: (  505/   admin)   Gid: (  505/   admin)
Access: 2011-11-03 18:45:29.000000000 +0800
Modify: 2011-11-03 18:38:33.000000000 +0800
Change: 2011-11-03 18:38:33.000000000 +0800

Linux Performance Monitoring and Tuning Introduction

UNIX Process Overview (Inside a Linux Process, and Types of Process)

7 Practical PS Command Examples for Process Monitoring

List Currently Running Processes (ps -ef, ps -aux)

 

List the Process based on the UID and Commands (ps -u, ps -C)

ps -f -u wwwrun,postfix

ps -f -C tatad.pl

List the processes based on PIDs or PPIDs (ps -p, ps –ppid)

ps -f –ppid 9576
ps -f  -p 25009,7258,2426

List Processes in a Hierarchy (ps –forest)

ps -e -o pid,args –forest

List all threads for a particular process (ps -L)

ps -C java -L -o pid,tid,pcpu,state,nlwp,args

Finding memory Leak (ps –sort pmem)

ps aux –sort pmem

6 Stages of Linux Boot Process (Startup Sequence)

Bg, Fg, &, Ctrl-Z – 5 Examples to Manage Unix Background Jobs

Executing a background job

Appending an ampersand ( & ) to the command runs the job in the background.

Sending the current foreground job to the background using CTRL-Z and bg command

• Press ‘CTRL+Z’ which will suspend the current foreground job.
• Execute bg to make that command to execute in background.

View all the background jobs using jobs command

 

Taking a job from the background to the foreground using fg command

  fg %1 will bring the job#1 (i.e download-file.sh) to the foreground.

Kill a specific background job using kill %

kill %2

Linux / Unix Command: ps

Linux下ps命令详解

linux上进程有5种状态:
1. 运行(正在运行或在运行队列中等待)
2. 中断(休眠中, 受阻, 在等待某个条件的形成或接受到信号)
3. 不可中断(收到信号不唤醒和不可运行, 进程必须等待直到有中断发生)
4. 僵死(进程已终止, 但进程描述符存在, 直到父进程调用wait4()系统调用后释放)
5. 停止(进程收到SIGSTOP, SIGSTP, SIGTIN, SIGTOU信号后停止运行运行)

ps工具标识进程的5种状态码:
D 不可中断 uninterruptible sleep (usually IO)
R 运行 runnable (on run queue)
S 中断 sleeping
T 停止 traced or stopped
Z 僵死 a defunct (”zombie”) process

au(x) 输出格式 :
USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND
USER: 行程拥有者
PID: pid
%CPU: 占用的 CPU 使用率
%MEM: 占用的记忆体使用率
VSZ: 占用的虚拟记忆体大小
RSS: 占用的记忆体大小
TTY: 终端的次要装置号码 (minor device number of tty)
STAT: 该行程的状态:
D: 不可中断的静止
R: 正在执行中
S: 静止状态
T: 暂停执行
Z: 不存在但暂时无法消除
W: 没有足够的记忆体分页可分配
<: 高优先序的行程
N: 低优先序的行程
L: 有记忆体分页分配并锁在记忆体内 (即时系统或捱A I/O)
START: 行程开始时间
TIME: 执行的时间
COMMAND:所执行的指令

PS命令常用用法

ps a 显示现行终端机下的所有程序，包括其他用户的程序。

ps -A 显示所有程序。

ps c 列出程序时，显示每个程序真正的指令名称，而不包含路径，参数或常驻服务的标示。

ps -e 此参数的效果和指定"A"参数相同。

ps e 列出程序时，显示每个程序所使用的环境变量。

ps f 用ASCII字符显示树状结构，表达程序间的相互关系。

ps -H 显示树状结构，表示程序间的相互关系。

ps -N 显示所有的程序，除了执行ps指令终端机下的程序之外。

ps s 采用程序信号的格式显示程序状况。

ps S 列出程序时，包括已中断的子程序资料。

ps -t<终端机编号> 指定终端机编号，并列出属于该终端机的程序的状况。

ps u 以用户为主的格式来显示程序状况。

ps x 显示所有程序，不以终端机来区分。

最常用的方法是ps -aux,然后再利用一个管道符号导向到grep去查找特定的进程,然后再对特定的进程进行操作。

Investment

【经济周期六个阶段】第1阶段经济下滑期：仅有债券是牛市。第2阶段：仅有商品是熊市。第3阶段经济复苏期：都是牛市。第4阶段：只有债券是熊市。第5阶段：只有商品是牛市。第6阶段经济滞胀期：都是熊市

JAVA

JVM -XX: 参数介绍

Understanding JVM Internals

Master/worker or P2P Grid? How about You choose?

JPPF

JPPF makes it easy to parallelize computationally intensive tasks and execute them on a Grid.

CPU 占用过高 （查看Java堆）

常用的Linux系统监控命令

nid : 对应的linux操作系统下的tid

tid: 这个应该是jvm的jmm内存规范中的唯一地址定位，如果你详细分析jvm的一些内存数据时用得上

Programming

再读《重构》

重构的意义之一也是提高开发进度。杀手锏是”不要告诉经理“。

The benefits of reducing memory consumption

Working set size

Subversion Tip of the Week-Recovering Deleted Items

svn log –verbose

This will list all of the changed items in each revision, allowing you to pinpoint the revision where you deleted the file.

svn merge {revision number}

svn copy {revision number}

SOA

服务治理过程演进

服务的调用量越来越大，服务的容量问题就暴露出来，这个服务需要多少机器支撑？什么时候该加机器？
为了解决这些问题，第一步，要将服务现在每天的调用量，响应时间，都统计出来，作为容量规划的参考指标。
其次，要可以动态调整权重，在线上，将某台机器的权重一直加大，并在加大的过程中记录响应时间的变化，直到响应时间到达阀值，记录此时的访问量，再以此访问量乘以机器数反推总容量。

服务多了，沟通成本也开始上升，调某个服务失败该找谁？服务的参数都有什么约定？
这时就需要登记每个服务都是谁负责的，并建立一个服务的文档库，方便检索。

慢慢一些敏感数据也都服务化了，安全问题开始变得重要，谁能调该服务？如何授权？

这样的服务可能需要一个密码，访问时需带着此密码，但如果用密码，要改密码时，就会很不方便，所有的消费方都要改，所以动态生成令牌(Token)可能会更好，提供方将令牌告之注册中心，由注册中心决定是否告之消费方，这样就能在注册中心页面上做复杂的授权模型。

就算是不敏感的服务，也不是能任意调用，比如某服务突然多了一个消费者，这个消费者的请求量直接把服务给拖跨了，其它消费者跟着一起故障。

首先服务提供方需要流控，当流程超标时，能拒绝部分请求，进行自我保护。
其次，消费者上线前和提供者约定《服务质量等级协定(SLA)》，SLA包括消费者承诺每天调用量，请求数据量，提供方承诺响应时间，出错率等，将SLA记录在监控中心，定时与监控数据对比，超标则报警。

虽然有SLA约定，如果不能控制，就只是君子协定，如何确保服务质量？
比如：一个应用很重要，一个不那么重要，它们调用同一个服务，这个服务就应该向重要应用倾斜，而不是一视同仁，当支撑不住时，应限制不重要应用的访问，保障重要应用的可用，如何做到这一点呢。这时，就需要服务路由，控制不同应用访问不同机器，比如：
应用分离：
consumer.application = foo => provider.host = 1,2,3
consumer.application != foo => provider.host = 5,6
读写分离：
method.name = find*,get* => provider.host = 1,2,3
method.name != find*,get* => provider.host = 5,6

随着服务的不停升级，总有些意想不到的事发生，比如cache写错了导致内存溢出，故障不可避免，每次核心服务一挂，影响一大片，人心慌慌，如何控制故障的影响面？服务是否可以功能降级？或者资源劣化？

应用间声明依赖强度，哪些功能强依赖，哪些弱依赖，然后基于依赖强度，计算出影响面，并定期测试复查，加强关键路径上的服务的优化和容错，清理不该在关键路径上的服务。

Windows

Windows 7中Telnet功能安装与测试

Programming

我们什么时候应该使用异常?

错误码

1. 错误信息不丰富
2. 加入错误状态码可能需要改变函数签名
3. 错误状态码可能会被忽略

 

Cloud

谁来拯救云计算

Scalability

Write Through Cache

Cache is a component that will magically store data so that future requests of that same data will not be to the Remote Server, and hence it will improve the performance of our application significantly faster.

Operations

Java应用运维

Architecture

关于排队系统

对事件驱动的消息订阅的再思考

​浅谈架构

如果要更正式点定义，架构就是model和pattern，从而把code串成system。而其中最重要的就是design principles (设计原则），即为什么这个问题要用这个而非那个。更文艺点，再结合点美学，也可以叫作design philosophy (设计哲学或理念)。

然后我们来看什么是model和pattern，这两个具体的定义我还没想出来。先说一下比较，model偏宏观，而pattern偏微观；model重抽象描述，而pattern重具体实现。比如，你的系统有一个服务端和一个客户端，那么client/server就是model，而client与server之间的交互方式则是pattern，比如RPC/message、同步/异步，比如用滑动窗口来组织请求与应答等等。当然，这和系统的尺度有关。如果你zoom in到服务端，此时的model可能就是模块的组织关系，而pattern则是调用方式，比如用function call还是event等。

架构是什么：其实"架构", 就是一个人用于解决常见(注意常见)设计问题的特定方法…

经常有人把"架构"说的很玄乎,很虚. 其实"架构", 就是一个人用于解决常见(注意常见)设计问题的特定方法(注意特定的, 但不一定是一个). 遇到问题稍许有些变化, 他能适当的调整自己的常用(注意常用)设计而去适合这个变化的能力. 这就叫:"架构"设计… 也就是说, 架构是:方法论, 是经验, 更是变通能力.

Reactor模式和NIO

Reactor模式，或者叫反应器模式

Java

 

使用Jakarta Commons Pool处理对象池化

对于没有状态的对象（例如String），在重复使用之前，无需进行任何处理；对于有状态的对象（例如StringBuffer），在重复使用之前，就需要把它们恢复到等同于刚刚生成时的状态。由于条件的限制，恢复某个对象的状态的操作不可能实现了的话，就得把这个对象抛弃，改用新创建的实例了。

Java克隆

Java Support for Large Memory Pages

Java HotSpot VM (Virtual Machine) Performance Tuning: Command-line options

Solving OutOfMemoryError (part 5) – JDK Tools

jps -lvm

-m Output the arguments passed to the main method. The output may be null for embedded JVMs.
-l Output the full package name for the application’s main class or the full path name to the application’s JAR file.
-v Output the arguments passed to the JVM.

Scalability

耗内存应用优化实际案例

Local Cache的小TIP

但本地缓存最大的问题就是数据同步，如果让集中式存储（cache,queue）来通知只会增加复杂度，因此通常最简单的方式就是根据业务数据的敏感度设置不同长短的本地失效时间。但现在如果要设置一个较短的有效期（例如一秒），对于计算机来说已经大大的减轻了压力（1秒对程序来说太久了），但是整体本地缓存对后端保护的效果不佳（特别是后端如果是并发处理能力较弱的系统），如果遇到并发量大的系统，那么就更为突出了。

OOP

Exceptions versus Return Values

深入浅出享元模式

单例模式是邪恶的么？

有状态vs无状态

Stateless or Stateful?
Service objects will usually be stateless. Stateless service layers are highly scalable: They pose no replication issues and there is no need to allocate additional resources for every client. (Remember that one of the key motivations of a middle tier is to share resources between multiple clients.) It is also much easier for stateless service layers to support remote clients, if necessary. A stateless service layer is one concession of object orientation that I find not too painful.

……
If possible, design applications to use a stateless service layer. Hold state in the web tier, rather than in the business logic tier, if possible.

LINUX

简明Vim 练级攻略

free命令中的buffers和cached

Understand UNIX / Linux Inodes Basics with Examples

An Inode number points to an Inode. An Inode is a data structure that stores the following information about a file :

• Size of file
• Device ID
• User ID of the file
• Group ID of the file
• The file mode information and access privileges for owner, group and others
• File protection flags
• The timestamps for file creation, modification etc
• link counter to determine the number of hard links
• Pointers to the blocks storing file’s contents

JAVA

jvm performance tuning (notes)

Thread state transitions diagram

Optimizing ArrayList.removeAll

Performance techniques used in the Hotspot JVM

JAVA线程dump的分析— jstack pid

怎样使用jstack诊断Java应用程序故障

The Commando Pattern

Improving Java Application Performance and Scalability by Reducing Garbage Collection Times and Sizing Memory Using JDK 1.4.1

Deep dive into assembly code from Java

"java -XX:+PrintOptoAssembly -server -cp . Main". The -XX:+PrintOptoAssembly is the magic option, and with this option I get the following, which shows the code of the "foo" method:

Throwable的fillInStackTrace方法

fillInStackTrace每次执行的时候，会清空原来的栈内的trace信息。然后在当前的调用位置处重新建立trace信息， 所以在方法b()中printStackTrace的执行结果跟c()中的是不一样的。 b()方法被c()调用，c()被a()调用，a()被main()调用， 所以在b()中fillInStackTrace时，栈内会包含b(), a(), main()的信息；而在c()中调用fillInStackTrace时，栈内的信息会被刷新为c(), a(), main()。

java数据结构-HashMap

Oracle时间索引的使用

Rope：理论与实践

Java?言默认的 String和 StringBuilder类很难支撑起操纵大量字符串的系统。rope 数据结构可能是更好的替代品。这篇文章介绍 Ropes for Java，这是针对 Java 平台的 rope 实现；本文还将研究性能问题，并提供一些有效使用 rope 库的指导。

Java Memory  Tips & Tricks

JAVA 基本数据类型长度

java关键字Transient

Java对象的大小

在Java中，一个空Object对象的大小是8byte，这个大小只是保存堆中一个没有任何属性的对象的大小。看下面语句：

Object ob = new Object();

    这样在程序中完成了一个Java对象的生命，但是它所占的空间为：4byte+8byte。4byte是上面部分所说的Java栈中保存引用的所需要的空间。而那8byte则是Java堆中对象的信息。因为所有的Java非基本类型的对象都需要默认继承Object对象，因此不论什么样的Java对象，其大小都必须是大于8byte。

   有了Object对象的大小，我们就可以计算其他对象的大小了。

Class NewObject {

    int count;

    boolean flag;

    Object ob;

}

    其大小为：空对象大小(8byte)+int大小(4byte)+Boolean大小(1byte)+空Object引用的大小 (4byte)=17byte。但是因为Java在对对象内存分配时都是以8的整数倍来分，因此大于17byte的最接近8的整数倍的是24，因此此对象的大小为24byte。

这里需要注意一下基本类型的包装类型的大小。因为这种包装类型已经成为对象了，因此需要把他们作为对象来看待。包装类型的大小至少是12byte（声明一个空Object至少需要的空间），而且12byte没有包含任何有效信息，同时，因为Java对象大小是8的整数倍，因此一个基本类型包装类的大小至少是16byte。这个内存占用是很恐怖的，它是使用基本类型的N倍（N>2），有些类型的内存占用更是夸张（随便想下就知道了）。因此，可能的话应尽量少使用包装类。在JDK5.0以后，因为加入了自动类型装换，因此，Java虚拟机会在存储方面进行相应的优化。

说说MaxTenuringThreshold这个参数

在计算存活周期这个阈值时，hotspot会遍历所有age的table，并对其所占用的大小进行累积，当累积的大小超过了survivor space的一半时，则以这个age作为新的存活周期阈值，最后取age和MaxTenuringThreshold中更小的一个值

如希望跟踪每次minor GC后新的存活周期的阈值，可在启动参数上增加：-XX:+PrintTenuringDistribution，输出的信息中的：
Desired survivor size 1048576 bytes, new threshold 7 (max 15)
new threshold 7即标识新的存活周期的阈值为7。

Understanding a Java thread dump

Java Memory Problems

The Top Java Memory Problems – Part 1

The Top Java Memortaiy Problems – Part 2

Hardware

Getting the hang of IOPS

Database

ORACLE数据库事务隔离级

当下列事件发生时，事务就开始了

1、连接到数据库，并执行第一条DML语句

2、前一个事务结束后，又输入了另一条DML语句

NETWOK

记一次TIME_WAIT网络故障

SOA

服务治理过程演进

LINUX

如何在Linux下来查看OS系统块的大小

getconf PAGESIZE

Java

logback与Log4J的区别

The Trove library provides high speed regular and primitive collections for Java

Put your fat Collections on a diet!

Java Collection Performance

Java Sequential IO Performance
HotSpot虚拟机对象探秘

Low GC in Java: Use primitives instead of wrappers

There are two good reason to use primitives instead of wrappers where possible.

• Clarity. By using a primitive, you are making it clear that a null value is not appropriate.
• Performance. Using primitives is often much faster.

Servlet 3.0 新特性详解

1. 异步处理支持：有了该特性，Servlet 线程不再需要一直阻塞，直到业务处理完毕才能再输出响应，最后才结束该 Servlet 线程。在接收到请求之后，Servlet 线程可以将耗时的操作委派给另一个线程来完成，自己在不生成响应的情况下返回至容器。针对业务处理较耗时的情况，这将大大减少服务器资源的占用，并且提高并发处理速度。
2. 新增的注解支持：该版本新增了若干注解，用于简化 Servlet、过滤器（Filter）和监听器（Listener）的声明，这使得 web.xml 部署描述文件从该版本开始不再是必选的了。
3. 可插性支持：熟悉 Struts2 的开发者一定会对其通过插件的方式与包括 Spring 在内的各种常用框架的整合特性记忆犹新。将相应的插件封装成 JAR 包并放在类路径下，Struts2 运行时便能自动加载这些插件。现在 Servlet 3.0 提供了类似的特性，开发者可以通过插件的方式很方便的扩充已有 Web 应用的功能，而不需要修改原有的应用。

Architecture

历届「Jolt Awards」获奖书籍

企业应用架构模式

响应性不同于请求处理，它是系统响应请求的速度有多快。这个指标在许多系统里非常重要，因为对于一些系统而言，如果其响应太慢，用户将难以忍受——尽管其响应时间可能不慢。如果能够在处理真正完成之前就给用户一些信息表明系统已经接到请求，则响应性就会好一些。例如，进展条。

一条关于依赖性的普遍原则：领域层和数据源层绝对不要依赖于表现层。

领域逻辑的组织可以分为三种主要的模式：事务脚本、领域模型以及表模块。

事务脚本是这样一个过程：从表示层获得输入、进行校验和计算处理、将数据存储到数据库中以及调用其他系统的操作等。基本的组织方式是让每个过程对应用户可能做的一个动作。所以，我们可以将这一模型想像成一个动作或业务事务的脚本。每一个动作是由一个过程来驱动。

在领域模型中，不再是由一个过程来控制用户某一动作的逻辑，而是由每一个对象都承担一部分相关逻辑。

在许多方面，表模块是事务脚本和领域模型的一个中间地带。它围绕表而非直接围绕过程来组织领域逻辑，提供了更多的结构，而且更容易发现和移除冗余代码。但是，你无法应用许多在领域模型中可以使用的组织细粒度逻辑结构的技术，例如继承、策略和其他面向对象的设计模式。

通常，序列化LOB（大对象Large OBject）对于用来组成应用程序部分的相对独立对象群而言是最好的。但如果过多使用它，最终会把数据库弄得和事务文件系统差不多。

对于任何继承结构，一般都有三种选择。可以为一个层次中的所有类建立一个表，即单表继承；也可以为每个具体类建立一个表，即具体表继承；或者为这个层次中每一个类建立一个表：类表继承。

这三种方法有利有弊。单表继承浪费空间，但避免了连接操作；具体表继承在超类改变时不得不改变所有表，但它也避免了连接操作，允许从一个表取得一个对象；类表继承需要多个连接操作来载入一个对象，这样通常损失了性能，但它是类和表之间最简单的关系。

如果机器处在屏幕流的控制下，那么你就需要应用控制器；如果这台机器是在用户的控制下，你就不要应用控制器。

在视图方面，可以考虑三种模式：转换视图、模板视图和两步视图。

对任何并发程序的本质来说，仅仅考虑正确性是不够的，还必须考虑灵活性（即有多少并发活动可以同时进行）。人们常常需要牺牲一些正确性以获取更多的灵活性，这取决于失败的严重性和可能性以及人们对并发处理数据的需求。

并发问题有两个非常重要的解决方案：一个是隔离（isolation），一个是不变性（immutability）。

在乐观锁和悲观锁之间进行选择的标准是：冲突的频率与严重性。如果冲突很少，或者冲突的后果不会很严重，那么通常情况下应该选择乐观锁，因为它能得到更好的并发性，而且更容易实现。但是，如果冲突的结果对于用户来说是痛苦的，那么就需要使用悲观锁策略。

超时控制和检测机制处理已经出现的死锁，而其他的方法则尽力防止死锁的发生。

跨越多个请求的事务称为长事务。

在请求开始时启动事务，在请求结束时提交事务，这是请求事务。

另一种方法是尽可能晚打开事务。使用延迟事务时，应在事务外完成读取数据的操作，只在修改数据的时候启动事务。然而，这可能会导致不一致读问题。

当可以并发执行并且结果与以某种顺序依次执行的结果相同时，事务就是可串行化的（serializable）。

如果系统中有很多用户，应该考虑使用集群来提高吞吐率。会话迁移（session migration） 允许一次会话从一台服务器转移到另一台服务器，从而可以由一台服务器处理一个请求，其他服务器处理其他的请求。与其相反的方式是服务器亲和（server affinity），它要求某次特定会话的所有请求只能由同一台服务器处理。

分布对象设计第一定律：不要分布使用对象。

这种情况下，怎样有效利用多处理器资源呢？大多数情况下是使用集群系统。在每一个处理器上都部署所有的对象并在其他几个节点上复制它们。这样一来，每个处理器上的对象只需用到本地调用，从而运行更快。还可以使用细粒度接口来设计对象，从而得到更简单的编程模型和更好的可维护性

Architecture

Event stream processing

Java

使maven2在下载依赖包的同时下载其源代码包

1. 使用maven命令：mvn dependency:sources 下载依赖包的源代码。
2. 使用参数： -DdownloadSources=true 下载源代码jar。 -DdownloadJavadocs=true 下载javadoc包。

Protocol Buffers, Avro, Thrift & MessagePacks

Thread-Local Allocation Buffers 

HotSpot JVM中的垃圾收集

快速分配
从下文对垃圾收集器的描述中可以看出，在许多情况下，内存中都有大块的连续空闲空间用以满足对象的分配请求。这种情形下的分配操作使用简单的“bump-the-pointer”技术，效率很高。按照这种技术，JVM内部维护一个指针（allocatedTail），它始终指向先前已分配对象的尾部，当新的对象分配请求到来时，只需检查代中剩余空间（从allocatedTail到代尾geneTail）是否足以容纳该对象，并在“是”的情况下更新allocatedTail指针并初始化对象。下面的伪代码具体展示了从连续内存块中分配对象时分配操作的简洁性和高效性：
void * malloc(int n){
if( geneTail – allocatedTail < n )

doGarbageCollection();
void * wasAllocatedTail = allocatedTail;
allocatedTail += n;
return wasAllocatedTail;
}
对于多线程应用，分配操作必须是线程安全的。如果使用全局锁为此提供保证，则分配操作必定成为一个性能瓶颈。基于此，HotSport JVM采用了一种被称为“线程局部分配缓冲区”（Thread-Local Allocation Buffers，TLAB）的技术。该项技术为每个线程提供一个独立的分配缓冲区（伊甸区的一小部分），借此来提高分配操作的吞吐量。因为针对每个TLAB，只有一个线程从中分配对象，故而分配操作可以使用“bump-the-pointer”技术快速完成，而不必使用任何锁机制；只有当线程将其已有TLAB填满并且需要获取一个新的TLAB时，同步才是必须的。同时，为了减少TLAB所带来的空间消耗，还使用了一些其他技术，例如，分配器能够把TLAB的平均大小限制在伊甸区的１％以下。
“bump-the-pointer”和TLAB技术的组合保证了分配操作的高效性，类似new Object()这样的操作在大部分时间内只需要大约10条机器指令即可完成

Java线程的6种状态

NEW

至今尚未启动的线程处于这种状态。

RUNNABLE

正在 Java 虚拟机中执行的线程处于这种状态。处于可运行状态的某一线程正在 Java 虚拟机中运行，但它可能正在等待操作系统中的其他资源，比如处理器。

BLOCKED

受阻塞并且正在等待监视器锁的某一线程的线程状态。处于受阻塞状态的某一线程正在等待监视器锁，以便进入一个同步的块/方法，或者在调用 Object.wait 之后再次进入同步的块/方法。

WAITING

无限期地等待另一个线程来执行某一特定操作的线程处于这种状态。某一线程因为调用下列方法之一而处于等待状态：

1、不带超时值的 Object.wait

2、不带超时值的 Thread.join

3、LockSupport.park

处于等待状态的线程正等待另一个线程，以执行特定操作。 例如，已经在某一对象上调用了 Object.wait() 的线程正等待另一个线程，以便在该对象上调用 Object.notify() 或 Object.notifyAll()。已经调用了 Thread.join() 的线程正在等待指定线程终止。

TIMED_WAITING

具有指定等待时间的某一等待线程的线程状态。某一线程因为调用以下带有指定正等待时间的方法之一而处于定时等待状态：

1、Thread.sleep

2、带有超时值的 Object.wait

3、带有超时值的 Thread.join

4、LockSupport.parkNanos

5、LockSupport.parkUntil

TERMINATED

已终止线程的线程状态。线程已经结束执行。

G1 Garbage Collector

Java关于JIT的原理和相关知识

关于Lazy-UnLocking（Reservation Lock）对Java锁的性能优化

关于JVM的Thin Lock, Fat Lock, SPIN Lock与Tasuki Lock

JVM相关知识

TLAB全称叫 Thread Local Allocation Buffer），Sun JDK为了提高对象生成的效率，在Eden哪里为每一个新创建的线程创造一个这么样的空间。TLAB的大小一般都是由JVM 运行计算得出的，但是可以通过-XX:TLABWasteTargetPercent来设置TLAB可占用的Eden Space
的百分比，默认值为1%。
在TLAB分配内存时不需要加锁，因为在堆上分配内存时候要加锁，所以在TLAB分配时效率快很多。当然 这只是适合小对象分配。其分配细节取决于具体的GC。

Windows

Windows 性能监控

perfmon.msc 性能监视器

Windows uses the term “Privileged Time” to represent kernel or system CPU Utilization.

typeperf

利用TypePerf.exe

LINUX

mpstat使用详解

user 在internal时间段里，用户态的CPU时间（%） ，不包含 nice值为负 进程 usr/total*100

nice 在internal时间段里，nice值为负进程的CPU时间（%） nice/total*100

system 在internal时间段里，核心时间（%） system/total*100

iowait 在internal时间段里，硬盘IO等待时间（%） iowait/total*100

irq 在internal时间段里，软中断时间（%） irq/total*100

soft 在internal时间段里，软中断时间（%） softirq/total*100

idle 在internal时间段里，CPU除去等待磁盘IO操作外的因为任何原因而空闲的时间闲置时间 （%） idle/total*100

intr/s 在internal时间段里，每秒CPU接收的中断的次数 intr/total*100

CPU总的工作时间=total_cur=user+system+nice+idle+iowait+irq+softirq

total_pre=pre_user+ pre_system+ pre_nice+ pre_idle+ pre_iowait+ pre_irq+ pre_softirq

user=user_cur – user_pre

total=total_cur-total_pre

其中_cur 表示当前值，_pre表示interval时间前的值。上表中的所有值可取到两位小数点。

使用pidstat命令监视进程

Scalability

CAP理论及BASE思想等

OOP

静态类的原罪

Java

各种java序列化工具性能对比

 

LINUX

linux 统计目录下的文件数量

第一种方法： ls -l|grep "^-"|wc -l ls -l 长列表输出该目录下文件信息(注意这里的文件，不同于一般的文件，可能是目录、链接、设备文件等)。

第二种方法： ls -lR|grep "^-"|wc -l

linux du 显示路径下各子目录大小

du -h –max-depth=1 /backup/

 

通过IOStat命令监控IO性能

• rrqm/s：队列中每秒钟合并的读请求数量
• wrqm/s：队列中每秒钟合并的写请求数量
• r/s：每秒钟完成的读请求数量
• w/s：每秒钟完成的写请求数量
• rsec/s：每秒钟读取的扇区数量
• wsec/s：每秒钟写入的扇区数量
• avgrq-sz：平均请求扇区的大小
• avgqu-sz：平均请求队列的长度 。毫无疑问，队列长度越短越好。
• await：平均每次请求的等待时间。await是平均每次请求的等待时间。这个时间包括了队列时间和服务时间，也就是说，一般情况下，await大于svctm，它们的差值越小，则说明队列时间越短，反之差值越大，队列时间越长，说明系统出了问题。
• svctm：平均每次请求的服务时间。从源代码里可以看出：(r/s+w/s)*(svctm/1000)=util。举例子：如果util达到100%，那么此时svctm=1000/(r/s+w/s)，假设IOPS是1000，那么svctm大概在1毫秒左右，如果长时间大于这个数值，说明系统出了问题。
• util：设备的利用率。如果它接近100%，通常说明设备能力趋于饱和（并不绝对）。有时候会出现大于100%的情况，这是因为读取数据的时候是非原子操作。

Scalability

深入浅出Flashcache（一）

投资

趋势是什么？总听到人说“顺势而为”，其实很多人并没搞清楚。股市的趋势是要分时间周期的，对以周为单位的人来说，最近3周的趋势无疑是下跌的；对于以日为单位的人来说，上周4的日内趋势就是上涨。因此请先确定你的操作频率，以周为单位应该做空，以日为单位在上周4就应该做多，都是可以盈利的！

欧债危机到底是怎么回事

Java

java nio 之MappedByteBuffer

理解Heap Profling名词-Shallow和Retained Sizes

Shallow Size
对象自身占用的内存大小，不包括它引用的对象。
针对非数组类型的对象，它的大小就是对象与它所有的成员变量大小的总和。当然这里面还会包括一些java语言特性的数据存储单元。
针对数组类型的对象，它的大小是数组元素对象的大小总和。

Retained Size
Retained Size=当前对象大小+当前对象可直接或间接引用到的对象的大小总和。(间接引用的含义：A->B->C, C就是间接引用)
换句话说，Retained Size就是当前对象被GC后，从Heap上总共能释放掉的内存。
不过，释放的时候还要排除被GC Roots直接或间接引用的对象。他们暂时不会被被当做Garbage。

LINUX

理解Inode

Architecture

关于复杂事件处理和事件驱动架构的争论

EDA: Event-Driven Architecture事件驱动架构

高性能队列Fqueue的设计和使用实践

Java读写

BufferedOutputStream虽然最快，但是易丢失数据，权衡之下，我们选择了MappedByteBuffer作为我们的文件操作实现