stonestrange's space

卸载Android模拟器中已经安装的程序

2009-04-26T02:43:00.000-07:00

1、开始->运行->cmd
2、cd \android-sdk-windows-1.0_r2\tools
3、adb shell
#cd /data/app
#ls
#rm *******.apk

【转】什么是实模式、保护模式和虚拟8086方式

2008-06-09T22:50:00.000-07:00

1:实模式：寻址采用和8086相同的16位段和偏移量，最大寻址空间1MB，最大分段64KB。可以使用32位指令。32位的x86 CPU用做高速的8086。
2:保护模式：寻址采用32位段和偏移量，最大寻址空间4GB，最大分段4GB (Pentium Pre及以后为64GB)。在保护模式下CPU可以进入虚拟8086方式，这是在保护模式下的实模式程序运行环境。

第一:实模式下程序的运行回顾.
程序运行的实质是什么?其实很简单,就是指令的执行,显然CPU
是指令得以执行的硬件保障,那么CPU如何知道指令在什么地方呢?
对了,80x86系列是使用CS寄存器配合IP寄存器来通知CPU指令在内存
中的位置.
程序指令在执行过程中一般还需要有各种数据,80x86系列有DS、
ES、FS、GS、SS等用于指示不同用途的数据段在内存中的位置。
程序可能需要调用系统的服务子程序，80x86系列使用中断机制
来实现系统服务。
总的来说，这些就是实模式下一个程序运行所需的主要内容
（其它如跳转、返回、端口操作等相对来说比较次要。）

第二：保护模式---从程序运行说起
无论实模式还是保护模式，根本的问题还是程序如何在其中运行。
因此我们在学习保护模式时应该时刻围绕这个问题来思考。
和实模式下一样，保护模式下程序运行的实质仍是“CPU执行指令，
操作相关数据”，因此实模式下的各种代码段、数据段、堆栈段、中
断服务程序仍然存在，且功能、作用不变。
那么保护模式下最大的变化是什么呢？答案可能因人而异，我的
答案是“地址转换方式”变化最大。

第三：地址转换方式比较
先看一下实模式下的地址转换方式，假设我们在ES中存入0x1000，
DI中存入0xFFFF,那么ES:DI=0x1000*0x10+0xFFFF=0x1FFFF,这就是众
所周知的“左移4位加偏移”。
那么如果在保护模式下呢？假设上面的数据不变ES=0x1000,
DI=0xFFFF，现在ES:DI等于什么呢？
公式如下：（注：0x1000=1000000000000b= 10 0000 0000 0 00）
ES:DI=全局描述符表中第0x200项描述符给出的段基址+0xFFFF
现在比较一下，好象是不一样。再仔细看看，又好象没什么区别！
为什么说没什么区别，因为我的想法是，既然ES中的内容都不是
真正的段地址，凭什么实模式下称ES为“段寄存器”，而到了保护模式
就说是“选择子”？
其实它们都是一种映射，只是映射规则不同而已：在实模式下这
个“地址转换方式”是“左移4位”；在保护模式下是“查全局/局部描述表”
。前者是系统定义的映射方式，后者是用户自定义的转换方式。而它
影响的都是“shadow register”
从函数的观点来看，前者是表达式函数，后者是列举式函数：
实模式： F(es-->segment)={segment |segment=es*0x10}
保护模式：F(es-->segment)={segment |(es,segment)∈GDT/LDT}
其中GDT、LDT分别表示全局描述符表和局部描述符表。

第四：保护模式基本组成
保护模式最基本的组成部分是围绕着“地址转换方式”的变化增设了
相应的机构。
1、数据段
前面说过，实模式下的各种代码段、数据段、堆栈段、中断服务程
序仍然存在，我将它们统称为“数据段”，本文从此向下凡提到数据段都
是使用这个定义。
2、描述符
保护模式下引入描述符来描述各种数据段，所有的描述符均为8个字
节（0-7)，由第5个字节说明描述符的类型，类型不同，描述符的结构也
有所不同。
若干个描述符集中在一起组成描述符表，而描述符表本身也是一种
数据段，也使用描述符进行描述。
从现在起，“地址转换”由描述符表来完成，从这个意义上说，描述符
表是一张地址转换函数表。
3、选择子
选择子是一个2字节的数，共16位，最低2位表示RPL，第3位表示查表
是利用GDT（全局描述符表）还是LDT（局部描述符表）进行，最高13位给
出了所需的描述符在描述符表中的地址。（注：13位正好足够寻址8K项）

有了以上三个概念之后可以进一步工作了，现在程序的运行与实模式
下完全一样！！！各段寄存器仍然给出一个“段值”，只是这个“假段值”
到真正的段地址的转换不再是“左移4位”，而是利用描述符表来完成。但
现在出现一个新的问题是：
系统如何知道GDT/LDT在内存中的位置呢？
为了解决这个问题，显然需要引入新的寄存器用于指示GDT/LDT在内
存中的位置。在80x86系列中引入了两个新寄存器GDR和LDR，其中GDR用于
表示GDT在内存中的段地址和段限（就是表的大小），因此GDR是一个48
位的寄存器，其中32位表示段地址，16位表示段限（最大64K，每个描述
符8字节，故最多有64K/8=8K个描述符）。LDR用于表示LDT在内存中的位
置，但是因为LDT本身也是一种数据段，它必须有一个描述符，且该描述
符必须放在GDT中，因此LDR使用了与DS、ES、CS等相同的机制，其中只
存放一个“选择子”，通过查GDT表获得LDT的真正内存地址。
对了，还有中断要考虑，在80x86系列中为中断服务提供中断/陷阱描
述符，这些描述符构成中断描述符表（IDT），并引入一个48位的全地址
寄存器存放IDT的内存地址。理论上IDT表同样可以有8K项，可是因为80x86
只支持256个中断，因此IDT实际上最大只能有256项（2K大小）。

第五：新要求---任务篇
前面介绍了保护模式的基本问题，也是核心问题，解决了上面的问题，
程序就可以在保护模式下运行了。
但众所周知80286以后在保护模式下实现了对多任务的硬件支持。我
的第一反应是：为什么不在实模式下支持多任务，是不能还是不愿？
思考之后，我的答案是：实模式下能实现多任务（也许我错了：））。
因为多任务的关键是有了描述符，可以给出关于数据段的额外描述，如权
限等，进而在这些附加信息的基础上进行相应的控制，而实模式下缺乏描
述符，但假设我们规定各段的前2个字节或若干字节用于描述段的附加属性，
我觉得和使用描述符这样的机制没有本质区别，如果再附加其他机制...
基于上述考虑，我更倾向于认为任务是独立于保护模式之外的功能。
下面我们来分析一下任务。任务的实质是什么呢？很简单，就是程序嘛！！
所谓任务的切换其实就是程序的切换！！
现在问题明朗了。实模式下程序一个接一个运行，因此程序运行的
“环境”不必保存；保护模式下可能一个程序在运行过程中被暂停，转而执行
下一个程序，我们要做什么？很容易想到保存程序运行的环境就行了（想
想游戏程序的保存进度功能），比如各寄存器的值等。
显然这些“环境”数据构成了一类新的数据段（即TSS）。延用前面的思路，
给这类数据段设置描述符（TSS描述符），将该类描述符放在GDT中（不能
放在LDT中，因为80x86不允许：）），最后再加一个TR寄存器用于查表。
TR是一个起“选择子”作用的寄存器，16位。
好了，任务切换的基本工作就是将原任务的“环境”存入TSS数据段，更
新TR寄存器，系统将自动查GDT表获得并装载新任务的“环境”，然后转到新
任务执行。

第六：附加要求---分页篇
为什么叫附加要求，因为现在任务还不能很好地工作。前面说过，任务
实质上是程序，不同的程序是由不同的用户写的，所有这些程序完全可能
使用相同的地址空间，而任务的切换过程一般不会包括内存数据的刷新，
不是不可能，而是如果那样做太浪费了。因此必须引入分页机制才可能有效
地完成对多任务的支持。
分页引入的主要目标就是解决不同任务相互之间发生地址冲突的问题。
分页的实质就是实现程序内地址到物理地址的映射，这也是一个“地址转换”
机制，同样可以使用前面的方案（即类似GDT的做法）：首先建立页表这样
一种数据段，在80x86中使用二级页表方案，增设一个CR3寄存器用于存放
一级页表（又称为页目录）在内存中的地址，CR3共32位，其低12位总是为
零，高20位指示页目录的内存地址，因此页目录总是按页对齐的。CR3作为
任务“环境”的一部分在任务切换时被存入TSS数据段中。
当然还得有相应的缺页中断机制及其相关寄存器CR2（页故障线性地址寄存器）。

第七：总结
保护模式下增加了什么？
1、寄存器 GDR LDR IDR TR CR3
2、数据段描述符表(GDT LDT) 任务数据段(TSS) 页表(页目录二级页表)
3、机制权限检测(利用选择子/描述符/页表项的属性位)
线性地址到物理地址的映射

第八：保护模式常用名词解释
前面内容中出现过的不再解释。
1、RPL 选择子当中的权限位确定的权限
2、CPL 特指CS中的选择子当中的权限位确定的权限
3、EPL EPL=Max(RPL,CPL),即RPL和CPL中数值较大的，或说权限等级较小的
4、DPL 描述符中的权限位确定的权限
5、PL 泛指以上4种特权级
6、任务特权 =CPL
7、I/O特权由EFLAGS寄存器的位13、14确定的权限
8、一致代码段一种特殊的代码段，它在CPL>=DPL时允许访问
正常的代码段在CPL=DPL RPL<=DPL时才允许访问

转自： http://www.c51bbs.com/c51blog/user1/13968/archives/2007/9636.shtml

【转】如何在Linux中添加新的系统调用

2008-05-04T01:00:00.000-07:00

如何在Linux中添加新的系统调用

系统调用是应用程序和操作系统内核之间的功能接口。其主要目的是使得用户
可以使用操作系统提供的有关设备管理、输入/输入系统、文件系统和进程控制、
通信以及存储管理等方面的功能，而不必了解系统程序的内部结构和有关硬件细
节，从而起到减轻用户负担和保护系统以及提高资源利用率的作用。

　　Linux操作系统作为自由软件的代表，它优良的性能使得它的应用日益广泛，
不仅得到专业人士的肯定，而且商业化的应用也是如火如荼。在Linux中，大部分
的系统调用包含在Linux的libc库中，通过标准的C函数调用方法可以调用这些系统
调用。那么，对Linux的发烧友来说，如何在Linux中增加新的系统调用呢？

1 Linux系统调用机制

　　在Linux系统中，系统调用是作为一种异常类型实现的。它将执行相应的机器
代码指令来产生异常信号。产生中断或异常的重要效果是系统自动将用户态切换为
核心态来对它进行处理。这就是说，执行系统调用异常指令时，自动地将系统切换
为核心态，并安排异常处理程序的执行。

　　Linux用来实现系统调用异常的实际指令是：

　　Int $0x80

　　这一指令使用中断/异常向量号128（即16进制的80）将控制权转移给内核。为
达到在使用系统调用时不必用机器指令编程，在标准的C语言库中为每一系统调用
提供了一段短的子程序，完成机器代码的编程工作。事实上，机器代码段非常简
短。它所要做的工作只是将送给系统调用的参数加载到CPU寄存器中，接着执行
int $0x80指令。然后运行系统调用，系统调用的返回值将送入CPU的一个寄存器
中，标准的库子程序取得这一返回值，并将它送回用户程序。

　　为使系统调用的执行成为一项简单的任务，Linux提供了一组预处理宏指令。
它们可以用在程序中。这些宏指令取一定的参数，然后扩展为调用指定的系统调用
的函数。

　　这些宏指令具有类似下面的名称格式：

　　_syscallN（parameters）

　　其中N是系统调用所需的参数数目，而parameters则用一组参数代替。这些参
数使宏指令完成适合于特定的系统调用的扩展。例如，为了建立调用setuid（）系
统调用的函数，应该使用：

　　_syscall1（ int， setuid， uid_t， uid ）

　　syscallN（）宏指令的第1个参数int说明产生的函数的返回值的类型是整
型，第2个参数setuid说明产生的函数的名称。后面是系统调用所需要的每个参
数。这一宏指令后面还有两个参数uid_t和uid分别用来指定参数的类型和名称。

　　另外，用作系统调用的参数的数据类型有一个限制，它们的容量不能超过四个
字节。这是因为执行int $0x80指令进行系统调用时，所有的参数值都存在32位的
CPU寄存器中。使用CPU寄存器传递参数带来的另一个限制是可以传送给系统调用的
参数的数目。这个限制是最多可以传递5个参数。所以Linux一共定义了6个不同的
_syscallN（）宏指令，从_syscall0（）、_syscall1（）直到_syscall5（）。

　　一旦_syscallN（）宏指令用特定系统调用的相应参数进行了扩展，得到的结
果是一个与系统调用同名的函数，它可以在用户程序中执行这一系统调用。

　

2 添加新的系统调用

　　如果用户在Linux中添加新的系统调用，应该遵循几个步骤才能添加成功，下
面几个步骤详细说明了添加系统调用的相关内容。

（1）添加源代码

　　第一个任务是编写加到内核中的源程序，即将要加到一个内核文件中去的一个
函数，该函数的名称应该是新的系统调用名称前面加上sys_标志。假设新加的系统
调用为mycall(int number)，在/usr/src/linux/kernel/sys.c文件中添加源代
码，如下所示：

