Be happy with Java

2007年2月13日 #

python 语言类型

一位博学的读者发给我 Python 如何与其它编程语言的比较的解释:

静态类型定义语言
一种在编译期间数据类型固定的语言。大多数静态类型定义语言是通过要求在使用所有变量之前声明它们的数据类型来保证这一点的。 JavaC 是静态类型定义语言。
动态类型定义语言
一种在运行期间才去确定数据类型的语言, 与静态类型定义相反。 VBScriptPython 是动态类型定义的, 因为它们确定一个变量的类型是在您第一次给它赋值的时候。
强类型定义语言
一种总是强制类型定义的语言。 JavaPython 是强制类型定义的。您有一个整数, 如果不明确地进行转换 , 不能将把它当成一个字符串。
弱类型定义语言
一种类型可以被忽略的语言, 与强类型定义相反。 VBScript 是弱类型定义的。在 VBScript 中, 您可以将字符串 '12' 和整数 3 进行连接得到字符串'123', 然后可以把它看成整数 123 , 所有这些都不需要任何的显示转换。

所以说 Python 既是 动态类型定义语言 (因为它不使用显示数据类型声明) , 又是 强类型定义语言 (因为一旦一个变量具有一个数据类型, 它实际上就一直是这个类型了) 。

posted @ 2007-02-13 11:56 SYBIL@BLOGJAVA 阅读(82) | 评论 (0)编辑 收藏

2007年2月12日 #

unix 高手的10个习惯,zz

UNIX 高手的 10 个习惯

克服不良的 UNIX 使用模式

developerWorks
文档选项
将此页作为电子邮件发送

将此页作为电子邮件发送

未显示需要 JavaScript 的文档选项


拓展 Tomcat 应用

下载 IBM 开源 J2EE 应用服务器 WAS CE 新版本 V1.1


级别: 中级

Michael Stutz (stutz@dsl.org), 作者, 顾问

2007 年 2 月 09 日

采用 10 个能够提高您的 UNIX® 命令行效率的好习惯——并在此过程中摆脱不良的使用模式。本文循序渐进地指导您学习几项用于命令行操作的技术,这些技术非常好,但是通常被忽略。了解常见错误和克服它们的方法,以便您能够确切了解为何值得采用这些 UNIX 习惯。

引言

当您经常使用某个系统时,往往会陷入某种固定的使用模式。有时,您没有养成以尽可能最好的方式做事的习惯。有时,您的不良习惯甚至会导致出现混乱。纠正此类缺点的最佳方法之一,就是有意识地采用抵制这些坏习惯的好习惯。本文提出了 10 个值得采用的 UNIX 命令行习惯——帮助您克服许多常见使用怪癖,并在该过程中提高命令行工作效率的好习惯。下面列出了这 10 个好习惯,之后对进行了更详细的描述。

采用 10 个好习惯

要采用的十个好习惯为:

  1. 在单个命令中创建目录树
  2. 更改路径;不要移动存档
  3. 将命令与控制操作符组合使用
  4. 谨慎引用变量
  5. 使用转义序列来管理较长的输入
  6. 在列表中对命令分组
  7. find 之外使用 xargs
  8. 了解何时 grep 应该执行计数——何时应该绕过
  9. 匹配输出中的某些字段,而不只是对行进行匹配
  10. 停止对 cat 使用管道

在单个命令中创建目录树

清单 1 演示了最常见的 UNIX 坏习惯之一:一次定义一个目录树。


清单 1. 坏习惯 1 的示例:单独定义每个目录树
	
~ $ mkdir tmp
~ $ cd tmp
~/tmp $ mkdir a
~/tmp $ cd a
~/tmp/a $ mkdir b
~/tmp/a $ cd b
~/tmp/a/b/ $ mkdir c
~/tmp/a/b/ $ cd c
~/tmp/a/b/c $

使用 mkdir-p 选项并在单个命令中创建所有父目录及其子目录要容易得多。但是即使对于知道此选项的管理员,他们在命令行上创建子目录时也仍然束缚于逐步创建每级子目录。花时间有意识地养成这个好习惯是值得的:


清单 2. 好习惯 1 的示例:使用一个命令来定义目录树
~ $ mkdir -p tmp/a/b/c

您可以使用此选项来创建整个复杂的目录树(在脚本中使用是非常理想的),而不只是创建简单的层次结构。例如:


清单 3. 好习惯 1 的另一个示例:使用一个命令来定义复杂的目录树
~ $ mkdir -p project/{lib/ext,bin,src,doc/{html,info,pdf},demo/stat/a}

过去,单独定义目录的唯一借口是您的 mkdir 实现不支持此选项,但是在大多数系统上不再是这样了。IBM、AIX®、mkdir、GNU mkdir 和其他遵守单一 UNIX 规范 (Single UNIX Specification) 的系统现在都具有此选项。

对于仍然缺乏该功能的少数系统,您可以使用 mkdirhier 脚本(请参见参考资料),此脚本是执行相同功能的 mkdir 的包装:

~ $ mkdirhier project/{lib/ext,bin,src,doc/{html,info,pdf},demo/stat/a}

更改路径;不要移动存档

