csusky

常用链接

统计

最新评论

#

异步IO的关闭事件

JAVA SOCKET只定义了四种事件

public static final int OP_READ = 1 << 0;
public static final int OP_WRITE = 1 << 2;
public static final int OP_CONNECT = 1 << 3;
public static final int OP_ACCEPT = 1 << 4;

是没有关闭事件的,我们怎么判断一个连接是否关闭呢?
如果你的selector注册了一个OP_READ事件,那么在连接关闭的时候将会产生一个OP_READ事件
也就是说本来阻塞的selector此时将会被唤醒,但是如果试图在此事件的通道中读取数据将会返回-1
如下:

Set<SelectionKey> readyKeys = selector.selectedKeys();

= readyKeys.iterator()

SelectionKey key 
= (SelectionKey)i.next();

if (operation == SelectionKey.OP_READ &&
                         key.isReadable())
                
{
                    ReadableByteChannel incomingChannel 
= (ReadableByteChannel)key.channel(); 
//此时将会得到-1,表明该链接已关闭
int n = incomingChannel.read(readBuffer);
}
此时我们需要取消该KEY 如下:
if (n == -1)
            
{
                key.cancel();
                  //关闭输入输出 
                  sc.socket().shutdownOutput();
                  sc.socket().shutdownInput();
                   //关闭SOCKET
                   sc.socket().close();
                  //关闭通道
                   incomingChannel.close();
            }

posted @ 2009-11-10 22:28 晓宇 阅读(410) | 评论 (1)编辑 收藏

ExecutorFilter

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
当然还需要覆盖相应的事件处理方法 如上所示

posted @ 2008-12-12 11:33 晓宇 阅读(1543) | 评论 (0)编辑 收藏

ORACLE的块大小

参数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



 

posted @ 2008-11-25 15:45 晓宇 阅读(1755) | 评论 (0)编辑 收藏

TIPS

将进酒  杯莫停  -------> 亭名:  悲默亭

全球通史

《诗经·采薇》

昔我往矣,杨柳依依 今我来思,雨雪霏霏

posted @ 2008-11-10 16:31 晓宇 阅读(177) | 评论 (0)编辑 收藏

SPRING整合IBMMQ实现全局事物

     摘要: <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans"     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance...  阅读全文

posted @ 2008-10-27 17:01 晓宇 阅读(2404) | 评论 (0)编辑 收藏

Lucene的切词 analysis包

在搜索引擎中,切词语是一个重要的部分,其中包括专有名词的提取、词的分割、词的格式化等等。
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类簇由于输入输出不同,所以不能嵌套







posted @ 2008-05-30 14:47 晓宇 阅读(1018) | 评论 (1)编辑 收藏

JDK1.5的自动装箱功能

在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章中介绍过==是用来比较两个基本数据类型的变量值是否相等,事实上==也用于判断两个对象引用名称是否参考至同一个对象。

在自动装箱时对于值从–128127之间的值,它们被装箱为Integer对象后,会存在内存中被重用,所以范例4.6中使用==进行比较时,i1 i2实际上参考至同一个对象。如果超过了从–128127之间的值,被装箱后的Integer对象并不会被重用,即相当于每次装箱时都新建一个Integer对象,所以范例4.7使用==进行比较时,i1i2参考的是不同的对象。

所以不要过分依赖自动装箱与拆箱,您还是必须知道基本数据类型与对象的差异。范例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使用这样的写法,相信也会比较放心一些,对于这些方便但隐藏细节的功能到底要不要用呢?基本上只有一个原则:如果您不确定就不要用。

posted @ 2008-05-16 11:33 晓宇 阅读(436) | 评论 (0)编辑 收藏

关于IndexWriter中的3个性能参数

IndexWriter中有3个重要的性能参数
mergeFactor           默认为10
minMergeDocs      默认为10
maxMergeDocs     默认为Integer.maxValue

maxMergeDocs     一个段中所能包含的最大的doc数,达到这个数目即不再将段进行合并 一般不改变这个值
minMergeDocs      是指在RAMDirectory中保存的Doc的个数,达到minMergeDocs 个即要合并到硬盘上去(在硬盘上新建一个段)
mergeFactor           合并因子,是控制硬盘上的段的合并的,每次在硬盘上新建一个段之后即执行
                                 targetMergeDocs*=mergeFactor(一开始targetMergeDocs=minMergeDocs) 如果硬盘上的doc数目大于等于                            targetMergeDocs则将硬盘上最后建立的mergeFactor个段进行合并成一个段