　　asmlinkage int sys_mycall(int number)

　　{

　　return number;

　　}

　　作为一个最简单的例子，我们新加的系统调用仅仅返回一个整型值。

（2）连接新的系统调用

　　添加新的系统调用后，下一个任务是使Linux内核的其余部分知道该程序的存
在。为了从已有的内核程序中增加到新的函数的连接，需要编辑两个文件。

　　在我们所用的Linux内核版本（RedHat 6.0，内核为2.2.5-15）中，第一个要
修改的文件是：

　　/usr/src/linux/include/asm-i386/unistd.h

　　该文件中包含了系统调用清单，用来给每个系统调用分配一个唯一的号码。文
件中每一行的格式如下：

　　#define __NR_name NNN

　　其中，name用系统调用名称代替，而NNN则是该系统调用对应的号码。应该将
新的系统调用名称加到清单的最后，并给它分配号码序列中下一个可用的系统调用
号。我们的系统调用如下：

　　#define __NR_mycall 191

　　系统调用号为191，之所以系统调用号是191，是因为Linux-2.2内核自身的系
统调用号码已经用到190。

　　第二个要修改的文件是：

　　/usr/src/linux/arch/i386/kernel/entry.S

　　该文件中有类似如下的清单：

　　.long SYMBOL_NAME（）

　　该清单用来对sys_call_table[]数组进行初始化。该数组包含指向内核中每个
系统调用的指针。这样就在数组中增加了新的内核函数的指针。我们在清单最后添
加一行：

　　.long SYMBOL_NAME(sys_mycall)

　　　　

（3）重建新的Linux内核

　　为使新的系统调用生效，需要重建Linux的内核。这需要以超级用户身份登
录。

　　#pwd
　　/usr/src/linux
　　#

　　超级用户在当前工作目录（/usr/src/linux）下，才可以重建内核。

　　#make config
　　#make dep
　　#make clearn
　　#make bzImage

　　编译完毕后，系统生成一可用于安装的、压缩的内核映象文件：

　　/usr/src/linux/arch/i386/boot/bzImage　

（4）用新的内核启动系统

　　要使用新的系统调用，需要用重建的新内核重新引导系统。为此，需要修
改/etc/lilo.conf文件，在我们的系统中，该文件内容如下：

　　boot=/dev/hda
　　map=/boot/map
　　install=/boot/boot.b
　　prompt
　　timeout=50

　　image=/boot/vmlinuz-2.2.5-15
　　label=linux
　　root=/dev/hdb1
　read-only

　　other=/dev/hda1
　　label=dos
　　table=/dev/had

　　首先编辑该文件，添加新的引导内核：

　　image=/boot/bzImage-new
　　label=linux-new
　　root=/dev/hdb1
　　read-only

　　添加完毕，该文件内容如下所示：

　　boot=/dev/hda
　　map=/boot/map
　　install=/boot/boot.b
　　prompt
　　timeout=50

　　image=/boot/bzImage-new
　　label=linux-new
　　root=/dev/hdb1
　　read-only

　　image=/boot/vmlinuz-2.2.5-15
　　label=linux
　　root=/dev/hdb1
　　read-only

　　other=/dev/hda1
　　label=dos
　　table=/dev/hda

　　这样，新的内核映象bzImage-new成为缺省的引导内核。

　　为了使用新的lilo.conf配置文件，还应执行下面的命令：

　　#cp /usr/src/linux/arch/i386/boot/zImage /boot/bzImage-new

　　其次配置lilo:

　　# /sbin/lilo

　　现在，当重新引导系统时，在boot:提示符后面有三种选择：linux-new 、
linux、dos，新内核成为缺省的引导内核。

　　至此，新的Linux内核已经建立，新添加的系统调用已成为操作系统的一部
分，重新启动Linux，用户就可以在应用程序中使用该系统调用了。

（5）使用新的系统调用

　　在应用程序中使用新添加的系统调用mycall。同样为实验目的，我们写了一个
简单的例子xtdy.c。

　　/* xtdy.c */

　　#include

　　_syscall1(int,mycall,int,ret)

　　main()

　　{

　　printf("%d n",mycall(100));

　　}

　　编译该程序：

　　# cc -o xtdy xtdy.c

　　执行：

　　# xtdy

　　结果：

　　# 100

　　注意，由于使用了系统调用，编译和执行程序时，用户都应该是超级用户身
份。

【转自】http://www.chinalinuxpub.com/read.php?wid=23

【转】如何集中注意力

2008-05-03T19:59:00.000-07:00

一、在阅读中培养自己的注意力
　　
　　研究指出，注意力是集中还是涣散直接影响着读书的效果。读书的目的就是理解书的精神实质，记住书的主要内容，要做到这些，就必须集中注意力，特别是在深入思考书中所讲内容的深刻含义时，必须聚精会神，高度集中注意力。所以说在阅读过程中集中注意力是理解和记忆的前提条件。那种随意乱翻，心不在焉的读书是没有什么收获的。
　　
　　阅读教材或有关参考资料，精读其它书籍时，要想获得好的学习效果，就必须集中注意力，而且把读书与训练注意力结合起来。许多著名的学者都很注意这方面的自我训练。如有的人在读书时，就经常在一些重要内容旁边写上注意，特别注意等。也有的用划符号或用“！”“？”以及“☆”作记号以引起注意。
　　
　　梁启超是我国近代一位大学问家。他曾经告诫他的学生，如果想要学会读书，就要读书读到能将书平面的字句浮凸出来为止。书平面的字句会浮起来呢？他的一个学生听了很纳闷。许多年过去了，这位学生在广博地读了许多之后，使平面的字句浮凸出来，指的是在读书过程中要对阅读材料选择性地给予不同程度的注意。那些不重要的字句游览一下就放过去了，而对那些重要的关键的字句，则要给予充分的重视，甚至做到在读某一篇文章时，能一下子注意那些最重要最关键的字句，好像这些字句是有别于其它字句浮凸在书面上似的。
　　
　　梁启超的读书法很有效。因为它能提纲挈领地马上使人掌握某一篇文章的重点和关键。掌握这个读书法的一个技巧，就是训练对那些关键词句的集中注意力。事先确定一个阅读范围，阅读时，只对最重要和最关键的部分给予最集中的注意，天长日久，每读一遍文章时，你就会发现书上总有某一个重要的注意点毫不吃力地浮凸出来了。
　　
　　注意力是影响学习效率的最重要因素之一。它是一种非智力因素，在学生的学习过程中起着重要的作用。
　　
　　二、根特的集中注意训练法
　　
　　根特先生是德国著名的哲学家，根特在读书时经常使用一种精神集中法。其做法是，当他读书前，或者在书房里深思冥想问题时，他必定是透过窗户凝视着远方屋顶上的一个随风摆动的风向标箭头，他一边眼盯着风向的转动，一边下意识地沉浸于深深地思考之中。这种方法大大帮助了他，哲学中的许多理论就是这样思考出来的。这种方法好像没有什么奇特，我们这些读书人，也有这方面的经验，当两眼凝视着某一点时，一边对着视点出神，一边思考着所要解决的问题，或者思考已读过的内容，好像无形之中，注意力就集中在一起，促进了思考的深度。
　　
　　这种做法所以会产生如此好的效果，也还是有其道理的。当人的双眼长时间地凝视在一点时，视野就会变得狭窄，那些容易吸引你并导致注意力分散的事物也就会进入眼帘，因此人的意识范围也随着变窄，从而使人达到注意力集中的心理境界。
　　
　　有一位获得较大成就的科学家说：他读书之前，或在思考问题时，喜欢双眼盯着窗外的松树枝，目不转睛地望着，望着，很快地就集中起精神来，不自觉在进入了学习的遐想，这种方法对他的读书或思考问题很有帮助。
　　
　　京剧大师梅兰芳小时候的事。梅兰芳是一代京剧宗师，是梅派创始人，我国四大名旦之首。这样一位名高盖世的京剧大师，他的戏得到中国乃至全世界戏剧界的尊崇，即使我们这些不懂京剧的人，也为他的演技所倾倒，特别是他那优美的姿势、悦耳的唱腔和活灵活现的眼神都给人以美的享受，使人为之倾倒。梅兰芳小时候，家庭多灾多难，父母早亡，家道早衰，而他自己也资质不高。第一位启蒙老师看到那时8岁的梅兰芳，小小的圆脸，相貌平常，而且眼皮下垂，两眼无神，呆滞近视，就觉得这孩子不像是个唱戏的料。在教戏时，一个上午只教四句，教了一遍又一遍，可是这个学生对这四句唱腔不是忘了词儿，就是唱错了腔，一次也没有唱好。这位先生一气之下，拂袖而去，赌气再也不教他了。梅兰芳后来发奋学戏，博采众家之长，融为一体，形成自己的风格。发展为梅派。所以说梅兰芳的成功完全是勤学苦炼的结果。梅兰芳大师在舞台生活四十年时说：“我是个拙笨的学艺者，没有充分的天才，全凭苦学。”
　　
　　梅兰芳先生从一个资质平常的孩子发展成长为世界名著艺术家，他的成功值得我们深思。
　　
　　眼神是演员的一大命脉，梅兰芳先生是如何将自己呆滞的眼睛治好的呢？说来也有点戏剧性，他是通过放鸽子治好的。
　　
　　以前北京有许多人爱养鸽子，梅兰芳先生小时候也非常爱养鸽子。养鸽子的人每天把自家的鸽子放出去，鸽子在天空飞翔，养鸽者在地面观察指挥，用一杆长竹竿，上面拴一条红绸子，指挥鸽子起飞，如换成绿绸子，就是要鸽子下降的信号。附近有许多家的鸽子放向天空，而鸽子也有个有趣的习性，爱相互串飞，如果自家的鸽子训练的不熟练，很可能给人家鸽子拐走。梅兰芳要手举高竿，不断摇动，给鸽子发出信号，同时还要仰着头，抬着眼，极目注视着高空中的鸽群，要极力分辨出里面有没有混入别家的鸽子。天长日久地练下来，梅兰芳先生的眼皮下垂竟然治好了，呆滞的眼神变成灵活传神了，视力也得到了极大的提高，臂力要腰劲也被练得发达了，注意力也更加容易集中了，学戏的效率提高了，思考能力增强了。
　　
　　据说以前练习射箭的人，将一个中间空的小铜钱挂在远处，经常远远注视它，分辨出铜币的空心，练到一定的时候，再练习注视高空中的飞鸟，极力分辨鸟的头和身子及其它部位，长期坚持训练，其结果不仅增强了视力，而且还增强了集中注意的能力。据说这是训练神箭手的方法。
　　
　　培养自己注意力的可靠途径就是，训练自己能在各式各样的环境条件下，专心学习或工作。一旦确定了要干的事，你就有计划有目的地集中注意力，去干好要干的事，不受其它刺激的影响和干扰。据说毛泽东主席青少年时代为了锻炼自己的注意力，就常到繁华闹市去读书，而且能不受周围环境的影响。坚持无论读书学习，还是干事情，都把它们当作锻炼注意力的机会和场合，久而久之，良好的注意习惯就逐步形成了。
　　
　　原苏联心理学家普拉托诺夫说：“要想使自己成为一个注意力很强的人，最好的方法是，无论干什么事，都不能漫不经心！”
　　
　　五、运用注意力的几点技巧
　　
　　注意力是指在认识事物的过程中，人的身心稳定和集中地指向于一定事物的意向活动。注意力在种认识和学习活动中都起着主导和保证作用。有人说注意是智力活动的警卫、组织者和维持者，可见注意与智力活动关系之密切。
　　
　　在智力活动中如何才能发挥好注意力的作用？这是一门学问，有技巧问题。下面我们介绍两点：
　　
　　（一）学会不想自己
　　
　　很多人都有这样一个毛病，常常以为自己是被注意的中心，因此不自觉地把注意力指向自己。例如，当我穿一件新衣服，或者戴一顶新帽子，总以为众人都在注视自己。当一个学生考试不理想，或做了件错事，他就觉得众人在议论自己，看不起自己，甚至觉得没脸见人。一个同学站座位上回答问题，虽紧张还能答出来，如果站到讲台上面对着全班，他会吓得张嘴结舌。他害怕答错了惹人耻笑，怕老师批评，怕同学会议论等，其结果是越想越怕，以致吓得连话都说不出来。其实这种以为众人在注视着自己的想法多半是或完全是自己的臆想，自己的许多不自然的态度和表现是自己遐想的结果。每个人都有自己的任务，有自己的事，每个人的思想重点或注意指向都不相同，他们不可能有那么多时间注视你、正像你自己常常把注意力指向自己一样，可能众人也还未顾得上注意你呢？即便众人注意你也没有什么可怕的。
　　
　　有位学者说：“自我的感觉是一种形式。别人并不会如你所想象的那样关心你。他们有各人的事要忙。记住这一点，你在他们面前便不会感觉不舒服了。”
　　
　　克服这种恐惧感的方法首先是不想自己，不要把注意力放到自己身上。第二是把注意力集中在眼前要解决的任务上，专心致志干事的人，不会为其它事引起不安。有人说：“专心想到自己是不能增加做事的效率和减少自我感觉的，专想到工作却能做到。”第三就是，如果眼前没有任务，那么你不妨想点别的事，把注意力引到其它事上去。有位专家说：“”不想自己的方法是要寻一点别的事来想。你必须寻找一种代替物。寻得代替物之后，想自己的毛病便可毫不费力地除去。假如你坐在礼堂的讲台上，当你看到台下坐满了人，你可能觉得大家在注意自己，在议论自己，在笑自己，你越觉得坐在台上不舒服，越感到紧张。甚至准备的演讲都忘了。假如你不想自己，把注意力转移到别处，就不会产生紧张害怕的心理。
　　
　　在考试也是如此，如果考前老是想，我考得不好会怎么样，同学老师会如何看我等，也会增加人为的紧张，倒不如把注意力转移到别处，转移到代替物上，如眼前的钢笔、手指之类，再配合着用深呼吸放松法，使紧张的情绪得以消除。
　　
　　（二）学会听的技巧
　　
　　学会听是很重要的。听是个体认识世界的重要方式之一。倾听也是人际交往中的重要方式之一。在人际交往时首先要倾听，只有认真听人讲，才能了解他人，学习他的知识，从而丰富自己；也只有通过倾听，才能理解他人，理解人格，理解人际关系的深层含义。这里所说的倾听就是指要深深地听，要听出深藏在表面语言下的人心灵深处的呼唤，一个善于倾听的人，在听他人讲话时，要反问自己，能不能觉察出讲话者内心世界的状态？倾听他人讲话不仅能使听者真正理解一个人，而且对于倾听者也有奇特的效果。倾诉者被认为已被人理解，似乎得到了解脱，从而消除了个人的孤寂感，使倾听者的心情得到了安慰和满足。因此，现代心理学家认为，倾听，不论是倾听他人或者是接受他人的倾听在人际关系中都是极为重要的，在双方体验的充实和人格的发展中都是不可缺少的。
　　
　　对于学生来说，学校学习的主要方式是课堂教学，课堂学习时间占据了学生学习的大部分时间。学会听课对于学生的学习和个人发展是至关重要的。
　　
　　听，有技巧问题，有注意力的稳定、分配和转移问题。有些不良习惯妨碍着我们大多数人的听的水平。一般来说，有以下几种。
　　
　　1、我们的思维不愿意等待。研究指出，人的思维的速度比人的说话速度快3—9倍。当听旁人说话的时候，个人的思考活动常处于等待状态，如果此时注意转移，去思考另外的问题，那么听到别人谈话的内容是时断时续的。结果听者的头脑里只留下片言只语，丢掉了别人说话的详细内容。
　　
　　2、当听人说话时，自以为知道了，不再注意听，其结果是这只耳朵进，那只耳朵出。
　　
　　3、先人为主的固定看法影响倾听。谈话时，因已有固定的看法而不注意倾听到的不过是他自己的意思而已，而不是他人要说的真正意思。因此，在倾听他人讲话时，不仅要注意听懂语言，更要揣摩其思想。
　　
　　4、情绪化会使人变成聋子。当听到自认为不正确的意见或不利于自己的言论时，即使忠言也逆耳，有一种情绪会阻止你继续听下去，甚至将你的注意力转移到进行反击的思想上去。
　　
　　5、一心不可二用。有的听人讲话时，一边听，一边翻报纸，听广播，或看看电视。如此一心二用，注意力分散，则往往是听的内容不连贯，看的内容不全面，甚至什么都没有留下。
　　
　　6、听而不闻。在听人讲话时，将注意力集中在诉说者的外貌和举止上，至于讲的内容反而跑掉了。
　　
　　妨碍倾听的毛病还不止这些，所以会出现这些问题，其关键在于没有很好地转移和分配注意，让自己的注意力集中在倾听和思考讲话者的语言内容及其深层的心理呼唤上。可见倾听是有技巧的。为帮助你建立良好的倾听习惯，再提出以下几点注意事项。
　　
　　1、适应讲话的速度，将注意力放在较慢讲话的速度上，边听边咀嚼其内容的意思，不要让思维的速度超越所听讲话的速度。
　　
　　2、将注意力集中在倾听上，不受其它事物的影响，不同时兼顾几件事。
　　
　　3、训练听力，听广播的内容，试着检查所听广播的内容要点和主要思想实质。听广播英语揣摩其发音和含义等都能提高听的能力。上课听讲，课后检查自己听课效果，不仅能促进自己的听课水平，而且直接促进自己的学习效果。
　　
　　4、学会理解不同的观点，包括你对立的看法。学会倾听不同的意见，学会倾听自己喜欢的人的讲话。你很有可能从这些讲话中获得新的知识和见解，即使有不对的地方，也应听完后再去交换自己的看法。
　　
　　5、学会一次就能听明白他人的谈话，对重要的内容可以默默地重复一下，准确地记住。
　　
　　6、在听人讲话或接电话时要养成随手记在纸上的习惯，学会从你获得的各种信息资料中，寻找出最有价值的信息。
　　
　　7、在倾听他人讲话时，不断地问自己，倾听者的话的意思是什么？目的何在？自己是否明白了对方深层的意思？用这些自我提问使注意力集中。
　　
　　（三）注意力与其它学习方法的相结合
　　
　　注意力的心理训练还有许多方法和技巧，在进行注意力自我训练时可以与之相配合，这里提出几点。
　　
　　1.注意力的心理训练与超越静思训练相结合。一般来说宁静的心态容易集中注意。
　　
　　2.注意力的训练与形象控制法相配合。也就是说，当心境处于轻松和积极状态时，注意的转移、分配和稳定性也能发挥得更好。
　　
　　3还可以找出一些与注意力相结合的训练方法，请大家留心。注意力的训练有方法技巧可讲，我们应尽力掌握它们，并进行认真的自我训练。同时还必须认识到，注意力的训练必须与学习活动、社会实践紧密结合，才能直接有效地增强自己的注意力。