另一个不良的使用模式是将 .tar 存档文件移动到某个目录,因为该目录恰好是您希望在其中提取 .tar 文件的目录。其实您根本不需要这样做。您可以随心所欲地将任何 .tar 存档文件解压缩到任何目录——这就是 -C 选项的用途。在解压缩某个存档文件时,使用 -C 选项来指定要在其中解压缩该文件的目录:


清单 4. 好习惯 2 的示例:使用选项 -C 来解压缩 .tar 存档文件
~ $ tar xvf -C tmp/a/b/c newarc.tar.gz

相对于将存档文件移动到您希望在其中解压缩它的位置,切换到该目录,然后才解压缩它,养成使用 -C 的习惯则更加可取——当存档文件位于其他某个位置时尤其如此。





回页首


将命令与控制操作符组合使用

您可能已经知道,在大多数 Shell 中,您可以在单个命令行上通过在命令之间放置一个分号 (;) 来组合命令。该分号是 Shell 控制操作符,虽然它对于在单个命令行上将离散的命令串联起来很有用,但它并不适用于所有情况。例如,假设您使用分号来组合两个命令,其中第二个命令的正确执行完全依赖于第一个命令的成功完成。如果第一个命令未按您预期的那样退出,第二个命令仍然会运行——结果会导致失败。相反,应该使用更适当的控制操作符(本文将描述其中的部分操作符)。只要您的 Shell 支持它们,就值得养成使用它们的习惯。

仅当另一个命令返回零退出状态时才运行某个命令

使用 && 控制操作符来组合两个命令,以便仅当 第一个命令返回零退出状态时才运行第二个命令。换句话说,如果第一个命令运行成功,则第二个命令将运行。如果第一个命令失败,则第二个命令根本就不运行。例如:


清单 5. 好习惯 3 的示例:将命令与控制操作符组合使用
~ $ cd tmp/a/b/c && tar xvf ~/archive.tar

在此例中,存档的内容将提取到 ~/tmp/a/b/c 目录中,除非该目录不存在。如果该目录不存在,则 tar 命令不会运行,因此不会提取任何内容。

仅当另一个命令返回非零退出状态时才运行某个命令

类似地,|| 控制操作符分隔两个命令,并且仅当第一个命令返回非零退出状态时才运行第二个命令。换句话说,如果第一个命令成功,则第二个命令不会运行。如果第一个命令失败,则第二个命令才会 运行。在测试某个给定目录是否存在时,通常使用此操作符,如果该目录不存在,则创建它:


清单 6. 好习惯 3 的另一个示例:将命令与控制操作符组合使用
~ $ cd tmp/a/b/c || mkdir -p tmp/a/b/c

您还可以组合使用本部分中描述的控制操作符。每个操作符都影响最后的命令运行:


清单 7. 好习惯 3 的组合示例:将命令与控制操作符组合使用
~ $ cd tmp/a/b/c || mkdir -p tmp/a/b/c && tar xvf -C tmp/a/b/c ~/archive.tar





回页首


谨慎引用变量

始终要谨慎使用 Shell 扩展和变量名称。一般最好将变量调用包括在双引号中,除非您有不这样做的足够理由。类似地,如果您直接在字母数字文本后面使用变量名称,则还要确保将该变量名称包括在方括号 ([]) 中,以使其与周围的文本区分开来。否则,Shell 将把尾随文本解释为变量名称的一部分——并且很可能返回一个空值。清单 8 提供了变量的各种引用和非引用及其影响的示例。


