BlogJava-星游领地-随笔分类-java

从Tomcat 6.0开始，Tomcat引入一个对Apache Commons Logging重命名包后的私有实现，从而允许web应用使用他们自己独立的原Apache Commons Logging库的lib包。在默认的发布包中，Apache Commons Logging私有实现是简单被硬编码到java.util.logging框架。

实际使用中，通过配置org.apache.catalina.valves.AccessLogValve可以让tomcat打印访问日志（默认禁用掉的）

王星游 2014-07-13 19:04 发表评论

logback_config_demo

王星游 — Sun, 13 Jul 2014 11:03:00 GMT

我自己常用的一个logback配置框架，有需要再在上面添加：

1 xml version="1.0" encoding="UTF-8"?>
2
3 <configuration>
4
5     <statusListener class="ch.qos.logback.core.status.OnConsoleStatusListener"/>
6
7
8     <consolePlugin />
9
10
11     <property name="LOG_PATH" value="d:/log" />
12
13
14
15     <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
16         <encoder>
17             <pattern>
18                 %d{HH:mm:ss.SSS} [%t] %-5p  %c{1} - %m%n
19             pattern>
20         encoder>
21     appender>
22
23
24     <appender name="COMMON-DEFAULT-APPENDER" class="ch.qos.logback.core.rolling.RollingFileAppender">
25         <File>${LOG_PATH}/common-default.logFile>
26         <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
27             <FileNamePattern>
28                 ${LOG_PATH}/common-default.%d.log.gz
29
30             FileNamePattern>
31         rollingPolicy>
32         <encoder>
33             <Pattern>
34                 %d [%t] %-5p  %c{1} - %m%n
35             Pattern>
36         encoder>
37
38     appender>
39
40
41     <appender name="COMMON-ERROR-APPENDER" class="ch.qos.logback.core.rolling.RollingFileAppender">
42         <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
43             <level>ERRORlevel>
44         filter>
45         <File>${LOG_PATH}/common-error.logFile>
46         <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
47             <FileNamePattern>
48                 ${LOG_PATH}/common-error.%d.log.gz
49
50             FileNamePattern>
51         rollingPolicy>
52         <encoder>
53             <Pattern>
54                 %d [%t] %-5p  %c{1} - %m%n
55             Pattern>
56         encoder>
57
58     appender>
59
60
61     <root>
62         <level value="DEBUG"/>
63         <appender-ref ref="STDOUT"/>
64         <appender-ref ref="COMMON-DEFAULT-APPENDER"/>
65         <appender-ref ref="COMMON-ERROR-APPENDER"/>
66     root>
67
68 configuration>
69

王星游 2014-07-13 19:03 发表评论

logback_eclipse_plugin_beagle

王星游 — Sun, 13 Jul 2014 11:01:00 GMT

http://logback.qos.ch/beagle/index.html

先安装依赖插件：

http://download.eclipse.org/technology/nebula/snapshot (注意这个是稳定的release版的地址，只需要安装“Nubula Release Individual Widgets”中的“Nebula Grid Feature”即可)

再安装logback-beagle插件：

http://logback.qos.ch/p2/ ( "Logback" "Logback Beagle" "SLF4J"这三个都得选)

完成后按“alt-shift-Q,Q”弹出view选择框，找到beagle打开即可（之后需要在logback-test.xml里配置，参见logback文档）。

在logback-test.xml里加上配置即可

——实际上这个配置会自动创建一个SocketAppender，并把日志发到本机的4321端口。

单击停止滚动，双击开始滚动

右键菜单可以跳转到调用行，也可以查看最多8行调用栈

配置：

eclipse的preference里:

Run/Debug - Beagle

在这里可以自定义控制台输出的pattern

General - Appearance - Colors and Fonts

可以单独对Beagle设置字体

王星游 2014-07-13 19:01 发表评论

logback_doc_manual_09_logging_separation

王星游 — Sun, 13 Jul 2014 11:00:00 GMT

http://logback.qos.ch/manual/loggingSeparation.html

主要处理多个应用程序运行在同一个web容器，并且每个应用使用各自独立的日志环境。

——想想一个tomcat运行了多个项目——也就是“一个JVM，多个ClassLoader，每个ClassLoader拥有自己独立的Logger Context”的问题。

Context Selectors

调用LoggerFactory.getLogger("foo")的时候，会要求SLF4J绑定一个ILoggerFactory，如果SLF4J使用的是logback，那么“绑定ILoggerFactory”的方法，会代理给一个ContextSelector实例，该实例会根据情况返回最合适的LoggerContext对象——这个对象实现了ILoggerFactory接口。

默认总是返回DefaultContextSelector，可以在系统属性里通过logback.ContextSelector属性指定自己的类。

ContextJNDISelector

根据JNDI查找Selector——这样可以在各个项目的web.xml里配置自己的JNDI环境变量。

为了在单个web项目重启和关闭的时候，对应的logger Context可以被回收，最好配置ContextDetachingSCL监听器

不过每次获取logger都查找JNDI太慢，可以配置LoggerContextFilter过滤器来避免——会在每个http请求到来的时候把logger context放在线程内部，从而允许之后跳过JNDI搜索。

此时最好把logger全声明成static的，减少logger的获取总次数。

Taming static references in shared libraries

如果有一个类属于共享包，被两个web项目同时引用

1，当这个类使用非静态logger时，一切良好，来自两个web项目的调用，会返回各自的logger context。

2，当这个类使用静态logger时，会错误的返回首次调用它的web项目的logger context——对这个问题ContextJNDISelector无能为力（eluded a solution for eons... 哈哈哈哈）

对于上述的“来自共类的静态logger，获取不同的logger context”的问题，有几个的办法：

1，共享类改成非静态logger——一般不现实，因为共享类的源码往往不受项目控制。

2，把共享类挪到web项目里——也够呛，一个两个类还好，那么多第三方依赖咋弄？

3，所以还有一种取巧的办法：用SiftingAppender，根据JNDI信息把不同的日志分别输出到不同的文件里去（logback提供了JNDIBasedContextDiscriminator帮助做这事儿）——也就是说，两个项目分享同一个logger，等到其关联的appender需要把event输出到文件时，再临时决定输出到哪个文件。

上述第3种方法有一个问题：

假如项目A和项目B都使用共享包S。

项目A启动并调用S的时候，就已经把S的logger context设置为A了，日志会写入A.log中。

B启动并调用S的时候logger contex依然是A（不过因为配置了SiftingAppender的存在，B的日志依然可以写到正确的B.log中）

——也就是说，共享logger的问题并没有实质解决，这个logger还是只能属于A或者B其中之一，只不过logger在写日志前根据MDC里的JNDI可以将日志写到正确的文件中去。

而初始化了两个不同的logger context都指向B.log，存在多个线程写同一个文件的不安全问题——需要对appender配置prudent参数来解决（会影响性能）。

（正常使用都是一个web container部署一个web项目，很少遇到上述情况。这部分文档看的很蛋疼……）

王星游 2014-07-13 19:00 发表评论

logback_doc_manual_07_filters

王星游 — Sun, 13 Jul 2014 10:59:00 GMT

http://logback.qos.ch/manual/filters.html

logback-classic有两种filter：Regular filters和turbo filters，挂在appender上

Regular filters

只有一个decide()方法，返回DENY, NEUTRAL or ACCEPT

LevelFilter

INFO

DENY

ThresholdFilter

高于或等于指定日志级别的记录，会返回NEUTRAL

INFO

EvaluatorFilter

EventEvaluator的实现判断某个条件是否满足。

GEventEvaluator

接受groovy语法的布尔表达式作为判断条件，需要依赖Groovy运行时，表达式语句在配置的时候完成编译。

logback会自动将目标事件作为一个变量传进来，可以用“event”或者“e”来引用。

TRACE, DEBUG, INFO, WARN and ERROR这些级别也引入了，所以可以这样判断相等： "event.level == DEBUG" 。

其他比较符，大于小于，需要转换成int再比较。

e.level.toInt() >= WARN.toInt() &&
!(e.mdc?.get("req.userAgent") =~ /Googlebot|msnbot|Yahoo/ )

DENY
NEUTRAL

JaninoEventEvaluator

使用java表达式，使用上比基于groovy的GEventEvaluator繁琐，但执行速度更快。

详情略。

Matchers

执行上面的过滤器时，可以调用String.matches()方法，但代价是每次需要重编译一个正则Pattern对象。

所以可以预先定义和编译一个，以便复用。

详情略。

TurboFilters

跟普通过滤器功能一样，但是：

1，TurboFilter是跟logging context关联的，而不是跟appender关联。作用域更大。不仅在指定appender使用时，而且在每次logging请求时都会被调用。

2，他们是在LoggingEvent对象创建之前被调用，过滤时不需要event实例做参数，所以性能更高（因为在event创建之前就已经执行过滤了）。

内置了一些TurboFilter：

MDCFilter 测试指定的值是否存在于MDC中

DynamicThresholdFilter 基于MDC的key和level来限流

MarkerFilter 测试指定的marker是否出现在请求中

DuplicateMessageFilter

自动过滤相同的消息。

使用简单的字符串比对——即使两个字符串基本相同，相差一两个字母：也会被认为不同。

仅比较raw字符串，用{}转义过的字符串不去比较。

可以通过AllowedRepetitions设置允许的重复上限，超过上限的会被抛弃。默认大小为5

需要通过一个内部cache来保存老的消息以便判断，可以通过CacheSize设置缓存大小，默认100.

在evaluator的expression里，将logging时间与项目启动时间对比，可以控制仅输出“项目启动后20秒内的某类型日志”——这个对于“确认某个定时任务在启动时是运行状态”很有用，例如：

logger.getName().contains("LoggingTask") &&
message.contains("Howdydy-diddly-ho") &&
(timeStamp - event.getStartTime()) >= 20000

DENY

王星游 2014-07-13 18:59 发表评论

logback_doc_manual_08_mapped_diagnostic_contexts

王星游 — Sun, 13 Jul 2014 10:59:00 GMT

http://logback.qos.ch/manual/mdc.html

MDC（注意这个类在org.slf4j包里）

基于“多个线程同步处理多个请求”的假设来设计的，上下文信息记录。

——子线程会自动拷贝双亲线程的这类信息。

——如果没有附加处理的话，放入线程池处理的任务会丢失MDC上下文。

该设计假定向MDC放数据的速度不会太快。

最常用的web场景，是集成在一个servlet的Filter中，在请求时载入MDC信息，doFilter处理完成后卸载MDC信息。

——最好在“验证用户”这个Filter之后（或者之中）进行，这样可以把用户验证信息（包括但不限于用户名）写入MDC。

交给线程池处理(submit)之前：MDC.getCopyOfContextMap()，把返回的map当作参数传给任务线程

线程池处理代码的第一行：MDC.setContextMapValues()，把接到的map参数设置到本线程的MDC中（别忘了最后清除掉）

MDCInsertingServletFilter

将web请求常用信息设置到MDC中：

req.remoteHost as returned by the getRemoteHost() method

req.xForwardedFor value of the "X-Forwarded-For" header

req.requestURI as returned by getRequestURI() method

req.requestURL as returned by getRequestURL() method

req.queryString as returned by getQueryString() method

req.userAgent value of the "User-Agent" header

web.xml中的配置

MDCInsertingServletFilter

ch.qos.logback.classic.helpers.MDCInsertingServletFilter

