只能在用window.open打开的页面中H口中可以访问到opener属性，而对于用showModalDialog和showModalessDialog弹出的窗口则不能讉K刎ͼ其opener属性引用ؓI?/p>
2.parentQtopQ获取的是对本窗口中对象层次元素的引用，对于用iframe或者frame的较有实际意?br />
对于用window.open和showModalDialog以及showModalessDialog打开的窗口而言Q返回的是本H口对象层次的元素引用，对于q种情况QparentQtopQself三者的引用相同Q都是当前的H体自nQ但对于H体中的frame和iframe加蝲的页面元素来_q回的则不相同。parent q回的时包含该iframe的页面窗口引用，top则返回最上层的窗口引用，self当然q回的仍然是自n的引用?br />
3.selfQwindow都是获取当前面H口自n对象的引?br />
每个面自n代码中访问页面自w窗体可以采用self和window来访问到?br />
4.利用window参数传递和dialogArguments来获取弹出窗口的H口引用
Z能够在用showModalDialog和showModalessDialog弹出H口中引用到弹出H口的引用，我们可以在showModalDialog和showModalessDialog的第二个参数传入windowQ然后再弹出的页面中用dialogArguments来获取刚才传入的windowQ即弹出H口的窗口的引用?br />
]]>
以下是偶写的一个关于生产者与消费者的E序Q看看对你理解有没有帮助?br />
//生?br />
class Producer implements Runnable{
private WOWOTou wwt=null;
private Basket bs=null;
private static int id=1;
private static boolean state=true;
Producer(Basket bs){
this.bs=bs;
}
public WOWOTou produce(){
try {
Thread.sleep( (long) (Math.random()*8000));
} catch (InterruptedException e) {
e.printStackTrace();
}
wwt=new WOWOTou(id);
//输出调试语句
System.out.println();
System.out.println(Thread.currentThread().getName()+"生了id?+id+"的包?);
id++;
return wwt;
}
public void push(){
bs.push(wwt);
wwt=null;
}
public void run() {
while(state){
synchronized(this){
produce();
push();
}
}
}
}
//消费?br />
class Custmer implements Runnable{
private Basket bs=null;
private WOWOTou wwt=null;
private static boolean state=true;
public Custmer(Basket bs) {
this.bs = bs;
}
public void cousme(){
try{
Thread.sleep((long) (Math.random()*8000));
}catch(InterruptedException e){
e.printStackTrace();
}
// 输出调试语句
System.out.println();
System.out.println(Thread.currentThread().getName()+"消费id?+wwt.getWOWOTouID()+"的包?);
wwt=null;
}
public void pop(){
wwt=bs.pop();
}
public void run() {
while(state){
synchronized(this){
pop();
cousme();
}
}
}
}
//装WOWOTou的Basket
class Basket{
private int index=0;
private final static int max=5;
private WOWOTou wwt=null;
private WOWOTou[] wwtbs=new WOWOTou[5];
private Producer p=null;
private static Basket bs=null;
private Basket(){}
public synchronized static Basket getBasket(){
if(bs==null)
bs=new Basket();
return bs;
}
public synchronized void push(WOWOTou wwt){
while(index==max){
System.out.println("包子满了Q赶紧吃包子");
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
this.notify();
//输出调试语句
System.out.println();
System.out.println("q是"+Thread.currentThread().getName()+"生的id?+wwt.getWOWOTouID()+"的包?);
wwtbs[index++]=wwt;
}
public synchronized WOWOTou pop(){
while(index==0){
System.out.println();
System.out.println("没包子了Q赶紧生产包?);
try{
this.wait();
}catch(InterruptedException e){
e.printStackTrace();
}
}
this.notify();
if(index>0)
index--;
//输出调试语句
System.out.println();
System.out.println(Thread.currentThread().getName()+"拿到id?+wwtbs[index].getWOWOTouID()+"的包?);
return wwtbs[index];
}
}
class WOWOTou{
private int id=0;
WOWOTou(int id){
this.id=id;
}
public int getWOWOTouID(){
return id;
}
}
当你明白U程后，应该考虑多线E和U程的性能问题Q尽量减锁的粒度，但要注意死锁问题?
]]>
一、简?br />
U程池类?java.util.concurrent.ThreadPoolExecutorQ常用构造方法ؓQ?br />
ThreadPoolExecutor(int corePoolSize, int maximumPoolSize,
long keepAliveTime, TimeUnit unit,
BlockingQueue<Runnable> workQueue,
RejectedExecutionHandler handler)
corePoolSizeQ?U程池维护线E的最数?br />
maximumPoolSizeQ线E池l护U程的最大数?br />
keepAliveTimeQ?U程池维护线E所允许的空闲时?br />
unitQ?U程池维护线E所允许的空闲时间的单位
workQueueQ?U程池所使用的缓冲队?br />
handlerQ?U程池对拒绝d的处理策?br />
一个Q务通过 execute(Runnable)Ҏ被添加到U程池，d是一?Runnablecd的对象，d的执行方法就?Runnablecd对象的run()Ҏ?br />
当一个Q务通过execute(Runnable)ҎƲ添加到U程池时Q?br />
如果此时U程池中的数量小于corePoolSizeQ即使线E池中的U程都处于空闲状态，也要创徏新的U程来处理被d的Q务?/p>
如果此时U程池中的数量等?corePoolSizeQ但是缓冲队?workQueue未满Q那么Q务被攑օ~冲队列?/p>
如果此时U程池中的数量大于corePoolSizeQ缓冲队列workQueue满，q且U程池中的数量小于maximumPoolSizeQ徏新的U程来处理被d的Q务?/p>
如果此时U程池中的数量大于corePoolSizeQ缓冲队列workQueue满，q且U程池中的数量等于maximumPoolSizeQ那么通过 handler所指定的策略来处理此Q务?br />
也就是：处理d的优先为：
核心U程corePoolSize、Q务队列workQueue、最大线EmaximumPoolSizeQ如果三者都满了Q用handler处理被拒l的d?br />
当线E池中的U程数量大于 corePoolSizeӞ如果某线E空闲时间超qkeepAliveTimeQ线E将被终止。这PU程池可以动态的调整池中的线E数?br />
unit可选的参数为java.util.concurrent.TimeUnit中的几个静态属性：
NANOSECONDS、MICROSECONDS、MILLISECONDS、SECONDS?br />
workQueue我常用的是：java.util.concurrent.ArrayBlockingQueue
handler有四个选择Q?br />
ThreadPoolExecutor.AbortPolicy()
抛出java.util.concurrent.RejectedExecutionException异常
ThreadPoolExecutor.CallerRunsPolicy()
重试d当前的Q务，他会自动重复调用execute()Ҏ
ThreadPoolExecutor.DiscardOldestPolicy()
抛弃旧的d
ThreadPoolExecutor.DiscardPolicy()
抛弃当前的Q?/p>
二、一般用法D?br />
//------------------------------------------------------------
//TestThreadPool.java
//package cn.simplelife.exercise;
import java.io.Serializable;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
public class TestThreadPool {
private static int produceTaskSleepTime = 2;
private static int consumeTaskSleepTime = 2000;
private static int produceTaskMaxNumber = 10;
public static void main(String[] args) {
//构造一个线E池
ThreadPoolExecutor threadPool = new ThreadPoolExecutor(2, 4, 3,
TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(3),
new ThreadPoolExecutor.DiscardOldestPolicy());
for(int i=1;i<=produceTaskMaxNumber;i++){
try {
//产生一个Q务，q将其加入到U程?br />
String task = "task@ " + i;
System.out.println("put " + task);
threadPool.execute(new ThreadPoolTask(task));
//便于观察Q等待一D|?br />
Thread.sleep(produceTaskSleepTime);
} catch (Exception e) {
e.printStackTrace();
}
}
}
/**
* U程池执行的d
* @author hdpan
*/
public static class ThreadPoolTask implements Runnable,Serializable{
private static final long serialVersionUID = 0;
//保存d所需要的数据
private Object threadPoolTaskData;
ThreadPoolTask(Object tasks){
this.threadPoolTaskData = tasks;
}
public void run(){
//处理一个Q务，q里的处理方式太单了Q仅仅是一个打印语?br />
System.out.println("start .."+threadPoolTaskData);
try {
////便于观察Q等待一D|?br />
Thread.sleep(consumeTaskSleepTime);
} catch (Exception e) {
e.printStackTrace();
}
threadPoolTaskData = null;
}
public Object getTask(){
return this.threadPoolTaskData;
}
}
}
//------------------------------------------------------------
说明Q?br />
1、在q段E序中，一个Q务就是一个Runnablecd的对象，也就是一个ThreadPoolTaskcd的对象?/p>
2、一般来说Q务除了处理方式外Q还需要处理的数据Q处理的数据通过构造方法传lQ务?/p>
3、在q段E序中，main()Ҏ相当于一个残忍的领导Q他z֏多Q务，丢给一个叫 threadPool的Q劳Q怨的组来做?/p>
q个组里面队员臛_有两个，如果他们两个忙不q来QQ务就被放CQ务列表里面?/p>
如果U压的Q务过多，多到d列表都装不下(过3?的时候，雇佣新的队员来帮忙。但是基于成本的考虑Q不能雇佣太多的队员Q至多只能雇?4个?/p>
如果四个队员都在忙时Q再有新的Q务，q个组处理不了了QQ务就会被通过一U策略来处理Q我们的处理方式是不停的z֏Q直到接受这个Q务ؓ?更残忍！呵呵)?/p>
因ؓ队员工作是需要成本的Q如果工作很Ԍ闲到 3SECONDS都没有新的Q务了Q那么有的队员就会被解雇了，但是Qؓ了小l的正常q{Q即使工作再Ԍ组的队员也不能于两个?/p>
4、通过调整 produceTaskSleepTime?consumeTaskSleepTime的大来实现Ҏ发Q务和处理d的速度的控Ӟ改变q两个值就可以观察不同速率下程序的工作情况?/p>
5、通过调整4中所指的数据Q再加上调整d丢弃{略Q换上其他三U策略，可以看Z同策略下的不同处理方式?/p>
6、对于其他的使用ҎQ参看jdk的帮助，很容易理解和使用?/p>
转自Qhttp://hi.baidu.com/gladfeel/blog/item/b52338731dd6c3198701b0b3.html
]]>
]]>
1Q烦引文?/strong>
索引文g׃文g和烦引表构成?br /> ①主文gQ文件本w?br /> ②烦引表Q在文g本n外徏立的一张表Q它指明逻辑记录和物理记录之间的一一对应关系?br />
2Q烦引表l成
索引表由若干索引组成。一般烦引项׃关键字和该关键字所在记录的物理地址l成?br /> 注意Q?/font>
索引表必Ld键字有序Q而主文g本n则可以按d键字有序或无序?br />
3Q烦引顺序文件和索引非顺序文?/strong>
Q?Q烦引顺序文?Indexed Sequential File)
L件按d键字有序的文件称索引序文g?br /> 在烦引顺序文件中Q可对一l记录徏立一个烦引项。这U烦引表UCؓE疏烦引?br />
Q?Q烦引非序文g(Indexed NonSequentail File)
L件按d键字无序得文件称索引非顺序文件?br /> 在烦引非序文g中，必须为每个记录徏立一个烦引项Q这样徏立的索引表称为稠密烦引?br /> 注意Q?/font>
?通常烦引非序文gUCؓ索引文g?br /> ?索引非顺序文件主文g无序Q顺序存取将会频J地引v头UdQ适合于随机存取，不适合于顺序存取?br /> ?索引序文g的主文g是有序的Q适合于随机存取、顺序存取?br /> ?索引序文g的烦引是E疏烦引。烦引占用空间较，是最常用的一U文件组l?br /> ?最常用的烦引顺序文ӞISAM文g和VSAM文g?br />
索引文g的存?br />
1Q烦引文件的存储
索引文g在存储器上分Z个区Q烦引区和数据区。烦引区存放索引表，数据区存放主文g?br />
2Q?索引文g的徏?/strong>
建立索引文g的过E：
Q?Q?按输入记录的先后ơ序建立数据区和索引表。其中烦引表中关键字是无序的
Q?Q?待全部记录输入完毕后对烦引表q行排序Q排序后的烦引表和主文g一起就形成了烦引文件?br /> 【例】对于表10.2的数据文Ӟd键字是职工号Q排序前的烦引表如表10.3所C，排序后的索引表见?0.4Q表10.2和表10.4一起Ş成了一个烦引文件?br />
学习|址:
http://student.zjzk.cn/course_ware/data_structure/web/wenjian/wenjian10.3.1.htm
]]>
lucene 索引文gl构分析
在分?lucene 的烦引文件结构之前，我们先要理解反向索引Qinverted indexQ这个概念，反向索引是一U以索引ؓ中心来组l文档的方式Q每个烦引项指向一个文档序列，q个序列中的文档都包含该索引V相反，在正向烦引中Q文档占据了中心的位|，每个文档指向了一个它所包含的烦引项的序列。你可以利用反向索引L的找到那些文档包含了特定的烦引项。lucene正是使用了反向烦引作为其基本的烦引结构?/p>
索引文g的逻辑视图
在lucene 中有索引块的概念Q每个烦引块包含了一定数目的文档。我们能够对单独的烦引块q行索。图 2 昄?lucene 索引l构的逻辑视图。烦引块的个数由索引的文档的L以及每个索引块所能包含的最大文档数来决定?/p>
?Q烦引文件的逻辑视图
lucene 中的关键索引文g
下面的部分将会分析lucene中的主要的烦引文Ӟ可能分析有些索引文g的时候没有包含文件的所有的字段Q但不会影响到对索引文g的理解?/p>
1Q烦引块文g
q个文g包含了烦引中的烦引块信息Q这个文件包含了每个索引块的名字以及大小{信息。表 2 昄了这个文件的l构信息?/p>
?Q烦引块文gl构
2Q域信息文g
我们知道Q烦引中的文档由一个或者多个域l成Q这个文件包含了每个索引块中的域的信息。表 3 昄了这个文件的l构?/p>
?Q域信息文gl构
3Q烦引项信息文g
q是索引文g里面最核心的一个文Ӟ它存储了所有的索引的g及相关信息，q且以烦引项来排序。表 4 昄了这个文件的l构?/p>
?Q烦引项信息文gl构
4Q频率文?/p>
q个文g包含了包含烦引项的文档的列表Q以及烦引项在每个文档中出现的频率信息。如果lucene在烦引项信息文g中发现有索引和搜烦词相匚w。那?lucene ׃在频率文件中找有哪些文g包含了该索引V表5昄了这个文件的一个大致的l构Qƈ没有包含q个文g的所有字Dc?/p>
?Q频率文件的l构
5Q位|文?/p>
q个文g包含了烦引项在每个文档中出现的位|信息，你可以利用这些信息来参与对烦引结果的排序。表 6 昄了这个文件的l构
?Q位|文件的l构
到目前ؓ止我们介l了 lucene 中的主要的烦引文件结构，希望能对你理?lucene 的物理的存储l构有所帮助?/p>
]]>