良好的注意力，是大脑进行感知、记忆、思维等认识活动的基本条件。在我们的学习过程中，注意力是打开我们心灵的门户，而且是唯一的门户。门开得越大，我们学到的东西就越多。而一旦注意力涣散了或无法集中，心灵的门户就关闭了，一切有用的知识信息都无法进入。正因为如此，法国生物学家乔治.居维叶说：“天才，首先是注意力。”
　　
　　在正常情况下，注意力使我们的心理活动朝向某一事物，有选择地接受某些信息，而抑制其它活动和其它信息，并集中全部的心理能量用于所指向的事物。因而，良好的注意力会提高我们工作与学习的效率。注意力障碍，主要表现为无法将心理活动指向某一具体事物，或无法将全部精力集中到这一事物上来，同时无法抑制对无关事物的注意。造成这种情况的原因比较复杂，许多较严重的心理障碍都可以引起注意力障碍。而对于学生来说，主要是由于学习负担重，心理压力过大，而造成高度的紧张和焦虑，从而导致了注意力无法集中的障碍。另外，睡眠不足，大脑得不到充分休息，也可能出现注意力涣散的情况。
　　
　　因此，当你因注意力无法集中而影响学习，倍感苦恼时，不妨采用以下方法来矫治：
　　
　　(1)、养成良好的睡眠习惯
　　
　　一些同学因学习负担重，因此，一到晚上便贪黑敖夜，有的同学甚至在宿舍打电筒读书，学到深夜；有的同学不能按时睡眠，在宿舍和同学闲聊等等。结果早晨不能按时起床，即便勉强起来，头脑也是昏沉沉的，一整天都打不起精神，有的甚至在课堂上伏桌睡觉。作为学生，主要的学习任务要在白天完成，白天无精打采，必然效率低下。所以，如果你是“夜猫子”型的，奉劝你学学“百灵鸟”，按时睡觉按时起床，养足精神，提高白天的学习效率。
　　
　　(2)、学会自我减压
　　
　　高中学生的学习任务本来就很重，老师、家长的期望，又给同学们心理加上一道法码；一些同学自己对成绩、考试等看得很重，无异是自己给自己加压，必然不堪重负，变得疲惫、紧张和烦躁，心理上难得片刻宁静。因此，我们要学会自我减压，别把成绩的好坏看得太重。一分耕耘，一分收获，只要我们平日努力了，付出了，必然会有好的回报，又何必让忧虑占据心头，去自寻烦恼呢？
　　
　　(3)、做些放松训练
　　
　　舒适地坐在椅子上或躺在床上，然后向身体的各部位传递休息的信息。先从左脚开始，使脚部肌肉绷紧，然后松驰，同时暗示它休息，随后命令脚脖子、小腿、膝盖、大腿，一直到躯干部休息，之后，再从脚到躯干，然后从左右手放松到躯干。这时，再从躯干开始到颈部、到头部、脸部全部放松。这种放松训练的技术，需要反复练习才能较好地掌握，而一旦你掌握了这种技术，会使你在短短的几分钟内，达到轻松、平静的状态。
　　
　　(4)、做些集中注意力的训练
　　
　　我国年轻的数学家杨乐、张广厚，小时候都曾采用快速做习题的办法，严格训练自己集中注意力。这里给大家介绍一种在心理学中用来锻炼注意力的小游戏。在一张有25个小方格的表中，将1-25的数字打乱顺序，填写在里面，然后以最快的速度从1数到25，要边读边指出，同时计时。
　　
　　研究表明：7-8岁儿童按顺序导找每张图表上的数字的时间是30-50秒，平均40-42秒；正常成年人看一张图表的时间大约是25-30 秒，有些人可以缩短到十几秒。你可以自己多制做几张这样的训练表，每天训练一遍，相信你的注意力水平一定会逐步提高。“培养良好注意品质，提高学生学习成绩”
　　
　　第二阶段：
　　
　　注意力的集中作为一种特殊的素质和能力，需要通过训练来获得。那么，训练自己注意力、提高自己专心致志素质的方法有哪些呢？
　　
　　方法之一：运用积极目标的力量
　　
　　这种方法的含义是什么？就是当你给自己设定了一个要自觉提高自己注意力和专心能力的目标时，你就会发现，你在非常短的时间内，集中注意力这种能力有了迅速的发展和变化。
　　
　　同学们要在训练中完成这个进步。要有一个目标，就是从现在开始我比过去善于集中注意力。不论做任何事情，一旦进入，能够迅速地不受干扰。这是非常重要的。比如，你今天如果对自己有这个要求，我要在高度注意力集中的情况下，将这一讲的内容基本上一次都记忆下来。当你有了这样一个训练目标时，你的注意力本身就会高度集中，你就会排除干扰。
　　
　　同学们知道，在军事上把兵力漫无目的地分散开，被敌人各个围歼，是败军之将。这与我们在学习、工作和事业中一样，将自己的精力漫无目标地散漫一片，永远是一个失败的人物。学会在需要的任何时候将自己的力量集中起来，注意力集中起来，这是一个成功者的天才品质。培养这种品质的第一个方法，是要有这样的目标。
　　
　　方法之二：培养对专心素质的兴趣
　　
　　有了这种兴趣，你们就会给自己设置很多训练的科目，训练的方式，训练的手段。你们就会在很短的时间内，甚至完全有可能通过一个暑期的自我训练，发现自己和书上所赞扬的那些大科学家、大思想家、大文学家、大政治家、大军事家一样，有了令人称赞的注意力集中的能力。
　　
　　同学们在休息和玩耍中可以散漫自在，一旦开始做一件事情，如何迅速集中自己的注意力，这是一个才能。就像一个军事家迅速集中自己的兵力，在一个点上歼灭敌人，这是军事天才。我们知道，在军事上，要集中自己的兵力而不被敌人觉察，要战胜各种空间、地理、时间的困难，要战胜军队的疲劳状态，要调动方方面面的因素，需要各种集中兵力的具体手段。同学们集中自己的精力，注意力，也要掌握各种各样的手段。这些都值得探讨，是很有兴趣的事情。
　　
　　方法之三：要有对专心素质的自信
　　
　　千万不要受自己和他人的不良暗示。有的家长从小就这样说孩子：我的孩子注意力不集中。在很多场合都听到家长说：我的孩子上课时精力不集中。有的同学自己可能也这样认为。不要这样认为，因为这种状态可以改变。
　　
　　如果你现在比较善于集中注意力，那么，肯定那些天才的科学家、思想家、事业家、艺术家在这方面还有值得你学习的地方，你还有不及他们的差距，你就要想办法超过他们。
　　
　　对于绝大多数同学，只要你有这个自信心，相信自己可以具备迅速提高注意力集中的能力，能够掌握专心这样一种方法，你就能具备这种素质。我们都是正常人、健康人，只要我们下定决心，不受干扰，排除干扰，我们肯定可以做到高度的注意力集中。希望同学们对自己实行训练。经过这样的训练，能够发生一个飞跃。
　　
　　方法之四：善于排除外界干扰
　　
　　要在排除干扰中训练排除干扰的能力。毛泽东在年轻的时候为了训练自己注意力集中的能力，曾经给自己立下这样一个训练科目，到城门洞里、车水马龙之处读书。为了什么？就是为了训练自己的抗干扰能力。同学们一定知道，一些优秀的军事家在炮火连天的情况下，依然能够非常沉静地、注意力高度集中地在指挥中心判断战略战术的选择和取向。生死的危险就悬在头上，可是还要能够排除这种威胁对你的干扰，来判断军事上如何部署。这种抗拒环境干扰的能力，需要训练。
　　
　　我在你们这么大的年纪时曾有意做过这种训练。就是不管环境多么嘈杂，当我进入我要阅读和学习的科目时，对周围的一切因素置若罔闻。这是可以训练成功的。
　　
　　方法之五：善于排除内心的干扰
　　
　　在这里要排除的不是环境的干扰，而是内心的干扰。环境可能很安静，在课堂上，周围的同学都坐得很好，但是，自己内心可能有一种骚动，有一种干扰自己的情绪活动，有一种与这个学习不相关的兴奋。对各种各样的情绪活动，要善于将它们放下来，予以排除。这时候，同学们要学会将自己的身体坐端正，将身体放松下来，将整个面部表情放松下来，也就是将内心各种情绪的干扰随同这个身体的放松都放到一边。常常内心的干扰比环境的干扰更严重。
　　
　　同学们可以想一下，在课堂上，为什么有的同学能够始终注意力集中呢？为什么有的同学注意力不能集中呢？除了有没有学习的目标、兴趣和自信之外，还有一个就是善于不善于排除自己内心的干扰。有的时候并不是周围的同学在骚扰你，而是你自己心头有各种各样浮光掠影的东西。要去除它们，这个能力是要训练的。如果你就是想浑浑噩噩、糊糊涂涂、庸庸俗俗过一生，乃至到了三十岁还要靠父母养活，或者你就是想混世一生，那你可以不训练这个。但是，如果你确实想做一个自己也很满意的现代人，就要具备这种事到临头能够集中自己注意力的素质和能力，善于在各种环境中不但能够排除环境的干扰，同时能够排除自己内心的干扰。
　　
　　方法之六：节奏分明的处理学习与休息的关系
　　
　　同学们千万不要这样学习：我这一天就是复习功课，然后，从早晨开始就好像在复习功课，书一直在手边，但是效率很低，同时一会儿干干这个，一会儿干干那个。十二个小时就这样过去了，休息也没有休息好，玩也没玩好，学习也没有什么成效。或者，你一大早到公园念外语，坐了一个小时或两个小时，散散漫漫，说念也念了，说不念也跟没念差不多，没有记住多少东西。这叫学习和休息、劳和逸的节奏不分明。正确的态度是要分明。那就是我从现在开始，集中一小时的精力，比如背诵80个英语单词，看我能不能背诵下来。高度地集中注意力，尝试着一定把这些单词记下来。学习完了，再休息，再玩耍。当需要再次进入学习的时候，又能高度集中注意力。这叫张弛有道。一定要训练这个能力。永远不要熬时间，永远不要折磨自己。一定要善于在短时间内一下把注意力集中，高效率地学习。要这样训练自己：安静的时候，像一棵树；行动的时候，像闪电雷霆；休息的时候，流水一样散漫；学习的时候，却像军事上实施进攻一样集中优势兵力。这样的训练才能使自己越来越具备注意力集中的能力。
　　
　　方法之七：空间清静
　　
　　这个方法，非常简单，当你在家中复习功课或学习时，要将书桌上与你此时学习内容无关的其他书籍、物品全部清走。在你的视野中，只有你现在要学习的科目。这种空间上的处理，是你训练自己注意力集中的最初阶段的一个必要手段。同学们常常会发现这样生动的场面，你坐在桌子前，想学数学了，这儿有一张报纸，本来是垫在书底下的，上面有些新闻，你止不住就看开了，看了半天，才知道我是来学数学的。一张报纸就把你牵挂走了。或者本来你是要学习的，桌子一角的小电视还开着呢，看着看着，从数学王国出去了，到了张学友那儿了。这是完全可能的。甚至可能是一个小纸片，上面写着什么字，看着看着又想起一件事情。
　　
　　所以，作为训练自己注意力的最初阶段，做一件事情之前，首先要清除书桌上全部无关的东西。然后，使自己迅速进入主题。如果你能够做到一分钟之内没有杂念，进入主题，你就了不起。如果你半分钟就能进入主题，就更了不起。如果你一坐在那里，十秒、五秒，当下就进入，那就是天才，那就是效率。有的人说，自己复习功课用了四个小时，其实那四个小时大多数在散漫中、低效率中度过，没有用。反之，你开始学习，一坐在那里，与此无关的全部内容置之脑外，这就是高效率。
　　
　　方法之八：清理大脑
　　
　　收拾书桌是为了用视野中的清理集中自己的注意力，那么，你同时也可以清理自己的大脑。你经常收拾书桌，慢慢就会有一个形象的类比，觉得自己的大脑也像一个书桌一样。
　　
　　大脑是一个屏幕，那里面也堆放着很多东西，一上来，将在自己心头此时此刻浮光掠影活动的各种无关的情绪、思绪和信息收掉，在大脑中就留下你现在要进行的科目，就像收拾你的桌子一样。
　　
　　同学们，这样的训练希望你们从今天开始就要做，它并不困难。当你将思想中的所有杂念都去除的时候，一瞬间你就进入了专一的主题，你的大脑就充分调动起来，你才有才智，你才有发明，你才有创造，你才有观察的能力、记忆的能力、逻辑推理的能力和想象的能力。如果不是这样，你坐在那里，十分钟之内脑袋瓜里还是车水马龙，还是风马牛不相及，还是天南海北，那么这十分钟是被浪费掉的。再有十分钟，不是车水马龙了，但依然是熙熙攘攘的街道，又十分钟过去了。到最后学习开始了，难免三心二意，效率很低。这种状态我们以后不能再要了，要善于迅速进入自己专心的主题。
　　
　　方法之九：对感官的全部训练
　　
　　我们讲了清理自己的书桌，其实更广义说，我们可以进行视觉、听觉、感觉方方面面的类似训练。同学们可以训练自己在视觉中一个时间内盯视一个目标，而不被其他的图像所转移。你们可以训练在一段时间内虽然有万千种声音，但是你们集中聆听一种声音。你们也可以在整个世界中只感觉太阳的存在或者只感觉月亮的存在，或者只感觉周围空气的温度。这种感觉上的专心训练是进行注意力训练的有用的技术手段。
　　
　　方法之十：不在难点上停留
　　
　　同学们都会意识到，我们理解的事物、有兴趣的事物，当我们去探究它、观察它时，就比较容易集中注意力。比如说我喜欢数学，数学课就比较容易集中注意力，因为我理解，又比较有兴趣。反之，因为我不太喜欢化学，缺乏兴趣，对老师讲的课又缺乏足够的理解，就有可能注意力分散。
　　
　　在这种情况下，我们就有了正反两个方面的对策。正的对策是，我们要利用自己的理解力、利用自己的兴趣集中自己的注意力。而对那些自己还缺乏理解、缺乏兴趣的事物，当我们必须研究它、学习它时，这就是一个特别艰难的训练了。