MDCInsertingServletFilter
/*

注意filter顺序，经过该filter过滤之后，其它filter才能打印出MDC信息（特别是struts之类依赖filter处理主逻辑的）

使用例子：

%X{req.remoteHost} %X{req.requestURI}%n%d - %m%n

——其实没多大意义，还是自己写这个filter，挑选自己的有效信息比较好。

王星游 2014-07-13 18:59 发表评论

logback_doc_manual_05_encoders

王星游 — Sun, 13 Jul 2014 10:58:00 GMT

http://logback.qos.ch/manual/encoders.html

Encoder

负责将事件对象转换为字节数组.

目前只有PatternLayoutEncoder是唯一有用的Encoder。

LayoutWrappingEncoder

兼容的包装器（因为老版本的logback是跳过Encoder直接依赖Layout的）

PatternLayoutEncoder

针对PatternLayout（最常用的layout）定制的兼容包装器。

immediateFlush属性：是否将日志立刻写入磁盘，默认为true。将这个选项设为false可以达高4到5倍的吞吐量。

foo.log

%d %-5level [%thread] %logger{0}: %msg%n

false

outputPatternAsHeader属性：在日志文件的顶部输出一行字符串样式，默认flase。

foo.log

%d %-5level [%thread] %logger{0}: %msg%n
true

输出结果：

#logback.classic pattern: %d [%thread] %-5level %logger{36} - %msg%n
2012-04-26 14:54:38,461 [main] DEBUG com.foo.App - Hello world
2012-04-26 14:54:38,461 [main] DEBUG com.foo.App - Hi again

王星游 2014-07-13 18:58 发表评论

logback_doc_manual_06_layouts

王星游 — Sun, 13 Jul 2014 10:58:00 GMT

http://logback.qos.ch/manual/layouts.html

PatternLayout

转换模式类似于C语言里的printf()。

转移字符：

c{length}

lo{length}

logger{length}

其中的length代表输出的logger长度。

设为0的话例外，仅输出最右边的logger名。

其余情况会自动计算，尽量使得输出的总字符串长度小于指定长度——但是，最右边的logger名称无论如何会完整保留，同时前面的每一级logger，最少会被精简到1个字符。

——%c{1}

C{length}

class{length}

打印调用者的类名称，设置方法与上面一样。

性能不高。

contextName

打印logger在event最初绑定的logger context的名称。

d{pattern}

date{pattern}

d{pattern, timezone}

date{pattern, timezone}

输入日志时间，使用java.text.SimpleDateFormat的日期格式化方法。

如果不指定日期格式，默认使用ISO8601，也就是2006-10-20 14:06:49,812这种形式。

——%d

F / file

输出java源文件的名称。

性能不高。

caller{depth}

caller{depth, evaluator-1, ... evaluator-n}

打印日志事件的调用堆栈。

使用评估器evaluator决定是否打印。

line

输出日志记录请求发起的行数。

性能不高。

msg

message

日志正文

——%m

method

日志调用方法名。

性能不高

操作系统对应的换行符

——%n

level

日志等级

relative

应用程序启动到日志创建的相对时间

thread

线程名

——%t

X{key:-defaultVal}

mdc{key:-defaultVal}

MDC信息

ex{depth}

exception{depth}

throwable{depth}

ex{depth, evaluator-1, ..., evaluator-n}

exception{depth, evaluator-1, ..., evaluator-n}

throwable{depth, evaluator-1, ..., evaluator-n}

输出异常堆栈深度（如果有的话），默认full全部输出。

可以指定的参数值：

short：打印堆栈的第一行

full：打印所有行

任何数字：指定行数

使用评估器evaluator决定是否打印。

xEx{depth}

xException{depth}

xThrowable{depth}

xEx{depth, evaluator-1, ..., evaluator-n}

xException{depth, evaluator-1, ..., evaluator-n}

xThrowable{depth, evaluator-1, ..., evaluator-n}

跟上面的类似，但是附加了包信息。

如果包信息不准确（是猜测的），那么会自动在包信息前面附加一个“~”字符。

如果在日志信息模式里，未指定任何异常格式，那么系统会自动在末尾加上一个%xEx。

如果不想打印包信息（例如netbean里会出问题），那么在日志模式的末尾明确指定%ex即可，就会输出不包含包信息的堆栈。

如果想不打印任何异常堆栈信息，可以使用%nopex。

——%xEx

nopex

nopexception

加上%nopex可以阻止系统自动在日志模式末尾添加%xEx——也就是完全禁止异常堆栈打印。

marker

输出关联的marker信息，如果marker多级关联，会都打印出来。

property{key}

输出key关联的属性——定义在logger context或者system properties里面。

replace(p){r, t}

将p中的所有符合r正则的字符串，都替换成t。

例如%replace(%logger%msg){'\.', '/'}，会将输出的logger和msg信息中的点号都替换成斜杠。

rEx{depth}

rootException{depth}

rEx{depth, evaluator-1, ..., evaluator-n}

rootException{depth, evaluator-1, ..., evaluator-n}

类似于xEx，也会打印异常的包信息，但是会将root exception打印到前面，跟普通的异常打印顺序是反着的。

转义百分号： \%

正常情况下转义字符会被正确分割，但有些时候例外，例如%date%nHello，系统会解析%nHello失败。如果真的需要在%n后紧跟一个Hello，可以这样：%date%n{}Hello

我一般用这个：

%d [%t] %-5p %c{1} - %m%n

------------------------------------------------------------------

Format modifiers

控制数据段的补齐。
例如 %20.30logger

如果logger长度小于20，则从左边用空格补齐；如果logger长度大于30，则从开头(左边)切去多余字符。

如果20或者30前面有负号，则左右颠倒。

假如想给日志级别只输出1个字符（T,D,W,I,E），不需要自己写一个Converter，而只需要配置一下即可：%.-1level

转义选项：

如果转义选项里面包含特殊字符（特别是在使用正则表达式的时候），例如大小括号、逗号、空格，那么可以用单引号或双引号括起来，例如：

%-5level - %replace(%msg){'\d{14,16}', 'XXXX'}%n

——这个可以把14到16位的数字（信用卡号）转换为XXXX。

------------------------------------------------------------------

括号的特殊作用：

%-30(%d{HH:mm:ss.SSS} [%thread]) %-5level %logger{32} - %msg%n

可以让括号里的两个表达式联合起来按照30个字符补齐。

括号可以用反斜杠转义：$%d{HH:mm:ss.SSS} [%thread]$

------------------------------------------------------------------

Coloring

着色，window需要引其它包，linux和mac os本身支持着色。

样例：[%thread] %highlight(%-5level) %cyan(%logger{15}) - %msg %n

%highlight会将ERROR设为红色加粗，WARN设为红色，INFO设为蓝色，其余默认。

%cyan会将logger名称设为蓝绿色。

------------------------------------------------------------------

Evaluators

EventEvaluator类的实现，用来评估一个事件是否符合打印条件。

logger.contains("chapters.layouts") && \
message.contains("who calls thee")

%-4relative [%thread] %-5level - %msg%n%caller{2, DISP_CALLER_EVAL}

注意因为xml的关系，要用&转义&

应用场景：

例如，如果日志级别是WARN以上，并且logger是来自一个财务模块——那么就打印caller信息。

注意：

在%caller转义模式中，当Evaluators返回true的时候才输出。

在%ex转义模式中，当Evaluatorstrue的时候不输出。

例如下面的配置，当异常对象为TestException时，不输出。

throwable != null && throwable instanceof \
chapters.layouts.TestException

%msg%n%ex{full, DISPLAY_EX_EVAL}

------------------------------------------------------------------

Creating a custom conversion specifier

略

------------------------------------------------------------------

HTMLLayout

使用html表格来布局日志信息。

可以使用普通的pattern转义符，但转义字符之前，不许用包括空格在内的任何字符分隔。

%relative%thread%mdc%level%logger%msg

test.html

HTMLLayout会自动创建一个DefaultThrowableRenderer，将异常信息打印到完整的一行里。如果不想这样，可以指定一个NOPThrowableRenderer。

用CSS指定表格的样式：略

该Layout最常见的用法是配合SMTPAppender，发送html格式的日志邮件。

------------------------------------------------------------------

Logback access

略

王星游 2014-07-13 18:58 发表评论

logback_doc_manual_04_appenders

王星游 — Sun, 13 Jul 2014 10:57:00 GMT

http://logback.qos.ch/manual/appenders.html

Appender都集成ch.qos.logback.core.Appender接口。

每个Appender可以绑定若干个Filter。

每个Appender可以将任务代理给Layout或者Encoder。

每个Layout或者Encoder只能属于1个Appender。

Appener也可以不包含Layout或者encoder，例如SocketAppender，直接把Event序列化传输。

ch.qos.logback.core.AppenderBase这是一个抽象类，对Appender接口提供了骨架实现，线程安全。

ch.qos.logback.core.UnsynchronizedAppenderBase是对应的线程不安全的类，但是可以将线程安全性委托给下一层的类（例如OutputStream）

OutputStreamAppender是文件输出和控制台输出Appender的父类，类层次结构如下：

ConsoleAppender

输出到System.out or System.err

可配置属性：

encoder

target: 默认是System.out

withJansi：默认false，用来在windows中支持控制台色彩的

样例：

%-4relative [%thread] %-5level %logger{35} - %msg %n

----------------------------------------------------------

FileAppender

写入到文件（新消息到来，写入前，才会判断是否该分割文件等）

可配置属性：

append：文件追加，默认为true

encoder：

file：文件路径和名词（如果windows下，记得分隔符转义）

prudent：谨慎模式，不同JVM（甚至存在于不同主机上）安全的写入同一个文件。默认关闭。

默认每行都flush到磁盘，可以修改Encoder的immediateFlush属性来改变这一行为。

样例：

testFile.log

true

%-4relative [%thread] %-5level %logger{35} - %msg%n

唯一名词的记录文件（通过启动时间戳）：

log-${bySecond}.txt

%logger{35} - %msg%n

——这样就可以在每次项目启动时生成一个新的文件。

默认是使用xml解析的时间，也可以指定使用log context的创建时间：

timeReference="contextBirth"/>

----------------------------------------------------------

RollingFileAppender

滚动记录日志文件

有两个子组件：

RollingPolicy ——接管“滚动”操作，控制该操作如何发生

TriggeringPolicy ——决定滚动操作是否发生，何时发生

默认情况下，必须同时含有上述两个组件。不过有的RollingPolicy也实现了后者的接口，那么可以身兼2职。

可配置属性：

file：

append：

encoder：

rollingPolicy：

triggeringPolicy：

prudent：

RollingPolicy

包含的操作：将当前的日志文件归档（并重命名），压缩（如果需要）

TimeBasedRollingPolicy

最常用的，基于时间滚动，同时实现了RollingPolicy和TriggeringPolicy

可配置属性：

fileNamePattern：文件名匹配格式

文件名+日期定义器“%d”

日期定义器的格式在SimpleDateFormat中定义

滚动周期是通过日期定义器推断出来的

其父元素RollingFileAppender中file属性可以省略（因为可以用fileNamePattern猜测出当前时间的日志名）

也可以不省略，这样可以为“当前日志文件”和“归档日志文件”分别制定不同的路径

日志定义器中的正反斜杠都会被认为是目录分隔符

可以指定多个日期定义器，但只能有1个是主要的，其余的必须标记为aux（辅助的）

maxHistory：最大文件数

cleanHistoryOnStart：启动时清除历史归档日志

对fileNamePattern的更详细的解释和示例：

/wombat/foo.%d

按天分隔日志

未指定格式，所以默认为yyyy-MM-dd（按天滚动）

如果在RollingFileAppender中指定了file（默认日志文件名）：

今天日志为 /wombat/foo.2006-11-24

昨天日志为 /wombat/foo.2006-11-23

如果没有在RollingFileAppender中指定file为“/wombat/foo.txt”，

今天日志为 /wombat/foo.txt

昨天日志为 /wombat/foo.2006-11-23

——其实不指定默认日志文件名的方式更好，因为避免了滚动时重命名操作，也就避免了潜在异常。

/wombat/%d{yyyy/MM}/foo.txt

按“年/月”分两级文件夹，文件名固定为“foo.txt”

如果在RollingFileAppender中指定了file（默认日志文件名）：

2006年10月日志为 /wombat/2006/10/foo.txt

2006年11月日志为 /wombat/2006/11/foo.txt

如果没有在RollingFileAppender中指定file为“/wombat/foo.txt”，

当前正在写的日志永远为 /wombat/foo.txt

归档的日志格式为 /wombat/2006/10/foo.txt

/wombat/foo.%d{yyyy-ww}.log

每个星期归档一个新文件（注意具体“哪天算是一个星期的第一天”取决于系统locale属性）

/wombat/foo%d{yyyy-MM-dd_HH}.log

每小时一次归档

/wombat/foo%d{yyyy-MM-dd_HH-mm}.log

每分钟一次归档

/foo/%d{yyyy-MM,aux}/%d.log

每天一次归档，但每个月一个新文件夹

如果fileNamePattern文件名是以.gz或者.zip结尾的，那么TimeBasedRollingPolicy会自动压缩：

/wombat/foo.%d.gz

日志归档是“记录日志的事件”触发的，所以有一定延迟。例如第二天的第一条日志是临晨01:00才过来，那么这个时候才会归档前一天的日志。

配置样例：

logFile.log

logFile.%d{yyyy-MM-dd}.log

%-4relative [%thread] %-5level %logger{35} - %msg%n

----------------------------------------------------------

FixedWindowRollingPolicy

可配置属性：

minIndex:

maxIndex:

fileNamePattern:

必须包含“%i”占位符，用来表示将当前索引值插入什么位置。

例如“MyLogFile%i.log”配合“最小1，最大3”，表示文件名为：MyLogFile1.log, MyLogFile2.log, MyLogFile3.log

同样加上zip或gz后缀可以启用压缩

因为每次需要很多重命名操作（重命名次数等于window size），所以如果设置size超过20，会被强制指定为20.

配置样例：

test.log

tests.%i.log.zip

5MB

%-4relative [%thread] %-5level %logger{35} - %msg%n

----------------------------------------------------------

SizeAndTimeBasedFNATP（File Naming And Triggering Policy）——是TimeBasedRollingPolicy的一个子组件

配置样例：

mylog.txt

mylog-%d{yyyy-MM-dd}.%i.txt

class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">

100MB

%msg%n

——每天滚动一个文件，如果文件体积达到100M，则也拆分。

——也支持自动删除老文件，可以通过maxHistory指定保存的最多文件数（每天最多这么多，还是一共最多这么多？）

----------------------------------------------------------

SizeBasedTriggeringPolicy——一般配合FixedWindowRollingPolicy使用

指定文件超过“maxFileSize”指定大小时，上层RollingFileAppender触发滚动操作。

默认“10MB”，可以指定各种后缀：KB,MB,GB

----------------------------------------------------------

SocketAppender and SSLSocketAppender

以及后面关于网络，数据库，远程日志服务器，JNDI等……省略……

----------------------------------------------------------

SiftingAppender

可以根据指定的变量分割文件。例如根据用户ID，则每个用户一个日志文件。

可配置参数：

timeout：如果一个关联的appender如果超过默认30分钟没有被访问，则被SiftingAppender卸载掉。

maxAppenderCount：可以最大追踪的关联appender数量，默认int最大值。

这个Appener会把日志记录动作代理给关联的appender。

选择条件由Discriminator指定，默认为MDCBasedDiscriminator。

示例，假设应用程序这样设置了MDC信息：

logger.debug("Application started");
MDC.put("userid", "Alice");
logger.debug("Alice says hello");

然后这样配置：

userid

unknown

${userid}.log

false

%d [%thread] %level %mdc %logger{35} - %msg%n

因为确定timeout和maxAppenderCount比较困难，所以如果程序可以知道“执行到某个地方很可能应该关闭对应的appender”，那么可以明确指定一个FINALIZE_SESSION的marker。这样siftingAppender关联的对应appender，会在接到这个marker的几秒钟后关闭。例如：

import static ch.qos.logback.classic.ClassicConstants.FINALIZE_SESSION_MARKER;

void job(String jobId) {

MDC.put("jobId", jobId);

logger.info("Starting job.");

// will cause the nested appender reach end-of-life. It will

// linger for a few seconds.

logger.info(FINALIZE_SESSION_MARKER, "About to end the job");

try {

.. perform clean up

} catch(Exception e);

// This log statement will be handled by the lingering appender.

// No new appender will be created.

logger.error("unexpected error while cleaning up", e);

}

----------------------------------------------------------

SMTPAppender

将日志事件缓存指定的数量，被特定事件触发后，异步发送邮件。

smtpHost

smtpPort 默认25

to 发送目标，多个联系人可以用逗号隔开，也可以用多个元素

from 发送者邮箱，如果想包含名字，可以用特定格式“Adam Smith <smith@moral.org>”

subject 邮件标题，可以使用PatternLayout的转义字符，会用“触发该邮件的日志事件”的信息替换转义字符

discriminator 默认只有一个缓存。通过指定该属性，可以有多个缓存，这样可以根据事件信息发给不同的人或者ip

evaluator 声明一个元素，通过class属性指定类型。默认为OnErrorEvaluator，也可以自己指定OnMarkerEvaluator,JaninoEventEvaluator,GEventEvaluator

cyclicBufferTracker 环形缓存跟踪器，基于discriminator的返回值工作。默认保存缓存大小为256

username

password

STARTTLS 如果开启，会发起STARTTLS命令，导致连接转换为SSL。连接默认是不使用加密的。默认为false

SSL 如果开启，那么使用SSL连接。默认false。

charsetEncoding 默认UTF-8

localhost 如果SMTP发送方的hostname没配置好，邮件服务器可能拒绝请求，这个时候可以设置这个值为客户端全名。

asynchronousSending 异步发送，默认true。特定情况下需要设置为false，例如应用程序发送完邮件就会立即关闭。

includeCallerData 包含调用者信息，默认为false。

sessionViaJNDI logback依赖javax.mail.Session来发送邮件。该属性默认为false，SMTPAppender会根据配置构建新的Session。如果设为true，会去web容器寻找Session对象，此时应用程序不应该再依赖mail.jar等

jndiLocation 查找JNDI的路径，例如"java:comp/env/mail/Session"

最多保存256条日志事件，否则内存消耗太大（不建议自己指定其它值）。

发邮件依赖JavaMail API (mail.jar)和JavaBeans Activation Framework (activation.jar) ——maven里引入前者会自动依赖后者。

发送者和接收者都可以是动态属性：

${smtpHost}
${to}
${from}

注意上面的layout也可以用patternLayout：

%date %-5level %logger{35} - %message%n

触发事件：

默认是OnErrorEvaluator，但可以自己定制。SMTPAppender仅维护一个Evaluator，这个Evaluator可以自己维护状态，例如可以实现一个CounterBasedEvaluator。

基于标记Marker的事件触发：

Marker notifyAdmin = MarkerFactory.getMarker("NOTIFY_ADMIN");
logger.error(notifyAdmin,
"This is a serious an error requiring the admin's attention",
new Exception("Just testing"));

NOTIFY_ADMIN

TRANSACTION_FAILURE

还可以使用更加通用的JaninoEventEvaluator或者GEventEvaluator，他们提供更复杂更强大的甄别功能（也包含了OnMarkerEvaluator的功能）。

身份验证/STARTTLS/SSL

SMTPAppender支持用户名和密码的加密验证。

STARTTLS方式是先使用非加密方式建立连接，然后切换到SSL（常用于server-server交互）。

SSL方式是直接建立SSL连接（一般用于client-sever交互）。

Appender configuration for Gmail (SSL)

smtp.gmail.com
465
true
YOUR_USERNAME@gmail.com
YOUR_GMAIL_PASSWORD

SMTPAppender for Gmail (STARTTLS)

smtp.gmail.com
587
true
YOUR_USERNAME@gmail.com
YOUR_GMAIL_xPASSWORD

Discriminator

用MDCBasedDiscriminator做示例，根据MDC的值，维护多个缓存

req.remoteHost
default

${HOSTNAME} -- %X{req.remoteHost} %msg"

%date%level%thread%X{req.remoteHost}%X{req.requestURL}%logger%msg

上面的例子先利用了MDCInsertingServletFilter把请求方的hostname或ip设置到MDC中。

每一个remoteHost都有一个自己的buffer，一旦某个remoteHost触发了发送邮件的请求，那么该buffer里的256条信息会被发送出去。

Buffer管理：

上面的例子，每一个远程地址都有自己的buffer，会极大的消耗内存。

默认情况下，logback内部最多允许64个buffer同时存在，LRU算法换出。超过30分钟未使用的buffer也会被换出。该值可以通过maxNumberOfBuffers来设置。

这里有问题，通过各种手段都无法设置此值，貌似是个bug，我在尽我所能查遍所有资料后，在stackoverflowh和官方jira上提了这个问题：

http://stackoverflow.com/questions/24836151

http://jira.qos.ch/browse/LOGBACK-996

在高强度系统中，上面的2个保护机制不够，需要加入手工管理：通过明确指定“FINALIZE_SESSION”这个Marker，来告诉logback去释放对应的buffer，这样就可以安全的将maxNumberOfBuffers设置为512乃至1024。（具体设置办法参照SiftingAppender里描述的）

这里是官方的一个SMTPAppender的例子：

http://logback.qos.ch/recipes/emailPerTransaction.html

注意Marker可以叠加，所以如果有必要，可以把“发送邮件的Marker”和“终结Session（以便清理buffer）的Marker”关联在一起。

Marker SMTP_TRIGGER = MarkerFactory.getMarker("SMTP_TRIGGER");

SMTP_TRIGGER.add(FINALIZE_SESSION_MARKER);

----------------------------------------------------------

AsyncAppender

类似于单独的一个事件分发器，所以必须引用另一个appender。

用一个BlockingQueue缓冲事件，然后创建一个线程，从队列里获取事件并分发给引用的appender。

默认情况下，如果队列达到80%的容量，则丢弃TRACE,DEBUG,INFO级别的日志。

应用程序停止的时候，会通知LoggerContext停止，在停止各个Appender时，AsyncAppender会停止接收日志，并将信息flush到磁盘。

配置参数：

queueSize：默认256

discardingThreshold：默认队列20%可用的时候开始选择性抛弃信息，设为0表示不抛弃

includeCallerData：是否包括调用者信息（重开销），默认只复制线程名和MDC信息（因为切换了线程，其余信息会丢失）

队列全满的时候，写日志动作会被block，直到队列有可用空间。

----------------------------------------------------------

自定义Appender

略

----------------------------------------------------------

Logback Access

大部分Appender，在logback-classic与logback-access中使用方式类似。

王星游 2014-07-13 18:57 发表评论

logback_doc_manual_03_configuration

王星游 — Sun, 13 Jul 2014 10:56:00 GMT

http://logback.qos.ch/manual/configuration.html

-------------------------------------------------------

与spring的配置：

貌似官网上没有介绍，但是作者在github上建立了一个扩展项目用于logback与spring结合。

https://github.com/qos-ch/logback-extensions

目前最新版本是0.1.2，很多maven公开库里已经有了。

maven配置：

org.logback-extensions

logback-ext-spring

0.1.2

web.xml配置日志框架启动监听器：

logbackConfigLocation

/WEB-INF/classes/logback.xml

ch.qos.logback.ext.spring.web.LogbackConfigListener

-------------------------------------------------------

logback中的配置：

可以用java程序配置，也可以用xml或者groovy脚本配置。

使用 http://logback.qos.ch/translator/ 可以把log4j的配置自动转换过来。

logback内部查找配置的过程：

1，在classpath查找“logback.groovy”

2，在classpath查找“logback-test.xml”

3，在classpath查找“logback.xml”

4，使用自身的BasicConfigurator做基本配置，所有日志被输出到控制台。

—— 一般把“logback-test.xml”放到maven的测试路径，把“logback.xml”放到maven的正式路径，前者优先级更高。

logback的状态，加载配置文件的过程：

代码打印：

LoggerContext lc = (LoggerContext) LoggerFactory.getILoggerFactory();

StatusPrinter.print(lc);

配置文件形式打印：

...

也可以通过设置StatusListener来监听logback的启动和打印状态——在生产环境挺有用，因为配置文件路径挺深。

通过在系统变量里加入"logback.configurationFile"指定logback配置文件路径：

java -Dlogback.configurationFile=/path/to/config.xml chapters.configuration.MyApp1

设置自动扫描和遇到变更时重新加载配置文件（不指定周期的话默认每1分钟）：

...

每当N个（logback会自动调节）日志请求，logback会检查一下扫描周期是否已经到达，如到达再检查配置文件。

通过web访问状态信息：

在web.xml配置：

ViewStatusMessages

ch.qos.logback.classic.ViewStatusMessagesServlet

ViewStatusMessages

/lbClassicStatus

然后访问：http://host/yourWebapp/lbClassicStatus

注册控制台状态监听器：

java代码方式：

LoggerContext lc = (LoggerContext) LoggerFactory.getILoggerFactory();

StatusManager statusManager = lc.getStatusManager();

OnConsoleStatusListener onConsoleListener = new OnConsoleStatusListener();

statusManager.add(onConsoleListener);

用配置文件方式：

...

系统变量方式：

java -Dlogback.statusListenerClass=ch.qos.logback.core.status.OnConsoleStatusListener

停止logback：

java代码方式：

LoggerContext loggerContext = (LoggerContext) LoggerFactory.getILoggerFactory();

loggerContext.stop();

web应用：

ServletContextListener.contextDestroyed()会自动调用上面的stop方法。

-------------------------------------------------------

配置文件格式：

最外层是元素，里面有元素

元素：

level属性可以这些值：TRACE, DEBUG, INFO, WARN, ERROR, ALL, OFF，也可以明确指定继承：INHERITED或者NULL

包含若干元素，指定appender的名字。

从DEBUG改为INFO级别：

%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n

-------------------------------------------------------

配置Appender：

name和class属性

内嵌0个或1个layout元素，0个或多个encoder元素，0个或多个filter元素。还可以内嵌任意数量的appdenter类的属性（例如自定义的appender类）。

layout元素应该内嵌具体的layout类，但是默认就是PatternLayoutEncoder。

Appender的累加性：

logger会记录在所有绑定在它自身的appender，同时也会记录在该logger祖先的appender上，所以有可能重复记录！

配置Logger Context（可以用在“多个项目写入同一个日志文件”这种情况）：

myAppName

...

-------------------------------------------------------

变量替换：

${USER_HOME}/myApp.log

...

——上面的变量定义在系统属性里也可以：java -DUSER_HOME="/home/sebastien" MyApp2

变量也可以定义在文件里：

${USER_HOME}/myApp.log

...

——对应路径的文件里应该加入“USER_HOME=/home/sebastien”

（这路径挺诡异啊，是maven的结构，那打包后岂不是不能用了？）

像这样引用classpath的还靠谱些：

变量可以指定作用域：local，context，system

变量可以相互引用：

USER_HOME=/home/sebastien

fileName=myApp.log

destination=${USER_HOME}/${fileName}

命名引用：如果"userid"会被替换为"alice"，那么"${${userid}.password}"会被替换为"alice.password"对应的值。

变量可以指定默认值：${aName:-golden} ——这就指定了默认值golden

变量的默认值也可以引用变量： "${id:-${userid}}

预置变量：HOSTNAME,CONTEXT_NAME

可以通过timestamp元素定义一个当前的日期和时间的动态元素。

可以自己继承PropertyDefiner实现动态生成属性，现在内置了2个动态属性生成器：

FileExistsPropertyDefiner 如果指定路径文件存在，则将指定属性设为“true”，反之亦然

ResourceExistsPropertyDefiner 如果指定资源存在，则将指定属性设为“true”，反之亦然

条件语句：

...

判断条件只支持context变量和system变量，用property()或者p()来引用——如果没有设定对应变量，这两个方法会返回空串（而不是null）

isDefine()和isNull()分别判断变量是否设置和变量是否为空。

...

可以从JNDI读取变量值（作用域为local）。也可以将从JNDI读取的变量存入另一个不同作用域的变量。

...

-------------------------------------------------------

文件包含（可以使用相对路径。当前路径已经在当前项目中定义，所以没必要与配置文件路径关联）：

...

被包含的文件必须用标签包裹：

"%d - %m%n"

还可以关联资源（例如classpath下的某个文件）：

还可以关联URL：

可以指定此次文件包含为“可选的”：

-------------------------------------------------------

LoggerContextListener

其中一个实现LevelChangePropagator会监听日志环境的合适的生命周期，并把日志级别的变化传播给JUL，这样JUL关闭的日志不会再传递给slf4j，用这种方式对性能冲击较小，适合jul-to-slf4j的桥接包。

王星游 2014-07-13 18:56 发表评论

logback_doc_manual_02_architecture

王星游 — Sun, 13 Jul 2014 10:55:00 GMT

http://logback.qos.ch/manual/architecture.html

Logger, Appender and Layout

-------------------------------------------------------

Logger:

Logger继承关系：

com.foo是com.foo.Bar的双亲（parent），同时也是其祖先（ancestor）

java是java.util.Vector的祖先，但不是其双亲。

root Logger是所有logger的祖先，可以这样获取：

Logger rootLogger = LoggerFactory.getLogger(org.slf4j.Logger.ROOT_LOGGER_NAME);

日志级别，在ch.qos.logback.classic.Level中，有TRACE, DEBUG, INFO, WARN and ERROR

日志级别类是final的，如果想扩展，可以用Marker类。

如果一个logger没有指定级别，那么它继承最近的祖先的级别。

root Logger默认是debug级别。

日志级别：TRACE < DEBUG < INFO < WARN < ERROR.

如果日志记录请求——例如logger.info()——的级别大于等于其logger的级别，那么该请求生效。

使用LoggerFactory.getLogger(String param)获取的logger，只要参数一致，那么获取到的logger也一致。

即使先创建子logger，再创建双亲logger，后者也会正确的插到logger树上。

-------------------------------------------------------

Appenders and Layouts:

一个logger可以绑定多个appender。

默认情况：每一个日志请求，会被发送到logger对应的所有Appender，以及更高层logger对应的所有appender上。

如果把某个logger的additivity标志设为false，那么这个logger会记录自身和下层（孙子logger）的日志，但不会再向上传递——也就是把下层的logger的日志拦截到了当前这一层logger为止了。

PatternLayout控制输出的格式，类似C语言的printf格式。

-------------------------------------------------------

参数化记录日志：

与slf4j完全相同

-------------------------------------------------------

日志记录的调用时序图：

王星游 2014-07-13 18:55 发表评论

slf4j笔记

王星游 — Sun, 13 Jul 2014 10:49:00 GMT

特性：

classes are loaded by the JVM

slf4j不需要classloader的原理(而common-logging需要classloader，所以会内存泄漏或者别的加载问题)
Mapped Diagnostic Context (MDC)只有log4j和logback支持，slf4j也支持

支持自定义日志级别（Marker），目前只有logback对其进行了实现。

支持国际化（个人认为：有毛用啊……）

-----------------------------------------------------------

用法：

log性能：
以下这种形式，不管是否log，都会损失拼接字符串的时间：
logger.debug("Entry number: " + i + " is " + String.valueOf(entry[i]));
以下这种形式，是对上述情况的改进，但很臃肿：
if(logger.isDebugEnabled()) {
logger.debug("Entry number: " + i + " is " + String.valueOf(entry[i]));
}
以下这种，在slf4j里支持，很完美：
logger.debug("The entry is {}.", entry);
多个参数的情况：
logger.debug("The new entry is {}. It replaces {}.", entry, oldEntry);
很多参数的情况（也可以利用Object...，不用显式指定Object[]）：
logger.debug("Value {} was inserted between {} and {}.", new Object[] {newVal, below, above});

对{}进行转义：
以下情况不需要转移(slf4j它只认紧挨着的{}符号)
logger.debug("Set {1,2} differs from {}", "3");
以下情况也不需要转义：
logger.debug("Set {1,2} differs from {{}}", "3");
实在需要转义时可以这样：
logger.debug("Set \\{} differs from {}", "3");
实在不需要转义时可以这样：
logger.debug("File name is C:\\\\{}.", "file.zip");

打印异常对象的堆栈信息，除了这种形式：

debug(String msg, Throwable t);

还可以结合参数化（转移字符{}）来使用：

logger.error("Failed to format {}", s, e);

——框架会发现最后一个参数是多余的，并查看其是否是一个异常对象，如果是则输出堆栈，否则忽略。

-----------------------------------------------------------

logger声明的讨论：

static和non-static各有好处：

static的CPU和内存性能更好

non-static对IOC更友好，而且在多个应用共用一套类库时，可以保持各自的日志环境

（logback无论如何都是安全的，但如果在多个应用分享同一个类库，并且为static的，那log4j会出问题：所有的日志都打印到第一个加载到内存的日志对象中）

在slf4j的1.5.3之后，non-static的logger不需要标记transient关键字，也不会被序列化（怎么做到的？）

建议的声明方式（我觉得加上static比较好，还有private）：

final (static) Logger logger = LoggerFactory.getLogger(MyClass.class);

-----------------------------------------------------------
迁移工具：

http://www.slf4j.org/migrator.html

-----------------------------------------------------------

实现包：

唯一必要的包：slf4j-api.jar

slf4j-log4j12-1.6.4.jar
Binding for log4j version 1.2, a widely used logging framework. You also need to place log4j.jar on your class path.

需要把log4j的包也一同放进来。
slf4j-jdk14-1.6.4.jar
Binding for java.util.logging, also referred to as JDK 1.4 logging

绑定到jdk的日志中
slf4j-nop-1.6.4.jar
Binding for NOP, silently discarding all logging.

绑定到“无操作”，静默。
slf4j-simple-1.6.4.jar
Binding for Simple implementation, which outputs all events to System.err. Only messages of level INFO and higher are printed. This binding may be useful in the context of small applications.

最简单的实现，直接输出到控制台
slf4j-jcl-1.6.4.jar
Binding for Jakarta Commons Logging. This binding will delegate all SLF4J logging to JCL.

绑定到common-logging，桥接过去。

logback-classic-1.0.13.jar (requires logback-core-1.0.13.jar)

绑定到原生实现的logback上，性能最高

在maven中声明包的实现：

对于普通项目（并不是一个工具包）：

logback：

声明对logback-classic-1.0.13.jar的依赖即可，会自动关联依赖slf4j-api-1.7.7.jar和logback-core-1.0.13.jar（显式声明这两个关联依赖也可以）

log4j：

声明对slf4j-log4j12-1.7.7.jar的依赖即可，会自动关联依赖slf4j-api-1.7.7.jar和log4j-1.2.17.jar

jdk log：

声明对slf4j-jdk14-1.7.7.jar的依赖即可，会自动关联依赖slf4j-api-1.7.7.jar

对于工具包项目：

仅仅依赖slf4j-api即可，让用户自己决定底层用什么实现。

二进制兼容性：

各个api绑定包，与下面的日志实现包，其版本必须对应。比如slf4j-api-1.7.7.jar应该对应slf4j-simple-1.7.7.jar.

而上层的应用程序，与其依赖的slf4j-api是各个版本都完全兼容的。

支持MDC，同时需要底层的日志包也支持，例如logback或者log4j。

-----------------------------------------------------------

桥接包：

http://www.slf4j.org/legacy.html

1，从Jakarta Commons Logging (JCL)迁移到slf4j：用“jcl-over-slf4j.jar”替换掉“commons-logging.jar”即可

如果在maven中：1，明确的标记exclusion掉common-logging.jar。2，声明common-logging.jar的依赖范围为“provided”（在IED里显示不太好，注意顺序）。

2，很少见的特殊情况，想要把slf4j日志转移到JCL上：用slf4j-jcl.jar包

——上述两个包不能一起用，否则死循环（这很好理解）

3，从log4j迁移到slf4j（居然直接针对log4j编码，太2了）：用“log4j-over-slf4j.jar”替换掉“log4j.jar”即可。

——上述包不能与“slf4j-log4j12.jar”一起用，否则死循环（一样的道理）。

4，从java.util.logging（JUL）迁移到slf4j——jvm自己的类不允许随便替换，所以这里比较复杂(SLF4JBridgeHandler+jul-to-slf4j.jar)，而且有性能问题，很少用到，用的时候再研究。

——上述包不能与“slf4j-jdk14.jar”一起用，否则死循环（一样的道理）。

王星游 2014-07-13 18:49 发表评论

java中Thread合理的中止,退出,暂停方式

王星游 — Sat, 17 Nov 2012 12:24:00 GMT

最近研究Thread时看到篇好文《Java 理论与实践: 处理 InterruptedException》，摘录下来备用：

http://www.ibm.com/developerworks/cn/java/j-jtp05236.html

1,当一个方法抛出 InterruptedException 时，它不仅告诉您它可以抛出一个特定的检查异常，而且还告诉您其他一些事情。例如，它告诉您它是一个阻塞（blocking）方法，如果您响应得当的话，它将尝试消除阻塞并尽早返回。

2,当一个方法抛出 InterruptedException 时，它是在告诉您，如果执行该方法的线程被中断，它将尝试停止它正在做的事情而提前返回，并通过抛出 InterruptedException 表明它提前返回。行为良好的阻塞库方法应该能对中断作出响应并抛出 InterruptedException，以便能够用于可取消活动中，而不至于影响响应。

3,如果抛出 InterruptedException 意味着一个方法是阻塞方法，那么调用一个阻塞方法则意味着您的方法也是一个阻塞方法，而且您应该有某种策略来处理 InterruptedException。通常最容易的策略是执行清理，然后自己抛出 InterruptedException，将它传播给调用者。

4,如果捕捉到 InterruptedException 但是不能重新抛出它，那么应该保留中断发生的证据，以便调用栈中更高层的代码能知道中断，并对中断作出响应。该任务可以通过调用当前线程的interrupt() 以 “中断当前线程自己” 来完成。

5,对于执行一个循环中的代码的任务，通常只需为每一个循环迭代检查一次中断。取决于循环执行的时间有多长，任何代码可能要花一些时间才能注意到线程已经被中断（或者是通过调用 Thread.isInterrupted() 方法轮询中断状态，或者是调用一个阻塞方法）。

6,不可中断的阻塞方法:并非所有的阻塞方法都抛出 InterruptedException。输入和输出流类会阻塞等待 I/O 完成，但是它们不抛出 InterruptedException，而且在被中断的情况下也不会提前返回。然而，对于套接字 I/O，如果一个线程关闭套接字，则那个套接字上的阻塞 I/O 操作将提前结束，并抛出一个 SocketException。java.nio 中的非阻塞 I/O 类也不支持可中断 I/O，但是同样可以通过关闭通道或者请求 Selector 上的唤醒来取消阻塞操作。

另据别的文章(忘了出处了):

interrupt方法其实只是改变了中断状态而已,而sleep、wait和join这些方法的内部会不断的检查中断状态的值，从而自己抛出InterruptEdException。

——所以该异常从“设置”到“抛出”不是即时的，但是只要调用过程有上述方法之一，就会最终检测到终端状态并抛出异常。

Thread类中destory,resume,stop,suspend这些废弃方法引用了一篇说明文章：

《Why Are Thread.stop, Thread.suspend,Thread.resume and Runtime.runFinalizersOnExit Deprecated?》

http://docs.oracle.com/javase/1.5.0/docs/guide/misc/threadPrimitiveDeprecation.html

以下是根据其写的demo:

1 /**
  2  * @author watchzerg
  3  */
  4 public class ThreadManager implements Runnable{
  5     //线程对象引用
  6     private Thread myThread;
  7     //休眠间隔
  8     private long interval=1000l;
  9     //用volatile保证变量同步
10     private volatile boolean threadSuspended;
11
12     //开始
13     public void start(){
14         myThread=new Thread(this,"myThread");
15         myThread.start();
16     }
17
18     /**
19      * 线程体(执行内容)：
20      * 如果线程不需要sleep之类的阻塞方法，
21      * 可以通过Thread.isInterrupted()方法来检测中断
22      */
23     @Override
24     public void run() {
25         Thread thisThread=Thread.currentThread();
26         while(myThread==thisThread){
27             try{
28                 Thread.sleep(interval);
29                 System.out.println(myThread.getName()+" is running.");
30                 //先if一下，避免每次都进入同步块带来的开销
31                 if(threadSuspended&&myThread==thisThread){
32                     synchronized(this){
33                         /* 如果线程在suspend状态被stop，那么myThread==null
34                          * 它在下一个循环就快速退出，不再等待了
35                          * 不过话说，wait方法本身也会抛中断异常的
36                          * 所以我觉得这里去掉"myThread==thisThread"也行
37                          * 元方，你怎么看？
38                          * */
39                         while(threadSuspended&&myThread==thisThread){
40                             wait();
41                         }
42                     }
43                 }
44             }catch(InterruptedException e){
45                 System.out.println(thisThread.getName()+
46                         " is interrupted by InterruptedException.");
47                 //如果这里不打算处理此异常,而又无法抛出去,可以重新断言自己:
48                 //Thread.currentThread().interrupt();
49             }
50         }
51         System.out.println(thisThread.getName()+": I'm out, do you copy? ");
52     }
53
54     /**
55      * 停止线程:
56      * 如果是sleep状态，是interrupt起作用；
57      * 如果是运行状态，是myThread==null终止了循环
58      */
59     public synchronized void stop(){
60         if(myThread==null){
61             return;
62         }
63         Thread moribund=myThread;
64         myThread=null;
65         moribund.interrupt();
66     }
67
68     /**
69      * 挂起线程：
70      * 反转条件，并通知其它等待线程
71      */
72     public synchronized void suspend(){
73         threadSuspended=!threadSuspended;
74         if(!threadSuspended){
75             notify();
76         }
77     }
78
79     //test
80     public static void main(String[] args) throws Exception {
81         ThreadManager manager=new ThreadManager();
82         //开始
83         manager.start();
84         System.out.println("sys:starting");
85         Thread.sleep(10000l);
86         //暂停
87         manager.suspend();
88         System.out.println("sys:suspend");
89         Thread.sleep(10000l);
90         //恢复
91         manager.suspend();
92         System.out.println("sys:resume");
93         Thread.sleep(10000l);
94         //暂停
95         manager.suspend();
96         System.out.println("sys:suspend");
97         Thread.sleep(5000l);
98         //在暂停状态下停止
99         manager.stop();
100         System.out.println("sys:stop");
101         Thread.sleep(10000l);
102         //退出
103         System.out.println("sys:exitnow what?");
104     }
105 }

