亚洲高清中文字幕,午夜男人视频在线观看,久久亚洲精华国产精华液

杂谈架构和架构设计师

Mon, 19 Dec 2005 03:08:00 GMT

     �pȝ��架构通俗的说��h��是�pȝ��的结构组�l�方�?原则上说, 架构只有好坏之分,而不存在有无的问�? 软�g的体�p�L��构可以直接体��Cؓ代码的类�l�构, 也可以表��Cؓ文��性的�~�码规范和全局�U�定�{? 如果软�g架构中能够抽象出一些稳定的元素, 那我们就可能得到一些所谓的框架代码. 一般业务架构是很难重用�? 目前常见的框架代码所描述的多半是与业务无关的技术架�?

    良好的系�l�架构应该体现出应用本��n的结构要�? 所谓各个�ؓ自己, 架构为大�? 只要各个局部符合规�? 应该由架构负责在合适的时刻按照合适的方式把它们组装在一�? 一个良好的架构�? 应该很少出现�l�构性的if语句, 不需要应用代码自己通过动态判断来定义某个�Ҏ(gu��)��的触发时�? 架构是一�U�规�? 当然也就是一�U�局�? 架构的可退化性是非常重要�? 否则一旦出现抽象泄�? 需要超出原有架构设计做出编码补充的时�? 往往无法��代码自然的融入原有的框架结�? 则整个框架出现大面积的失效情�? 而有的时候更�p�糕的情冉|��一些关键性的资源处在原有技术架构的�U�有控制之中, 我们��Z��克服架构限制不得不采用各�U�trick来hack原有框架, 造成错误的篏加和传播, 而补丁的补丁是最隄��护的.

    架构问题�q�不是一成不变的. 在一些情形下无关紧要的问题在另一�U�情形下可能会成为灾难性的架构问题. 例如在多层B/S架构�? 如果现在要求为每一个表增加一个对应的历史�? �q�对其进行查看和�l�护操作. ��Z��最大限度的重用代码, �q�要求我们的多层�l�构中的每一层都能够参数�? �q�样我们才能用同��L(f��ng)��代码处理不同的数据表. 如果我们的money很��, ��弟够多, 有��够的人月�怸��? 那么我们完全可以把业务表和历史表分开处理, 但如果反�?我们��׃��遇到一个典型的架构问题.

    架构师未必有自己的框�? 因�ؓ设计不等价于创�? 架构师只要知道如何把�pȝ��中的各种元素按照可行的方式组装在一起就可以�? 但是一个架构设计是非常依赖于我们所能采用的技术手�D늚�, 当现有各�U�可用的技术元素都无法满��我们的需求的时�? 某些架构师可能会选择创造一�U�技术元�? 当然, 创造是艰难�? 它所要求的甚��x��不同的技�? Sun的Green��目创造了java语言, 从而开启了一个伟大的时代, �q�绝对不会是大多数架构设计师的选择(有趣的是,Green��目本��n��p�|�?. EJB现在�q�有多少人在真正使用, ��x��当年多少架构师在吹嘘�q�些东西. 他们对于技术的把握真的��那么幼�E�吗? 架构设计�q�不是凭�I�出现的, 当时可选的东西��是如此, 而spring和hibernate�q�些都不属于架构设计本��n的内�?它们是一�U�创�?

    架构师未必是团队的领��D�? ��实,他的工作�c�M��于编�? 负责执行的一般是导演. 事实�?一个徏�{�设计师是极��直接领��g��个工�E�队�?架构师也未必比高�U�程序员要高�? 他们负责的是不同的内�? 至于产品�?商标及商标的相关元素"�?技术市场架�?�{�也不属于架构师的工作范�? 他不能去抢��品经理的饭碗. 当然,在国内的现实情况�? 很多所谓的架构师所做的最重要的工作可能是公关工作, 向客��L(f��ng)��出所谓的理念, 与实际开发是不搭嘎的.

    理论上说, 架构师可以不是编�E�的��? 也可以不军_��一些具体数据结构的选择, 但他不能不了解各�U�技术抉择潜在的影响. �q�就如同一个徏�{�设计师可以不精通工�E�力�?但是他不能愚蠢到藐视重力, 设计出倒三角式的大�? 与徏�{�不同的�? 在��Y件中我们所面��(f��)的不是一�U?凝固的艺�?, 我们无法以完全静态的方式理解代码,而必��d��头脑中把它们�q�行��h��. 架构师应该写下一些实际的代码, 以检验各个接口的可配合性�ƈ获得对于代码�l�构的直接感�? 实际�? 按照现在软�g业的成熟�? 一般我们无法实现徏�{�中建筑设计师与土木工程师的分工, 很多时候��Y件架构师都需要直接面对实现的�l�节. 如果�l�内�~�Z��非常强�?zh��n)�的coder, 有编�E�能力的架构师亲自操刀实现关键性代码的时候也是很多的.

    架构师必��L��l�验, 但他所依赖的不能只是经�? 只要��一��架构师的年�U? ��׃��知道以他们在�q�个世界上的存在旉��, �q�不��以使得他们�l�历各种技术细�? 架构设计更多的是依赖我们对于�pȝ��l�构原理的理�? 而经验可以让我们规避那些原理失效的地�?例如�pȝ��U�bug). 君子非异能也, 善假于物�? 很多时�?我们更应该从有经验的朋友或者技术支持那里搜集技术细�? 以确保它们能够满��x��们在架构上的原理性需�? Know Why而不仅仅是Know How是非帔R��要的. 一个农民发明家也许可以得到某个巧妙的机械设�? 但是没有�pȝ��的掌握工�E�力�? 他们是无法去开发精密的导弹控制�pȝ��?当然, 软�g开发还处在非常原始的阶�D? 掌握一些设计原理和设计模式多半也不�q�是五十步笑百步而已, �l�验的地位是无可替代�?

    架构师不是预�a��? 在多变的业务环境�? 架构师的目标不应该是预测到所有的变化可能, �q�把它们表达到系�l�架构中. �q�个世界上不乏一些耗资数十�?设计三四�q?但最�l�每个谈到它的�h都要说一句shit的��品开发项�? 架构设计所能做到的最好的�E�度是自然的标注出系�l�的�l�构边界,成功的delay各种技术抉�?

    架构师不是超�? 他所考虑的东西也许要�q�一�? 所需要��^衡的利益也许要多一�? 但是单独一个�h是无法对整个产品或者项目的成��|负责�? 如果ThoughtWorks的Martin Follower来处理国内的某些��目, 我估计他会死得很隄��.架构师也是�h, 也会犯错�?甚至是很低��的错�? 而每个�h都会有一些独特的��x��. �l�历的多�? 你就会回归到�l�极的认�? 一切都只是��云, 只有money才是��道�?

2005-12-18 17:35 作�? canonical 【评�?3�?/FONT>【阅�?97�?/P>

只牵�q�只�?/a> 2005-12-19 11:08 发表评论

�_�֍�:Rundll32.exe文�g详解

Thu, 15 Dec 2005 04:04:00 GMT

winexec(Pchar('StrCommand'),sw_Show);
其中"StrCommand"代表以下命��o之一(使用Windows中的�q�行不要加引�?�Q?
"rundll32 shell32,Control_RunDLL" - �q�行控制面板
"rundll32 shell32,OpenAs_RunDLL" - 打开"打开方式"�H�口
"rundll32 shell32,ShellAboutA Info-Box" - 打开"关于"�H�口
"rundll32 shell32,Control_RunDLL desk.cpl" - 打开"昄��属�?�H�口
"rundll32 user,cascadechildwindows" - 层叠全部�H�口
"rundll32 user,tilechildwindows" - 最��化所有的子窗�?
"rundll32 user,repaintscreen" - ��h��桌面
"rundll32 shell,shellexecute Explorer" - 重新�q�行W(xu��)indows Explorer
"rundll32 keyboard,disable" - 锁写键盘
"rundll32 mouse,disable" - 让鼠标失�?
"rundll32 user,swapmousebutton" - 交换鼠标按钮
"rundll32 user,setcursorpos" - 讄��鼠标位置�?0,0)
"rundll32 user,wnetconnectdialog" - 打开"映射�|�络驱动�?�H�口
"rundll32 user,wnetdisconnectdialog" - 打开"断开�|�络驱动�?�H�口
"rundll32 user,disableoemlayer" - 昄��BSOD�H�口, (BSOD) = Blue Screen Of
Death, 卌��?
"rundll32 diskcopy,DiskCopyRunDll" - 打开��盘复制�H�口
"rundll32 rnaui.dll,RnaWizard" - �q�行"Internet�q�接向导",
如果加上参数"/1"则�ؓsilent模式
"rundll32 shell32,SHFormatDrive" - 打开"格式化磁�?A)"�H�口
"rundll32 shell32,SHExitWindowsEx -1" - 冷启动Windows Explorer
"rundll32 shell32,SHExitWindowsEx 1" - ��x��
"rundll32 shell32,SHExitWindowsEx 0" - 退当前用户
"rundll32 shell32,SHExitWindowsEx 2" Windows9x 快速重�?
"rundll32 krnl386.exe,exitkernel" - ��退出Windows 9x(无确�?
"rundll rnaui.dll,RnaDial "MyConnect" - �q�行"�|�络�q�接"对话�?
"rundll32 msprint2.dll,RUNDLL_PrintTestPage" - 选择打印机和打印��试��?
"rundll32 user,setcaretblinktime" - 讄��光标闪烁速度
"rundll32 user, setdoubleclicktime" - ��试鼠标双击速度
"rundll32 sysdm.cpl,InstallDevice_Rundll" - 搜烦非PnP讑֤�
　控制面板中的各项功能

　winexec('rundll32.exe shell32.dll, Control_RunDLL', 9);
　{辅助选项属�?键盘}
　winexec('rundll32.exe shell32.dll, Control_RunDLL access.cpl, 1', 9);
　{辅助选项属�?声音}
　winexec('rundll32.exe shell32.dll, Control_RunDLL access.cpl, 2', 9);
　{辅助选项属�?昄��}
　winexec('rundll32.exe shell32.dll, Control_RunDLL access.cpl, 3', 9);
　{辅助选项属�?鼠标}
　winexec('rundll32.exe shell32.dll, Control_RunDLL access.cpl, 4', 9);
　{辅助选项属�?常规}
　winexec('rundll32.exe shell32.dll, Control_RunDLL access.cpl, 5', 9);
　{��d��/删除�E�序属�?安装/卸蝲}
　winexec('rundll32.exe shell32.dll, Control_RunDLL Appwiz.cpl, 1', 9);
　{��d��/删除�E�序属�?Windows安装�E�序}
　winexec('rundll32.exe shell32.dll, Control_RunDLL Appwiz.cpl, 2', 9);
　{��d��/删除�E�序属�?启动盘}
　winexec('rundll32.exe shell32.dll, Control_RunDLL Appwiz.cpl, 3', 9);
　{昄�� 属�?背景}
　winexec('rundll32.exe shell32.dll, Control_RunDLL desk.cpl, 0', 9);　
　{昄�� 属�?屏幕保护�E�序}
　winexec('rundll32.exe shell32.dll, Control_RunDLL desk.cpl, 1', 9);
　{昄�� 属�?外观}
　winexec('rundll32.exe shell32.dll, Control_RunDLL desk.cpl, 2', 9);
　{昄�� 属�?讄��}
　winexec('rundll32.exe shell32.dll, Control_RunDLL desk.cpl, 3', 9);
　{Internet 属�?常规}
　winexec('rundll32.exe shell32.dll, Control_RunDLL Inetcpl.cpl, 0',
9);
　{Internet 属�?安全}
　winexec('rundll32.exe shell32.dll, Control_RunDLL Inetcpl.cpl, 1',
9);
　{Internet 属�?内容}
　winexec('rundll32.exe shell32.dll, Control_RunDLL Inetcpl.cpl, 2',
9);
　{Internet 属�?�q�接}
　winexec('rundll32.exe shell32.dll, Control_RunDLL Inetcpl.cpl, 3',
9);
　{Internet 属�?�E�序}
　winexec('rundll32.exe shell32.dll, Control_RunDLL Inetcpl.cpl, 4',
9);
　{Internet 属�?高��}
　winexec('rundll32.exe shell32.dll, Control_RunDLL Inetcpl.cpl, 5',
9);
　{区域讄�� 属�?区域讄��}
　winexec('rundll32.exe shell32.dll, Control_RunDLL Intl.cpl, 0', 9);
　{区域讄�� 属�?数字}
　winexec('rundll32.exe shell32.dll, Control_RunDLL Intl.cpl, 1', 9);
　{区域讄�� 属�?货币}
　winexec('rundll32.exe shell32.dll, Control_RunDLL Intl.cpl, 2', 9);
　{区域讄�� 属�?旉��}
　winexec('rundll32.exe shell32.dll, Control_RunDLL Intl.cpl, 3', 9);
　{区域讄�� 属�?日期}
　winexec('rundll32.exe shell32.dll, Control_RunDLL Intl.cpl, 4', 9);
　
　winexec('rundll32.exe shell32.dll, Control_RunDLL Joy.cpl, 0', 9);

winexec('rundll32.exe shell32.dll, Control_RunDLL Joy.cpl, 1', 9);
　{鼠标属性}
　winexec('rundll32.exe shell32.dll, Control_RunDLL Main.cpl', 9);
　{多媒�?属�?音频}
　winexec('rundll32.exe shell32.dll, Control_RunDLL Mmsys.cpl, 0', 9);
　{多媒�?属�?视频}
　winexec('rundll32.exe shell32.dll, Control_RunDLL Mmsys.cpl, 1', 9);
　{多媒�?属�?MIDI}
　winexec('rundll32.exe shell32.dll, Control_RunDLL Mmsys.cpl, 2', 9);
　{多媒�?属�?CD音乐}
　winexec('rundll32.exe shell32.dll, Control_RunDLL Mmsys.cpl, 3', 9);
　{多媒�?属�?讑֤�}
　winexec('rundll32.exe shell32.dll, Control_RunDLL Mmsys.cpl, 4', 9);
　{调制解调�?属性}
　winexec('rundll32.exe shell32.dll, Control_RunDLL Modem.cpl', 9);
　
　winexec('rundll32.exe shell32.dll, Control_RunDLL Netcpl.cpl', 9);
　{密码属性}
　winexec('rundll32.exe shell32.dll, Control_RunDLL Password.cpl', 9);
　{扫描仪与数字相机属性}
　winexec('rundll32.exe shell32.dll, Control_RunDLL Sticpl.cpl', 9);
　{�pȝ�� 属�?常规}
　winexec('rundll32.exe shell32.dll, Control_RunDLL Sysdm.cpl, 0', 9);
　{�pȝ�� 属�?讑֤��理器}
　winexec('rundll32.exe shell32.dll, Control_RunDLL Sysdm.cpl, 1', 9);
　{�pȝ�� 属�?��g配置文�g}
　winexec('rundll32.exe shell32.dll, Control_RunDLL Sysdm.cpl, 2', 9);
　{�pȝ�� 属�?性能}
　winexec('rundll32.exe shell32.dll, Control_RunDLL Sysdm.cpl, 3', 9);
　{日期/旉�� 属性}
　winexec('rundll32.exe shell32.dll, Control_RunDLL timedate.cpl', 9);
　{甉|��理属性}
　winexec('rundll32.exe shell32.dll, Control_RunDLL Powercfg.cpl', 9);
　
　winexec('rundll32.exe shell32.dll, Control_RunDLL Telephon.cpl', 9);
关于调用后的判断处理��Q?
先声明一个cardinal�c�d��的变量RtnCardinal获取�q�回��D��行判断如�Q?
RtnCardinal := winexec('rundll32.exe shell32.dll, Control_RunDLL
Telephon.cpl', 9);
　�q�回�?可能原因
　0 �E�序��出内存　
ERROR_BAD_FORMAT �E�序��Z��个非法的Win32.EXE�E�序
ERROR_FILE_NOT_FOUND 指定文�g没找到　
ERROR_PATH_NOT_FOUND 指定路径没找�?

使用�Ҏ(gu��)��Q?
点击“开始－�E�式�Q�Ms�Q�Dos方式”，�q�入Dos视窗�Q�然後键�?rundll32.exe
user.exe,restartwindows"�Q�再按下回�R键，�q�时你将看到�Q�机器被重启了！怎么��P��是不是很有趣�Q?
　　当然�Q�Rundll的功能绝不仅仅是重启你的机器。其实，Rundll者，��֐�思义�Q�执行Dll也，它的功能��是以命令列的方式呼叫Windows的动态链�l�库�Q�Rundll32.exe与Rundll.exe的区别就在於前者是呼叫32位的铄��库，而後者是�q�用�?6位的铄��库，它们的命令格式是�Q?
　　RUNDLL.EXE �Q�，
　　�q�里要注意三点：1.Dll��案名中不能含有�I�格�Q�比如该��案位於c:Program
Files目录�Q�你要把�q�个路径�Ҏ(gu��)��c:Progra�?�Q?.Dll档案名与Dll入口炚w��的逗号不能��，否则�E�式��出错�ƈ且不会给��Z�Q何资讯！3.�q�是最重要的一点：Rundll不能用来呼叫含返回值参数的Dll�Q�例如Win32API中的GetUserName(),GetTextFace()�{�。在Visual
Basic中，提供了一条执行外部程式的指��oShell,格式为：
　　Shell “命令列�?
　　如果能配合Rundll32.exe用好Shell指��o�Q�会使�?zh��n)�的VB�E�式拥有用其他方法难以甚��x��法实现的效果�Q�仍以重启�ؓ例，传统的方法需要你在VB工程中先建立一个模�l�，然後写入WinAPI的声明，最後才能在�E�式中呼叫。而现在只需一�?
　　Shell “rundll32.exe
user.exe,restartwindows”就搞定了！是不是方便多了？
　　实际上，Rundll32.exe在呼叫各�U�Windows控制面板和系�l�选项斚w��有著独特的优�ѝ��下面，我就��本人在因特�|�上攉��的有关Rundll的指令列丑֦�下（很有用的�Q�能省去你很多呼叫Windows
API的时��_��Q�）�Q�供大家在程式设计中引用�Q?
　　命��o�? rundll32.exe shell32.dll,Control_RunDLL
　　功能: 昄��控制面板
　　命��o�? rundll32.exe shell32.dll,Control_RunDLL access.cpl,,1
　　功能: 昄��“控刉��板－辅助选项�Q�键盘”选项视窗
　　命��o�? rundll32.exe shell32.dll,Control_RunDLL access.cpl,,2
　　功能: 昄��“控刉��板－辅助选项�Q�声音”选项视窗
　　命��o�? rundll32.exe shell32.dll,Control_RunDLL access.cpl,,3
　　功能: 昄��“控刉��板－辅助选项�Q�显�C�”选项视窗
　　命��o�? rundll32.exe shell32.dll,Control_RunDLL access.cpl,,4
　　功能: 昄��“控刉��板－辅助选项�Q�滑鼠”选项视窗
　　命��o�? rundll32.exe shell32.dll,Control_RunDLL access.cpl,,5
　　功能: 昄��“控刉��板－辅助选项�Q�传�l�”选项视窗
　　命��o�? rundll32.exe shell32.dll,Control_RunDLL sysdm.cpl @1
　　功能: 执行“控刉��板－��d��新硬体”向对{�?
　　命��o�? rundll32.exe shell32.dll,SHHelpShortcuts_RunDLL AddPrinter
　　功能: 执行“控刉��板－��d��新印表机”向对{�?
　　命��o�? rundll32.exe shell32.dll,Control_RunDLL appwiz.cpl,,1
　　功能: 昄�� “控刉��板－��d��/删除�E�式�Q�安�?卸蝲�?面板�?
　　命��o�? rundll32.exe shell32.dll,Control_RunDLL appwiz.cpl,,2
　　功能: 昄�� “控刉��板－��d��/删除�E�式�Q�安装Windows�?面板�?
　　命��o�? rundll32.exe shell32.dll,Control_RunDLL appwiz.cpl,,3
　　功能: 昄�� “控刉��板－��d��/删除�E�式�Q�启动盘�?面板�?
　　命��o�? rundll32.exe syncui.dll,Briefcase_Create
　　功能: 在桌面上建立一个新的“我的公文包”�?
　　命��o�? rundll32.exe diskcopy.dll,DiskCopyRunDll
　　功能: 昄��复制软碟视窗
　　命��o�? rundll32.exe apwiz.cpl,NewLinkHere �Q?
　　功能:
昄��“徏立快��h��式”的对话框，所建立的快��h��式的位置由％1参数军_��?
　　命��o�? rundll32.exe shell32.dll,Control_RunDLL timedate.cpl,,0
　　功能: 昄��“日期与旉��”选项视窗�?

命��o�? rundll32.exe shell32.dll,Control_RunDLL timedate.cpl,,1
　　功能: 昄��“时区”选项视窗�?
　　命��o�? rundll32.exe rnaui.dll,RnaDial [某个拨号�q�接的名�U�]
　　功能:
昄��某个拨号�q�接的拨可��H�。如果已�l�拨可��接，则显�C�目前的�q�接状态的视窗�?
　　命��o�? rundll32.exe rnaui.dll,RnaWizard
　　功能: 昄��“新建拨可��接”向导的视窗�?
　　命��o�? rundll32.exe shell32.dll,Control_RunDLL desk.cpl,,0
　　功能: 昄��“显�C�属性－背景”选项视窗�?
　　命��o�? rundll32.exe shell32.dll,Control_RunDLL desk.cpl,,1
　　功能: 昄��“显�C�属性－萤屏保护”选项视窗�?
　　命��o�? rundll32.exe shell32.dll,Control_RunDLL desk.cpl,,2
　　功能: 昄��“显�C�属性－外观”选项视窗�?
　　命��o�? rundll32.exe shell32.dll,Control_RunDLL desk.cpl,,3
　　功能: 昄��昄��“显�C�属性－属性”选项视窗�?
　　命��o�? rundll32.exe shell32.dll,SHHelpShortcuts_RunDLL FontsFolder
　　功能: 昄��Windows的“字体”��案夹�?
　　命��o�? rundll32.exe shell32.dll,Control_RunDLL main.cpl @3
　　功能: 同样是显�C�Windows的“字体”��案夹�?
　　命��o�? rundll32.exe shell32.dll,SHformatDrive
　　功能: 昄��格式化��Y��对话框�?
　　命��o�? rundll32.exe shell32.dll,Control_RunDLL joy.cpl,,0
　　功能: 昄��“控刉��板－游戏控制器－一般”选项视窗�?
　　命��o�? rundll32.exe shell32.dll,Control_RunDLL joy.cpl,,1
　　功能: 昄��“控刉��板－游戏控制器－�q�阶”选项视窗�?
　　命��o�? rundll32.exe mshtml.dll,PrintHTML (HTML文档)
　　功能: 列印HTML文��?
　　命��o�? rundll32.exe shell32.dll,Control_RunDLL mlcfg32.cpl
　　功能: 昄��Microsoft Exchange一般选项视窗�?
　　命��o�? rundll32.exe shell32.dll,Control_RunDLL main.cpl @0
　　功能: 昄��“控刉��板－滑鼠�?选项 �?
　　命��o�? rundll32.exe shell32.dll,Control_RunDLL main.cpl @1
　　功能: 昄�� “控刉��板－键盘属性－速度”选项视窗�?
　　命��o�? rundll32.exe shell32.dll,Control_RunDLL main.cpl @1,,1
　　功能: 昄�� “控刉��板－键盘属性－语言”选项视窗�?
　　命��o�? rundll32.exe shell32.dll,Control_RunDLL main.cpl @2
　　功能: 昄��Windows“印表机”档案夹�?
　　命��o�? rundll32.exe shell32.dll,Control_RunDLL main.cpl @3
　　功能: 昄��Windows“字体”��案夹�?
　　命��o�? rundll32.exe shell32.dll,Control_RunDLL main.cpl @4
　　功能: 昄��“控刉��板－输入法属性－输入法”选项视窗�?
　　命��o�? rundll32.exe shell32.dll,Control_RunDLL modem.cpl,,add
　　功能: 执行“添加新调制解调器”向对{�?
　　命��o�? rundll32.exe shell32.dll,Control_RunDLL mmsys.cpl,,0
　　功能: 昄��“控刉��板－多媒体属性－音频”属性页�?
　　命��o�? rundll32.exe shell32.dll,Control_RunDLL mmsys.cpl,,1
　　功能: 昄��“控刉��板－多媒体属性－视频”属性页�?
　　命��o�? rundll32.exe shell32.dll,Control_RunDLL mmsys.cpl,,2
　　功能: 昄��“控刉��板－多媒体属性－MIDI”属性页�?
　　命��o�? rundll32.exe shell32.dll,Control_RunDLL mmsys.cpl,,3
　　功能: 昄��“控刉��板－多媒体属性－CD音乐”属性页�?
　　命��o�? rundll32.exe shell32.dll,Control_RunDLL mmsys.cpl,,4
　　功能: 昄��“控刉��板－多媒体属性－讑֤�”属性页�?
　　命��o�? rundll32.exe shell32.dll,Control_RunDLL mmsys.cpl @1
　　功能: 昄��“控刉��板－声音”选项视窗�?
　　命��o�? rundll32.exe shell32.dll,Control_RunDLL netcpl.cpl
　　功能: 昄��“控刉��板－�|��\”选项视窗�?
　　命��o�? rundll32.exe shell32.dll,Control_RunDLL odbccp32.cpl
　　功能: 昄��ODBC32资料��理选项视窗�?
　　命��o�? rundll32.exe shell32.dll,OpenAs_RunDLL
功能: 昄��指定��案(drive:pathfilename)的“打开方式”对话框�?
　　命��o�? rundll32.exe shell32.dll,Control_RunDLL password.cpl
　　功能: 昄��“控刉��板－密码”选项视窗�?
　　命��o�? rundll32.exe shell32.dll,Control_RunDLL powercfg.cpl
　　功能: 昄��“控刉��板－甉|��理属性”选项视窗�?
　　命��o�? rundll32.exe shell32.dll,SHHelpShortcuts_RunDLL
PrintersFolder
　　功能: 昄��Windows“印表机”��案夹�?同rundll32.exe
shell32.dll,Control_RunDLL main.cpl @2)
　　命��o�? rundll32.exe shell32.dll,Control_RunDLL intl.cpl,,0
　　功能: 昄��“控刉��板－区域讄��属性－区域讄��”选项视窗�?
　　命��o�? rundll32.exe shell32.dll,Control_RunDLL intl.cpl,,1
　　功能: 昄��“控刉��板－区域讄��属性－数字”选项视窗�?
　　命��o�? rundll32.exe shell32.dll,Control_RunDLL intl.cpl,,2
　　功能: 昄��“控刉��板－区域讄��属性－货币”选项视窗�?
　　命��o�? rundll32.exe shell32.dll,Control_RunDLL intl.cpl,,3
　　功能: 昄��“控刉��板－区域讄��属性－旉��”选项视窗�?
　　命��o�? rundll32.exe shell32.dll,Control_RunDLL intl.cpl,,4
　　功能: 昄��“控刉��板－区域讄��属性－日期”选项视窗�?
　　命��o�? rundll32.exe desk.cpl,InstallScreenSaver [萤屏保护档案名]
　　功能:
��指定的萤屏保护��案讄��为Windows的屏保，�q�显�C��屏保护属性视�H��?
　　命��o�? rundll32.exe shell32.dll,Control_RunDLL sysdm.cpl,,0
　　功能: 昄��“控刉��板－�pȝ��属性－传统”属性视�H��?
　　命��o�? rundll32.exe shell32.dll,Control_RunDLL sysdm.cpl,,1
　　功能: 昄��“控刉��板－�pȝ��属性－讑֤��理器”属性视�H��?
　　命��o�? rundll32.exe shell32.dll,Control_RunDLL sysdm.cpl,,2
　　功能: 昄��“控刉��板－�pȝ��属性－��体配置��案”属性视�H��?
　　命��o�? rundll32.exe shell32.dll,Control_RunDLL sysdm.cpl,,3
　　功能: 昄��“控刉��板－�pȝ��属性－性能”属性视�H��?
　　命��o�? rundll32.exe user.exe,restartwindows
　　功能: ��关闭所有程式�ƈ重启机器�?
　　命��o�? rundll32.exe user.exe,exitwindows
　　功能: ��关闭所有程式�ƈ��x��?
　　命��o�? rundll32.exe shell32.dll,Control_RunDLL telephon.cpl
　　功能: 昄��“拨号属性”选项视窗
　　命��o�? rundll32.exe shell32.dll,Control_RunDLL themes.cpl
　　功能: 昄��“桌面主旨”选项面板
　　当然�Q�不止是VisualBasic�Q�象Delphi.VisualC�Q�＋�{�其他程式设计语�a�也可以通过呼叫外部命��o的方法来使用Rundll的这些功能，具体�Ҏ(gu��)��q�里��׃��再详�l�叙�q�C��。灵�zȝ��使用Rundll,一定会使你的程式设计轻��L��松，辑ֈ�事半功倍的效果

只牵�q�只�?/a> 2005-12-15 12:04 发表评论

Wed, 14 Dec 2005 00:54:00 GMT

java多线�E�设计模�?

java语言已经内置了多�U�程支持�Q�所有实现Runnable接口的类都可被启动一个新�U�程�Q�新�U�程会执行该实例的run()�Ҏ(gu��)��Q�当run()�Ҏ(gu��)��执行完毕后，�U�程��q��束了。一旦一个线�E�执行完毕，�q�个实例��׃��能再重新启动�Q�只能重新生成一个新实例�Q�再启动一个新�U�程�?/P>

Thread�c�L��实现了Runnable接口的一个实例，它代表一个线�E�的实例�Q��ƈ且，启动�U�程的唯一�Ҏ(gu��)��是通过Thread�cȝ��start()实例�Ҏ(gu��)��Q?/P>

Thread t = new Thread();
t.start();

start()�Ҏ(gu��)��是一个native�Ҏ(gu��)��Q�它?y��u)��启动一个新�U�程�Q��ƈ执行run()�Ҏ(gu��)��。Thread�c�默认的run()�Ҏ(gu��)��什么也不做��退��Z��。注意：直接调用run()�Ҏ(gu��)��q�不会启动一个新�U�程�Q�它和调用一个普通的java�Ҏ(gu��)��没有什么区别�?/P>

因此�Q�有两个�Ҏ(gu��)��可以实现自己的线�E�：

�Ҏ(gu��)��1�Q�自��q��c�extend Thread�Q��ƈ复写run()�Ҏ(gu��)��Q�就可以启动新线�E��ƈ执行自己定义的run()�Ҏ(gu��)��。例如：

public class MyThread extends Thread {
    public run() {
        System.out.println("MyThread.run()");
    }
}

在合适的地方启动�U�程�Q�new MyThread().start();

�Ҏ(gu��)��2�Q�如果自��q��c�d��l�extends另一个类�Q�就无法直接extends Thread�Q�此�Ӟ��必须实现一个Runnable接口�Q?/P>

public class MyThread extends OtherClass implements Runnable {
    public run() {
        System.out.println("MyThread.run()");
    }
}

��Z��启动MyThread�Q�需要首先实例化一个Thread�Q��ƈ传入自己的MyThread实例�Q?/P>

MyThread myt = new MyThread();
Thread t = new Thread(myt);
t.start();

事实上，当传入一个Runnable target参数�l�Thread后，Thread的run()�Ҏ(gu��)��׃��调用target.run()�Q�参考JDK源代码：

public void run() {
    if (target != null) {
        target.run();
    }
}

�U�程�q�有一些Name, ThreadGroup, isDaemon�{�设�|�，�׃��和线�E�设计模式关联很��，�q�里��׃��多说了�?BR>

�׃��同一�q�程内的多个�U�程�׃�n内存�I�间�Q�在Java中，��是�׃�n实例�Q�当多个�U�程试图同时修改某个实例的内�Ҏ(gu��)��Q�就会造成冲突�Q�因此，�U�程必须实现�׃�n互斥�Q��多线�E�同步�?/P>

最��单的同步是将一个方法标��Cؓsynchronized�Q�对同一个实例来��_��M��时刻只能有一个synchronized�Ҏ(gu��)��在执行。当一个方法正在执行某个synchronized�Ҏ(gu��)��Ӟ��其他�U�程如果惌��执行�q�个实例的�Q意一个synchronized�Ҏ(gu��)��Q�都必须�{�待当前执行 synchronized�Ҏ(gu��)��的线�E�退出此�Ҏ(gu��)��后，才能依次执行�?/P>

但是�Q�非synchronized�Ҏ(gu��)��不受影响�Q�不��当前有没有执行synchronized�Ҏ(gu��)��Q�非synchronized�Ҏ(gu��)��都可以被多个�U�程同时执行�?/P>

此外�Q�必��L��意，只有同一实例的synchronized�Ҏ(gu��)��同一旉��只能被一个线�E�执行，不同实例的synchronized�Ҏ(gu��)��是可以�ƈ发的。例如，class A定义了synchronized�Ҏ(gu��)��sync()�Q�则不同实例a1.sync()和a2.sync()可以同时�׃��个线�E�来执行�?BR>

多线�E�同步的实现最�l�依赖锁机制。我们可以想象某一�׃�n资源是一间屋子，每个人都是一个线�E�。当A希望�q�入戉K��Ӟ��他必��获得门锁，一旦A获得门锁�Q�他�q�去后就立刻��门锁上�Q�于是B,C,D...��׃��得不在门外等待，直到A释放锁出来后�Q�B,C,D...中的某一人抢��C��该锁�Q�具体抢法依赖于 JVM的实玎ͼ�可以先到先得�Q�也可以随机挑选）�Q�然后进屋又��门锁上。这��P��M��时刻最多有一人在屋内�Q��用共享资源）�?/P>

Java语言规范内置了对多线�E�的支持。对于Java�E�序来说�Q�每一个对象实例都有一把“锁”，一旦某个线�E�获得了该锁�Q�别的线�E�如果希望获得该锁，只能�{�待�q�个�U�程释放锁之后。获得锁的方法只有一个，��是synchronized关键字。例如：

public class SharedResource {
    private int count = 0;

    public int getCount() { return count; }

    public synchronized void setCount(int count) { this.count = count; }

}

同步�Ҏ(gu��)��public synchronized void setCount(int count) { this.count = count; } 事实上相当于�Q?/P>

public void setCount(int count) {
synchronized(this) { // 在此获得this�?BR> this.count = count;
} // 在此释放this�?BR>}

�U�色部分表示需要同步的代码�D�，该区域�ؓ“危险区域”，如果两个以上的线�E�同时执行，会引发冲�H�，因此�Q�要更改SharedResource的内部状态，必须先获得SharedResource实例的锁�?/P>

退出synchronized块时�Q�线�E�拥有的锁自动释放，于是�Q�别的线�E�又可以获取该锁了�?/P>

��Z��提高性能�Q�不一定要锁定this�Q�例如，SharedResource有两个独立变化的变量�Q?/P>

public class SharedResouce {
    private int a = 0;
    private int b = 0;

    public synchronized void setA(int a) { this.a = a; }

    public synchronized void setB(int b) { this.b = b; }
}

若同步整个方法，则setA()的时候无法setB()�Q�setB()时无法setA()。�ؓ了提高性能�Q�可以��用不同对象的锁：

public class SharedResouce {
    private int a = 0;
    private int b = 0;
    private Object sync_a = new Object();
    private Object sync_b = new Object();

    public void setA(int a) {
        synchronized(sync_a) {
            this.a = a;
        }
    }

    public synchronized void setB(int b) {
        synchronized(sync_b) {
            this.b = b;
        }
    }
}

通常�Q�多�U�程之间需要协调工作。例如，��览器的一个显�C�图片的�U�程displayThread惌��执行昄��囄��的�Q务，必须�{�待下蝲�U�程 downloadThread��该囄��下蝲完毕。如果图片还没有下蝲完，displayThread可以暂停�Q�当downloadThread完成了�Q务后�Q�再通知displayThread“图片准备完毕，可以昄��了”，�q�时�Q�displayThread�l�箋执行�?/P>

以上逻辑��单的说就是：如果条�g不满��I��则等待。当条�g满��Ӟ��{�待该条件的�U�程��被唤醒。在Java中，�q�个机制的实��C��赖于wait/notify。等待机制与锁机制是密切兌��的。例如：

synchronized(obj) {
    while(!condition) {
        obj.wait();
    }
    obj.doSomething();
}

当线�E�A获得了obj锁后�Q�发现条件condition不满��I��无法�l�箋下一处理�Q�于是线�E�A��wait()�?/P>

在另一�U�程B中，如果B更改了某些条�Ӟ��使得�U�程A的condition条�g满��了，��可以唤醒线�E�A�Q?/P>

synchronized(obj) {
condition = true;
obj.notify();
}

需要注意的概念是：

# 调用obj的wait(), notify()�Ҏ(gu��)��前，必须获得obj锁，也就是必��d��在synchronized(obj) {...} 代码�D�内�?/P>

# 调用obj.wait()后，�U�程A��释放了obj的锁�Q�否则线�E�B无法获得obj锁，也就无法在synchronized(obj) {...} 代码�D�内唤醒A�?/P>

# 当obj.wait()�Ҏ(gu��)��q�回后，�U�程A需要再�ơ获得obj锁，才能�l�箋执行�?/P>

# 如果A1,A2,A3都在obj.wait()�Q�则B调用obj.notify()只能唤醒A1,A2,A3中的一个（具体哪一个由JVM军_��Q��?/P>

# obj.notifyAll()则能全部唤醒A1,A2,A3�Q�但是要�l�箋执行obj.wait()的下一条语句，必须获得obj锁，因此�Q�A1,A2,A3只有一个有��Z��获得锁��l�执行，例如A1�Q�其余的需要等待A1释放obj锁之后才能��l�执行�?/P>

# 当B调用obj.notify/notifyAll的时候，B正持有obj锁，因此�Q�A1,A2,A3虽被唤醒�Q�但是仍无法获得obj锁。直到B退出synchronized块，释放obj锁后�Q�A1,A2,A3中的一个才有机会获得锁�l�箋执行�?/P>

前面讲了wait/notify机制�Q�Thread�q�有一个sleep()静态方法，它也能�ɾU�程暂停一�D�|��间。sleep与wait的不同点是： sleep�q�不释放锁，�q�且sleep的暂停和wait暂停是不一��L(f��ng)��。obj.wait会�ɾU�程�q�入obj对象的等待集合中�q�等待唤醒�?/P>

但是wait()和sleep()都可以通过interrupt()�Ҏ(gu��)��打断�U�程的暂停状态，从而�ɾU�程立刻抛出InterruptedException�?/P>

如果�U�程A希望立即�l�束�U�程B�Q�则可以对线�E�B对应的Thread实例调用interrupt�Ҏ(gu��)��。如果此�ȝ��E�B正在 wait/sleep/join�Q�则�U�程B会立��L��出InterruptedException�Q�在catch() {} 中直接return卛_��安全地结束线�E��?/P>

需要注意的是，InterruptedException是线�E�自�׃��内部抛出的，�q�不是interrupt()�Ҏ(gu��)��抛出的。对某一�U�程调用 interrupt()�Ӟ��如果该线�E�正在执行普通的代码�Q�那么该�U�程�Ҏ(gu��)��׃��会抛出InterruptedException。但是，一旦该�U�程�q�入�?wait()/sleep()/join()后，��׃��立刻抛出InterruptedException�?/P>

GuardedSuspention模式主要思想是：

当条件不满��Ӟ��U�程�{�待�Q�直到条件满��x��Q�等待该条�g的线�E�被唤醒�?/P>

我们设计一个客��L(f��ng)��U�程和一个服务器�U�程�Q�客��L(f��ng)��U�程不断发送请求给服务器线�E�，服务器线�E�不断处理请求。当��h��队列为空�Ӟ��服务器线�E�就必须�{�待�Q�直到客��L(f��ng)��发送了��h��?/P>

先定义一个请求队列：Queue

package com.crackj2ee.thread;

import java.util.*;

public class Queue {
    private List queue = new LinkedList();

    public synchronized Request getRequest() {
        while(queue.size()==0) {
            try {
                this.wait();
            }
            catch(InterruptedException ie) {
                return null;
            }
        }
        return (Request)queue.remove(0);
    }

    public synchronized void putRequest(Request request) {
        queue.add(request);
        this.notifyAll();
    }

}

蓝色部分��是服务器线�E�的�{�待条�g�Q�而客��L(f��ng)��U�程在放入了一个request后，��׃��服务器线�E�等待条件满��I��于是唤醒服务器线�E��?/P>

客户端线�E�：ClientThread

package com.crackj2ee.thread;

public class ClientThread extends Thread {
    private Queue queue;
    private String clientName;

    public ClientThread(Queue queue, String clientName) {
        this.queue = queue;
        this.clientName = clientName;
    }

    public String toString() {
        return "[ClientThread-" + clientName + "]";
    }

    public void run() {
        for(int i=0; i<100; i++) {
            Request request = new Request("" + (long)(Math.random()*10000));
            System.out.println(this + " send request: " + request);
            queue.putRequest(request);
            try {
                Thread.sleep((long)(Math.random() * 10000 + 1000));
            }
            catch(InterruptedException ie) {
            }
        }
        System.out.println(this + " shutdown.");
    }
}

服务器线�E�：ServerThread

package com.crackj2ee.thread;
public class ServerThread extends Thread {
    private boolean stop = false;
    private Queue queue;

    public ServerThread(Queue queue) {
        this.queue = queue;
    }

    public void shutdown() {
        stop = true;
        this.interrupt();
        try {
            this.join();
        }
        catch(InterruptedException ie) {}
    }

    public void run() {
        while(!stop) {
            Request request = queue.getRequest();
            System.out.println("[ServerThread] handle request: " + request);
            try {
                Thread.sleep(2000);
            }
            catch(InterruptedException ie) {}
        }
        System.out.println("[ServerThread] shutdown.");
    }
}

服务器线�E�在�U�色部分可能会阻塞，也就是说�Q�Queue.getRequest是一个阻塞方法。这和java标准库的许多IO�Ҏ(gu��)��c�M��?/P>

最后，写一个Main来启动他们：

package com.crackj2ee.thread;

public class Main {

    public static void main(String[] args) {
        Queue queue = new Queue();
        ServerThread server = new ServerThread(queue);
        server.start();
        ClientThread[] clients = new ClientThread[5];
        for(int i=0; i            clients[i] = new ClientThread(queue, ""+i);
            clients[i].start();
        }
        try {
            Thread.sleep(100000);
        }
        catch(InterruptedException ie) {}
        server.shutdown();
    }
}

我们启动�?个客��L(f��ng)��U�程和一个服务器�U�程�Q�运行结果如下：

[ClientThread-0] send request: Request-4984
[ServerThread] handle request: Request-4984
[ClientThread-1] send request: Request-2020
[ClientThread-2] send request: Request-8980
[ClientThread-3] send request: Request-5044
[ClientThread-4] send request: Request-548
[ClientThread-4] send request: Request-6832
[ServerThread] handle request: Request-2020
[ServerThread] handle request: Request-8980
[ServerThread] handle request: Request-5044
[ServerThread] handle request: Request-548
[ClientThread-4] send request: Request-1681
[ClientThread-0] send request: Request-7859
[ClientThread-3] send request: Request-3926
[ServerThread] handle request: Request-6832
[ClientThread-2] send request: Request-9906
......

可以观察到ServerThread处理来自不同客户端的��h��?/P>

思�?/FONT>

Q: 服务器线�E�的wait条�gwhile(queue.size()==0)能否换成if(queue.size()==0)?

A: 在这个例子中可以�Q�因为服务器�U�程只有一个。但是，如果服务器线�E�有多个�Q�例如Web应用�E�序有多个线�E�处理�ƈ发请求，�q�非常普遍）�Q�就会造成严重问题�?/P>

Q: 能否用sleep(1000)代替wait()?

A: �l�对不可以。sleep()不会释放锁，因此sleep期间别的�U�程�Ҏ(gu��)��没有办法调用getRequest()和putRequest()�Q�导致所有相关线�E�都被阻塞�?/P>

Q: (Request)queue.remove(0)可以攑ֈ�synchronized() {}块外面吗�Q?/P>

A: 不可以。因为while()是测试queue�Q�remove()是��用queue�Q�两者是一个原子操作，不能攑֜�synchronized外面�?/P>

�ȝ��

多线�E�设计看似简单，实际上必��非�总��l�地考虑各种锁定/同步的条�Ӟ��E�不��心�Q�就可能出错。�ƈ且，当线�E�较?y��u)��时�Q�很可能发现不了问题�Q�一旦问题出现又难以调试�?/P>

所�q�的是，已有一些被验证�q�的模式可以供我们��用，我们会��l�介�l�一些常用的多线�E�设计模式�?BR>

前面谈了多线�E�应用程序能极大地改善用��L(f��ng)��应。例如对于一个Web应用�E�序�Q�每当一个用戯��求服务器�q�接�Ӟ��服务器就可以启动一个新�U�程为用��h��务�?/P>

然而，创徏和销毁线�E�本�w�就有一定的开销�Q�如果频�J�创建和销毁线�E�，CPU和内存开销��׃��可忽略，垃圾攉��器还必须负担更多的工作。因此，�U�程池就是�ؓ了避免频�J�创建和销毁线�E��?/P>

每当服务器接受了一个新的请求后�Q�服务器��׃��U�程池中挑选一个等待的�U�程�q�执行请求处理。处理完毕后�Q�线�E��ƈ不结束，而是转�ؓ��d��状态再�ơ被攑օ��U�程池中。这样就避免了频�J�创建和销毁线�E��?/P>

Worker Pattern实现了类似线�E�池的功能。首先定义Task接口�Q?/P>

package com.crackj2ee.thread;
public interface Task {
void execute();
}

�U�程��负责执行execute()�Ҏ(gu��)��。注意到��d��是由子类通过实现execute()�Ҏ(gu��)��实现的，�U�程本��n�q�不知道自己执行的�Q务。它只负责运行一个耗时的execute()�Ҏ(gu��)��?/P>

具体��d��由子�c�d��玎ͼ�我们定义了一个CalculateTask和一个TimerTask�Q?/P>

// CalculateTask.java
package com.crackj2ee.thread;
public class CalculateTask implements Task {
    private static int count = 0;
    private int num = count;
    public CalculateTask() {
        count++;
    }
    public void execute() {
        System.out.println("[CalculateTask " + num + "] start...");
        try {
            Thread.sleep(3000);
        }
        catch(InterruptedException ie) {}
        System.out.println("[CalculateTask " + num + "] done.");
    }
}

// TimerTask.java
package com.crackj2ee.thread;
public class TimerTask implements Task {
    private static int count = 0;
    private int num = count;
    public TimerTask() {
        count++;
    }
    public void execute() {
        System.out.println("[TimerTask " + num + "] start...");
        try {
            Thread.sleep(2000);
        }
        catch(InterruptedException ie) {}
        System.out.println("[TimerTask " + num + "] done.");
    }
}

以上��d��均简单的sleep若干�U��?/P>

TaskQueue实现了一个队列，客户端可以将��h��攑օ�队列�Q�服务器�U�程可以从队列中取出��d��Q?/P>

package com.crackj2ee.thread;
import java.util.*;
public class TaskQueue {
    private List queue = new LinkedList();
    public synchronized Task getTask() {
        while(queue.size()==0) {
            try {
                this.wait();
            }
            catch(InterruptedException ie) {
                return null;
            }
        }
        return (Task)queue.remove(0);
    }
    public synchronized void putTask(Task task) {
        queue.add(task);
        this.notifyAll();
    }
}

�l�于��C��真正的WorkerThread�Q�这是真正执行�Q务的服务器线�E�：

package com.crackj2ee.thread;
public class WorkerThread extends Thread {
    private static int count = 0;
    private boolean busy = false;
    private boolean stop = false;
    private TaskQueue queue;
    public WorkerThread(ThreadGroup group, TaskQueue queue) {
        super(group, "worker-" + count);
        count++;
        this.queue = queue;
    }
    public void shutdown() {
        stop = true;
        this.interrupt();
        try {
            this.join();
        }
        catch(InterruptedException ie) {}
    }
    public boolean isIdle() {
        return !busy;
    }
    public void run() {
        System.out.println(getName() + " start.");
        while(!stop) {
            Task task = queue.getTask();
            if(task!=null) {
                busy = true;
                task.execute();
                busy = false;
            }
        }
        System.out.println(getName() + " end.");
    }
}

前面已经讲过�Q�queue.getTask()是一个阻塞方法，服务器线�E�可能在此wait()一�D�|��间。此外，W(xu��)orkerThread�q�有一个shutdown�Ҏ(gu��)��Q�用于安全结束线�E��?/P>

最后是ThreadPool�Q�负责管理所有的服务器线�E�，�q�可以动态增加和减少�U�程敎ͼ�

package com.crackj2ee.thread;
import java.util.*;
public class ThreadPool extends ThreadGroup {
    private List threads = new LinkedList();
    private TaskQueue queue;
    public ThreadPool(TaskQueue queue) {
        super("Thread-Pool");
        this.queue = queue;
    }
    public synchronized void addWorkerThread() {
        Thread t = new WorkerThread(this, queue);
        threads.add(t);
        t.start();
    }
    public synchronized void removeWorkerThread() {
        if(threads.size()>0) {
            WorkerThread t = (WorkerThread)threads.remove(0);
            t.shutdown();
        }
    }
    public synchronized void currentStatus() {
        System.out.println("-----------------------------------------------");
        System.out.println("Thread count = " + threads.size());
        Iterator it = threads.iterator();
        while(it.hasNext()) {
            WorkerThread t = (WorkerThread)it.next();
            System.out.println(t.getName() + ": " + (t.isIdle() ? "idle" : "busy"));
        }
        System.out.println("-----------------------------------------------");
    }
}

currentStatus()�Ҏ(gu��)��是�ؓ了方便调试，打印出所有线�E�的当前状态�?/P>

最后，Main负责完成main()�Ҏ(gu��)��Q?/P>

package com.crackj2ee.thread;
public class Main {
    public static void main(String[] args) {
        TaskQueue queue = new TaskQueue();
        ThreadPool pool = new ThreadPool(queue);
        for(int i=0; i<10; i++) {
            queue.putTask(new CalculateTask());
            queue.putTask(new TimerTask());
        }
        pool.addWorkerThread();
        pool.addWorkerThread();
        doSleep(8000);
        pool.currentStatus();
        pool.addWorkerThread();
        pool.addWorkerThread();
        pool.addWorkerThread();
        pool.addWorkerThread();
        pool.addWorkerThread();
        doSleep(5000);
        pool.currentStatus();
    }
    private static void doSleep(long ms) {
        try {
            Thread.sleep(ms);
        }
        catch(InterruptedException ie) {}
    }
}

main()一开始放入了20个Task�Q�然后动态添加了一些服务线�E�，�q�定期打印线�E�状态，�q�行�l�果如下�Q?/P>

worker-0 start.
[CalculateTask 0] start...
worker-1 start.
[TimerTask 0] start...
[TimerTask 0] done.
[CalculateTask 1] start...
[CalculateTask 0] done.
[TimerTask 1] start...
[CalculateTask 1] done.
[CalculateTask 2] start...
[TimerTask 1] done.
[TimerTask 2] start...
[TimerTask 2] done.
[CalculateTask 3] start...
-----------------------------------------------
Thread count = 2
worker-0: busy
worker-1: busy
-----------------------------------------------
[CalculateTask 2] done.
[TimerTask 3] start...
worker-2 start.
[CalculateTask 4] start...
worker-3 start.
[TimerTask 4] start...
worker-4 start.
[CalculateTask 5] start...
worker-5 start.
[TimerTask 5] start...
worker-6 start.
[CalculateTask 6] start...
[CalculateTask 3] done.
[TimerTask 6] start...
[TimerTask 3] done.
[CalculateTask 7] start...
[TimerTask 4] done.
[TimerTask 7] start...
[TimerTask 5] done.
[CalculateTask 8] start...
[CalculateTask 4] done.
[TimerTask 8] start...
[CalculateTask 5] done.
[CalculateTask 9] start...
[CalculateTask 6] done.
[TimerTask 9] start...
[TimerTask 6] done.
[TimerTask 7] done.
-----------------------------------------------
Thread count = 7
worker-0: idle
worker-1: busy
worker-2: busy
worker-3: idle
worker-4: busy
worker-5: busy
worker-6: busy
-----------------------------------------------
[CalculateTask 7] done.
[CalculateTask 8] done.
[TimerTask 8] done.
[TimerTask 9] done.
[CalculateTask 9] done.

仔细观察�Q�一开始只有两个服务器�U�程�Q�因此线�E�状态都是忙�Q�后来线�E�数增多�Q?个线�E�中的两个状态变成idle�Q�说明处于wait()状态�?/P>

思�?/STRONG>�Q�本例的�U�程调度��法其实�Ҏ(gu��)��没有�Q�因��个应用是围绕TaskQueue设计的，不是以Thread Pool��Z��心设计的。因此，Task调度取决于TaskQueue的getTask()�Ҏ(gu��)��Q�你可以改进�q�个�Ҏ(gu��)��Q�例如��用优先队列，使优先��高的��d��先被执行�?/P>

如果所有的服务器线�E�都处于busy状态，则说明�Q务繁忙，TaskQueue的队列越来越长，最�l�会��D��服务器内存耗尽。因此，可以限制 TaskQueue的等待�Q务数�Q�超�q�最大长度就拒绝处理。许多Web服务器在用户��h��J�忙时就会拒�l�用��P��HTTP 503 SERVICE UNAVAILABLE

多线�E�读写同一个对象的数据是很普遍的，通常�Q�要避免��d��冲突�Q�必��M��证�Q何时候仅有一个线�E�在写入�Q�有�U�程正在��d��的时候，写入操作��必��ȝ��待。简单说�Q�就是要避免“写-写”冲�H�和“读-写”冲�H�。但是同时读是允许的�Q�因为“读-诠Z��不冲突�Q�而且很安全�?/P>
要实��C��上的ReadWriteLock�Q�简单的使用synchronized��׃��行，我们必须自己设计一个ReadWriteLock�c�，在读之前�Q�必��d��获得“读锁”，写之前，必须先获得“写锁”。�D例说明：

DataHandler对象保存了一个可��d��的char[]数组�Q?/P>
package com.crackj2ee.thread;

public class DataHandler {
    // store data:
    private char[] buffer = "AAAAAAAAAA".toCharArray();

    private char[] doRead() {
        char[] ret = new char[buffer.length];
        for(int i=0; i            ret[i] = buffer[i];
            sleep(3);
        }
        return ret;
    }

    private void doWrite(char[] data) {
        if(data!=null) {
            buffer = new char[data.length];
            for(int i=0; i                buffer[i] = data[i];
                sleep(10);
            }
        }
    }

    private void sleep(int ms) {
        try {
            Thread.sleep(ms);
        }
        catch(InterruptedException ie) {}
    }
}

doRead()和doWrite()�Ҏ(gu��)��是非�U�程安全的读写方法。�ؓ了演�C�，加入了sleep()�Q��ƈ讄��ȝ��速度大约是写�?倍，�q�符合通常的情��c�?/P>
��Z��让多�U�程能安全读写，我们设计了一个ReadWriteLock�Q?/P>
package com.crackj2ee.thread;
public class ReadWriteLock {
    private int readingThreads = 0;
    private int writingThreads = 0;
    private int waitingThreads = 0; // waiting for write
    private boolean preferWrite = true;

    public synchronized void readLock() throws InterruptedException {
        while(writingThreads>0 || (preferWrite && waitingThreads>0))
            this.wait();
        readingThreads++;
    }

    public synchronized void readUnlock() {
        readingThreads--;
        preferWrite = true;
        notifyAll();
    }

    public synchronized void writeLock() throws InterruptedException {
        waitingThreads++;
        try {
            while(readingThreads>0 || writingThreads>0)
                this.wait();
        }
        finally {
            waitingThreads--;
        }
        writingThreads++;
    }

    public synchronized void writeUnlock() {
        writingThreads--;
        preferWrite = false;
        notifyAll();
    }
}

readLock()用于获得读锁�Q�readUnlock()释放读锁�Q�writeLock()和writeUnlock()一栗��由于锁用完必须释放�Q�因此，必须保证lock和unlock匚w��。我们修改DataHandler�Q�加入ReadWriteLock�Q?/P>
package com.crackj2ee.thread;
public class DataHandler {
    // store data:
    private char[] buffer = "AAAAAAAAAA".toCharArray();
    // lock:
    private ReadWriteLock lock = new ReadWriteLock();

    public char[] read(String name) throws InterruptedException {
        System.out.println(name + " waiting for read...");
        lock.readLock();
        try {
            char[] data = doRead();
            System.out.println(name + " reads data: " + new String(data));
            return data;
        }
        finally {
            lock.readUnlock();
        }
    }

    public void write(String name, char[] data) throws InterruptedException {
        System.out.println(name + " waiting for write...");
        lock.writeLock();
        try {
            System.out.println(name + " wrote data: " + new String(data));
            doWrite(data);
        }
        finally {
            lock.writeUnlock();
        }
    }

    private char[] doRead() {
        char[] ret = new char[buffer.length];
        for(int i=0; i            ret[i] = buffer[i];
            sleep(3);
        }
        return ret;
    }
    private void doWrite(char[] data) {
        if(data!=null) {
            buffer = new char[data.length];
            for(int i=0; i                buffer[i] = data[i];
                sleep(10);
            }
        }
    }
    private void sleep(int ms) {
        try {
            Thread.sleep(ms);
        }
        catch(InterruptedException ie) {}
    }
}

public�Ҏ(gu��)��read()和write()完全��装了底层的ReadWriteLock�Q�因此，多线�E�可以安全地调用�q�两个方法：

// ReadingThread不断��d��数据�Q?BR>package com.crackj2ee.thread;
public class ReadingThread extends Thread {
    private DataHandler handler;
    public ReadingThread(DataHandler handler) {
        this.handler = handler;
    }
    public void run() {
        for(;;) {
            try {
                char[] data = handler.read(getName());
                Thread.sleep((long)(Math.random()*1000+100));
            }
            catch(InterruptedException ie) {
                break;
            }
        }
    }
}

// WritingThread不断写入数据�Q�每�ơ写入的都是10个相同的字符�Q?BR>package com.crackj2ee.thread;
public class WritingThread extends Thread {
    private DataHandler handler;
    public WritingThread(DataHandler handler) {
        this.handler = handler;
    }
    public void run() {
        char[] data = new char[10];
        for(;;) {
            try {
                fill(data);
                handler.write(getName(), data);
                Thread.sleep((long)(Math.random()*1000+100));
            }
            catch(InterruptedException ie) {
                break;
            }
        }
    }
    // 产生一个A-Z随机字符�Q�填入char[10]:
    private void fill(char[] data) {
        char c = (char)(Math.random()*26+'A');
        for(int i=0; i            data[i] = c;
    }
}

最后Main负责启动�q�些�U�程�Q?/P>
package com.crackj2ee.thread;
public class Main {
    public static void main(String[] args) {
        DataHandler handler = new DataHandler();
        Thread[] ts = new Thread[] {
                new ReadingThread(handler),
                new ReadingThread(handler),
                new ReadingThread(handler),
                new ReadingThread(handler),
                new ReadingThread(handler),
                new WritingThread(handler),
                new WritingThread(handler)
        };
        for(int i=0; i            ts[i].start();
        }
    }
}

我们启动�?个读�U�程�?个写�U�程�Q�运行结果如下：

Thread-0 waiting for read...
Thread-1 waiting for read...
Thread-2 waiting for read...
Thread-3 waiting for read...
Thread-4 waiting for read...
Thread-5 waiting for write...
Thread-6 waiting for write...
Thread-4 reads data: AAAAAAAAAA
Thread-3 reads data: AAAAAAAAAA
Thread-2 reads data: AAAAAAAAAA
Thread-1 reads data: AAAAAAAAAA
Thread-0 reads data: AAAAAAAAAA
Thread-5 wrote data: EEEEEEEEEE
Thread-6 wrote data: MMMMMMMMMM
Thread-1 waiting for read...
Thread-4 waiting for read...
Thread-1 reads data: MMMMMMMMMM
Thread-4 reads data: MMMMMMMMMM
Thread-2 waiting for read...
Thread-2 reads data: MMMMMMMMMM
Thread-0 waiting for read...
Thread-0 reads data: MMMMMMMMMM
Thread-4 waiting for read...
Thread-4 reads data: MMMMMMMMMM
Thread-2 waiting for read...
Thread-5 waiting for write...
Thread-2 reads data: MMMMMMMMMM
Thread-5 wrote data: GGGGGGGGGG
Thread-6 waiting for write...
Thread-6 wrote data: AAAAAAAAAA
Thread-3 waiting for read...
Thread-3 reads data: AAAAAAAAAA
......

可以看到�Q�每�ơ读/写都是完整的原子操作�Q�因为我们每�ơ写入的都是10个相同字�W�。�ƈ且，每次��d��的都是最�q�一�ơ写入的内容�?/P>
如果��L��ReadWriteLock�Q?/P>
package com.crackj2ee.thread;
public class DataHandler {

    // store data:
    private char[] buffer = "AAAAAAAAAA".toCharArray();

    public char[] read(String name) throws InterruptedException {
        char[] data = doRead();
        System.out.println(name + " reads data: " + new String(data));
        return data;
    }
    public void write(String name, char[] data) throws InterruptedException {
        System.out.println(name + " wrote data: " + new String(data));
        doWrite(data);
    }

    private char[] doRead() {
        char[] ret = new char[10];
        for(int i=0; i<10; i++) {
            ret[i] = buffer[i];
            sleep(3);
        }
        return ret;
    }
    private void doWrite(char[] data) {
        for(int i=0; i<10; i++) {
            buffer[i] = data[i];
            sleep(10);
        }
    }
    private void sleep(int ms) {
        try {
            Thread.sleep(ms);
        }
        catch(InterruptedException ie) {}
    }
}

�q�行�l�果如下�Q?/P>
Thread-5 wrote data: AAAAAAAAAA
Thread-6 wrote data: MMMMMMMMMM
Thread-0 reads data: AAAAAAAAAA
Thread-1 reads data: AAAAAAAAAA
Thread-2 reads data: AAAAAAAAAA
Thread-3 reads data: AAAAAAAAAA
Thread-4 reads data: AAAAAAAAAA
Thread-2 reads data: MAAAAAAAAA
Thread-3 reads data: MAAAAAAAAA
Thread-5 wrote data: CCCCCCCCCC
Thread-1 reads data: MAAAAAAAAA
Thread-0 reads data: MAAAAAAAAA
Thread-4 reads data: MAAAAAAAAA
Thread-6 wrote data: EEEEEEEEEE
Thread-3 reads data: EEEEECCCCC
Thread-4 reads data: EEEEEEEEEC
Thread-1 reads data: EEEEEEEEEE

可以看到在Thread-6写入EEEEEEEEEE的过�E�中�Q?个线�E�读取的内容是不同的�?/P>
思�?/STRONG>

java的synchronized提供了最底层的物理锁�Q�要在synchronized的基��上，实现自己的逻辑锁，��必��M��l�设计ReadWriteLock�?/P>
Q: lock.readLock()��Z��么不攑օ�try{ } 内？
A: 因�ؓreadLock()会抛出InterruptedException�Q�导致readingThreads++不执行，而readUnlock()�?finally{ } 中，��D��readingThreads--执行�Q�从而��readingThread状态出错。writeLock()也是�c�M��的�?/P>
Q: preferWrite有用吗？
A: 如果��L��preferWrite�Q�线�E�安全不受媄响。但是，如果��d��U�程很多�Q�上一个线�E�还没有��d��完，下一个线�E�又开始读了，��导致写入线�E�长旉��无法获得writeLock�Q�如果写入线�E�等待的很多�Q�一个接一个写�Q�也会导致读取线�E�长旉��无法获得readLock。preferWrite的作用是让读 /写交替执行，避免�׃��ȝ��E�繁忙导致写无法�q�行和由于写�U�程�J�忙��D��L��法进行�?/P>
Q: notifyAll()换成notify()行不行？
A: 不可以。由于preferWrite的存在，如果一个线�E�刚��d��完毕�Q�此时preferWrite=true�Q�再notify()�Q�若恰好唤醒的是一个读�U�程�Q�则while(writingThreads>0 || (preferWrite && waitingThreads>0))可能为true��D��该读�U�程�l�箋�{�待�Q�而等待写入的�U�程也处于wait()中，�l�果所有线�E�都处于wait ()状态，谁也无法唤醒谁。因此，notifyAll()比notify()要来得安全。程序验证notify()带来的死锁：

Thread-0 waiting for read...
Thread-1 waiting for read...
Thread-2 waiting for read...
Thread-3 waiting for read...
Thread-4 waiting for read...
Thread-5 waiting for write...
Thread-6 waiting for write...
Thread-0 reads data: AAAAAAAAAA
Thread-4 reads data: AAAAAAAAAA
Thread-3 reads data: AAAAAAAAAA
Thread-2 reads data: AAAAAAAAAA
Thread-1 reads data: AAAAAAAAAA
Thread-5 wrote data: CCCCCCCCCC
Thread-2 waiting for read...
Thread-1 waiting for read...
Thread-3 waiting for read...
Thread-0 waiting for read...
Thread-4 waiting for read...
Thread-6 wrote data: LLLLLLLLLL
Thread-5 waiting for write...
Thread-6 waiting for write...
Thread-2 reads data: LLLLLLLLLL
Thread-2 waiting for read...
�Q�运行到此不动了�Q?/FONT>

注意到这�U�死锁是�׃��所有线�E�都在等待别的线�E�唤醒自己，�l�果都无法醒�q�来。这和两个线�E�希望获得对方已有的锁造成死锁不同。因此多�U�程设计的难度远�q�高于单�U�程应用�?/P>

只牵�q�只�?/a> 2005-12-14 08:54 发表评论

在不容许使用�W�三个变量下�Q�实��C��个函敎ͼ�把两个整型参数的值对�?

Sun, 27 Nov 2005 04:43:00 GMT
解答一:
swap(int a, int b)
{
  a -= b;  // a(new) = a-b
  b += a;  // b(new) = b+a(new) = b+(a-b)=a
  a = b-a;  // a(result) = b-a(new)= a-(a-b)=b
}

解答�?

b=(a=(b=(a^b))^a)^b

解答�?
a = a^(a^b);
b = b^(a^b);

只牵�q�只�?/a> 2005-11-27 12:43 发表评论