【转自】http://www.douban.com/group/topic/2844212/
　　

迷你小词典升级版

2008-05-03T19:35:00.000-07:00

特别感谢海词http://dict.cn/

/*
*实现的功能：
*1.保存历史记录，并且可以回到任意历史记录
*2.有快捷键返回上次历史记录和下次历史记录
*3.能够导出个人单词簿
*4.对于给出的任意一句话，给相应的单词标注音标
*/

Dict.java文件

import java.net.*;
import org.eclipse.swt.*;
import org.eclipse.swt.widgets.*;
import org.eclipse.swt.events.*;
import org.eclipse.swt.graphics.*;
import org.eclipse.swt.browser.*;
import org.eclipse.jface.dialogs.*;
import org.eclipse.swt.dnd.*;
import org.xml.sax.*;
import javax.xml.parsers.*;

public class Dict {

private List history;

private Text searchWord;

private String wordInHistory;

public Dict(Display display,Shell shell) {

//final Clipboard clipboard = new Clipboard(display);

final Browser browser = new Browser(shell, SWT.NONE);
browser.setBounds(116, 66, 366, 255);

final ToolBar toolBar = new ToolBar(shell, SWT.WRAP);
toolBar.setBounds(20, 19, 48, 22);

ToolItem backward = new ToolItem(toolBar, SWT.PUSH);
backward.setImage(new Image(display, "image/backward.gif"));
backward.addSelectionListener(new SelectionAdapter() {
public void widgetSelected(SelectionEvent e) {
browser.back();
}
});

ToolItem forward = new ToolItem(toolBar, SWT.PUSH);
forward.setImage(new Image(display, "image/forward.gif"));
forward.addSelectionListener(new SelectionAdapter() {
public void widgetSelected(SelectionEvent e) {
browser.forward();
}
});

searchWord = new Text(shell, SWT.BORDER);
searchWord.setBounds(83, 19, 199, 22);

final Button search = new Button(shell, SWT.NONE);
final Image searchImage = new Image(display, "image/filter.gif");
search.setText("search");
search.setBounds(296, 19, 87, 22);
search.setImage(searchImage);
search.addSelectionListener(new SelectionAdapter() {
public void widgetSelected(SelectionEvent e) {
String word = searchWord.getText();
String[] wordList = word.split(" ", -2);
int length = wordList.length;
if (length == 1) {
String url = "http://dict.cn/mini.php?q=";
if (word == null || word.equals("")) {
MessageDialog.openInformation(new Shell(),"显示提示", "失败信息!"
+ '\n' + '\n' + "注意：待查单词不能为空!!!...");
} else {
url = url + word;
browser.setUrl(url);
history.add(word);
}
} else {
try {
SAXParserFactory sf = SAXParserFactory.newInstance();
SAXParser sp = sf.newSAXParser();
XmlReader reader = new XmlReader();
for (int j = 0; j < length; j++) {
sp.parse(new InputSource("http://dict.cn/ws.php?q="
+ wordList[j]), reader);

}
} catch (Exception a) {
}
}

}
});

final Label label = new Label(shell, SWT.NONE);
label.setText(" History");
label.setBounds(20, 56, 76, 22);

history = new List(shell, SWT.BORDER);
history.setBounds(20, 84, 76, 237);
history.addMouseListener(new MouseAdapter() {
public void mouseDown(MouseEvent e) {
String word = history.getSelection()[0];
String url = "http://dict.cn/mini.php?q=";
url = url + word;
browser.setUrl(url);
}
});

final Button wordList = new Button(shell, SWT.NONE);
wordList.setText("导出个人单词本");
wordList.setBounds(395, 19, 87, 22);
wordList.addSelectionListener(new SelectionAdapter() {
public void widgetSelected(SelectionEvent e) {
Txt txt = new Txt();
int count = history.getItemCount();
for(int i = 0;i < count;i ++){
wordInHistory = history.getItem(i);
txt.aLine(wordInHistory);
}
txt.finish();
}
});

}
}

Txt.java

import java.io.File;
import java.io.FileWriter;
import java.io.PrintWriter;
import java.io.IOException;

public class Txt {

public File result = new File("wordList.txt");

public FileWriter writer;

public PrintWriter pw;

public Txt() {
try {
writer = new FileWriter("wordList.txt");

pw = new PrintWriter(writer);
} catch (IOException iox) {
System.err.println(iox);
}

}

public void aLine(String in) { // 写入一行
pw.println(in);
}

public void finish() { // 关闭输入流，将文字从缓存写入文件

try {
pw.flush();
writer.close();
} catch (IOException iox) {
System.err.println(iox);
}

}
}

XmlReader.java文件

import org.xml.sax.*;
import org.xml.sax.helpers.*;
import javax.xml.parsers.*;
import java.io.UnsupportedEncodingException;

public class XmlReader extends DefaultHandler {

java.util.Stack tags = new java.util.Stack();

public String currentName;

public StringBuffer currentValue = new StringBuffer();

public XmlReader() {
super();
}

public void startElement(String uri, String localName, String qName,
Attributes attributes)

throws SAXException {
currentName = qName;
}

public void characters(char ch[], int start, int length)
throws SAXException {

XmlReader xmlreader = new XmlReader();

if(currentName=="pron"){
String pron = new String(ch, start, length);
System.out.println(pron);
}
}

public void endElement(String uri, String localName, String qName)
throws SAXException {

}

}

test.java文件

import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;

public class test {

/**
* Launch the application
* @param args
*/
public static void main(String[] args) {

final Display display = Display.getDefault();
final Shell shell = new Shell(display);
shell.setSize(508, 377);
shell.setText("Dict --by stonestrange");

Dict dict = new Dict(display,shell);

shell.open();
shell.layout();
while (!shell.isDisposed()) {
if (!display.readAndDispatch())
display.sleep();
}
}
}

【转】怎样背英语单词效率最高记得最久

2008-05-03T19:18:00.000-07:00

怎样背英语单词效率最高记得最久

背单词的捷径

