1 . 用Executors构造一个新的线程池
ExecutorService executor = Executors.newCachedThreadPool();
方法 newCachedThreadPool();
创建一个可根据需要创建新线程的线程池，但是在以前构造的线程可用时将重用它们，并在需要时使用提供的 ThreadFactory 创建新线程。
2. 用构造的线程池创建ExecutorFilter
ExecutorFilter es= new ExecutorFilter(executor));
在ExecutorFilter内部:
只需要将相应的事件分发到到线程池的相应线程即可，但是SessionCreated事件只能在主线程中，不能分发
触发方法
1 .
首先构造一个IoFilterEvent，这个IoFilterEvent包含1、事件的类型，2、下一个过滤器
然后触发该时间的处理方法。
if (eventTypes.contains(IoEventType.SESSION_OPENED)) 
{
fireEvent(new IoFilterEvent(nextFilter, IoEventType.SESSION_OPENED,
session, null));
}
2 .
从线程池中取出一个线程执行事件处理
protected void fireEvent(IoFilterEvent event) {
getExecutor().execute(event);
}
在构造ExecutorFilter 时如果没有传入IoEventType则默认只对如下几种几件感兴趣
EXCEPTION_CAUGHT
MESSAGE_RECEIVED
MESSAGE_SENT
SESSION_CLOSED
SESSION_IDLE
SESSION_OPENED
当然还需要覆盖相应的事件处理方法 如上所示
参数db_block_size；
这个参数只能设置成底层操作系统物理块大小的整数倍，最好是2的n次方倍。
如WINDOWS下4KB，8KB,16KB
且该参数需要在建库的时候指定，一旦指定不能更改。
虽然在ORACLE9I以上可以指定表空间的数据库大小，允许同时使用包括非默认大小在内的数据库块大小。不过需要设置指定大小数据块的buffer_cache.
小的块：
小的块降低块竞争，因为每个块中的行较少.
小的块对于小的行有益.
小的块对于随意的访问较好.如果一个块不太可能在读入内存后被修改，那么块的大小越小使用buffer cache越有效率。当内存资源很珍贵时尤为重要，因为数据库的buffer cache是被限制大小的。
劣势：
小块的管理消费相对大.
因为行的大小你可能只在块中存储很小数目的行，这可能导致额外的I/O。
小块可能导致更多的索引块被读取
大的块
好处：
更少的管理消费和更多存储数据的空间.
大块对于有顺序的读取较好. 譬如说全表扫描
大块对很大的行较好
大块改进了索引读取的性能.大的块可以在一个块中容纳更多的索引条目,降低了大的索引级的数量.越少的index level意味着在遍历索引分支的时候越少的I/O。
劣势：
大块不适合在OLTP中用作索引块,因为它们增加了在索引叶块上的块竞争。
如果你是随意的访问小的行并有大的块，buffer cache就被浪费了。例如，8 KB的block size 和50 byte row size,你浪费了7,950
将进酒 杯莫停 -------> 亭名： 悲默亭
全球通史
《诗经·采薇》
昔我往矣,杨柳依依 今我来思,雨雪霏霏
摘要: <?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance...
阅读全文
在搜索引擎中，切词语是一个重要的部分，其中包括专有名词的提取、词的分割、词的格式化等等。
TokenStream 类几乎是所有这些类的基类
有两个需要被子类实现的方法Token next() 和 close()
首先来看analysis包，这个包主要是提供一些简单的词汇化处理
以Tokenizer结尾的类是将要处理的字符串进行分割成Token流，而根据分割的依据的又产生了以下几个Tokenizer类
首先Tokenizer类是所有以Tokenizer结尾的类的基类
然后是CharTokenizer，所有的以Tokenizer结尾的类都是从这个类继承的
这个类中有一个抽象方法
protected abstract boolean isTokenChar(char c);
另外一个需要被子类覆写的方法
protected char normalize(char c) {}；
是对单个字符进行处理的方法譬如说将英文字母全部转化为小写
还有一个变量
protected Reader input;
这个读取器是这些类所处理的数据的 数据源
输入一个Reader ，产生一个Token流
这个方法是是否进行切分的依据，依次读取char流，然后用这个方法对每个char进行检测，如果返回false则将预先存储在
词汇缓冲区中的char数组作为一个Token返回
LetterTokenizer ：
protected boolean isTokenChar(char c) {
return Character.isLetter(c);
}
WhitespaceTokenizer：
protected boolean isTokenChar(char c) {
return !Character.isWhitespace(c);
}
LowerCaseTokenizer extends LetterTokenizer：
protected char normalize(char c) {
return Character.toLowerCase(c);
}
在构造函数中调用super(in);进行和 LetterTokenizer同样的操作，但是在词汇化之前所有的词都转化为小写了
然后是以Filter结尾的类，这个类簇主要是对已经词汇化的Token流进行进一步的处理
输入是Token流 , 输出仍然是Token流。
TokenFilter extends TokenStream 是所有这些类的父类
protected TokenStream input;
在TokenFilter 中有一个TokenStream 变量，是Filter类簇处理的数据源，而Filter类簇又是继承了TokenStream 类的
有一个public final Token next()方法,这个方法以TokenStream.next()产生的Token流 为处理源，产生的仍然是Token流
只不过中间有一些处理的过程
LowerCaseFilter：将所有的Token流的转化为小写
t.termText = t.termText.toLowerCase();
StopFilter：过滤掉一些停止词，这些停止词由构造函数指定
for (Token token = input.next(); token != null; token = input.next())
if (!stopWords.contains(token.termText))
return token;
比较一下Tokenizer类簇和Filter类簇，可以知道
Tokenizer类簇主要是对输入的Reader流，实际上是字符流按照一定的规则进行分割，产生出Token流
其输入是字符串的Reader流形式，输出是Token流
Filter类簇主要是对输入的Token流进行更进一步的处理，如去除停止词，转化为小写
主要为一些格式化操作。
由于Filter类簇的输入输出相同，所以可以嵌套几个不同的Filter类，以达到预期的处理目的。
前一个Filter类的输出作为后一个Filter类的输入
而Tokenizer类簇由于输入输出不同，所以不能嵌套
在JAVA JDK1.5以后具有的自动装箱与拆箱的功能，所谓的自动装箱
与拆箱也就是把基本的数据类型自动的转为封装类型。
如：自动装箱，它可以直接把基本类型赋值给封装类型
Integer num = 10 ;
Double d = 2d ;
自动拆箱，它可以把封装类型赋值给基本类型
int num = new Integer(10);
double d = new Double(2d);
自动装箱与拆箱的功能事实上是编译器来帮您的忙，编译器在编译时期依您所编写的语法，决定是否进行装箱或拆箱动作。在自动装箱时对于值从-128到127之间的值，它们被装箱为Integer对象后，会存在内存中被重用，所以范例4.6中使用==进行比较时，i1 与 i2实际上参考至同一个对象。如果超过了从-128到127之间的值，被装箱后的Integer对象并不会被重用，即相当于每次装箱时都新建一个Integer对象，所以范例4.7使用==进行比较时，i1与i2参考的是不同的对象。所以不要过分依赖自动装箱与拆箱，您还是必须知道基本数据类型与对象的差异。
public void testBoxingUnboxing() {
int i = 10;
Integer inta = i;
inta++;
inta += 1;
int j = inta;
assertTrue(j == inta);结果是：true//junit里面的方法
assertTrue(j == new Integer(j)); 结果是：true
assertTrue(10000 == new Integer(10000)); 结果是：true
}
Integer i = 100.相当于编译器自动为您作以下的语法编译：
Integer i = new Integer(100).所以自动装箱与拆箱的功能是所谓的“编译器蜜糖”(Compiler Sugar)，虽然使用这个功能很方便，但在程序运行阶段您得了解Java的语义。例如下面的程序是可以通过编译的：
Integer i = null.int j = i.这样的语法在编译时期是合法的，但是在运行时期会有错误，因为这种写法相当于：
Integer i = null.int j = i.intValue().null表示i没有参考至任何的对象实体，它可以合法地指定给对象参考名称。由于实际上i并没有参考至任何的对象，所以也就不可能操作intValue()方法，这样上面的写法在运行时会出现NullPointerException错误。
自动装箱、拆箱的功能提供了方便性，但隐藏了一些细节，所以必须小心。再来看范例4.6，您认为结果是什么呢？
Ü. 范例4.6 AutoBoxDemo2.java
public class AutoBoxDemo2 {
public static void main(String[] args) {
Integer i1 = 100;
Integer i2 = 100;
if (i1 == i2)
System.out.println("i1 == i2");
else
System.out.println("i1 != i2").
}
}
从自动装箱与拆箱的机制来看，可能会觉得结果是显示i1 == i2，您是对的。那么范例4.7的这个程序，您觉得结果是什么？
Ü. 范例4.7 AutoBoxDemo3.java
public class AutoBoxDemo3 {
public static void main(String[] args) {
Integer i1 = 200;
Integer i2 = 200;
if (i1 == i2)
System.out.println("i1 == i2");
else
System.out.println("i1 != i2");
}
}
结果是显示i1 != i2，这有些令人惊讶，两个范例语法完全一样，只不过改个数值而已，结果却相反。
其实这与==运算符的比较有关，在第3章中介绍过==是用来比较两个基本数据类型的变量值是否相等，事实上==也用于判断两个对象引用名称是否参考至同一个对象。
在自动装箱时对于值从–128到127之间的值，它们被装箱为Integer对象后，会存在内存中被重用，所以范例4.6中使用==进行比较时，i1 与 i2实际上参考至同一个对象。如果超过了从–128到127之间的值，被装箱后的Integer对象并不会被重用，即相当于每次装箱时都新建一个Integer对象，所以范例4.7使用==进行比较时，i1与i2参考的是不同的对象。
所以不要过分依赖自动装箱与拆箱，您还是必须知道基本数据类型与对象的差异。范例4.7最好还是依正规的方式来写，而不是依赖编译器蜜糖(Compiler Sugar)。例如范例4.7必须改写为范例4.8才是正确的。
Ü. 范例4.8 AutoBoxDemo4.java
public class AutoBoxDemo4 {
public static void main(String[] args) {
Integer i1 = 200;
Integer i2 = 200;
if (i1.equals(i2))
System.out.println("i1 == i2");
else
System.out.println("i1 != i2");
}
}
结果这次是显示i1 == i2。使用这样的写法，相信也会比较放心一些，对于这些方便但隐藏细节的功能到底要不要用呢？基本上只有一个原则：如果您不确定就不要用。