王星游 2012-11-17 20:24 发表评论

mongoDB java驱动学习笔记

王星游 — Sat, 22 Sep 2012 14:32:00 GMT

指定新mongo实例：

Mongo m = new Mongo();

Mongo m = new Mongo( "localhost" );

Mongo m = new Mongo( "localhost" , 27017 );

// or, to connect to a replica set, supply a seed list of members

Mongo m = new Mongo(Arrays.asList(new ServerAddress("localhost", 27017),

new ServerAddress("localhost", 27018),

new ServerAddress("localhost", 27019)));

然后发起连接（必须指定数据库名，可以不存在）

DB db = m.getDB( "mydb" );

注意Mongo已经实现了连接池，并且是线程安全的。

大部分用户使用mongodb都在安全内网下，但如果将mongodb设为安全验证模式，就需要在客户端提供用户名和密码：

boolean auth = db.authenticate(myUserName, myPassword);

获取集合(collection)的名称列表(类似show databases):

Set colls = db.getCollectionNames();

获取一个集合（以便增删改查操作）：

DBCollection coll = db.getCollection("testCollection")

-------------------------------------------------------------

先假设要插入的json数据如下：

{

"name" : "MongoDB",

"type" : "database",

"count" : 1,

"info" : {

x : 203,

y : 102

}

将其插入数据库：

BasicDBObject doc = new BasicDBObject();

doc.put("name", "MongoDB");

doc.put("type", "database");

doc.put("count", 1);

BasicDBObject info = new BasicDBObject();

info.put("x", 203);

info.put("y", 102);

doc.put("info", info);

coll.insert(doc);

-------------------------------------------------------------

设定write concern，以便操作失败时得到提示：

m.setWriteConcern(WriteConcern.SAFE);

-------------------------------------------------------------

查找一个/第一个记录：

DBObject myDoc = coll.findOne();

System.out.println(myDoc);

注意：属性名不能以下划线或者美元符号开始，mongodb自己保留。

获取总记录数：

System.out.println(coll.getCount());

使用游标操作查询结果：

DBCursor cursor = coll.find();

try {

while(cursor.hasNext()) {

System.out.println(cursor.next());

}

} finally {

cursor.close();

}

条件查询：

BasicDBObject query = new BasicDBObject();

query.put("i", 71);

cursor = coll.find(query);

try {

while(cursor.hasNext()) {

System.out.println(cursor.next());

}

} finally {

cursor.close();

}

如果想使用shell里的类似以下语句的功能：

db.things.find({j: {$ne: 3}, k: {$gt: 10} });

在java驱动里，{$ne: 3}也是一个普通的DBObject：

BasicDBObject query = new BasicDBObject();

query.put("j", new BasicDBObject("$ne", 3));

query.put("k", new BasicDBObject("$gt", 10));

cursor = coll.find(query);

try {

while(cursor.hasNext()) {

System.out.println(cursor.next());

}

} finally {

cursor.close();

}

条件查询一批数据：

以下是查询i > 50的记录：

query = new BasicDBObject();

query.put("i", new BasicDBObject("$gt", 50)); // e.g. find all where i > 50

cursor = coll.find(query);

try {

while(cursor.hasNext()) {

System.out.println(cursor.next());

}

} finally {

cursor.close();

}

以下是查询20 < i <= 30的记录：

query = new BasicDBObject();

query.put("i", new BasicDBObject("$gt", 20).append("$lte", 30)); // i.e. 20 < i <= 30

cursor = coll.find(query);

try {

while(cursor.hasNext()) {

System.out.println(cursor.next());

}

} finally {

cursor.close();

}

-------------------------------------------------------------

创建索引：

指定collection和要index的列即可，1代表升序，-1代表降序。

coll.createIndex(new BasicDBObject("i", 1)); // create index on "i", ascending

获取索引列表：

List list = coll.getIndexInfo();

for (DBObject o : list) {

System.out.println(o);

}

-------------------------------------------------------------

数据库管理相关的命令：

获取数据库名称列表：

m.getDatabaseNames()

删除数据库：

m.dropDatabase("my_new_db");

-------------------------------------------------------------

聚合函数：使用DBCollection.aggregate()产生聚合任务:

http://www.mongodb.org/display/DOCS/Using+The+Aggregation+Framework+with+The+Java+Driver

// create our pipeline operations, first with the $match

DBObject match = new BasicDBObject("$match", new BasicDBObject("type", "airfare") );

// build the $projection operation

DBObject fields = new BasicDBObject("department", 1);

fields.put("amount", 1);

fields.put("_id", 0);

DBObject project = new BasicDBObject("$project", fields );

// Now the $group operation

DBObject groupFields = new BasicDBObject( "_id", "$department");

groupFields.put("average", new BasicDBObject( "$avg", "$amount"));

DBObject group = new BasicDBObject("$group", groupFields);

// run aggregation

AggregationOutput output = collection.aggregate( match, project, group );

返回结果是一个AggregationOutput对象，可以用以下方式获取其中信息：

public Iterable results()

public CommandResult getCommandResult

public DBObject getCommand()

示例：

System.out.println(output.getCommandResult());

{

"serverUsed" : "/127.0.0.1:27017" ,

"result" : [

{"_id" : "Human Resources" , "average" : 74.91735537190083} ,

{"_id" : "Sales" , "average" : 72.30275229357798} ,

{"_id" : "Engineering" , "average" : 74.1}

] ,

"ok" : 1.0

}

-------------------------------------------------------------

使用DBObject存取对象：

http://www.mongodb.org/display/DOCS/Java+-+Saving+Objects+Using+DBObject

假设一个类叫做twitter，存储前必须实现DBObject接口：

public class Tweet implements DBObject {

/* ... */

}

然后就可以存了：

Tweet myTweet = new Tweet();

myTweet.put("user", userId);

myTweet.put("message", msg);

myTweet.put("date", new Date());

collection.insert(myTweet);

一个文档从数据库取出时，自动被转为DBObject。如果想取出时转为需要的类，可以先调用DBCollection.setObjectClass()，然后再进行类型强制转换：

collection.setObjectClass(Tweet.class);

Tweet myTweet = (Tweet)collection.findOne();

如果想要改变Tweet类的属性，可以改完后再存入：

Tweet myTweet = (Tweet)collection.findOne();

myTweet.put("message", newMsg);

collection.save(myTweet);

-------------------------------------------------------------

JAVA驱动的并发：

http://www.mongodb.org/display/DOCS/Java+Driver+Concurrency

mongodb的java驱动是线程安全的，如果是在web服务环境下，应该创建单例的mongo对象，用这个对象处理每一个请求。mongo对象维护一个内部连接池（默认大小为10），对于每个请求（查找插入等），java线程会从线程池取一个连接，执行操作，然后释放连接——这意味着每次操作所使用的连接很有可能是不同的。

------------------------------

在复制（replica）模式下，如果设置slaveOK选项为on，那么读操作会被均匀的分布到各个slave上。这意味着对于同一个线程，一个写操作后紧跟着的一个读操作，有可能被发送到不同的服务器上（写操作发送到master上，读操作发送到slave上），这样读操作有可能不会立刻反映出上一个写操作的数据(因为主从的异步性)。

如果你想要确保在一个session中完整的一致性（例如在一个http请求中），你可能希望java驱动是用同一个socket连接，这时你可以通过使用"consistent request"来达到目的——在操作前后分别调用requestStart()和requestDone()。

DB db...;

db.requestStart();

try {

//Ensures that a connection exists for the "consistent request"

db.requestEnsureConnection();

code....

} finally {

db.requestDone();

}

------------------------------

在单独写操作上的WriteConcern选项：

默认情况下，每次写操作后，连接就被释放回连接池——此时你调用getLastError()是没用的。

所以可以采用两种方式：

1，使用类似WriteConcern.SAFE这样的写策略来代替默认策略，这样java驱动会自动首先调用getLastError()，然后才将连接放回连接池。

DBCollection coll...;

coll.insert(..., WriteConcern.SAFE);

2，采用上述的requestStart()和requestDone()方式来维持连接不被释放，中间调用getLastError()获取错误信息。

DB db...;

DBCollection coll...;

db.requestStart();

try {

coll.insert(...);

DBObject err = db.getLastError();

} finally {

db.requestDone();

}

这两种方式等价。

-------------------------------------------------------------

java类型：

http://www.mongodb.org/display/DOCS/Java+Types

----------------------------

Object id被用来自动生成唯一的ID：

ObjectId id = new ObjectId();

ObjectId copy = new ObjectId(id);

----------------------------

正则表达式：

java驱动使用JDK的java.util.regex.Pattern表达正则：

Pattern john = Pattern.compile("joh?n", CASE_INSENSITIVE);

BasicDBObject query = new BasicDBObject("name", john);

// finds all people with "name" matching /joh?n/i

DBCursor cursor = collection.find(query);

----------------------------

java驱动使用JDK的 java.util.Date表示日期时间：

Date now = new Date();

BasicDBObject time = new BasicDBObject("ts", now);

collection.save(time);

----------------------------

com.mongodb.DBRef被用来表示数据库引用(官方一般建议手动引用)：

DBRef addressRef = new DBRef(db, "foo.bar", address_id);

DBObject address = addressRef.fetch();

DBObject person = BasicDBObjectBuilder.start()

.add("name", "Fred")

.add("address", addressRef)

.get();

collection.save(person);

DBObject fred = collection.findOne();

DBRef addressObj = (DBRef)fred.get("address");

addressObj.fetch()

----------------------------

二进制数据：

java中的字节数组会自动被包装成二进制数据存入数据库。

二进制类可以被用来表示二进制对象，这可以用来取一个自定义类型的字节。

----------------------------

时间戳数据(BSONTimestamp对象)：

时间戳数据是一个mongoDB使用的特殊对象，表示一个(以秒为单位的时间，自增ID)的键值对，这被用于主从复制的操作日志中。

----------------------------

代码对象：

用于表示javascript代码，例如保存可执行的方法到system.js集合中。

Code和CodeWScope类用来表示这种数据。

注意有些方法(比如map/reduce)接收字符串，但是在驱动中将其包装为代码对象。

----------------------------

嵌套对象：

在javascript里面这样一个json文档：

{

"x" : {

"y" : 3

}

在java中对应的形式是：

BasicDBObject y = new BasicDBObject("y", 3);

BasicDBObject x = new BasicDBObject("x", y);

----------------------------

数组：

java中所有实现List接口的都被以数组形式在数据库中保存：

所以如果想保存这样一个json:

{

"x" : [

{"foo" : "bar"},

]

}

在java中可以这么做：

ArrayList x = new ArrayList();

x.add(1);

x.add(2);

x.add(new BasicDBObject("foo", "bar"));

x.add(4);

BasicDBObject doc = new BasicDBObject("x", x);

-------------------------------------------------------------

在java驱动中的优先读取策略（Read Preferences）和节点标记（Tagging）

http://www.mongodb.org/display/DOCS/Read+Preferences+and+Tagging+in+The+Java+Driver

用来允许应用程序开发者能将读写操作指定在某个主从集合的成员节点上。

2.2版本在节点标记(node tagging)带来些新的东西让你能更好的控制你的数据的读写。

java驱动的2.9.0集成了mongodb2.2提供的所有新特性。

----------------------------

优先读取策略（Read Preferences）：

用于提供客户端程序选择那个节点来读取，有以下五个选择：

PRIMARY : 默认方式，从主节点读取，如果主节点不可用则抛出异常，无法与标签（tags）一起使用。

PRIMARY PREFERRED : 优先读取主节点，失败的话从副节点读取。

SECONDARY : 从副节点读取，失败则抛异常。

SECONDARY PREFERRED : 优先读取副节点，失败则从主节点读取。

NEAREST : 从最近的节点读取，“最近”的定义为ping的响应时间最短(也得满足15毫秒以内)。

java实现：类ReadPreference的工厂模式可以创建对应上述五种策略的对象：

ReadPreference.primary();

ReadPreference.primaryPreferred();

ReadPreference.secondary();

ReadPreference.secondaryPreferred();

ReadPreference.nearest();

例如：假设我们的应用需要保持强一致性(写入的数据立即可以被读出)，但是我们又希望万一主库挂掉以后，从库依然可以读取。这种情况下，我们需要选择PRIMARY PREFERRED模式：

ReadPreference preference = ReadPreference.primaryPreferred();

DBCursor cur = new DBCursor(collection, query, null, preference);

java驱动保持着各个节点的状态信息（每隔一段时间ping一次所有节点），在这个例子中，java驱动会检测到主库的挂掉，从而将读操作指向从节点。

----------------------------

节点标记(Tags)：

在mongoDB2.0之后，主从集群中的每一个节点都可以被标记一个描述，称为tags。可以用来标记一个节点的位置，和在集群中的从属关系或者特性。这可以让你的应用程序从指定节点中读写。

例子：

假设我们要运行一个三节点的主从集群，三个节点分别在三个不同地理位置的数据中心当中。我们希望确保我们的数据在灾难中也可以恢复，所以我们对每一个节点标记其地理位置，配置文件样例如下：

foo:SECONDARY> rs.conf()

{

"_id":"foo",

"version":103132,

"members":[

{

"_id":0,

"host":"localhost:27017",

"priority":10,

"tags":{

"datacenter":"Los Angeles",

"region":"US_West"

}

{

"_id":1,

"host":"localhost:27018",

"tags":{

"datacenter":"San Jose",

"region":"US_West"

}

{

"_id":2,

"host":"localhost:27019",

"tags":{

"datacenter":"Richmond",

"region":"US_Eest"

}

"settings":{

"getLastErrorModes":{

"DRSafe":{

"region":2

}

foo:SECONDARY>

注意上面settings字段，我们定义了一个新的getLastErrorModes对象，键为DRSafe。当我们客户端采用此错误模式作为WriteConcern的时候，它会使写操作在完成前复制到至少两个节点上。下面是使用的例子：

//使用自定义的getLastErrorMode创建WriteConcern

WriteConcern concern = new WriteConcern("DRSafe");

//使用自定义的WriteConcern进行写操作

coll.insert(new BasicDBObject("name", "simple doc"), concern);

----------------------------

在优先读取策略（Read Preferences）中使用节点标记(Tags)：

假如我们想要将读请求发送到最近的节点上以便减少请求延时：

DBObject query = new BasicDBObject("name", "simple doc")

DBObject result = coll.findOne(query, null, ReadPreference.nearest());

这样java驱动会自动将读请求发送到ping值最小的节点(也有可能是主节点)。

但是，如果我们的java驱动可以确定自己的请求发送源位置，那么就可以明确指定将读请求发送到距离最近的数据中心。再看上面的例子，假如这个读请求来自南加利福尼亚，我们就明确指定这个读请求到Los Angeles数据中心：

// initialize a properly tagged read preference

ReadPreference tagged_pref = ReadPreference.secondaryPreferred(new BasicDBObject("datacenter", "Los Angeles"));

// include the tagged read preference in this request}}

DBObject result = coll.findOne(}}

new BasicDBObject("name", "simple doc"), null, tagged_pref);

下面的例子指定多个tag，如果读请求在Los Angeles失败，则发送到"US_West"区域的某个节点：

// read from either LA or US_West

DBObject tagSetOne = new BasicDBObject("datacenter", "Los Angeles"):

DBObject tagSetTwo = new BasicDBObject("region", "US_West");

ReadPreference pref = ReadPreference.primaryPreferred(tagSetOne, tagSetTwo);

下面的例子同样指定多个tag，首先请求"datacenter=Los Angeles"且"rack=1"的节点，如果失败则查找"region=US_West"的节点

// read from either LA or US_West

DBObject tagSetOne = new BasicDBObject("datacenter", "Los Angeles");

tagSetOne.put("rack", "1");

DBObject tagSetTwo = new BasicDBObject("region", "US_West");

ReadPreference pref = ReadPreference.primaryPreferred(tagSetOne, tagSetTwo);

优先读取策略（Read Preferences）可以在operation, collection, DB, Mongo, MongoOptions, MongoURI各个级别来设置，而且设置会以slaveOK和WriteConcer类似的方式来继承。

优先读取策略（Read Preferences）在支持主从复制的服务器上(1.6+)都可以使用。

在优先读取策略（Read Preferences）中使用节点标记(Tags)在所有支持节点标记的服务器(2.0+)都可以使用。

在分片(shard)上使用节点标记(Tags)，必须是2.2+版本的服务器才可以。

王星游 2012-09-22 22:32 发表评论

morphia与spring的整合

王星游 — Fri, 21 Sep 2012 10:09:00 GMT

摘要: 最近研究mongoDB的各种pojo-mapping框架，中意的就两个：morphia和spring-data-mongodb。本来想着spring-data-mongodb与spring的结合更紧密些，但悲剧的是其要求spring3.0.x以上版本，与生产环境不符。查了查stackoverflow，大家评价morphia更老牌更稳定一些，于是就用这个了。研究了一番，果然与spring整合起来很麻... 阅读全文

王星游 2012-09-21 18:09 发表评论

mongodb的morphia框架学习笔记(补充)

王星游 — Fri, 21 Sep 2012 09:19:00 GMT

morphia的更新操作详解：

-------------------------

用id字段匹配是最快的，因为mongodb默认为id列做了索引：

Query updateQuery = datastore.createQuery(Hotel.class).field("_id").equal(hotel.getId());

除了"_id"外，还有一种静态常量描述ID的方式：

Query updateQuery = datastore.createQuery(Hotel.class).field(Mapper.ID_KEY).equal(hotel.getId());

注意，用的是equal()方法，而不是equals()方法！

-------------------------

set和unset方法：

改旅店名：

ops = datastore.createUpdateOperations(Hotel.class).set("name", "Fairmont Chateau Laurier");

改旅店地址名：

ops = datastore.createUpdateOperations(Hotel.class).set("address.city", "Ottawa");

删除name属性，会导致下次读取时name=null

ops = datastore.createUpdateOperations(Hotel.class).unset("name");

-------------------------

inc和dec方法：

星级加1：

ops = datastore.createUpdateOperations(Hotel.class).inc("stars");

星级加4：

ops = datastore.createUpdateOperations(Hotel.class).inc("stars", 4);

-------------------------

add和addAll方法：

将11加入房间号数组中：

ops = datastore.createUpdateOperations(Hotel.class).add("roomNumbers", 11);

这与add("roomNumbers", 11, false)等价

在非数组字段上执行add操作将报错。

add的第三个参数标识“是否加入重复元素”。若为true，如果已存在相同元素，不会加入，也不会报错。

-------------------------

removeFirst/Last/All方法：

假设目前是[ 1, 2, 3, 3 ]，运行以下方法之后：

ops = datastore.createUpdateOperations(Hotel.class).removeAll("roomNumbers", 3);

就剩下了[ 1, 2 ]——所有的3都被移除了。

假设目前是[ 1, 2, 3, 3 ]，运行以下方法之后：

ops = datastore.createUpdateOperations(Hotel.class).removeAll("roomNumbers", Arrays.asList(2, 3));

就剩下了[ 1 ] ——所有的2和3都被移除了。

-------------------------

多重操作：

ops = datastore.createUpdateOperations(Hotel.class).set("city", "Ottawa").inc("stars");

如果在同一个updateOperation对象上对同一个字段多次操作，结果是不定的。

-------------------------

update/updateFirst方法：

在默认driver里，使用update默认只更新第一个元素(multi默认为false)。

但是在morphia里，update影响所有记录(对应的底层driver里的update第四个参数multi为true)，updateFirst才是影响第一个元素(对应的底层driver里的update第四个参数multi为false)。

-------------------------

createIfMissing参数：

morphia里所有的方法都重载，最后可以附加一个参数“createIfMissing”

对应的底层driver或者shell里的操作是upsert = true：

db.collection.update( criteria, objNew, true, multi );

-------------------------------------------------

乐观锁注解@Version的使用：

http://code.google.com/p/morphia/wiki/MongoNewsletterArticleDec2010

class Person {

@Id String name;

String phone;

@Version

long version;

}

Person me = new Person("Scott Hernandez");

ds.save(me) //保存一个person

Person meAgain = ds.get(Person.class, "Scott Hernandez"); //把这个person读出来先放着

me.setPhone("111-376-7379");

ds.save(me); //把原来的me修改一下再存进去，版本号已经变化

meAgain.setPhone("123-376-7379");

ds.save(meAgain); //刚次读出来的meAgain是老版本号，此时存储将抛出并发异常

注：目前乐观锁的版本号实现方式是时间戳，根据作者的回答：

http://code.google.com/p/morphia/wiki/MongoNewsletterArticleDec2010

下一个版本的morphia将使用自增数字来代替时间戳作为乐观锁的版本号使用，以避免多服务器时间不一致等问题。

王星游 2012-09-21 17:19 发表评论

LinkedList的源码阅读笔记

王星游 — Fri, 07 Sep 2012 19:11:00 GMT

1，基本的链表实现，内部类Node表示存储节点。

2，移除某个节点时，会手动将节点的item属性设为null，以便GC更好的收集。

3，addAll()方法也并没有调用入参的集合的迭代器，而是将其toArray()后，循环这个数组。

4，调用clear()时，为了防止某个迭代器还在引用，也为了GC的回收，将每个节点的内容及前后引用都手动设置为null。

5，定位某个位置的节点时，根据位置距离头尾的距离来决定从first还是last节点开始查找。

6，LinkedList在内部覆盖了listIterator()，但是没有覆盖iterator()，所以LinkedList.iterator()调用过程如下：

LinkedList.iterator() -> AbstractSequentialList.iterator() -> AbstractList.listIterator() -> LinkedList.listIterator(int index)

最终返回的是LinkedList.ListItr对象实例，稍微有点绕，有兴趣的朋友可以打断点试试。

7，如果没有ListIterator.nextIndex()，里面其实可以不用设定nextIndex变量来记录当前位置的。

8，序列化时会将size和“顺序排列的元素流”依次跟在“默认ArrayList对象流”后面。

王星游 2012-09-08 03:11 发表评论

ArrayList的源码阅读笔记

王星游 — Fri, 07 Sep 2012 10:50:00 GMT

JDK版本：1.7

1，使用构造方法或者addAll()方法批量加入某个Collection的元素时，为了效率考虑，是调用目标的toArray()方法，然后批量数组复制的。

2，在添加单个元素或批量添加元素时，都要检查一下确保数组可以容纳本次操作所要添加的数目，必要时扩展数组。

3，扩展数组时做到“一步到位”，在“容纳本次添加操作的最小数组长度”和“当前数组长度的1.5倍”之间取最大值。

4，为效率考虑，contains()、indexOf()和lastIndexOf()方法采用的是数组循环遍历，而不是调用自身的迭代器。

5，调用clone()后的新对象，修改计数器modCount会被重置为0.

6，数组从某一位置起批量移动的时候调用System.arraycopy()，源数组与目标数组为同一个，指定起始位置和偏移量即可。

7，与移除元素有关的方法仅仅是将目标位置设为null，其余的交给GC。

8，调用clear()之后，数组长度不变，只是改了引用和size——必要时可以调用trimToSize()来缩小数组到真实容量。

9，调用removeAll()和retainAll()取空集和交集时，在自身的数组上遍历，用遍历过的部分当作新的存储空间，需要读写指针各一个。

1     private boolean batchRemove(Collection c, boolean complement) {
2         final Object[] elementData = this.elementData;
3         int r = 0, w = 0;
4         boolean modified = false;
5         try {
6             for (; r < size; r++)
7                 if (c.contains(elementData[r]) == complement)
8                     elementData[w++] = elementData[r];
9         } finally {
10             // Preserve behavioral compatibility with AbstractCollection,
11             // even if c.contains() throws.
12             if (r != size) {
13                 System.arraycopy(elementData, r,
14                                  elementData, w,
15                                  size - r);
16                 w += size - r;
17             }
18             if (w != size) {
19                 for (int i = w; i < size; i++)
20                     elementData[i] = null;
21                 modCount += size - w;
22                 size = w;
23                 modified = true;
24             }
25         }
26         return modified;
27     }

这里没看懂的是方法第一行为什么要声明一个“final”的引用，代码结构上完全可以去掉，是为了执行效率？

10，内部数组是transient类型的，不会被自动序列化。序列化时会将“数组长度值”和“顺序排列的数组元素流”依次跟在“默认ArrayList对象流”后面。

11，每次内容修改都会更改modCount计数器。迭代器初始化时复制此计数器，之后每次迭代都检查此计数器以实现快速失败特性。

12，subList只是一个指向parentList的包装视图，且可以多层包装。

王星游 2012-09-07 18:50 发表评论

java中Writer的线程安全性

王星游 — Sat, 01 Sep 2012 16:13:00 GMT

以前负责一个项目，我负责从一个超大的文本文件中读取信息存入数据库再进一步分析。而文本文件内容是每行一个json串。我在解析的过程中发现，有很小的概率json串的结构会破坏，比如前一个json串只写了半行，后面就被另一个json串覆盖掉了。

与产生日志的部门沟通，他们说是多线程使用log4j写入，可能偶尔会有串行。

具体他们是否使用log4j的AsyncAppender我不太了解，暂时也没去看log4j的源码，当时只是简单的忽略异常的行了事儿。

现在比较闲，想测试一下jdk里面各种输出方式，例如Writer，在多线程交替写入文件一行时是否会出现串行的情况，于是便出现了本文。

测试分两部分：

1，多个线程各自开启一个FileWriter写入同一个文件。

2，多个线程共用一个FileWriter写入同一个文件。

--------------------------------------------------

首先来看FileWriter的JDK说明：

“某些平台一次只允许一个 FileWriter（或其他文件写入对象）打开文件进行写入”——如果是这样，那么第1个测试便不用做了，可事实上至少在windows下并非如此。

上代码(别嫌丑，咱是在IO，不是在测多线程，您说是吧？)：

1，多个线程各自开启一个FileWriter写入同一个文件。

1     //在100毫秒的时间内，10个线程各自开一个FileWriter，
2     //同时向同一个文件写入字符串，每个线程每次写一行。
3     //测试结果：文件内容出现混乱，串行
4     private void multiThreadWriteFile() throws IOException{
5         File file=new File(basePath+jumpPath+fileName);
6         file.createNewFile();
7
8         //创建10个线程
9         int totalThreads=10;
10         WriteFileThread[] threads=new WriteFileThread[totalThreads];
11         for(int i=0;i12             WriteFileThread thread=new WriteFileThread(file,i);
13             threads[i]=thread;
14         }
15
16         //启动10个线程
17         for(Thread thread: threads){
18             thread.start();
19         }
20
21         //主线程休眠100毫秒
22         try {
23             Thread.sleep(100);
24         } catch (InterruptedException e) {
25             e.printStackTrace();
26         }
27
28         //所有线程停止
29         for(WriteFileThread thread: threads){
30             thread.setToStop();
31         }
32         System.out.println("还楞着干什么，去看一下文件结构正确与否啊！");
33     }

1     class WriteFileThread extends Thread{
2         private boolean toStop=false;
3         private FileWriter writer;
4         private int threadNum;
5         private String lineSeparator;
6
7         WriteFileThread(File file,int threadNum) throws IOException{
8             lineSeparator=System.getProperty("line.separator");
9             writer=new FileWriter(file,true);
10             this.threadNum=threadNum;
11         }
12
13         @Override
14         public void run() {
15             while(!toStop){
16                 try {
17                     writer.append("线程"+threadNum+"正在写入文件，" +
18                             "妈妈说名字要很长才能够测试出这几个线程有没有冲突啊，" +
19                             "不过还是没有论坛里帖子的名字长，怎么办呢？" +
20                             "哎呀，后面是换行符了"+lineSeparator);
21
22                 } catch (IOException e) {
23                     e.printStackTrace();
24                 }
25             }
26             System.out.println("---------线程"+threadNum+"停止执行了");
27         }
28
29         public void setToStop() {
30             this.toStop = true;
31         }
32     }

测试结果：

产生5MB左右的文本文件，里面出现大约5%的文本串行现象。

--------------------------------------------------

接下来我们看多个线程共用一个FileWriter写入同一个文件的情况：

在Writer抽象类里面有一个protected类型的lock属性，是一个简单Object对象。

JDK里对这个lock属性的描述如下：“用于同步针对此流的操作的对象。为了提高效率，字符流对象可以使用其自身以外的对象来保护关键部分。因此，子类应使用此字段中的对象，而不是 this 或者同步的方法。 ”——看来，多线程共用同一个writer的方案有戏。

继续看下源代码，从FileWriter的writer方法开始看起，调用过程如下：

FileWriter->OutputStreamWriter.write->StreamEncoder.write

其中StreamEncoder.write的源码如下：

(JDK自带源码不包括StreamExcoder，可以在这里查看 http://www.docjar.com/html/api/sun/nio/cs/StreamEncoder.java.html)

1 public void write(char cbuf[], int off, int len) throws IOException {
2     synchronized (lock) {
3         ensureOpen();
4         if ((off < 0) || (off > cbuf.length) || (len < 0) ||
5                 ((off + len) > cbuf.length) || ((off + len) < 0))
6             {
7                 throw new IndexOutOfBoundsException();
8             } else if (len == 0) {
9                 return;
10             }
11         implWrite(cbuf, off, len);
12     }
13 }

可以看到FileWriter在写入时，同步在了对应的FileOutputStream对象上——依此分析，多个线程共用一个FileWriter写入同一个文件，一次一行的情况下，不会出现串行。

写代码测试一下：

1     //多线程争抢写入同一个文件的测试，一次一行
2     //多个线程公用一个FileWriter
3     //测试结果：
4     private void multiThreadWriteFile2() throws IOException{
5         File file=new File(basePath+jumpPath+fileName);
6         file.createNewFile();
7         FileWriter fw=new FileWriter(file);
8
9         //创建10个线程
10         int totalThreads=10;
11         WriteFileThread2[] threads=new WriteFileThread2[totalThreads];
12         for(int i=0;i13             WriteFileThread2 thread=new WriteFileThread2(fw,i);
14             threads[i]=thread;
15         }
16
17         //启动10个线程
18         for(Thread thread: threads){
19             thread.start();
20         }
21
22         //主线程休眠100毫秒
23         try {
24             Thread.sleep(100);
25         } catch (InterruptedException e) {
26             e.printStackTrace();
27         }
28
29         //所有线程停止
30         for(WriteFileThread2 thread: threads){
31             thread.setToStop();
32         }
33         System.out.println("还楞着干什么，去看一下文件结构正确与否啊！");
34     }

1     class WriteFileThread2 extends Thread{
2         private boolean toStop=false;
3         private FileWriter writer;
4         private int threadNum;
5         private String lineSeparator;
6
7         WriteFileThread2(FileWriter writer,int threadNum){
8             lineSeparator=System.getProperty("line.separator");
9             this.writer=writer;
10             this.threadNum=threadNum;
11         }
12
13         @Override
14         public void run() {
15             while(!toStop){
16                 try {
17                     writer.append("线程"+threadNum+"正在写入文件，" +
18                             "妈妈说名字要很长才能够测试出这几个线程有没有冲突啊，" +
19                             "不过还是没有论坛里帖子的名字长，怎么办呢？" +
20                             "哎呀，后面是换行符了"+lineSeparator);
21                 } catch (IOException e) {
22                     e.printStackTrace();
23                 }
24             }
25             System.out.println("---------线程"+threadNum+"停止执行了");
26         }
27
28         public void setToStop() {
29             this.toStop = true;
30         }
31     }

测试结果：

产生2.2MB左右的文本文件，里面没有出现任何串行现象。

--------------------------------------------------

那么BufferedWriter又如何呢？

按道理BufferedWriter只是把别的Writer装饰了一下，在底层写的时候也是同步的。

看源码：

1     void flushBuffer() throws IOException {
2         synchronized (lock) {
3             ensureOpen();
4             if (nextChar == 0)
5                 return;
6             out.write(cb, 0, nextChar);
7             nextChar = 0;
8         }
9     }

BufferedWriter.write和BufferedWriter.flushBuffer的方法同步在了被包装的Writer这个对象上。

也就是说，BufferedWriter.write和BufferedWriter.flushBuffer都有同步块包围，说明按上述环境测试时，是不会出现串行现象的。

--------------------------------------------------

最终结果：

1，windows下，可以开多个线程操作多个FileWriter写入同一个文件，多个FileWriter切换时，会导致相互交错，破坏字符串结构的完整性。

2，多个线程操作FileWriter或者BufferedWriter时，每一次写入操作都是可以保证原子性的，也即：FileWriter或者BufferedWriter是线程安全的——呃，这个结论貌似好简单啊，JDK文档里有说明吗？没看到啊。

3，由于第2条中的线程安全，写入速度下降超过一半。

王星游 2012-09-02 00:13 发表评论

java集合框架印象

王星游 — Sun, 26 Aug 2012 17:26:00 GMT

http://docs.oracle.com/javase/6/docs/technotes/guides/collections/overview.html

集合框架层次上比较复杂，网上有无数文字和图片来说明，这里按我的思路整理了一下:

省略了AbstractCollection,AbstractList等层次的抽象类

省略了RoleList等javax包中的应用方向的实现

省略了Vector,Stack,HashTable这些著名的老家伙。

按照我的一般认识进行归类，例如LinkedList同时实现了Deque和List，这里归入List中；再例如Deque本应继承自Queue，但这里放在同一个级别上。

一切都是为了尽可能建立一个较清晰的第一印象，知道该在什么场景下使用什么类。

-------------------------------------------------

Collection 集合接口(传统包util)

Queue 队列

PriorityQueue 无界优先级队列

Deque 双端队列

ArrayDeque 基于数组的无界双端队列，做队列和栈都很合适

List 有序集合

ArrayList 基于数组的有序集合

LinkedList 基于链表的有序结合(其实也是一个Deque)

Set

EnumSet 枚举专用的set，效率高

HashSet 基本的快速哈希Set，基于HashMap

LinkedHashSet 附加了链表的哈希Set，插入慢，迭代快，有序

TreeSet 插入时就维持顺序，基于TreeMap实现，可快速获取子集

总结：

栈和队列，用ArrayDeque或者linkedList(各有千秋)；其余类的适应范围都比较明确。

-------------------------------------------------

Collection 集合接口(并发包concurrent)

Queue 队列

ConcurrentLinkedQueue 基于链接节点的无界线程安全队列

BlockingQueue 阻塞队列

ArrayBlockingQueue 基于数组的有界阻塞队列

DelayQueue 无界阻塞队列，只有在延迟期满时才能从中提取元素

LinkedBlockingQueue 基于链表的无界阻塞队列

PriorityBlockingQueue 带优先级的无界阻塞队列

SynchronousQueue 无容量的同步队列，两个线程插入与移除交替进行

Deque 双端队列

BlockingDeque 阻塞双端队列

LinkedBlockingDeque 基于链表的阻塞双端队列

List 有序集合

CopyOnWriteArrayList 可变操作通过底层复制来实现，适合多读取，少修改

Set

ConcurrentSkipListSet 多线程可以安全地发执行各种操作，迭代器弱一致

CopyOnWriteArraySet 可变操作通过底层复制来实现，适合多读取，少修改

总结：

1，ConcurrentLinkedQueue与LinkedBlockingQueue：

http://www.javacodegeeks.com/2010/09/java-best-practices-queue-battle-and.html#ixzz1seaiSLwp

如果生产者与消费者的关系是“多对多”，选LinkedBlockingQueue(阻塞方式)要快很多，代价是迭代遍历的效率奇低。

如果生产者与消费者的关系是“一对多”或者“多对一”，选ConcurrentLinkedQueue(无等待方式)会有一定性能提升。

2，ArrayBlockingQueue比LinkedBlockingQueue的表现更稳定和更可预测，但是后者的吞吐量往往更高。

3，List：

CopyOnWriteArrayList貌似只适合“多读取，少写入”的场景，其余情况还是乖乖的Collections.synchronizedList()吧。

4，Set：

ConcurrentSkipListSet可以当作并发版的TreeSet。

CopyOnWriteArraySet可以当作并发版的linkedHashSet，适合多读取，少修改。

奇怪的是java没有提供ConcurrentHashSet，按理说基于ConcurrentHashMap可以实现的。

读写都频繁的同步Set只能凑合了，用ConcurrentSkipListSet可能比synchronizedSet要强？

http://dhruba.name/2009/08/05/concurrent-set-implementations-in-java-6/

按上面的链接说法，可以试试这个：

Collections.newSetFromMap(new ConcurrentHashMap())

Use this when you have large sets, a good (and fast) hash function and can estimate the set size and needed concurrency before creating the map.

-------------------------------------------------

Map 映射接口 (传统包util)

EnumMap 枚举专用的map，效率高

HashMap 基本的快速哈希表

LinkedHashMap 附加了链表的哈希表，插入慢，迭代快，有序

IdentityHashMap 实现中用“==”运算代替“equals()”作为判断键和值是否相等

TreeMap 基于红黑树，插入时就维持顺序，可快速获取子集

WeakHashMap 以“弱键”实现，其中的键可能会被垃圾回收，导致此映射被移除

-------------------------------------------------

Map 映射接口 (并发包concurrent)

ConcurrentMap

ConcurrentHashMap

ConcurrentSkipListMap

总结：

ConcurrentHashMap可以当作并发版的HashMap

ConcurrentSkipListMap可以当作并发版的TreeMap

-------------------------------------------------

How to choose which Java collection class to use?

http://www.javamex.com/tutorials/collections/how_to_choose_2.shtml

the Queue interface

http://www.javamex.com/tutorials/synchronization_concurrency_8_queues_2.shtml

-------------------------------------------------

吐槽：不知道“基于数组的无界双端队列”这句话中的“无界”会不会被敏感掉，想起了“十六嘴交换机”的故事。

王星游 2012-08-27 01:26 发表评论