背单词最重要的一点，就是：...如果想比别人成功，就一定要走捷径。不要期盼自己比别人幸运，也不要指望自己比别人更聪明或者更勤奋。从智力上说，从机遇上说，自己和别人都是差不了多少的，想超过和自己差不多的人，就一定要走捷径，捷径，捷径！
背单词捷径的第一条，就是：一定要每次都大量地背。因为自己不比别人聪明，所以背完单词，别人忘掉五分之一，自己决不会比别人忘得少。然而，别人每天背十个单词，自己却可以背一百个，忘掉五分之一，还剩八十个，是别人最聪明状态下的十倍。每天一百个是最低限。其实背到后来您会发现这个要求并不高，一个月后，您可能自然而然地就背到三百或者五百。这一百个要分成四组来背，上午三十,中午十个，下午三十，晚上三十。第二天早晨复习以前没背下来的词。背的时候，要一目十词(注意，是十个而不是更多或更少)，不要认认真真背，因为没有认认真真的时间。一边看一边读每个词的读音，默读也成。看完后回忆一遍，回忆不起来的再看。这次背的目的在于留下个大概印象，下次看见能知道这个词，所以背到大部分都能回忆得起来就成了，把剩下的词单独抄出来。
背单词捷径的第二条，就是：背字典！为什么要背字典呢？因为字典上每个词的解释比较全面，而且相同字母开头的单词都集中在一起。不是什么字典都可以拿来背的，一定要找只包含自己想背的词的字典。另外，最好有英文方式的解释和例句。而且，一定要有音标！如果是为了考TOFEL或者GRE，注意要选美音音标的字典。一般教材课文后面的词汇表都是为那些认认真真听课的好学生准备的，想走捷径就千万不要去背那些东西。背字典的时候，按开头字母(Z,Y,X,Q,J,K,U)、(V,W,N,O,L)、(FG,IT,HM,BDE,R)、(C,P,S,A)的顺序背，其中C,P,S,A每个都要分三部分背。这样背有几个好处：
（一）能增加成就感，提高兴趣。至于为什么，您翻翻字典就明白了。
（二）便于清楚地知道那些单词已经背过，那些还没背。
（三）能先把最基本的词先掌握。
三万单词里，分为三个等级：三千到四千，八千到一万，两万二到三万。也就是说，您得分别准备三本字典。这几个等级之间各自有非常不同的特性，所以需要分别用不同方法背。俺当时没有认识到这一点，所以在从一万到三万之间走了一段弯路，浪费了一些时间，不然或许能突破到五万吧！俺的经验是新概念第一二册，然后大学泛读课本前两册，然后是另外的一个泛读教程初级部分，然后新概念第三册，泛读课本第三册，某一种听力教材高级听力部分的教师用书，然后新概念第四册，泛读课本第四五册...这么个顺序进度比较合适。
所以，背单词捷径的下面这条就有了三个分支。
背单词捷径的第三条，就是：和单词多见面。一个单词能不能记住，取决于和它在不同场合见面的频率，不在于每次看着它的时间长短。一般想记住一个单词，每星期要和它在*不同场合*见三到四次面。俺在上文中提到大量背的时候，不要抠某一个字记住与否就是这个意思。因为是否一见钟情都是无所谓的，关键在于有更多不同类型的见面机会。不过，根据要背的单词的等级不同，增加见面机会的方式也有所不同。
第一个分支：瞎听！三千到四千这个等级，是非常常用的单词，而且几乎囊括了表达最基本思想所需要的一切词汇。每篇文章中百分之八十都是这些词汇，而且这些词都是最基本的语素(或称"词根")，就是分割到最小无法再分割，互相之间也没什么类似之处的东西。对付这些词的最好方法，就是进行大量的，不间断的，简单的初级听力练习。因为阅读材料中，还有百分之二十其他词汇，所以光凭这个等级的词还看不懂那些阅读材料。但是听力练习都是最基本的对话，而且发音一般很标准，多听能够增加单词的重复率，而且可以为以后背八千到一万那个等级的词打下语音基。听的时候，要分精听和泛听两部分。精听当然是指每个词都要弄懂，俺着重讲一下泛听。泛听是最重要的，因为掌握语速和语调，以及总体印象都要泛听。而这些都是背八千到一万等级单词的基础?泛听能够让经常用到的词(也就是那些最必要掌握的词)把您的耳朵磨出茧子来，让您模模糊糊听到个音就能反应出它是什么意思。泛听中您听到的词，才是您真正应该记住的词，所以别害怕精听的时候什么都听不懂。到底什么是泛听呢？泛听，就是说您听的时候，精神要分散，要一边干着其他事(比如撮饭或和别人大声讨论撮饭;)~)，一边有一搭没一搭地听着。泛听一定要见缝插针，一有机会就听着，最好耳机不离耳朵。而精听的意义就在于找出您没听清的那些词。啊哈，那就是您背过但还不熟悉的词了。:)把这些词单独记在另外一个地方，别跟没背下来的词混了。泛听要听精听已经听过的内容。比如精听听到了第二盘磁带，那么泛听就听第一盘磁带，正好。
第二个分支：狂看！八千到一万这个等级，基本包含了剩下的百分之二十。这些单词在听力教材里很难找到。但是，可不要停止听的练习呦，因为听能巩固您的语调感觉，而这是背这个等级单词的一个关键。不过，背这个等级的词，需要在听以外增加看的内容。看，同样要分精读和泛读两种。就象听一样，也是泛读更重要一些。泛读要挑不太长，能有耐心看完的文章，而且看不懂的词不要太多，一篇文章有两三个不认识的就足够了。千万不要一上来就看英语报刊杂志小说，那些东西不但很难看懂，而且看懂了也对背单词没什么促进作用。泛读也需要大量练习，只要您有耐心，又有足够时间，就一直看下去吧！看的时候不要仔细阅读，扫一眼明白个大概意思就成了，然后把这一眼没看懂的词画上记号，别琢磨它是什么意思，继续扫描吧！全部看完之后，回头再看这些单词，有的可能已经想起来了，有的....还没想起来？那就查查字典，要是自己还没背过，就扔掉它，要是已经背过了，就单独抄下来吧，和听力练习中没听出来的词放在一起。
第三个分支：乱说！这只适合背两万二到三万的词。因为其他的词不用说就已经背下来了。而这个等级的词在阅读材料里非常少，可能阅读十篇文章却一个这个等级的词也没有。所以*阅读来增加见面机会已经不行了。这些词甚至有的老外一辈子都没见过，咋能指望他们能写出来呢？尤其是GRE词汇，什么"给马穿衣服"， "纽约的流氓"，"从非洲吹向南欧的风"....这些词都是一些精致的修辞，也就是说，如果您话里净是这些词，那您可以假冒一位学者了。一般的老外都是听不懂您说的这些话的，所以不用这些词也能表达同样的含义。好了，您的机会来了，您可以跟老外讲话中带上这些单词，然后很自豪地假装谦虚地跟他们解释这些词的含义。每次跟老外解释一两个词就足够了，老外会佩服您佩服得五体投地的。HL就向ws解释吧！要大胆而耐心，尤其是大胆。这个阶段，您就别再练听力了，因为练了进步也不大。还记得开头那句话么？要想成功，得走捷径。凡是不能在短时期内取得巨大进步的行动，都不必浪费时间去做。不过，这时候的阅读材料成了问题：您会发现，过去看的东西觉得太浅没意思，看其他深的东西又看不懂。您还会发现一个新的有趣现象：那就是您想看的文章里，现在全是第一个等级的那些词，每个词您都确切知道它的含义，但整个文章您就是看不懂。那您该看什么呢？就看第二个等级的那些浅显文章?Ｋ淙磺诚裕??馨镏??恢劣谕?斯?ケ吵隼吹某晒?Ｖ劣谀?床欢?哪切┪恼拢?鹱偶保?饶?屠贤饨涣鞫嗔耍??匀痪投?耍?嵌际且恍┐首椤①涤锘蛭姆ㄗ槌傻奈恼隆?br> 背单词捷径的第四条，就是：联想，联想，联想，.....背单词的第一个动作是什么？端详一下它的外貌。第二第三个动作呢？看看它的内涵和发音。而第四个动作，就应该是联想，再联想..... 联想它和其他背过的词有没有外表类似的？读音类似的？意思类似或相反的？如果有，就赶紧记在旁边，在另外那些词旁边也把这个词加上。这样，以后看见其他词，也会联想起这个词，等于又增加了一次见面机会。而且，在第二、第三个等级的词汇里，还有许多单词是由"前缀"，"词根"，"后缀"组成的，前缀比如"re"，"in"，"pseud"...，后缀比如 "er"， "a"， "oid"...，然后共同组成一个新词。如果掌握了这些前后缀，就可以很方便地猜出一个生词到底什么意思。另外，有很多读音相近的词也有相似的意思，这在俚语、诗歌和儿童用语中更普遍。
如果每天记80个单词，一个月只能背2400个单词，但掌握了这些规律后，实际上背的速度越来越快，几乎一万多单词都是不用背就会了的。不过，在GRE单词中，有很多是既没有和其他词的关系，又没有前后缀，看起来既简单又记不住的单词。这些词里边有希腊语，意大利语，德语，拉丁语，甚至还有日语译音。这就只能*和别人解释来掌握了。

【转自】http://www.makeit.net.cn/learn/words/61

【转】如何背单词

2008-05-03T19:16:00.000-07:00

千万别死背单词的拼写，那样跟死背电话号码没有差别，谁也背不下成千上万的电话号码，同样谁也背不下成千上万个由26个字母组成的电话号码(即英语)。英语是拼音文字，记住英语单词的最正确方法、也是最简单方法、最可靠方法就是记住单词的发音。其他的方法都不是根本方法，记住的单词都会被忘记。请大家想一想，有哪个中国人背过汉语拼音，可掌握了汉语拼音的人都可以用汉语拼音在计算机上打字，人们打字时打进的拼音是什么，是记住的汉语拼音字母吗，不是，而是汉字的发音，音发得准的人都能使用汉语拼音打字，同样英语音发得准的人就可以记住英语单词的拼写。中国人从没有见过谁背汉语拼音，同样外国人从没见过谁背过英语单词的拼写，拼音文字靠发准音记住拼写，这是天经地义的。要想记住英语单词的拼写，必须发准英语音。请练准英语单词的发音，就可以进入记字无难，记字无忧的境界。

怎样快速牢固地记忆单词呢？

　　1：快速多次。被单词时不要一次在某一单词上花费大量的时间太多，一定要每次都大量的背。它可以使单词的意思牢牢地在同学们的头脑中生根，不易遗忘。只有快速，才能多次。只有多次，才能记住。有的同学会问：“背多遍会不会
浪费时间呢？”实际上，一本单词书背第一遍的时候，可能需要一个月，而第二偏的时候，由于一部分单词已经背会，不会的单词也有印象，可能十来天就背完了。第三遍也许5天时间就可以完成。因为只背一遍对单词的印象是不太深刻的，那么遗忘的速度和遗忘率都会很高，不如多背几遍，省时省力还踏时。

　　2：注意单词之间的联系。当然，可能刚开始时能建立联系的单词很少，但要注意培养这种意识，争取一串串地背单词看见一个就能想起一串。比如：同义的，反义的，形近的，同根的，同类的单词防在一块儿记。

　　3：将认识的和不认识的词分类。大家在背单词时，在书上将不忍市的词用特殊的记号标出，这样，将主要精力集中于不认识的词，可以大大节省时间，缓解压力。

　　4：脑，眼，口手并用。背单词不是看小说，应该找一个安静的地方，抛开一切杂念。译本书，一叠纸，一张嘴，脑中想着这个单词，眼里看着它，嘴里念着它，用笔在纸上写着这个单词，这样才能加强对这个原来根本不认识的单词的印象，去得好的记忆效果。

　　5：记得模糊一些。背单词的时候是不是要把单词的所有的意思和用法都记得很请清楚楚呢？回答是否定的对大多数单词，只要知道它的大概意思就可以了，就不会对阅读和做题产生影响。只有极少数的核心词汇，才需要不仅了解它的意思，还要了解它的用法。

　　6：经常复习。笔者本人的单词在两万左右，基本上每周都拿出一个半天将其中的一些单词背一遍，有的单词确实有些模糊了，将它在加强一下，笔者并不感到负担，相反觉得很有意思。

【转自】http://www.makeit.net.cn/learn/words/61

【转】越看越不错的海报~~~~~~~

2008-04-29T06:32:00.000-07:00

转自网络蚯蚓~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

迷你小词典~

2008-04-22T04:14:00.000-07:00

原创小词典~~~~~~~~~使用了海词的提供的API~~~~~~~~在此感谢啦~~~~~~~~
import org.eclipse.swt.*;
import org.eclipse.swt.SWT;
import org.eclipse.swt.widgets.*;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Text;
import org.eclipse.swt.events.*;
import org.eclipse.swt.browser.*;
import org.eclipse.swt.browser.Browser;

public class Dict {

private Text express;

private Text searchWord;

public Dict() {

final Display display = Display.getDefault();

final Shell shell = new Shell(display);
shell.setSize(500, 380);
shell.setText("Dict --by stonestrange");

final Browser browser = new Browser(shell, SWT.NONE);
browser.setBounds(116, 66, 363, 282);

searchWord = new Text(shell, SWT.BORDER);
searchWord.setBounds(91, 19, 268, 22);

final Button search = new Button(shell, SWT.NONE);
search.setText("search");
search.setBounds(385, 19, 94, 22);
search.setImage(searchImage);
search.addSelectionListener(new SelectionAdapter() {
public void widgetSelected(SelectionEvent e) {
String word = searchWord.getText();
String url = "http://dict.cn/mini.php?q=";
url = url + word;
browser.setUrl(url);
}
});

express = new Text(shell, SWT.BORDER);
express.setBounds(116, 66, 363, 282);

shell.open();
shell.layout();

while (!shell.isDisposed()) {
if (!display.readAndDispatch())
display.sleep();
}
}

public static void main(String[] args) {
new Dict();
}
}

[转]如何判断真假性近视

2008-04-15T21:29:00.000-07:00