清单 8. 好习惯 4 的示例:引用(和非引用)变量
~ $ ls tmp/
a b
~ $ VAR="tmp/*"
~ $ echo $VAR
tmp/a tmp/b
~ $ echo "$VAR"
tmp/*
~ $ echo $VARa

~ $ echo "$VARa"

~ $ echo "${VAR}a"
tmp/*a
~ $ echo ${VAR}a
tmp/a
~ $





回页首


使用转义序列来管理较长的输入

您或许看到过使用反斜杠 (\) 来将较长的行延续到下一行的代码示例,并且您知道大多数 Shell 都将您通过反斜杠联接的后续行上键入的内容视为单个长行。然而,您可能没有在命令行中像通常那样利用此功能。如果您的终端无法正确处理多行回绕,或者您的命令行比通常小(例如在提示符下有长路经的时候),反斜杠就特别有用。反斜杠对于了解键入的长输入行的含义也非常有用,如以下示例所示:


清单 9. 好习惯 5 的示例:将反斜杠用于长输入
~ $ cd tmp/a/b/c || \
> mkdir -p tmp/a/b/c && \
> tar xvf -C tmp/a/b/c ~/archive.tar

或者,也可以使用以下配置:


清单 10. 好习惯 5 的替代示例:将反斜杠用于长输入
~ $ cd tmp/a/b/c \
>                 || \
> mkdir -p tmp/a/b/c \
>                    && \
> tar xvf -C tmp/a/b/c ~/archive.tar

然而,当您将输入行划分到多行上时,Shell 始终将其视为单个连续的行,因为它总是删除所有反斜杠和额外的空格。

注意:在大多数 Shell 中,当您按向上箭头键时,整个多行输入将重绘到单个长输入行上。





回页首


在列表中对命令分组

大多数 Shell 都具有在列表中对命令分组的方法,以便您能将它们的合计输出向下传递到某个管道,或者将其任何部分或全部流重定向到相同的地方。您一般可以通过在某个 Subshell 中运行一个命令列表或通过在当前 Shell 中运行一个命令列表来实现此目的。

在 Subshell 中运行命令列表

使用括号将命令列表包括在单个组中。这样做将在一个新的 Subshell 中运行命令,并允许您重定向或收集整组命令的输出,如以下示例所示:


清单 11. 好习惯 6 的示例:在 Subshell 中运行命令列表
~ $ ( cd tmp/a/b/c/ || mkdir -p tmp/a/b/c && \
> VAR=$PWD; cd ~; tar xvf -C $VAR archive.tar ) \
> | mailx admin -S "Archive contents"

在此示例中,该存档的内容将提取到 tmp/a/b/c/ 目录中,同时将分组命令的输出(包括所提取文件的列表)通过邮件发送到地址 admin

当您在命令列表中重新定义环境变量,并且您不希望将那些定义应用于当前 Shell 时,使用 Subshell 更可取。

在当前 Shell 中运行命令列表

将命令列表用大括号 ({}) 括起来,以在当前 Shell 中运行。确保在括号与实际命令之间包括空格,否则 Shell 可能无法正确解释括号。此外,还要确保列表中的最后一个命令以分号结尾,如以下示例所示:


清单 12. 好习惯 6 的另一个示例:在当前 Shell 中运行命令列表
~ $ { cp ${VAR}a . && chown -R guest.guest a && \
> tar cvf newarchive.tar a; } | mailx admin -S "New archive"





回页首


在 find 之外使用 xargs

使用 xargs 工具作为筛选器,以充分利用从 find 命令挑选的输出。find 运行通常提供与某些条件匹配的文件列表。此列表被传递到 xargs 上,后者然后使用该文件列表作为参数来运行其他某些有用的命令,如以下示例所示:


清单 13. xargs 工具的经典用法示例
~ $ find some-file-criteria some-file-path | \
> xargs some-great-command-that-needs-filename-arguments

然而,不要将 xargs 仅看作是 find 的辅助工具;它是一个未得到充分利用的工具之一,当您养成使用它的习惯时,将会希望进行所有试验,包括以下用法。

传递空格分隔的列表

在最简单的调用形式中,xargs 就像一个筛选器,它接受一个列表(每个成员分别在单独的行上)作为输入。该工具将那些成员放置在单个空格分隔的行上:


清单 14. xargs 工具产生的输出示例
~ $ xargsabcControl-D
a b c
~ $

您可以发送通过 xargs 来输出文件名的任何工具的输出,以便为其他某些接受文件名作为参数的工具获得参数列表,如以下示例所示:


清单 15. xargs 工具的使用示例
~/tmp $ ls -1 | xargs
December_Report.pdf README a archive.tar mkdirhier.sh
~/tmp $ ls -1 | xargs file
December_Report.pdf: PDF document, version 1.3
README: ASCII text
a: directory
archive.tar: POSIX tar archive
mkdirhier.sh: Bourne shell script text executable
~/tmp $

xargs 命令不只用于传递文件名。您还可以在需要将文本筛选到单个行中的任何时候使用它:


清单 16. 好习惯 7 的示例:使用 xargs 工具来将文本筛选到单个行中
~/tmp $ ls -l | xargs
-rw-r--r-- 7 joe joe 12043 Jan 27 20:36 December_Report.pdf -rw-r--r-- 1 \
root root 238 Dec 03 08:19 README drwxr-xr-x 38 joe joe 354082 Nov 02 \
16:07 a -rw-r--r-- 3 joe joe 5096 Dec 14 14:26 archive.tar -rwxr-xr-x 1 \
joe joe 3239 Sep 30 12:40 mkdirhier.sh
~/tmp $

谨慎使用 xargs

从技术上讲,使用 xargs 很少遇到麻烦。缺省情况下,文件结束字符串是下划线 (_);如果将该字符作为单个输入参数来发送,则它之后的所有内容将被忽略。为了防止这种情况发生,可以使用 -e 标志,它在不带参数的情况下完全禁用结束字符串。





回页首


了解何时 grep 应该执行计数——何时应该绕过

避免通过管道将 grep 发送到 wc -l 来对输出行数计数。grep-c 选项提供了对与特定模式匹配的行的计数,并且一般要比通过管道发送到 wc 更快,如以下示例所示:


清单 17. 好习惯 8 的示例:使用和不使用 grep 的行计数
~ $ time grep and tmp/a/longfile.txt | wc -l
2811

real    0m0.097s
user    0m0.006s
sys     0m0.032s
~ $ time grep -c and tmp/a/longfile.txt
2811

real    0m0.013s
user    0m0.006s
sys     0m0.005s
~ $ 

除了速度因素外,-c 选项还是执行计数的好方法。对于多个文件,带 -c 选项的 grep 返回每个文件的单独计数,每行一个计数,而针对 wc 的管道则提供所有文件的组合总计数。

然而,不管是否考虑速度,此示例都表明了另一个要避免地常见错误。这些计数方法仅提供包含匹配模式的行数——如果那就是您要查找的结果,这没什么问题。但是在行中具有某个特定模式的多个实例的情况下,这些方法无法为您提供实际匹配实例数量 的真实计数。归根结底,若要对实例计数,您还是要使用 wc 来计数。首先,使用 -o 选项(如果您的版本支持它的话)来运行 grep 命令。此选项 输出匹配的模式,每行一个模式,而不输出行本身。但是您不能将它与 -c 选项结合使用,因此要使用 wc -l 来对行计数,如以下示例所示:


清单 18. 好习惯 8 的示例:使用 grep 对模式实例计数
~ $ grep -o and tmp/a/longfile.txt | wc -l
3402
~ $

在此例中,调用 wc 要比第二次调用 grep 并插入一个虚拟模式(例如 grep -c)来对行进行匹配和计数稍快一点。





回页首


匹配输出中的某些字段,而不只是对行进行匹配

当您只希望匹配输出行中特定字段 中的模式时,诸如 awk 等工具要优于 grep

下面经过简化的示例演示了如何仅列出 12 月修改过的文件。


清单 19. 坏习惯 9 的示例:使用 grep 来查找特定字段中的模式
~/tmp $ ls -l /tmp/a/b/c | grep Dec
-rw-r--r--  7 joe joe  12043 Jan 27 20:36 December_Report.pdf
-rw-r--r--  1 root root  238 Dec 03 08:19 README
-rw-r--r--  3 joe joe   5096 Dec 14 14:26 archive.tar
~/tmp $

在此示例中,grep 对行进行筛选,并输出其修改日期和名称中带 Dec 的所有文件。因此,诸如 December_Report.pdf 等文件是匹配的,即使它自从一月份以来还未修改过。这可能不是您希望的结果。为了匹配特定字段中的模式,最好使用 awk,其中的一个关系运算符对确切的字段进行匹配,如以下示例所示:


清单 20. 好习惯 9 的示例:使用 awk 来查找特定字段中的模式
~/tmp $ ls -l | awk '$6 == "Dec"'
-rw-r--r--  3 joe joe   5096 Dec 14 14:26 archive.tar
-rw-r--r--  1 root root  238 Dec 03 08:19 README
~/tmp $

有关如何使用 awk 的更多详细信息,请参见参考资料





回页首


停止对 cat 使用管道

grep 的一个常见的基本用法错误是通过管道将 cat 的输出发送到 grep 以搜索单个文件的内容。这绝对是不必要的,纯粹是浪费时间,因为诸如 grep 这样的工具接受文件名作为参数。您根本不需要在这种情况下使用 cat,如以下示例所示:


清单 21. 好习惯和坏习惯 10 的示例:使用带和不带 cat 的 grep
	
~ $ time cat tmp/a/longfile.txt | grep and
2811

real    0m0.015s
user    0m0.003s
sys     0m0.013s
~ $ time grep and tmp/a/longfile.txt
2811

real    0m0.010s
user    0m0.006s
sys     0m0.004s
~ $ 

此错误存在于许多工具中。由于大多数工具都接受使用连字符 (-) 的标准输入作为一个参数,因此即使使用 cat 来分散 stdin 中的多个文件,参数也通常是无效的。仅当您使用带多个筛选选项之一的 cat 时,才真正有必要在管道前首先执行连接。





回页首


结束语:养成好习惯

最好检查一下您的命令行习惯中的任何不良的使用模式。不良的使用模式会降低您的速度,并且通常会导致意外错误。本文介绍了 10 个新习惯,它们可以帮助您摆脱许多最常见的使用错误。养成这些好习惯是加强您的 UNIX 命令行技能的积极步骤。

posted @ 2007-02-12 17:39 SYBIL@BLOGJAVA 阅读(91) | 评论 (0)编辑 收藏

2007年2月4日 #

线程池

100行Java代码构建一个线程池

在现代的操作系统中,有一个很重要的概念――线程,几乎所有目前流行的操作系统都支持线程,线程来源于操作系统中进程的概念,进程有自己的虚拟地址空间以及正文段、数据段及堆栈,而且各自占有不同的系统资源(例如文件、环境变量等等)。与此不同,线程不能单独存在,它依附于进程,只能由进程派生。如果一个进程派生出了两个线程,那这两个线程共享此进程的全局变量和代码段,但每个线程各拥有各自的堆栈,因此它们拥有各自的局部变量,线程在UNIX系统中还被进一步分为用户级线程(由进程自已来管理)和系统级线程(由操作系统的调度程序来管理)。

  既然有了进程,为什么还要提出线程的概念呢?因为与创建一个新的进程相比,创建一个线程将会耗费小得多的系统资源,对于一些小型的应用,可能感觉不到这点,但对于那些并发进程数特别多的应用,使用线程会比使用进程获得更好的性能,从而降低操作系统的负担。另外,线程共享创建它的进程的全局变量,因此线程间的通讯编程会更将简单,完全可以抛弃传统的进程间通讯的IPC编程,而采用共享全局变量来进行线程间通讯。

  有了上面这个概念,我们下面就进入正题,来看一下线程池究竟是怎么一回事?其实线程池的原理很简单,类似于操作系统中的缓冲区的概念,它的流程如下:先启动若干数量的线程,并让这些线程都处于睡眠状态,当客户端有一个新请求时,就会唤醒线程池中的某一个睡眠线程,让它来处理客户端的这个请求,当处理完这个请求后,线程又处于睡眠状态。可能你也许会问:为什么要搞得这么麻烦,如果每当客户端有新的请求时,我就创建一个新的线程不就完了?这也许是个不错的方法,因为它能使得你编写代码相对容易一些,但你却忽略了一个重要的问题――性能!就拿我所在的单位来说,我的单位是一个省级数据大集中的银行网络中心,高峰期每秒的客户端请求并发数超过100,如果为每个客户端请求创建一个新线程的话,那耗费的CPU时间和内存将是惊人的,如果采用一个拥有200个线程的线程池,那将会节约大量的的系统资源,使得更多的CPU时间和内存用来处理实际的商业应用,而不是频繁的线程创建与销毁。

  既然一切都明白了,那我们就开始着手实现一个真正的线程池吧,线程编程可以有多种语言来实现,例如C、C++、java等等,但不同的操作系统提供不同的线程API接口,为了让你能更明白线程池的原理而避免陷入烦琐的API调用之中,我采用了JAVA语言来实现它,由于JAVA语言是一种跨平台的语言,因此你不必为使用不同的操作系统而无法编译运行本程序而苦恼,只要你安装了JDK1.2以上的版本,都能正确地编译运行本程序。另外JAVA语言本身就内置了线程对象,而且JAVA语言是完全面像对象的,因此能够让你更清晰地了解线程池的原理,如果你注意看一下本文的标题,你会发现整个示例程序的代码只有大约100行。

  本示例程序由三个类构成,第一个是TestThreadPool类,它是一个测试程序,用来模拟客户端的请求,当你运行它时,系统首先会显示线程池的初始化信息,然后提示你从键盘上输入字符串,并按下回车键,这时你会发现屏幕上显示信息,告诉你某个线程正在处理你的请求,如果你快速地输入一行行字符串,那么你会发现线程池中不断有线程被唤醒,来处理你的请求,在本例中,我创建了一个拥有10个线程的线程池,如果线程池中没有可用线程了,系统会提示你相应的警告信息,但如果你稍等片刻,那你会发现屏幕上会陆陆续续提示有线程进入了睡眠状态,这时你又可以发送新的请求了。

  第二个类是ThreadPoolManager类,顾名思义,它是一个用于管理线程池的类,它的主要职责是初始化线程池,并为客户端的请求分配不同的线程来进行处理,如果线程池满了,它会对你发出警告信息。

  最后一个类是SimpleThread类,它是Thread类的一个子类,它才真正对客户端的请求进行处理,SimpleThread在示例程序初始化时都处于睡眠状态,但如果它接受到了ThreadPoolManager类发过来的调度信息,则会将自己唤醒,并对请求进行处理。


  首先我们来看一下TestThreadPool类的源码:



//TestThreadPool.java
1 import java.io.*;
2
3
4 public class TestThreadPool
5 {
6 public static void main(String[] args)
7 {
8 try{
9 BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
10 String s;
11 ThreadPoolManager manager = new ThreadPoolManager(10);
12 while((s = br.readLine()) != null)
13 {
14 manager.process(s);
15 }
16 }catch(IOException e){}
17 }
18 }



  由于此测试程序用到了输入输入类,因此第1行导入了JAVA的基本IO处理包,在第11行中,我们创建了一个名为manager的类,它给ThreadPoolManager类的构造函数传递了一个值为10的参数,告诉ThreadPoolManager类:我要一个有10个线程的池,给我创建一个吧!第12行至15行是一个无限循环,它用来等待用户的键入,并将键入的字符串保存在s变量中,并调用ThreadPoolManager类的process方法来将这个请求进行处理。

  下面我们再进一步跟踪到ThreadPoolManager类中去,以下是它的源代码:



//ThreadPoolManager.java
1 import java.util.*;
2
3
4 class ThreadPoolManager
5 {
6
7 private int maxThread;
8 public Vector vector;
9 public void setMaxThread(int threadCount)
10 {
11 maxThread = threadCount;
12 }
13
14 public ThreadPoolManager(int threadCount)
15 {
16 setMaxThread(threadCount);
17 System.out.println("Starting thread pool...");
18 vector = new Vector();
19 for(int i = 1; i <= 10; i++)
20 {
21 SimpleThread thread = new SimpleThread(i);
22 vector.addElement(thread);
23 thread.start();
24 }
25 }
26
27 public void process(String argument)
28 {
29 int i;
30 for(i = 0; i < vector.size(); i++)
31 {
32 SimpleThread currentThread = (SimpleThread)vector.elementAt(i);
33 if(!currentThread.isRunning())
34 {
35 System.out.println("Thread "+ (i+1) +" is processing:" +
argument);
36 currentThread.setArgument(argument);
37 currentThread.setRunning(true);
38 return;
39 }
40 }
41 if(i == vector.size())
42 {
43 System.out.println("pool is full, try in another time.");
44 }
45 }
46 }//end of class ThreadPoolManager



  我们先关注一下这个类的构造函数,然后再看它的process()方法。第16-24行是它的构造函数,首先它给ThreadPoolManager类的成员变量maxThread赋值,maxThread表示用于控制线程池中最大线程的数量。第18行初始化一个数组vector,它用来存放所有的SimpleThread类,这时候就充分体现了JAVA语言的优越性与艺术性:如果你用C语言的话,至少要写100行以上的代码来完成vector的功能,而且C语言数组只能容纳类型统一的基本数据类型,无法容纳对象。好了,闲话少说,第19-24行的循环完成这样一个功能:先创建一个新的SimpleThread类,然后将它放入vector中去,最后用thread.start()来启动这个线程,为什么要用start()方法来启动线程呢?因为这是JAVA语言中所规定的,如果你不用的话,那这些线程将永远得不到激活,从而导致本示例程序根本无法运行。

  下面我们再来看一下process()方法,第30-40行的循环依次从vector数组中选取SimpleThread线程,并检查它是否处于激活状态(所谓激活状态是指此线程是否正在处理客户端的请求),如果处于激活状态的话,那继续查找vector数组的下一项,如果vector数组中所有的线程都处于激活状态的话,那它会打印出一条信息,提示用户稍候再试。相反如果找到了一个睡眠线程的话,那第35-38行会对此进行处理,它先告诉客户端是哪一个线程来处理这个请求,然后将客户端的请求,即字符串argument转发给SimpleThread类的setArgument()方法进行处理,并调用SimpleThread类的setRunning()方法来唤醒当前线程,来对客户端请求进行处理。

  可能你还对setRunning()方法是怎样唤醒线程的有些不明白,那我们现在就进入最后一个类:SimpleThread类,它的源代码如下:

//SimpleThread.java
1 class SimpleThread extends Thread
2 {
3 private boolean runningFlag;
4 private String argument;
5 public boolean isRunning()
6 {
7 return runningFlag;
8 }
9 public synchronized void setRunning(boolean flag)
10 {
11 runningFlag = flag;
12 if(flag)
13 this.notify();
14 }
15
16 public String getArgument()
17 {
18 return this.argument;
19 }
20 public void setArgument(String string)
21 {
22 argument = string;
23 }
24
25 public SimpleThread(int threadNumber)
26 {
27 runningFlag = false;
28 System.out.println("thread " + threadNumber + "started.");
29 }
30
31 public synchronized void run()
32 {
33 try{
34 while(true)
35 {
36 if(!runningFlag)
37 {
38 this.wait();
39 }
40 else
41 {
42 System.out.println("processing " + getArgument() + "... done.");
43 sleep(5000);
44 System.out.println("Thread is sleeping...");
45 setRunning(false);
46 }
47 }
48 } catch(InterruptedException e){
49 System.out.println("Interrupt");
50 }
51 }//end of run()
52 }//end of class SimpleThread

  如果你对JAVA的线程编程有些不太明白的话,那我先在这里简单地讲解一下,JAVA有一个名为Thread的类,如果你要创建一个线程,则必须要从Thread类中继承,并且还要实现Thread类的run()接口,要激活一个线程,必须调用它的start()方法,start()方法会自动调用run()接口,因此用户必须在run()接口中写入自己的应用处理逻辑。那么我们怎么来控制线程的睡眠与唤醒呢?其实很简单,JAVA语言为所有的对象都内置了wait()和notify()方法,当一个线程调用wait()方法时,则线程进入睡眠状态,就像停在了当前代码上了,也不会继续执行它以下的代码了,当调用notify()方法时,则会从调用wait()方法的那行代码继续执行以下的代码,这个过程有点像编译器中的断点调试的概念。以本程序为例,第38行调用了wait()方法,则这个线程就像凝固了一样停在了38行上了,如果我们在第13行进行一个notify()调用的话,那线程会从第38行上唤醒,继续从第39行开始执行以下的代码了。

  通过以上的讲述,我们现在就不难理解SimpleThread类了,第9-14行通过设置一个标志runningFlag激活当前线程,第25-29行是SimpleThread类的构造函数,它用来告诉客户端启动的是第几号进程。第31-50行则是我实现的run()接口,它实际上是一个无限循环,在循环中首先判断一下标志runningFlag,如果没有runningFlag为false的话,那线程处理睡眠状态,否则第42-45行会进行真正的处理:先打印用户键入的字符串,然后睡眠5秒钟,为什么要睡眠5秒钟呢?如果你不加上这句代码的话,由于计算机处理速度远远超过你的键盘输入速度,因此你看到的总是第1号线程来处理你的请求,从而达不到演示效果。最后第45行调用setRunning()方法又将线程置于睡眠状态,等待新请求的到来。

  最后还有一点要注意的是,如果你在一个方法中调用了wait()和notify()函数,那你一定要将此方法置为同步的,即synchronized,否则在编译时会报错,并得到一个莫名其妙的消息:“current thread not owner”(当前线程不是拥有者)。

  至此为止,我们完整地实现了一个线程池,当然,这个线程池只是简单地将客户端输入的字符串打印到了屏幕上,而没有做任何处理,对于一个真正的企业级运用,本例还是远远不够的,例如错误处理、线程的动态调整、性能优化、临界区的处理、客户端报文的定义等等都是值得考虑的问题,但本文的目的仅仅只是让你了解线程池的概念以及它的简单实现,如果你想成为这方面的高手,本文是远远不够的,你应该参考一些更多的资料来深入地了解它。

posted @ 2007-02-04 12:28 SYBIL@BLOGJAVA 阅读(671) | 评论 (0)编辑 收藏

2007年2月2日 #

这就不行了?

for  ( int  i  =   1 ; i  <=   10 ; i ++ {
//                 int i = 7;
            MNPClientThread mnpct  =   new  MNPClientThread(i);

            mnpct.start();
            System.out.println(i);
        }

public  MNPClientThread( int  i)  {
        
this .count  =  i;
    }


    
public   void  run()  {
        
try   {
            
for ( int  i = 1 ;i <= 800000 ;i ++ ) {
                StringBuffer phoneNumber 
=   new  StringBuffer( " 88600 " );
                phoneNumber.append(count);
                phoneNumber.append(
" 0000 " );
                phoneNumber.append(i);
                Thread.sleep(
800 );
//                 System.out.println("****************"+phoneNumber.toString());
                MNPClientTest client  =   new  MNPClientTest();
                client.runTest(phoneNumber.toString());
//             java.util.Date d2 = new java.util.Date();
                System.out.println( " Thread  "   +  count  +   "  Runs " );
//                 System.out.println(new java.util.Date());
//                 System.out.println(i);
            }

        }
  catch  (Exception ex)  {
            ex.printStackTrace();
        }

    }

运行3小时左右,发了不到10Wquery就挂了???
报这个:
Exception in thread "Thread-1" java.lang.OutOfMemoryError: Java heap space

我加了-Xms128m -Xmx800m 还是不行?是内存泄露吗??

posted @ 2007-02-02 15:54 SYBIL@BLOGJAVA 阅读(497) | 评论 (2)编辑 收藏

2007年1月25日 #

links read

ENUM:
http://www.ptsn.net.cn/article_new/show_article.php?article_id=expert_9039d306-6d61-d622-14d5-43c49c788fef

e164:
http://www.mc21st.net/old/faq/reply.asp?ID=7471

IMSI:
http://zhidao.baidu.com/question/7853752.html

http://baike.baidu.com/view/715091.htm

posted @ 2007-01-25 11:59 SYBIL@BLOGJAVA 阅读(161) | 评论 (0)编辑 收藏

2007年1月21日 #

……忘了转正这件事了

一言难尽

posted @ 2007-01-21 13:08 SYBIL@BLOGJAVA 阅读(166) | 评论 (0)编辑 收藏

2007年1月12日 #

第一章 思考题与练习题[原]

第一章    思考题与练习题

 

1. 什么是移动通信?能否说移动通信就是“无线电通信”?为什么?

移动通信是指通信双方或至少有一方在移动中进行信息交换的通信方式。

不能,移动通信是有线、无线相结合的通信方式。

2. 移动通信有哪些特点?存在的问题分别用哪些方法解决?

移动通信是有线、无线相结合的通信方式;电波传播条件恶劣,存在严重的多径衰落;强干扰条件下工作;具有多卜勒效应;存在阴影区(盲区);用户经常移动。

移动台必须体积要小、重量要轻、操作使用要简便安全,另外,其成本要低;在进行移动通信系统的设计时,必须具有一定的抗衰落的能力和储备;移动通信设备必须具有良好的选择性,使用自动功率控制电路,移动通信系统在组网时,必须考虑同频干扰;锁相技术;考虑阴影区在网络规划、设置基站时;位置登记、越区切换及漫游访问等跟踪交换技术。

3. 移动通信常用的工作方式有哪些?公用蜂窝移动电话系统中使用哪些?

单工方式,半双工方式,双工方式。

双工。

4. 什么是小区制?为什么小区制既能解决频道数有限和用户数增大的矛盾,又能不断适应用户数增大的需要?

小区制是将整个服务区划分为若干个小无线区,每个小无线区分别设置一个基站负责本区的移动通信的联络和控制,同时又可在 MSC 的统一控制下,实现小区间移动通信的转接及与市话网的联系。

小区制中,每个小区使用一组频道,邻近小区使用不同的频道。由于小区内基站服务区域缩小,同频复用距离减小,所以在整个服务区中,同一组频道可以多次重复使用,因而大大提高了频率利用率。另外,在区域内可根据用户的多少确定小区的大小。随着用户数目的增加,小区还可以继续划小,即实现“小区分裂”,以适应用户数的增加。因此,小区制解决了大区制中存在的频道数有限而用户数不断增加的矛盾,可使用户容量大大增加。

5. 无线区域的划分为什么采用正六边形小区形状?正六边形无线区群构成应满足什么条件?

假定整个服务区的地形地物相同,并且基站采用全向天线,覆盖面积大体上上一个圆,即无线小区是圆形的。由考虑到多个小区彼此邻接来覆盖整个区域,用圆内接正多边形代替圆。圆内接正多边形彼此邻接构成平面时,只能是正三角形、正方形和正六边形三种面状区域。正六边形,其相邻小区的中心距离最小,便于实现跟踪交换;其覆盖面积最大,对于同样大小的服务区域,采用正六边形构成小区制所需的小区数最少,即所需基站数最少;所需的频率个数最少,频率利用率高。

满足以下两个条件:一是若干单位无线区群能彼此邻接;二是相邻单位无线区群中的同频小区中心间隔相等。

6. 什么是多信道共用?有何优点?

多信道共用是指在网内的大量用户共同享有若干无线信道,这与市话用户共同享有中继线相类似。相对于独立信道方式来说,可以显著提高信道利用率。

7. 大容量的移动通信系统采用何种信道选择方式?有什么优缺点?

专用呼叫信道方式。

处理一次呼叫过程所需的时间很短,所以设立一个专用呼叫信道就可以处理成百上千个用户的呼叫,适用于大容量系统中;由于专门抽出一个信道作呼叫信道,相对而言,减少了通话信道的数目,因此对小容量系统来说,是不合算的。

8. 若需设计一移动通信系统,用户容量要求为 600 户,每天每个用户平均呼叫 5 次,每次平均占用信道时间为 60 秒,呼损率要求为 10% ,忙时击中率为 0.125 ,问需要多少信道才能满足 600 个用户的需要?

A/A 用户 =600

A 用户 =CTK/3600=5*60*0.125=37.5/3600

A=6.25

查表得: 9

9. 话务量是怎样定义的?什么是呼损率?呼损率与接通话务量的关系如何?

单位时间( 1 小时)内呼叫次数与每次呼叫的平均占用信道时间之积。

当多个信道共用时,通常总是用户数大于信道数,当多个用户同时要求服务而信道数不够时,只能让一部分用户先通话,另一部分用户等信道空闲时在通话。后一部分用户因无空闲信道而不能通话,即为呼叫失败,简称呼损。在一个通信系统中,造成呼叫失败的概率称为呼叫损失概率,简称呼损率。

呼损率为呼叫失败的次数与总呼叫次数之百分比。

10.              爱尔兰呼损表应用的条件是什么?已知 A 用户 =0.02Erl/ 用户,如果要求呼损率为 10% ,现有 70 个用户,需共用的频道数为多少?如果 920 个用户共用 18 个频道,那么呼损率是多少?

每次呼叫相对独立,互不相关,即呼叫具有随机性,也就是说,一个用户要求通话的概率与正在通话的用户数无关;每次呼叫在时间上都有相同的概率。

A/n=70*0.02/n, A=1.4, 查表得 n=4

A/n=920*0.02/n, A=18.4, 查表得呼损率为 20%

11.              如何提高频率利用

频率复用、频率协调和频率规划

12.              系统对移动交换机有哪些特殊要求?

用户数据的存储;用户位置的登记;寻呼用户的信令系统识别及处理;越区频道转换的处理;过荷控制;远距离档案存取;路由的控制等。

13.              什么是位置登记、一齐呼叫、越区切换、漫游?

位置登记是指移动台向基站发送报文,表明自己所处的位置的过程。

若位置信息表明被呼移动用户在某个位置区,但不知其所处的具体小区,因此,位置区内所有基站一齐呼出被呼移动用户识别码,被叫移动用户应答后,即由应答小区提供接续服务,系统的这种功能称为“一齐呼叫”。

为了保证通信的连续性,正在通话的移动台从一个小区进入相邻的另一小区时,工作频道从一个无限频道上转换到另一个无限频道上,而通话不中断,这就是越区切换。

在联网的移动通信系统中,移动台从一个 MSC 区到另一个 MSC 区后,仍能入网使用的通信服务功能称为漫游。

posted @ 2007-01-12 18:51 SYBIL@BLOGJAVA 阅读(884) | 评论 (0)编辑 收藏

2007年1月9日 #

junt 4&static import

JUnit 4:
http://www.ibm.com/developerworks/cn/java/j-junit4.html

逐渐挖掘Static Import
更简单的访问静态成员
http://blog.csdn.net/avius/archive/2004/08/27/86744.aspx

posted @ 2007-01-09 18:02 SYBIL@BLOGJAVA 阅读(186) | 评论 (0)编辑 收藏

2007年1月6日 #

说说希望……

    《妙手人心3》,廖碧儿和一脑科医生刚刚做医生,看到急症室一病人无论如何也抢救不过来,一阵唏嘘……林保仪走过去,问他们做医生是为了什么?两个小医生说是救死扶伤……林否定,说人的生命不是医生能够掌握的,你们不必耿耿于怀。随后,两人问林,那你为什么要做医生?林答:希望,给病人希望……
    另:……这个省略号以前一直不知道是怎么打出来的,刚看韩寒的blog有说,终于学会了!原来他也不会,哈哈……再也不用。。。。。。了
    记住了是谢夫特加6哦^^

posted @ 2007-01-06 23:54 SYBIL@BLOGJAVA 阅读(180) | 评论 (1)编辑 收藏

2007年1月5日 #

JUnit使用经验(1)(2)(3)

http://www.z6688.com/info/27393-1.htm

http://www.z6688.com/info/27394-1.htm

http://www.z6688.com/info/27392-1.htm

比较有用的是测试执行顺序那锅和不必写捕获异常的那锅。

posted @ 2007-01-05 17:01 SYBIL@BLOGJAVA 阅读(750) | 评论 (1)编辑 收藏

仅列出标题  下一页