拿默认的参数举例:
如果硬盘上面已经有9个段  每个段分别存储了10个Document,共(90个DOC),这时候如果程序再向硬盘合并一个新的段(含10个DOC),合并完之后targetMergeDocs=10*10  程序检查已经合并的最后(按照创建的时间先后顺序)mergeFactor个段的document的总和100是否大于等于targetMergeDocs(这里是100,刚好满足要求)于是程序又将硬盘上面的后10个段合并为一个新的段。

另外一个例子:
doc数目            段数目
  1000---------------9个
  100-----------------9个
  10   ----------------9个
这时如果再象硬盘中新建一个新的包含了10个doc的段
    doc数目            段数目
  (1) 1000----------------9个

  (2)  100-----------------9个

  (3)   10  ----------------9个
                                     
  (4)    10 ----------------1个
这时候(3)(4)首先合并成一个新的段(3-4)包含100个doc
 然后(2)(3-4)和并成一个新段(2-3-4)包含1000个doc
然后(1)(2-3-4)合并成一个新的段  包含10000个doc
最后合并成一个段


private final void maybeMergeSegments() throws IOException {
    
long targetMergeDocs = minMergeDocs;
    
while (targetMergeDocs <= maxMergeDocs) {
      
// find segments smaller than current target size
      int minSegment = segmentInfos.size();
      
int mergeDocs = 0;
      
while (--minSegment >= 0{
        SegmentInfo si 
= segmentInfos.info(minSegment);
        
if (si.docCount >= targetMergeDocs)
          
break;
        mergeDocs 
+= si.docCount;
      }


      
if (mergeDocs >= targetMergeDocs)          // found a merge to do
        mergeSegments(minSegment+1);
      
else
        
break;

      targetMergeDocs 
*= mergeFactor;        // increase target size
      System.out.println("- -- - -targetMergeDocs:"+targetMergeDocs);
      
try {Thread.sleep(5000);} catch(Exception e) {};
    }

  }

posted @ 2008-05-15 19:27 晓宇 阅读(1418) | 评论 (0)编辑 收藏

HIBERNATE的一对多和多对一关联

HIBERNATE一多对关联中  要求在持久化类中定义集合类属性时,必须把属性声明为接口,因为HIBERNATE在调用持久化类的SET/GET方法时传递的是HIBERNATE自己定义的集合类。
在定义集合时,一般先初始化为集合实现类的一个实例 : private Set orders=new HashSet(),这样可以避免访问空集合出现NullPointerException.

posted @ 2008-05-14 11:01 晓宇 阅读(229) | 评论 (0)编辑 收藏

Lucene索引文件的格式

segments文件的格式: (段的信息)
int:  =-1    查看文件是否是Lucene合法的文件格式
long:        版本号,每更新一次该文件将会将版本号加1
int:         用来命名新段
int:         段的数目
String + int 段的信息 String是段的名称  int是段中所含的doc数目
String + int 同上


.fnm的文件格式:   (Field的信息)
int:               Field的个数,最少为1,最少有一个Field("",false),在初始化的时候写入(暂时不知道原因); 名称为空字符串,未索引,        未               向           量化。readVInt()读取
String: byte      String是 Field的名称  byte指示该Field 是否被索引,是否向量化 (值有:11,10,01)第一个1代表被索引,第二个代表被向量化
String: byte Field 同上
     

 

.fdx的文件格式:主要是提供对.fdt中存储的document的随即读取
long :       第一个document在.fdt文件中的位置
long:        第二个document在.fdt文件中的位置


.fdt的文件格式:  .fdt文件存储了一系列document的信息
VInt:        该document中的isStored属性为true的域的个数
(VInt:)      如果该field的isStored属性为true则得到该field的fieldNumber,暂时不知道这个fieldNumber是怎么产生的,有什么用,初步估计是按照field创建的顺序产生的,每次再上一个field的fieldNumber基础上加1。
byte:        如果该field的isTokenized属性为true写入1否则写入false。
String:      该field的stringValue()值。
一个document结束,下面的数据将会开始一个新的document,每个新的document的开始点的文件位置都会在.fdx中有记载,便于随即访问

 

posted @ 2008-04-21 17:52 晓宇 阅读(474) | 评论 (0)编辑 收藏

仅列出标题
共4页: 1 2 3 4 下一页