假性近视是真性近视眼之前的一种疲劳状态，如果这种状态不能及时缓解，眼睛发生器质性改变就会形成真性近视。判断真假近视眼需要做散瞳验光,散瞳的目的是解除眼睛疲劳，让紧张的肌肉放松，这样验出的屈光度才是准确的。如果散瞳后裸眼视力能够达到1.0，那就是“假性近视”，在短期内能治愈，比如药物、针灸及理疗仪器等，都可放松肌肉，缓解疲劳，使视力恢复到正常状态。如不想治疗，只要经常眺望远方，注意休息，视力也有可能恢复。但是如果散瞳后裸眼视力低于0.8，就是“真性近视”了。真性近视眼一旦形成就不可逆转，它是眼球发生的器质性改变。眼球的前后轴变长，外界物象通过眼睛的屈光系统成像在视网膜前，视网膜上没有清晰的物象，当然就不会有良好的视力了。这种器质性改变除了手术外，任何方法都不能使眼球缩短、屈光度改变，这就是近视眼难以治愈的原因。目前屈光手术是唯一可治疗近视眼、降低屈光度的方法。

[转自http://bbs.hefei.cc/viewthread.php?tid=1109460]

[转]10个世界著名的卡通形象

2008-04-07T22:50:00.000-07:00

一、小熊维尼

喜爱这个憨态可掬的小熊，喜欢它的笨拙，喜欢嗜食蜂蜜，喜欢它的朋友--胆小的猪和同样胆小的虎。A·A·米那是英国著名的小说家，他以儿子克里斯多夫和玩具熊为主角出了两本童话书《Winnie-the Pooh》(1926)《Welcome the Pooh Comer》(1928)其中出色的文字和插图，令小读者们一下爱上了小熊维尼。

小熊维尼档案：

●Pooh和朋友的历险故事发生在百亩林(hundred Acre Wood)。

●Pooh的电视动画赢过奥斯卡奖（1968）和艾美奖（1989及1990）。

二、芭比

她是永远的大明星；她青春永驻；她有无数种身份和无数套衣服（当然价值不菲）；她有经专家精心设计的三围和五官，她是所有女性的梦想。1959年，美国汉德尔太太制成第一个芭比娃娃，灵感来自女儿芭芭拉（小名芭比）的纸制洋娃娃，一经上市立即卖得火热。40多年来小女孩们通过玩芭比了解成人世界，竖立偶像。

芭比档案：

●全名是Barbie Millicent Roberts。

●有3姊妹，Skipper（1964年出世）、Stacie(1992)，男朋友是Ken，1961年已相识，至今情比金坚，Ken有弟弟Tommy。

●从1959年至今，Barbie拥有达10亿套时装及10亿双鞋。

●共穿过45个国家或民族的服装。

三、巴特·辛普森

在美国，最受欢迎的电视动画片《辛普森一家》（港译《阿森一族》）已经播到了第10季。10年来，春田镇上的这个五口之家用他们荒诞的经历讽刺着当代美国社会的生活和文化。辛普森一家的形象随着电视剧的走红而成为世界性的流行符号，其中爱捣乱的长子巴特?辛普森已经成为一个大众偶像，连《时代》周刊也将他选为“20世纪演艺界最重要的人物”之一。

其实巴特在动画片里只能算是令人头痛，捣个乱撒个谎，没事爱跟大人对着干，祸闯大了一样傻眼，这样的小孩世界上何止千千万万，不过当他被推到潮流前线，注册商标就变成了“春田镇的坏男孩（Bad boy of Springfield)”，因为他的坏已经等同于“酷”，“坏”的一面也被特别放大、突出，大家爱就爱他身上一股天不怕地不怕、我是小孩我怕谁的气质。

四、加菲猫

没有一只猫像它一样好吃、自私、贪婪、胆怯、市侩……它的生命中最大的乐趣就是吃和戏弄奥多狗和自己的主人，它就是个有缺点的普通人。

吉姆·戴维斯只为以狗为主角的漫画太多而不平，便创造了加菲。他将头脑中猫的特性结合祖父詹姆斯·加菲?戴维斯的个性，结果加菲因为漫画形象前所未有的人性化大受欢迎。

加菲猫档案：

●出生日期：1978年6月19日

●出生地点：Mama Leone 意大利餐厅厨房

●出生体重：5磅6安士

●喜爱食物：意大利面条

●喜爱饮品：咖啡

●玩偶：啤啤熊Pooky

●玩伴：Odie狗

●最讨厌：蜘蛛、邮差

五、机器猫

这是藤子不二雄最经典的漫画，从1969年到1996年，机器猫红了整整27年。来自22世纪，它有一个四维空间袋和无数高科技法宝；它没有耳朵，全身发蓝；最怕老鼠，最爱红豆饼；它有一个比白痴稍强一丁点的主人、自己也不太聪明……可是，我爱机器猫，因为他代表了有难时能全心帮助你的朋友--不论它有没有这本事。

机器猫档案：

●出生日期：公元2112年9月3日

●身高：129.3cm

●体重：129.3kg

●四围：上中下和头围均是129.3cm

●马力：129.3匹

●遇见老鼠时跳跃力：129.3cm

●时速：每小时129.3公里

●亲戚朋友：大雄、静宜、技安、牙擦仔、妹妹叮铃。

六、Kitty猫

Kitty是个很女性化的猫（就像加菲的男性化）她干净、温顺、乖巧、无害。

1974年，Sanrio设计师为小钱包设计了一只小白猫，她绑着一条红丝带，名叫Hello Kitty，天生一副明星相。一经出世，她就被印得哪儿都是，各种小文具、儿童用品、服装配饰上都有她的身影。

Kitty档案：

●性格：又cute又温柔、上进有活力

●出生：11月1日，天蝎座

●体重：3个苹果般重

●身高：3个苹果直排

●喜爱食物：苹果派

●专长：火局曲奇、运动和弹钢琴

●嘴巴：没有，因为可以分享别人的感受

七、米老鼠

1928年，米奇诞生于火车上，这源于沃特?迪斯尼的一次心血来潮。刚出道时的米奇顽劣成性。可是随着时间的推移，米奇变成了一个形象可爱、性格温驯的绅士。而迪斯尼王国也由它开始了辉煌的历史。

如今，米奇的乐观善良已影响了整个美国乃至整个世界。人们都爱煞了这个整天傻笑的胖老鼠。

米老鼠档案：

●米奇老鼠是于1928年11月18日初登银幕，电影名《Steamboat Willie》。

●米奇老鼠是第一只商品化的卡通角色，时为1929年。同年，米奇老鼠拥有了Mickey Mouse Club。

●1955年开始，米奇老鼠移居迪斯尼乐园做亲善大使，接待

中外名人不计其数。

八、史努比

去年，史努比的创造者查尔斯·M·舒尔兹离开人世。而由于没有合适的继承者，伴随人们50年的史努比的故事也落了幕，令人不胜唏嘘。是呀，谁还能接手为这个有思想、有内涵的小狗注入新的生命，继续它的冷静，多愁善感，善解人意，而且从不认为自己是只狗？

史努比档案：

●史努比的父亲曾于1989年6月18日连载的《花生》中出现过，提及它有8名子女，但至今只出现6名史努比家族成员，包括哥哥Spike、妹妹Belle、弟弟Marbles、Olaf、Andy。

●1970年，史努比雇用了一只季候鸟当秘书，便是胡士托。

●史努比最讨厌的就是邻居的小猫WWLL。

九、芝麻街

它们挑战着人类的传统美学。玩具设计大师Jim Henson和FrankOz一同制作了《芝麻街》。60年代，泛世界观念的人们将一切人为界限打破，支持美的形式多种多样。1969年，一个义务教育团体Children's TelevisionWorkshop（CTW）制作播出了《芝麻街》寓教于乐。一大帮怪兽通过不同人物的故事，藉唱歌、讲故事向孩子们软说教，形象自然深入人心。

十、泰迪熊

它的名字和走红得多谢一位总统--老罗斯福。1902年这位总统拒绝用枪射杀一只被当成靶子绑在树上的小熊，而成为有爱心的代表。而布鲁克林的一位文具店的老板因而触发灵感，将太太制作的两只小熊命名为Teddy（这是总统的昵称，当然毫无讽刺之意）并展示在橱窗内，谁知，这一下红了近百年。

泰迪熊自然粗糙的质感和呆板的眼神，可能是它惹人怜爱的原因。

泰迪熊档案：

●三大名厂：德国Steiff、英国Merrythought及Hermann三大厂限量生产的Teddy Bear最富炒卖价值。

●一世熊友：欧洲有在婴儿出生时送他一只小熊的传统，陪伴他成长，是他一生的朋友。

转自：网络蚯蚓~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

java解析xml

2008-04-07T22:42:00.000-07:00

在这段代码中~~~~我解析的是海词提供的xml~~~~~~~~~~~~~运行环境是Eclipse~~~~~~~~~~不过在编码部分还存在一定的问题~~~~~~~~~有待努力~~~~~~~继续提高~~~~~~~~~~嘿嘿~~~~~~~~~~~~~~~

import org.xml.sax.*;
import org.xml.sax.helpers.*;
import javax.xml.parsers.*;

public class MyXMLReader extends DefaultHandler {

java.util.Stack tags = new java.util.Stack();

private String currentName;

private StringBuffer currentValue = new StringBuffer();

public MyXMLReader() {
super();
}

public void startElement(String uri, String localName, String qName,
Attributes attributes)

throws SAXException {

}

public void characters(char ch[], int start, int length)
throws SAXException {
System.out.println(new String(ch,start,length));
}

public void endElement(String uri, String localName, String qName) throws SAXException {

//props.put(qName.toLowerCase(), currentValue.toString().trim());

}

public static void main(String args[]) {
try {
SAXParserFactory sf = SAXParserFactory.newInstance();
SAXParser sp = sf.newSAXParser();
MyXMLReader reader = new MyXMLReader();
sp.parse(new InputSource("http://dict.cn/ws.php?q=stone"), reader);
} catch (Exception e) {
//e.printStackTrace();
}
}
}

[转]在Java中调用C语言生成的DLL文件

2008-04-07T22:40:00.000-07:00

一、JAVA中所需要做的工作

在JAVA程序中，首先需要在类中声明所调用的库名称，如下：

static {

System.loadLibrary(“goodluck”);

}

在这里，库的扩展名字可以不用写出来，究竟是DLL还是SO，由系统自己判断。

还需要对将要调用的方法做本地声明，关键字为native。并且只需要声明，而不需要具体实现。如下：

public native static void set(int i);

public native static int get();

然后编译该JAVA程序文件，生成CLASS，再用JAVAH命令，JNI就会生成C/C++的头文件。

例如程序testdll.java，内容为：

public class testdll

{

static

{

System.loadLibrary("goodluck");

}

public native static int get();

public native static void set(int i);

public static void main(String[] args)

{

testdll test = new testdll();

test.set(10);

System.out.println(test.get());

}

用javac testdll.java编译它，会生成testdll.class。

再用javah testdll，则会在当前目录下生成testdll.h文件，这个文件需要被C/C++程序调用来生成所需的库文件。

二、C/C++中所需要做的工作

对于已生成的.h头文件，C/C++所需要做的，就是把它的各个方法具体的实现。然后编译连接成库文件即可。再把库文件拷贝到JAVA程序的路径下面，就可以用JAVA调用C/C++所实现的功能了。

接上例子。我们先看一下testdll.h文件的内容：

/* DO NOT EDIT THIS FILE - it is machine generated */

#include

/* Header for class testdll */

#ifndef _Included_testdll

#define _Included_testdll

#ifdef __cplusplus

extern "C" {

#endif

* Class: testdll

* Method: get

* Signature: ()I

JNIEXPORT jint JNICALL Java_testdll_get

(JNIEnv *, jclass);

* Class: testdll

* Method: set

* Signature: (I)V

JNIEXPORT void JNICALL Java_testdll_set

(JNIEnv *, jclass, jint);

#ifdef __cplusplus

}

#endif

在具体实现的时候，我们只关心两个函数原型

JNIEXPORT jint JNICALL Java_testdll_get (JNIEnv *, jclass);

和

JNIEXPORT void JNICALL Java_testdll_set (JNIEnv *, jclass, jint);

这里JNIEXPORT和JNICALL都是JNI的关键字，表示此函数是要被JNI调用的。而jint是以JNI为中介使JAVA的int类型与本地的int沟通的一种类型，我们可以视而不见，就当做int使用。函数的名称是JAVA_再加上java程序的package路径再加函数名组成的。参数中，我们也只需要关心在JAVA程序中存在的参数，至于JNIEnv*和jclass我们一般没有必要去碰它。

好，下面我们用testdll.cpp文件具体实现这两个函数：

#include "testdll.h"

int i = 0;

JNIEXPORT jint JNICALL Java_testdll_get (JNIEnv *, jclass)

{

return i;

}

JNIEXPORT void JNICALL Java_testdll_set (JNIEnv *, jclass, jint j)

{

i = j;

}

编译连接成库文件，本例是在WINDOWS下做的，生成的是DLL文件。并且名称要与JAVA中需要调用的一致，这里就是goodluck.dll

把goodluck.dll拷贝到testdll.class的目录下，java testdll运行它，就可以观察到结果了。

转自：http://buttom2008.blog.163.com/blog/static/71449844200837511649/

缓冲区管理

2008-04-07T22:34:00.000-07:00

//假设系统中有两个分别名为P1、P2的进程
//两台均可进行输入、输出操作的设备d1、d2
//两个进程可以从两台设备中的任何一台输入数据，并可以向其中的任何一台设备输出数据。

#include
#include
#include
#include
#include

#define NUMOFBUFFER 10
#define SIZEOFBUFFER 100
#define NO -1
#define MAX 200

struct buffer{ //系统中的缓冲区
int count; //缓冲区中现在的字符个数
char databuffer[SIZEOFBUFFER]; //数据区
struct buffer *p; //用作队列指针
}buf[NUMOFBUFFER];

typedef struct queue{ //队列
int buf[NUMOFBUFFER]; //保存队列中的元素
int front; //头指针
int rear; //尾指针
int currentSize; //当前长度
int maxSize; //最大长度
}SqQueue;

SqQueue emptyBuffer;
SqQueue outputOfDevice1;
SqQueue outputOfDevice2;
SqQueue inputOfDevice1;
SqQueue inputOfDevice2;

int mutex = 1;
int od1,od2,id1,id2;

int mistake = 0;

//初始化空队列
void InitEmptyQueue(SqQueue &L){
int i;
for(i = 0;i <>
L.buf[i] = i;
L.front = 0;
L.rear = 9;
L.currentSize = 10;
L.maxSize = NUMOFBUFFER;
}

//初始化队列
void InitQueue(SqQueue &L){
int i;
for(i = 0;i <>
L.buf[i] = NO;
L.front = 0;
L.rear = L.front - 1;
L.currentSize = 0;
L.maxSize = NUMOFBUFFER;
}

//P操作
void Pprocess(int source){
source --;
if(source <>
printf("Sorry.There is no empty buffer.Please wait.:-(\n");
mistake = 1;
}
}

//V操作
void Vprocess(int source){
source ++;
if(source > 0)
mistake = 0;
}

//入队
void EnQueue(SqQueue &L,int buf){
Pprocess(mutex);

if(L.currentSize == 0){
L.front = 0;
L.rear = -1;
}

if(L.rear == 9) //队满的情况已经在主函数中做过处理
L.rear = fmod(L.rear + 1,10);
else
L.rear ++;
L.buf[L.rear] = buf;
L.currentSize ++;

Vprocess(mutex);
}

//出队
int DeQueue(SqQueue &L){ //队空的情况已经在主函数中做过处理
int e;

Pprocess(mutex);

e = L.buf[L.front];
L.buf[L.front] = NO;
L.front ++;
L.currentSize --;

Vprocess(mutex);

return e;
}

//完成缓冲区和各个队列的初始化操作
void init(){

//缓冲区初始化操作
int i,j;
for(i = 0;i <>
buf[i].count = 0;
for(j = 0;j <>
buf[i].databuffer[j] = ' ';
buf[i].p = &buf[i + 1];
}

//各个队列的初始化操作
InitEmptyQueue(emptyBuffer);
InitQueue(outputOfDevice1);
InitQueue(outputOfDevice2);
InitQueue(inputOfDevice1);
InitQueue(inputOfDevice2);
}

//从空队列中取出一个缓冲区
int getBuffer(){
int index;
int size = emptyBuffer.currentSize;

Pprocess(size);

if(mistake != 1){
Pprocess(mutex); //对空缓冲区队列进行互斥操作
index = DeQueue(emptyBuffer);
Vprocess(mutex);
}

return index;
}

//空队列中放入一个缓冲区
void putBuffer(int index){
int size = emptyBuffer.currentSize;

Pprocess(mutex); //对空缓冲区队列进行互斥操作
EnQueue(emptyBuffer,index);
Vprocess(mutex);

Vprocess(size);
}

//输出内容，格式控制函数
void print(){
int i = 0,k = 0,index;

printf("...........................................\n");
printf("...........................................\n");

//显示空缓冲区队列
printf("emptyBuffer : ");
if(emptyBuffer.currentSize == 0 || mistake == 1)
printf("NULL");
else{
i = emptyBuffer.front;
do{
index = fmod((i+k),10);
printf("%d ",emptyBuffer.buf[index]);
k ++;
}while(k <>
}
putchar('\n');

//显示设备一的输出队列
printf("outputOfDevice1 : ");
if(outputOfDevice1.currentSize == 0)
printf("NULL");
else{
i = outputOfDevice1.front;
k = 0;
do{
index = fmod((i+k),10);
printf("%d ",outputOfDevice1.buf[index]);
k ++;
}while(k <>
}
putchar('\n');

//显示设备二的输出队列
printf("outputOfDevice2 : ");
if(outputOfDevice2.currentSize == 0)
printf("NULL");
else{
i = outputOfDevice2.front;
k = 0;
do{
index = fmod((i+k),10);
printf("%d ",outputOfDevice2.buf[index]);
k ++;
}while(k <>
}
putchar('\n');

//显示设备一的输入队列
printf("inputOfDevice1 : ");
if(inputOfDevice1.currentSize == 0)
printf("NULL");
else{
i = inputOfDevice1.front;
k = 0;
do{
index = fmod((i+k),10);
printf("%d ",inputOfDevice1.buf[index]);
k ++;
}while(k <>
}
putchar('\n');

//显示设备二的输入队列
printf("inputOfDevice2 : ");
if(inputOfDevice2.currentSize == 0)
printf("NULL");
else{
i = inputOfDevice2.front;
k = 0;
do{
index = fmod((i+k),10);
printf("%d ",inputOfDevice2.buf[index]);
k ++;
}while(k <>
}
putchar('\n');

printf("...........................................\n");
}

//设备选择显示函数
int withTools(){
char dc = getch();
if(dc == '1')
printf("device1.");
else{
if(dc == '2')
printf("device2.");
else
printf("error.");
}
putchar('\n');
printf("...........................................\n");
int tool = (int)dc - 48;
return tool;
}

//线程选择显示函数
int withType(){
int dc = getch();
if(dc == '1')
printf("thread1.");
else{
if(dc == '2')
printf("thread2.");
else
printf("error.");
}
putchar('\n');
printf("...........................................\n");
int type = (int)dc - 48;
return type;
}

//完成进程的数据处理.
//按照inputdev指定的设备号从该设备的输入队列中取出一个缓冲区；
//按照procnum的序号对缓冲区中的数据进行指定的数据处理操作；
//按照outputdev指定的设备号将缓冲区放入该设备的输出队列。
void process(int procnum,int inputdev,int outputdev){
int index;

switch (inputdev){
case 1:
id1 = inputOfDevice1.currentSize;
Pprocess(id1);
index = DeQueue(inputOfDevice1);
break;
case 2:
id2 = inputOfDevice2.currentSize;
Pprocess(id2);
index = DeQueue(inputOfDevice2);
break;
}

strupr(buf[index].databuffer); //小写字母转换成大写字母

switch (outputdev){
case 1:
od1 = outputOfDevice1.currentSize;
EnQueue(outputOfDevice1,index);
Vprocess(od1);
break;
case 2:
od2 = outputOfDevice2.currentSize;
EnQueue(outputOfDevice2,index);
Vprocess(od2);
break;
}

printf("thread: %d---inputdevice: %d---outputdevice: %d\n",procnum,inputdev,outputdev);
print();
}

//完成设备的读写操作.其中参数devnum指出需要进行I/O操作的设备,flag为操作类型
void deviceReadAndWrite(int devnum,int flag){
int index;
char input[SIZEOFBUFFER];

if(flag == 1){ //读操作
index = getBuffer(); //从空队列中取出一个缓冲区
if(mistake == 1){
printf("You must make a full buffer empty.:-(\n");
goto lab;
}
else{
printf("Please input some letters : ");
scanf("%s",input);
strcpy(buf[index].databuffer,input); //从终端读入一行字符串，放入缓冲区的数据区
buf[index].count = strlen(input);
if(devnum == 1){ //按照指定的设备号将缓冲区放入相应的设备输入队列
id1 = inputOfDevice1.currentSize;
EnQueue(inputOfDevice1,index);
Vprocess(id1);
}
else{
id2 = inputOfDevice2.currentSize;
EnQueue(inputOfDevice2,index);
Vprocess(id2);
}
}
}
else{ //写操作
if(devnum == 1){
od1 = outputOfDevice1.currentSize;
Pprocess(od1); //p(od1)
index = DeQueue(outputOfDevice1); //按照指定的设备号，从设备的输出队列中取出一个装满数据的缓冲区
printf("The contents of this buffer is : ");
printf("%s\n",buf[index].databuffer); //将缓冲区中的数据在终端上显示
putBuffer(index); //将空缓冲区放入空缓冲区队列
}
if(devnum == 2){
od2 = outputOfDevice2.currentSize;
Pprocess(od2); //p(od2)
index = DeQueue(outputOfDevice2); //按照指定的设备号，从设备的输出队列中取出一个装满数据的缓冲区
printf("The contents of this buffer is : ");
printf("%s\n",buf[index].databuffer); //将缓冲区中的数据在终端上显示
putBuffer(index); //将空缓冲区放入空缓冲区队列
}
}

lab:
print();
}

//代码使用控制函数
void getIn(){
char password[7] = {'0','5','2','2','2','6'};
char input[10];
int i = 0;

printf("-------------------------------------------\n");
printf("-------------------------------------------\n");

printf("Password : ");
char c = getch();

while(c != '*'){
input[i] = c;
i ++;
putchar('*');
c = getch();
}
input[i] = '\0';
putchar('\n');

if(strcmp(password,input) != 0){
printf("You do not have the right to use this code. :-(\n");
exit(0);
}

printf("-------------------------------------------\n");
printf("-------------------------------------------\n");
}

//模式选择函数
int printTip(){
printf("This code support three work models : \n");
printf("A.input B.output C.deal D.exit \n");
printf("Please choose : ");
char c = getch();
int model;

switch(c){
case 'A':
printf("input.\n");
model = 1;
break;
case 'B':
printf("output.\n");
model = 2;
break;
case 'C':
printf("deal.\n");
model = 3;
break;
case 'D':
printf("exit.\n");
model = 4;
break;
}
printf("...........................................\n");
return model;
}

//判断输出队列是否为空
int judgeOutput(int tool){
int emp; //0非空1空

switch (tool){
case 1:
if(outputOfDevice1.currentSize == 0)
emp = 1;
else
emp = 0;
break;
case 2:
if(outputOfDevice2.currentSize == 0)
emp = 1;
else
emp = 0;
break;
}
return emp;
}

//判断输入队列是否为空
int judgeInput(int tool){
int emp; //0非空1空
switch (tool){
case 1:
if(inputOfDevice1.currentSize == 0)
emp = 1;
else
emp = 0;
break;
case 2:
if(inputOfDevice2.currentSize == 0)
emp = 1;
else
emp = 0;
break;
}
return emp;
}

//判断输入队列是否为满
int judgeInputFull(int tool){
int full; //0非满1满
switch (tool){
case 1:
if(inputOfDevice1.currentSize == 10)
full = 1;
else
full = 0;
break;
case 2:
if(inputOfDevice2.currentSize == 10)
full = 1;
else
full = 0;
break;
}
return full;
}

//判断输出队列是否为满
int judgeOutputFull(int tool){
int full; //0非满1满
switch (tool){
case 1:
if(outputOfDevice1.currentSize == 10)
full = 1;
else
full = 0;
break;
case 2:
if(outputOfDevice2.currentSize == 10)
full = 1;
else
full = 0;
break;
}
return full;
}

void main(){
void InitEmptyQueue(SqQueue &L);
void InitQueue(SqQueue &L);
void EnQueue(SqQueue &L,int buf);
int DeQueue(SqQueue &L);
void init();
int getBuffer();
void putBuffer(int index);
void print();
int withTools();
int withType();
void process(int procnum,int inputdev,int outputdev);
void Pprocess(int source);
void Vprocess(int source);
void deviceReadAndWrite(int devnum,int flag);
void getIn();
int printTip();
int judgeOutput(int tool);
int judgeInput(int tool);
int judgeInputFull(int tool);
int judgeOutputFull(int tool);

int tool,thrd,model,tools;

getIn();
printf("Initiate : \n");
init();
print();

do{
model = printTip();
switch(model){
case 1: //输入
do{
printf("1:device1 2:device2\nPlease choose : ");
tool = withTools();
if(judgeInputFull(tool) == 1){ //判断输入队列是否为满
printf("The list of inputDevice%d is full.:-(\n",tool);
printf("Please input again.\n");
}
}while(judgeInputFull(tool) == 1);
deviceReadAndWrite(tool,model);
break;
case 2: //输出
do{
printf("1:device1 2:device2\nPlease choose : ");
tool = withTools();
if(judgeOutput(tool) == 1){ //判断输出队列是否为空
printf("The list of outputOfDevice%d is empty.:-(\n",tool);
printf("Please input again.\n");
}
}while(judgeOutput(tool) == 1);
deviceReadAndWrite(tool,model);
break;
case 3: //数据处理
printf("1:thread1 2:thread2\nPlease choose : ");
thrd = withType();
do{
printf("1:device1 2:device2\nThe device of input : ");
tool = withTools();
if(judgeInput(tool) == 1){ //判断输入队列是否为空
printf("The list of input of device%d is empty.:-(\n",tool);
printf("Please input again.\n");
}
}while(judgeInput(tool) == 1);
do{
printf("1:device1 2:device2\nThe device of output : ");
tools = withTools();
if(judgeOutputFull(tool) == 1){ //判断输出队列是否为满
printf("The list of output of device%d is full.:-(\n",tool);
printf("Please input again.\n");
}
}while(judgeOutputFull(tool) == 1);
process(thrd,tool,tools);
break;
case 4: //退出
break;
}
}while(model != 4);

printf("...........................................\n");
printf("...........................................\n");
printf("Thank you for using by 052226.:-)\n");
}

UNIX磁盘空间管理算法

2008-04-07T22:33:00.000-07:00

#include
#include
#include

#define NO -1

struct size{//每一个磁盘块都有一个数组,该数组包含10个元素,当该磁盘快成为当前组的第一个时,用于存放下一组的信息
int blocl[10];
};

struct blocd{//定义组,每组有10个磁盘块
struct size a[10];//用于在空闲磁盘块号链中存放磁盘块号
}block[40];

struct File{
int fileblocd[100];//用于记录分别分配给文件的磁盘块号,每个文件最多占有100个磁盘快
}file[5];

struct SqStack{ //定义一个记录磁盘块号的堆栈
int *base;
int *top; //指向栈顶元素
int stacksize;
int s_nfree; //记录栈中现有磁盘块数的变量
}s_free;

void InitStack(SqStack &S){
S.base = (int *)malloc(10 * sizeof(int));
if(!S.base)
exit(OVERFLOW);
S.top = S.base - 1;
S.stacksize = 10;
S.s_nfree = 0;
}

void Push(SqStack &S, int e){
S.top ++;
*S.top = e;
S.s_nfree ++;
}

int Pop(SqStack &S){
int e = *S.top;
S.top --;
S.s_nfree --;
return e;
}

int label;//用来记录当前磁盘块的绝对名字
int nextLabel;//用来记录下一个磁盘块的绝对名字

//完成空闲磁盘块号堆栈、空闲磁盘块号队列及记录文件占用磁盘块状态的file结构数组
void init(){
int i,j,k;

//初始化空闲磁盘块号队列
for(i = 0;i <>
for(j = 0;j <>
if(i == 0){ //第0组中每个磁盘块内的数组中的每个元素都是NO
for(k = 0;k <>
block[i].a[j].blocl[k] = NO;
}
else{ //其他组中,除第0个磁盘块外,其他磁盘块的数组中的每个元素都是NO
if(j == 0){
for(k = 9;k >= 0;k --){
block[i].a[j].blocl[k] = label;
label --;
}
}
else{
for(k = 0;k <>
block[i].a[j].blocl[k] = NO;
}
}
}
j = j - 1;
label = i * 10 + j;
}

//初始化空闲磁盘块号堆栈
int tmp[10];
InitStack(s_free);
for(i = 0;i <>
tmp[i] = label;
label --;
} //循环结束时,label为下一组的最后一个元素的绝对名字
for(i = 9;i >= 0;i --)
Push(s_free,tmp[i]);

//初始化文件占用磁盘块状态
for(i = 0;i <>
for(j = 0;j <>
file[i].fileblocd[j] = NO;
}
}

int getLine(int name){
int line = name/10;
return line;
}

int getCount(int name){
int count = fmod(name,10);
return count;
}

void keepStackFull(int name){
int line = getLine(name);
int count = getCount(name);
int temp[10],i;

for(i = 0;i <>
temp[i] = block[line].a[count].blocl[i];
Push(s_free,temp[i]);
}

}

void keepStackEmpty(int nextName){
int line = getLine(nextName);
int count = getCount(nextName);

int temp[10],i,j;
for(i = 0;i <>
temp[i] = Pop(s_free);
for(i = 0,j = 9;i <>
block[line].a[count].blocl[i] = temp[j];

}

//fileno为文件序号，用于指定需要分配的文件;blockd为所需要磁盘块数目
void alloc(int fileno,int blockd){
int i;
for(i = 0;i <>
if(s_free.s_nfree == 0)
keepStackFull(label);
label = Pop(s_free);
file[fileno].fileblocd[i] = label;
}
}

void free(int fileno){
int i = 0;
do{
label = file[fileno].fileblocd[i];

if(s_free.s_nfree == 10){
//if(fmod(label,10) != 0)
//keepStackEmpty(nextLabel);
//else
keepStackEmpty(label);
}

Push(s_free,label);
file[fileno].fileblocd[i] = NO;
nextLabel = file[fileno].fileblocd[i+1];
i ++;
}while(nextLabel != NO);
}

//设置打印格式
void print(){
int i = 0,j,k,num;
printf("............................................................................\n");
printf("Free block : \n");
int st[10];
int line,count;
if(s_free.s_nfree != 0){
while(s_free.s_nfree != 0){
st[i] = Pop(s_free);
i ++;
}
}
else{
j = 9;
line = getLine(label);
count = getCount(label);
while(j >= 0){
st[i] = block[line].a[count].blocl[j];
i ++;
j --;
}
}

num = i;
for(i = num - 1;i >= 0;i --)
Push(s_free,st[i]);
for(i = 0;i <>
printf(" %3d ",st[i]);
putchar('\n');

line = getLine(st[num-1]);
count = getCount(st[num-1]);
do{
for(i = 9;i >= 0;i --)
printf(" %3d ",block[line].a[count].blocl[i]);
putchar('\n');
st[num - 1] = block[line].a[count].blocl[0];
line = getLine(st[num-1]);
count = getCount(st[num-1]);
}while(block[line].a[count].blocl[0] != NO);
printf("............................................................................\n");
printf("File : \n");
for(i = 0;i <>
printf("file[%d] :",i);
j = 0;
k = 0;
do{
if(file[i].fileblocd[j] == NO){
printf(" NULL");
break;
}
else{
printf(" %3d ",file[i].fileblocd[j]);
nextLabel = file[i].fileblocd[j+1];
j ++;
k ++;
if(fmod(k,10) == 0){
putchar('\n');
printf(" ");
}
}
}while(nextLabel != NO);
putchar('\n');
}
printf("............................................................................\n");
}

void main(){
init();
printf("初始化 : \n");
print();

int i,s;
char c,null;
int count_f = 0,count_h = 0;
step:
do{
printf("请输入待分配的文件的序号 : \n");
scanf("%d",&i);
null = getchar();
printf("请输入待分配的文件的所需的磁盘块数目 : \n");
judge:
scanf("%d",&s);
null = getchar();
alloc(i,s);
print();
if(s > 100){
printf("请重新输入文件所需的磁盘块数目 : ");
goto judge;
}
count_f = count_f + 1;
if(count_h > 0)
count_h = count_h - 1;
if(count_f == 5){
printf("已经有5个文件存在，达到最大值 . :-(\n");
break;
}
printf("分配 ? y or n ?\n");
c = getchar();
}while(c == 'y');

do{
printf("请输入待回收的文件的序号 : \n");
scanf("%d",&i);
null = getchar();
free(i);
print();
count_h = count_h + 1;
count_f = count_f - 1;
if(count_h == 5 || count_f == 0){
printf("已经没有文件存在，无法删除. :-(\n");
break;
}
printf("回收 ? y or n ?\n");
c = getchar();
null = getchar();
}while(c == 'y');
printf("分配 ? y or n ?\n");
c = getchar();

if(c == 'y')
goto step;
printf("感谢使用 by 052226 .:-)\n");
}

用信号量来实现读者-写者问题

2008-04-07T22:28:00.000-07:00

1、定义一个数据缓存buffer及用于实现同步互斥的信号量。
2、定义一个读者函数：

l 当有写者在占用buffer时，读者应该等待，直到写者不再使用该buffer。

l 当有其他读者在占用buffer时，读者可对buffer进行读取操作。

l 当buffer中有数据时，则从其中读取一个数据，并显示然后退出。

l 当buffer中没有数据时，应等待，直到buffer中有数据可读。

3、定义一个写者函数

l 当有读者在占用buffer时，写者应该等待，直到所有的读者都退出为止。

l 当有其他写者占用buffer时，该写者应该等待，直到占用buffer的写者退出为止。

l 当buffer有空闲时，写者应该在buffer中写入一个数据并退出。

l 当buffer满时，写者应该等待，直到buffer有空闲为止。

#include
#include
#include
#include
#include
#include

#define MAX 8

int reader_count = 0; //纪录读者数目
long currentTime = 0; //纪录相对时间
int buffer = 0; //缓冲区标记：0空;1满
HANDLE w; //控制读者写者对缓冲区访问
HANDLE mutex; //互斥体

struct People{
HANDLE thread; //定义处理线程的句柄
int type; //进程类型（读写）1读，0写
int StartWorkTime; //开始工作时间（相对时间）
int WorkTime; //工作时间
};

People per[MAX]; //人
People *pl = per;

void createMutex(HANDLE mutex){ //创建互斥体用于访问数值
mutex = CreateMutex(
NULL,
TRUE,
NULL);
}

void createSemaphore(HANDLE w){ //创建信号量
w = CreateSemaphore(
NULL,
1, //当前可用的资源数为1
10, //最大为10
NULL);
}

DWORD WINAPI ReadProc(LPVOID lpParam){ //读过程
People *pers = (People*)lpParam;
int st = 1;
while(st == 1 || buffer == 1){
int count = 1;
while(currentTime <>StartWorkTime){ //未到达工作时间时，读者等待
if(count == 1)
printf("%d read_thread is waiting for time.\n",GetCurrentThreadId());
count ++;
}
printf("%d thread is requesting read.\n",GetCurrentThreadId());
count = 1;
while(buffer == 0){ //缓冲区为空时，读者等待
if(count == 1) //等待第一次时，显示输出
printf("%d read_thread is waiting for write_thread.\n",GetCurrentThreadId());
count ++;
}
WaitForSingleObject(mutex,INFINITE); //P(mutex);
reader_count ++; //Rcount++;
if(reader_count == 1){ //if (Rcount==1)
WaitForSingleObject(w,INFINITE); //P(w);
}
ReleaseMutex(mutex);
pers->StartWorkTime = currentTime; //重新设置工作时间
count = 1;
while(currentTime <= pers->StartWorkTime + pers->WorkTime){ //读
if(count == 1)
printf("%d thread is reading.\n",GetCurrentThreadId());
count ++;
}
WaitForSingleObject(mutex,INFINITE); //P(mutex);
reader_count --; //Rcount--;
if(reader_count == 0){ //最后一个读者离开时，缓冲区清空，即0； if (Rcount==0)
buffer = 0;
ReleaseSemaphore(w,1,NULL); //V(w);
}
ReleaseMutex(mutex); //V(mutex);
printf("%d thread finished reading-work and exited.\n",GetCurrentThreadId());
st ++;
Sleep(600);
}
CloseHandle(pers->thread);
return 0;
}

DWORD WINAPI WriteProc(LPVOID lpParam){ //写过程
People *pers = (People*)lpParam;
int count = 1;
while(currentTime <>StartWorkTime){ //未到达工作时间时，读者等待
if(count == 1)
printf("%d write_thread is waiting for time.\n",GetCurrentThreadId());
count ++;
}
printf("%d thread is requesting write.\n",GetCurrentThreadId());
count = 1;
while(buffer == 1){ //缓冲区为满时，写者等待
if(count == 1)
printf("%d write_thread is waiting for buffer.\n",GetCurrentThreadId());
count ++;
}

WaitForSingleObject(w,INFINITE); //P(w);

pers->StartWorkTime = currentTime;
count = 1;
printf("%d thread is writing.\n",GetCurrentThreadId()); //写
buffer = 1; //缓冲区满
printf("%d thread finished writing-work and exited.\n",GetCurrentThreadId());
ReleaseSemaphore(w,1,NULL); //V(w);
CloseHandle(pers->thread);
return 0;
}

void create(int num){
int count = 0;
do{
per[count].StartWorkTime = 1;
per[count].WorkTime = 2;
per[count].type = 0; //写
per[count].thread = CreateThread(
NULL, //默认安全性
0, //默认堆栈
WriteProc, //类范围内的线程proc
(LPVOID)(&per), //发送per指针给proc
0, //线程创建后可立即执行的标志为0
NULL);
count ++;
}while(count < num/2);
do{
per[count].StartWorkTime = 1;
per[count].WorkTime = 2;
per[count].type = 1; //读
per[count].thread = CreateThread(
NULL, //默认安全性
0, //默认堆栈
ReadProc, //类范围内的线程proc
(LPVOID)(&per), //发送per指针给proc
0, //线程创建后可立即执行的标志为0
NULL);
count ++;
}while(count < num);

}

void main(){
char password[7] = {'0','5','2','2','2','6'};
char input[10];
int i = 0;
char c = getch();
while(c != '*'){
input[i] = c;
i ++;
putchar('*');
c = getch();
}
input[i] = '\0';
putchar('\n');
if(strcmp(password,input) == 0){
createMutex(mutex); //创建互斥体
createSemaphore(w); //创建信号量
create(MAX); //创建读者写者
currentTime = 0; //初始化当前时间
while(currentTime < 30){
printf("currentTime = %d\n",currentTime);
Sleep(300);
currentTime++;
}
printf("Time over!\n");
CloseHandle(mutex);
CloseHandle(w);
printf("Thank you for using.:-)\n");
}
else printf("You do not have the right to use this code.:-(\nThank you.\n");
}