涛涛 http://zhtxc.blog.sohu.com/ Sun, 28 Sep 2008 12:00:36 +0800 搜狐博客 http://blog.sohu.com http://js.pp.sohu.com/ppp/blog/images/common/logo_150_60.gif http://blog.sohu.com/ 100 43 搜狐博客 转载： sphinx 搜索引擎 http://zhtxc.blog.sohu.com/100851479.html http://zhtxc.blog.sohu.com/100851479.html#comment 涛涛 Sun, 28 Sep 2008 12:00:36 +0800 java http://zhtxc.blog.sohu.com/100851479.html 原文：http://blog.s135.com/read.php/360.htm

前言：

本文阐述的是一款经过生产环境检验的千万级数据全文检索（搜索引擎）架构。本文只列出前几章的内容节选，不提供全文内容。

在DELL PowerEdge 6850服务器（四颗64 位Inter Xeon MP 7110N处理器 / 8GB内存）、RedHat AS4 Linux操作系统、MySQL 5.1.26、MyISAM存储引擎、key_buffer=1024M环境下实测，单表1000万条记录的数据量（这张MySQL表拥有int、 datetime、varchar、text等类型的10多个字段，只有主键，无其它索引），用主键（PRIMARY KEY）作为WHERE条件进行SQL查询，速度非常之快，只耗费0.01秒。

出自俄罗斯的开源全文搜索引擎软件 Sphinx ，单一索引最大可包含1亿条记录，在1千万条记录情况下的查询速度为0.x秒（毫秒级）。Sphinx创建索引的速度为：创建100万条记录的索引只需 3～4分钟，创建1000万条记录的索引可以在50分钟内完成，而只包含最新10万条记录的增量索引，重建一次只需几十秒。

基于以上几点，我设计出了这套搜索引擎架构。在生产环境运行了一周，效果非常不错。有时间我会专为配合Sphinx搜索引擎，开发一个逻辑简单、速 度快、占用内存低、非表锁的MySQL存储引擎插件，用来代替MyISAM引擎，以解决MyISAM存储引擎在频繁更新操作时的锁表延迟问题。另外，分布 式搜索技术上已无任何问题。

一、搜索引擎架构设计：

1、搜索引擎架构图：

2、搜索引擎架构设计思路：

(1)、调用方式最简化：

尽量方便前端Web工程师，只需要一条简单的SQL语句“SELECT ... FROM myisam_table JOIN sphinx_table ON (sphinx_table.sphinx_id=myisam_table.id) WHERE query='...';”即可实现高效搜索。

(2)、创建索引、查询速度快：

①、Sphinx Search 是由俄罗斯人Andrew Aksyonoff 开发的高性能全文搜索软件包，在GPL与商业协议双许可协议下发行。

Sphinx的特征：

  • Sphinx支持高速建立索引（可达10MB/秒，而Lucene建立索引的速度是1.8MB/秒）
  • 高性能搜索（在2-4 GB的文本上搜索，平均0.1秒内获得结果）
  • 高扩展性（实测最高可对100GB的文本建立索引，单一索引可包含1亿条记录）
  • 支持分布式检索
  • 支持基于短语和基于统计的复合结果排序机制
  • 支持任意数量的文件字段（数值属性或全文检索属性）
  • 支持不同的搜索模式（“完全匹配”，“短语匹配”和“任一匹配”）
  • 支持作为Mysql的存储引擎

②、通过国外《High Performance MySQL》专家组的测试可以看出，根据主键进行查询的类似“SELECT ... FROM ... WHERE id = ...”的SQL语句（其中id为PRIMARY KEY），每秒钟能够处理10000次以上的查询，而普通的SELECT查询每秒只能处理几十次到几百次：

③、Sphinx不负责文本字段的存储。假设将数据库的id、date、title、body字段，用sphinx建立搜索索引。根据关键字、时 间、类别、范围等信息查询一下sphinx，sphinx只会将查询结果的ID号等非文本信息告诉我们。要显示title、body等信息，还需要根据此 ID号去查询MySQL数据库，或者从Memcachedb等其他的存储中取得。安装SphinxSE作为MySQL的存储引擎，将MySQL与 Sphinx结合起来，是一种便捷的方法。

创建一张Sphinx类型表，将MyISAM表的主键ID和Sphinx表的ID作一个JOIN联合查询。这样，对于MyISAM表来所，只相当于 一个WHERE id=...的主键查询，WHERE后的条件都交给Sphinx去处理，可以充分发挥两者的优势，实现高速搜索查询。

(3)、按服务类型进行分离：

为了保证数据的一致性，我在配置Sphinx读取索引源的MySQL数据库时，进行了锁表。Sphinx读取索引源的过程会耗费一定时间，由于 MyISAM存储引擎的读锁和写锁是互斥的，为了避免写操作被长时间阻塞，导致数据库同步落后跟不上，我将提供“搜索查询服务”的和提供“索引源服务”的 MySQL数据库进行了分开。监听3306端口的MySQL提供“搜索查询服务”，监听3406端口的MySQL提供“索引源服务”。

(4)、“主索引＋增量索引”更新方式：

一般网站的特征：信息发布较为频繁；刚发布完的信息被编辑、修改的可能性大；两天以前的老帖变动性较小。

基于这个特征，我设计了Sphinx主索引和增量索引。对于前天17:00之前的记录建立主索引，每天凌晨自动重建一次主索引；对于前天17:00之后到当前最新的记录，间隔3分钟自动重建一次增量索引。

(5)、“Ext3文件系统＋tmpfs内存文件系统”相结合：

为了避免每3分钟重建增量索引导致磁盘IO较重，从而引起系统负载上升，我将主索引文件创建在磁盘，增量索引文件创建在tmpfs内存文件系统 “/dev/shm/”内。“/dev/shm/”内的文件全部驻留在内存中，读写速度非常快。但是，重启服务器会导致“/dev/shm/”内的文件丢 失，针对这个问题，我会在服务器开机时自动创建“/dev/shm/”内目录结构和Sphinx增量索引。

(6)、中文分词词库：

我根据“百度早期中文分词库”＋“搜狗拼音输入法细胞词库”＋“LibMMSeg高频字库”＋... 综合整理成一份中文分词词库，出于某些考虑暂不提供。你可以使用LibMMSeg自带的中文分词词库。

]]> commons DBCP 配置参数 http://zhtxc.blog.sohu.com/100596095.html http://zhtxc.blog.sohu.com/100596095.html#comment 涛涛 Thu, 25 Sep 2008 10:47:06 +0800 其他 http://zhtxc.blog.sohu.com/100596095.html jdbc.driverClassName=oracle.jdbc.driver.OracleDriver
jdbc.url=jdbc:oracle:thin:@127.0.0.1:1521:DBSERVER
jdbc.username=user
jdbc.password=pass

#<!-- 初始化连接 -->
dataSource.initialSize=10

#<!-- 最大空闲连接 -->
dataSource.maxIdle=20

#<!-- 最小空闲连接 -->
dataSource.minIdle=5

#最大连接数量
dataSource.maxActive=50

#是否在自动回收超时连接的时候打印连接的超时错误
dataSource.logAbandoned=true

#是否自动回收超时连接
dataSource.removeAbandoned=true

#超时时间(以秒数为单位)
#设置超时时间有一个要注意的地方，超时时间=现在的时间-程序中创建Connection的时间，如果 maxActive比较大，比如超过100，那么removeAbandonedTimeout可以设置长一点比如180，也就是三分钟无响应的连接进行 回收，当然应用的不同设置长度也不同。
dataSource.removeAbandonedTimeout=180

#<!-- 超时等待时间以毫秒为单位 -->
#maxWait代表当Connection用尽了，多久之后进行回收丢失连接
dataSource.maxWait=1000
]]> 六种用ruby调用执行shell命令的方法 http://zhtxc.blog.sohu.com/99150531.html http://zhtxc.blog.sohu.com/99150531.html#comment 涛涛 Fri, 5 Sep 2008 21:40:24 +0800 ruby http://zhtxc.blog.sohu.com/99150531.html 六种用ruby调用执行shell命令的方法
1.Exec方法:
    Kernel#exec方法通过调用指定的命令取代当前进程：
  例子：
      $ irb
      >> exec 'echo "hello $HOSTNAME"'
         hello nate.local
      $
值得注意的是，exec方法用echo命令来取代了irb进程从而退出了irb。主要的缺点是，你无法从你的ruby脚本里知道这个命令是成功还是失败。
 
2.System方法。
  Kernel#system方法操作命令同上， 但是它是运行一个子shell来避免覆盖当前进程。如果命令执行成功则返回true，否则返回false。
 
 $ irb           
  >> system 'echo "hello $HOSTNAME"'
  hello nate.local
  => true
  >> system 'false'
  => false
  >> puts $?
  256
  => nil
  >>
3.反引号（Backticks，Esc键下面那个键）
$ irb
  >> today = `date`
  => "Mon Mar 12 18:15:35 PDT 2007n"
  >> $?
  => #<Process::Status: pid=25827,exited(0)>
  >> $?.to_i
  => 0
这种方法是最普遍的用法了。它也是运行在一个子shell中。
4.IO#popen
  $ irb
  >> IO.popen("date") { |f| puts f.gets }
  Mon Mar 12 18:58:56 PDT 2007
  => nil
5.open3#popen3
$ irb
  >> stdin, stdout, stderr = Open3.popen3('dc')
  => [#<IO:0x6e5474>, #<IO:0x6e5438>, #<IO:0x6e53d4>]
  >> stdin.puts(5)
  => nil
  >> stdin.puts(10)
  => nil
  >> stdin.puts("+")
  => nil
  >> stdin.puts("p")
  => nil
  >> stdout.gets
  => "15n"
6.Open4#popen4
$ irb
  >> require "open4"
  => true
  >> pid, stdin, stdout, stderr = Open4::popen4 "false"
  => [26327, #<IO:0x6dff24>, #<IO:0x6dfee8>, #<IO:0x6dfe84>]
  >> $?
  => nil
  >> pid
  => 26327
  >> ignored, status = Process::waitpid2 pid
  => [26327, #<Process::Status: pid=26327,exited(1)>]
  >> status.to_i
  => 256
 
]]> http://www.javaeye.com/topic/200065 http://zhtxc.blog.sohu.com/99140058.html http://zhtxc.blog.sohu.com/99140058.html#comment 涛涛 Fri, 5 Sep 2008 19:22:14 +0800 http://zhtxc.blog.sohu.com/99140058.html jvm参数 http://zhtxc.blog.sohu.com/97543600.html http://zhtxc.blog.sohu.com/97543600.html#comment 涛涛 Mon, 18 Aug 2008 16:55:20 +0800 http://zhtxc.blog.sohu.com/97543600.html -Xmx
set maximum Java heap size

-Xms
set initial Java heap size

-XX:MinHeapFreeRatio=40
Minimum percentage of heap free after GC to avoid expansion.

-XX:MaxHeapFreeRatio=70
Maximum percentage of heap free after GC to avoid shrinking.

-XX:NewRatio=2
Ratio of new/old generation sizes. [Sparc -client:8; x86 -server:8; x86 -client:12.]-client:8 (1.3.1+), x86:12]

-XX:NewSize=2.125m
Default size of new generation (in bytes) [5.0 and newer: 64 bit VMs are scaled 30% larger; x86:1m; x86, 5.0 and older: 640k]

-XX:MaxNewSize=
Maximum size of new generation (in bytes). Since 1.4, MaxNewSize is computed as a function of NewRatio.

-XX:SurvivorRatio=25
Ratio of eden/survivor space size [Solaris amd64: 6; Sparc in 1.3.1: 25; other Solaris platforms in 5.0 and earlier: 32]

-XX:PermSize=
Initial size of permanent generation

-XX:MaxPermSize=64m
Size of the Permanent Generation.  [5.0 and newer: 64 bit VMs are scaled 30% larger; 1.4 amd64: 96m; 1.3.1 -client: 32m.]



堆(Heap)和非堆(Non-heap)内存

　　按照官方的说法：“Java 虚拟机具有一个堆，堆是运行时数据区域，所有类实例和数组的内存均从此处分配。堆是在 Java 虚拟机启动时创建的。”“在JVM中堆之外的内存称为非堆内存(Non-heap memory)”。可以看出JVM主要管理两种类型的内存：堆和非堆。简单来说堆就是Java代码可及的内存，是留给开发人员使用的;非堆就是JVM留给 自己用的，所以方法区、JVM内部处理或优化所需的内存(如JIT编译后的代码缓存)、每个类结构(如运行时常数池、字段和方法数据)以及方法和构造方法 的代码都在非堆内存中。

　　堆内存分配

　　JVM初始分配的内存由-Xms指定，默认是物理内存的1/64;JVM最大分配的内存由-Xmx指定，默认是物理内存的1/4。默认空余堆内 存小于40%时，JVM就会增大堆直到-Xmx的最大限制;空余堆内存大于70%时，JVM会减少堆直到-Xms的最小限制。因此服务器一般设置-Xms、-Xmx相等以避免在每次GC 后调整堆的大小。

　　非堆内存分配

　　JVM使用-XX:PermSize设置非堆内存初始值，默认是物理内存的1/64;由XX:MaxPermSize设置最大非堆内存的大小，默认是物理内存的1/4。

　　JVM内存限制(最大值)

　　首先JVM内存限制于实际的最大物理内存(废话!呵呵)，假设物理内存无限大的话，JVM内存的最大值跟操作系统有很大的关系。简单的说就32位处理器虽然可控内存空间有4GB,但是具体的操作系统会给一个限制，这个限制一般是2GB-3GB(一般来说Windows系统下为1.5G-2G，Linux系统下为2G-3G)，而64bit以上的处理器就不会有限制了。

]]> 转载：Ruby 全局变量 http://zhtxc.blog.sohu.com/97483671.html http://zhtxc.blog.sohu.com/97483671.html#comment 涛涛 Sun, 17 Aug 2008 22:31:36 +0800 ruby http://zhtxc.blog.sohu.com/97483671.html
全局变量由$开头.它们可以在程序的任何位置访问到.在初始化前,全局变量有一个特殊的值 nil.
这里列出了一些以$打头并跟单个字符的特殊变量.比如,$$包含了Ruby解释器的进程id,它是只读的.这里是主要的系统变量以及它们的含义(细节可在Ruby的参考手册中查到):
$! 最近一次的错误信息
$@ 错误产生的位置
$_ gets最近读的字符串
$. 解释器最近读的行数(line number)
$& 最近一次与正则表达式匹配的字符串
$~ 作为子表达式组的最近一次匹配
$n 最近匹配的第n个子表达式(和$~[n]一样)
$= 是否区别大小写的标志
$/ 输入记录分隔符
$\ 输出记录分隔符
$0 Ruby脚本的文件名
$* 命令行参数
$$ 解释器进程ID
$? 最近一次执行的子进程退出状态

上面的 $_ 和 $~ 都有作用范围.它们的名字暗示其为全局的,但它们一般都是这样用的,关于它们的命名有历史上的原因.
]]> 转载：实例变量、类变量、类方法 http://zhtxc.blog.sohu.com/97482794.html http://zhtxc.blog.sohu.com/97482794.html#comment 涛涛 Sun, 17 Aug 2008 22:32:00 +0800 ruby http://zhtxc.blog.sohu.com/97482794.html
学习编程的过程，就是深化理解变量的过程。在面向对象编程中也不例外，这一节，我们继续深化理解变量。
先把 Ruby 放在一边，从编程语言的视角来探讨变量。
如果一个变量，第一次赋值后，就不再允许改变变量值，这样的变量称之为常变量，简称常量。就像数学分析中的常函数，y = 3 是一个平行于 x 轴，并且函数值总是为 3 的函数。常量名用大写字母开头。
如果一个变量，在其作用域上的每一个执行点，都可以改变变量值，这样的变量称之为可变量，简称变量。
如果一个变量，其作用域遍及在程序的任何位置，这样的变量称之为全局变量；与之相对，作用域仅限于在程序的某一单元的变量，称之为局部变量。
面向对象的编程，以类为单元模块。类是设计蓝图，具体的事物是实例对象。前面 5.3 节说到：“变量名，变量值，变量类型，变量的作用域，是我们学习命令式语言不可回避的几个要素”。对于面向过程的命令式语言，这四个要素已经够了；对于面 向对象的命令式语言，还要加上变量的第五个要素——共享性。
如果一个变量，只能被某个实例对象使用，这样的变量称之为实例变量；如果一个变量，能被某个类的所有实例对象共享，这样的变量称之为类变量。
回到 Ruby 。常量可以定义在类和模块中，不能定义在方法中。如果在外部访问类或模块中的常量，要使用域作用符:: 。
全局变量用$ 开头。
实例变量，变量名用@ 开头；类变量，变量名用@@ 开头。
Ruby中所说的局部变量，可以是存在于类中、方法中、模块中、一个循环中、一个过程对象中。局部变量名用小写字母开头。
在4.3节，我们使用的@name（姓名）、@age（年龄）、@motherland（国籍），都是实例变量，被每个实例独享。程序 E4.3-1.rb 中，实例 p1与实例 p2的姓名不一样，年龄也不一样。
如果我们希望一类事物共享某个变量，比如：在 4.4节 Student 类中，需要有一个变量来代表班级人数，实例 p3与实例 p4假使在一个班级里，班级人数这个属性应该是相同的，当然，随着 Student 类的实例不断生成，班级人数也要不断增加，如何解决呢？
类变量能够很好地实现这个需求，看程序 E6.3-1.rb：
Ruby代码 
  1. #E6.3-1.rb   
  2. class StudentClass   
  3.   @@count=0  
  4.   
  5.   def initialize( name )  
  6.     @name = name  
  7.     @@count+=1  
  8.   end     
  9.    
  10.   def talk  
  11.     puts "I am #@name, This class have #@@count students."  
  12.   end    
  13. end  
  14.   
  15. p1=StudentClass.new("Student 1 ")  
  16. p2=StudentClass.new("Student 2 ")  
  17. p3=StudentClass.new("Student 3 ")  
  18. p4=StudentClass.new("Student 4 ")  
  19. p3.talk         # =>  I am Student 3 , This class have 4 students.  
  20. p4.talk         # =>  I am Student 4 , This class have 4 students.  
#E6.3-1.rb 
class StudentClass 
  @@count=0

  def initialize( name )
    @name = name
    @@count+=1
  end   
 
  def talk
    puts "I am #@name, This class have #@@count students."
  end  
end

p1=StudentClass.new("Student 1 ")
p2=StudentClass.new("Student 2 ")
p3=StudentClass.new("Student 3 ")
p4=StudentClass.new("Student 4 ")
p3.talk         # =>  I am Student 3 , This class have 4 students.
p4.talk         # =>  I am Student 4 , This class have 4 students.

与全局变量和实例变量不同，类变量在使用前必须要初始化；全局变量和实例变量如果没有初始化，其值为 nil 。
如果教务主任想知道某个班级现在有多少人数，不需要到这个班级去问学生，应该可以通过其它途径来获取信息。这里要用到类方法——不依赖于任何特定 实例对象的方法。类方法与实例方法的定义方式不同，定义类方法要在方法名前加上类名和一个点号“.”。看程序 E6.3-2.rb：
Ruby代码 
  1. #E6.3-2.rb    
  2. class StudentClass   
  3.   @@count=0    
  4.   
  5.   def initialize  
  6.     @@count+=1  
  7.   end      
  8.   
  9.   def  StudentClass.student_count  
  10.     puts "This class have #@@count students."  
  11.   end    
  12. end  
  13.   
  14. p1=StudentClass.new  
  15. p2=StudentClass.new  
  16. StudentClass.student_count   # =>  This class have 2 students.  
  17.   
  18. p3=StudentClass.new  
  19. p4=StudentClass.new  
  20. StudentClass.student_count   # =>  This class have 4 students.  
#E6.3-2.rb  
class StudentClass 
  @@count=0  

  def initialize
    @@count+=1
  end    

  def  StudentClass.student_count
    puts "This class have #@@count students."
  end  
end

p1=StudentClass.new
p2=StudentClass.new
StudentClass.student_count   # =>  This class have 2 students.

p3=StudentClass.new
p4=StudentClass.new
StudentClass.student_count   # =>  This class have 4 students.

调用一个类方法，与定义类方法一样，要在方法名前加上类名和一个点号“.”。类方法提供了一个途径，在类的外部访问类变量，无须通过类的实例方法。
类变量，类方法在 Java 里与之相对应的是 static变量，static方法。
在Java里，你写一个类，是在画设计图纸，当你 new 的时候，才生成一个实例对象。Ruby语言中，一切都是对象，单个实例（具体事物）是对象，类（蓝图）也是对象。你拿着设计图纸可以生产出很多汽车，而设 计图纸对于纸来说，只是纸这类事物的一个具体实例。 Ruby里，有元类的概念，通过关键字self 与类方法的灵活使用，程序代码可以产生很多变化，这里不再展开叙述。可以思考用类方法来实现《设计模式》一书中的单子模式。]]> iostat mpstat vmstat http://zhtxc.blog.sohu.com/97377172.html http://zhtxc.blog.sohu.com/97377172.html#comment 涛涛 Sat, 16 Aug 2008 12:46:19 +0800 http://zhtxc.blog.sohu.com/97377172.html iostat -c 1 10
mpstat
vmstat


]]> Java Garbage Collection Tuning http://zhtxc.blog.sohu.com/95430836.html http://zhtxc.blog.sohu.com/95430836.html#comment 涛涛 Thu, 24 Jul 2008 16:55:17 +0800 http://zhtxc.blog.sohu.com/95430836.html
Correctly tuning Java garbage collection is important for high traffic web applications. This document provides some general guidelines as well as links to additional resources.

General Guidelines

Server Mode

For server-side applications the JVM should be run with the "-server" flag. This enables the server mode for garbage collection which will reduce the number of garbage collections to increase overall application throughput. There is also a difference between minor and full garbage collections in this mode. Minor garbage collections clean up more volatile objects and take a short amount of time. Full garbage collections take longer but run over the entire heap to clean up more memory.

Minimum and Maximum Heap Size

The heap size for the JVM should be specified based on the application's expected memory usage. The minimum heap size is less important as it is only useful at startup and may save a small amount of time due to fewer garbage collection/memory allocation cycles needing to be processed. Use -Xms(memorySize) to set the minimum heap size. For example -Xms512m sets the minimum heap size to 512MB.

The maximum heap size is very important. If the maximum heap size is not large enough the application can cause OutOfMemoryExceptions or there may be an excessive number of garbage collections which will decrease application throughput and responsiveness. However, the maximum heap should not be set to more than 1 GB of memory unless testing has shown the JVM will work well with a specific setting. Experience shows that the garbage collector has difficulty with larger heap sizes. Use -Xmx(memorySize) to set the maximum heap size. For example -Xmx1024m sets the maximum heap size to 1024MB or 1GB.

For specific recommendations on heap sizes for Jive Software products, the general rule is that the maximum heap size should be two to three times the total size of the application caches.

MaxPermSize

The JVM stores class metadata such as Method and Class objects in memory in the permanent generation. The default setting for -server mode in most environments is 64 MB (in other environments it may be 32 MB). This setting does not generally need to be changed, but if there are unexplained OutOfMemory exceptions after properly sizing the maximum heap size then increasing the MaxPermSize to 128 MB is recommended. This configuration can be done by including -XX:MaxPermSize=128m in the JVM startup command. Note that the increased capacity will only be used if it is needed by the JVM.

Other Garbage Collection Settings

There are other garbage collector settings which can make a difference depending on the computing environment. Please see the resources section for additional information.

Garbage Collection Logging

When a garbage collection issue is suspected there are several tools which can help confirm the possibility. To log garbage collection information, use the following two JVM command-line switches:

Enable Garbage Collector Logging

-verbose:gc

This setting enables garbage collector logging.

Log File

-Xloggc:<file>

This setting will cause the garbage collector log information to go into the file specified by <file>. Note that you should copy the garbage collection log file before restarting or else the file will get overridden.

Garbage Collection Details

Using these two settings will increase the amount of helpful information in the garbage collection logs.

-XX:+PrintGCTimeStamps -XX:+PrintGCDetails

Garbage Collection Logging Summary

Add all of these parameters to the JVM startup command:

-verbose:gc -Xloggc:<file> -XX:+PrintGCTimeStamps -XX:+PrintGCDetails

Analyzing the Garbage Collector Log Files

Analyzing the garbage collector log files can be done visually by reading the logs or with a tool such as HP's HPjtune (see the Resources section). The format of the garbage collector logs is:

<timestamp>: [<allocation change>(<total heap allocated>), <time for garbage collection>]

For example, this line shows that 60.5 seconds after JVM startup a minor garbage collection was done which tool 0.0116410 seconds and decreased heap memory usage from 98255K to 88403K. The total heap size allocated from the operating system is 162676K.

60.500: [98255K->88403K(162676K), 0.0116410 secs]

Another example shows a full garbage collection. Full garbage collections should happen much less frequently than minor garbage collections. This example shows a full garbage collection that occurred 304.528 seconds after JVM startup and took 1.4657250 seconds. Heap usage went from 47707K to 29607K out of a total allocation of 76800K.

304.528: [Full GC 47707K->29607K(76800K), 1.4657250 secs]

Resources

Tuning Garbage Collection with the 1.4.2 Java[tm] Virtual Machine
Sun's documentation on garbage collector tuning.

Tuning Garbage Collection OutlineA summary of the Sun document above.

HP's HPjtune
A tool from HP for visualizing garbage collection logs.

Eye on performance: Tuning garbage collection in the HotSpot JVM
An IBM article on garbage collector tuning.

Setting up a HotSpot server or client mode on a Java 2 SDK
Configuring the JVM Server Mode on IBM WebSphere Application Server ]]> ruby way之IO之二 http://zhtxc.blog.sohu.com/94023353.html http://zhtxc.blog.sohu.com/94023353.html#comment 涛涛 Tue, 15 Jul 2008 11:26:55 +0800 ruby http://zhtxc.blog.sohu.com/94023353.html
ruby一般使用他自己内置的缓冲:

Ruby代码
  1. print "Hello... "  
  2. sleep 10  
  3. print "Goodbye!\n"  
print "Hello... "
sleep 10
print "Goodbye!\n"


如果你运行这个程序，你将会注意到hello,和Goodbye!\n在sleep之后同时打印到屏幕，而且Hello...后面并没有换行符.

我们这时可以使用flush方法来来刷新缓冲区，在这里我们使用 $defout作为接收者：

Ruby代码 
  1. print "Hello... "  
  2. STDOUT.flush  
  3. sleep 10  
  4. print "Goodbye!\n  
print "Hello... "
STDOUT.flush
sleep 10
print "Goodbye!\n


sync= 方法可以关闭缓冲，sync则可以返回此时的是否有缓冲:
Ruby代码 
  1. buf_flag = $defout.sync    # true  
  2. STDOUT.sync = false  
  3. buf_flag = STDOUT.sync     # false  
buf_flag = $defout.sync    # true
STDOUT.sync = false
buf_flag = STDOUT.sync     # false


这里还有一个更底层的缓冲操作，getc方法返回一个字符，ungetc则将一个字符压回流:
Ruby代码 
  1. ch = mystream.getc    # ?A  
  2. mystream.ungetc(?C)  
  3. ch = mystream.getc    # ?C  
ch = mystream.getc    # ?A
mystream.ungetc(?C)
ch = mystream.getc    # ?C


这里注意，这个缓冲和上面所说的并不一样，比如sync= false并不能关掉上面的缓冲。ungetc将不能在比如sysread方法里使用，因为sysread是一个没有缓冲的读操作.

9操作文件的权限和所有权

为了得到一个文件的权限和所有者，我们能够是用File的uid和gid方法：

Ruby代码 
  1. data = File.stat("somefile")  
  2. owner_id = data.uid  
  3. group_id = data.gid  
data = File.stat("somefile")
owner_id = data.uid
group_id = data.gid


类File::Stat 有一个实力方法mode,它返回文件的权限:

Ruby代码 
  1. perms = File.stat("somefile").mode  
perms = File.stat("somefile").mode


File的chown方法能够改变一个文件的拥有者和组id:

Ruby代码 
  1. uid = 201  
  2. gid = 10  
  3. File.chown(uid, gid, "alpha", "beta")  
  4. f1 = File.new("delta")  
  5. f1.chown(uid, gid)  
  6. f2 = File.new("gamma")  
  7. f2.chown(nil, gid)      # Keep original owner id  
uid = 201
gid = 10
File.chown(uid, gid, "alpha", "beta")
f1 = File.new("delta")
f1.chown(uid, gid)
f2 = File.new("gamma")
f2.chown(nil, gid)      # Keep original owner id


chmod 方法能够改变一个文件的权限：

Ruby代码 
  1. File.chmod(0644, "epsilon", "theta")  
  2. f = File.new("eta")  
  3. f.chmod(0444)  
File.chmod(0644, "epsilon", "theta")
f = File.new("eta")
f.chmod(0444)


我们经常需要知道某个文件，我们是否有读或者写的权限，我们可以使用File::Stat类的一些实例方法:

Ruby代码 
  1. info = File.stat("/tmp/secrets")  
  2. rflag = info.readable?  
  3. wflag = info.writable?  
  4. xflag = info.executable?  
info = File.stat("/tmp/secrets")
rflag = info.readable?
wflag = info.writable?
xflag = info.executable?


有时我们需要区分有效的用户id,和实际的用户id,我们可以使用readable_real?, writable_real?, 和 executable_real?:
Ruby代码 
  1. info = File.stat("/tmp/secrets")  
  2. rflag2 = info.readable_real?  
  3. wflag2 = info.writable_real?  
  4. xflag2 = info.executable_real?  
info = File.stat("/tmp/secrets")
rflag2 = info.readable_real?
wflag2 = info.writable_real?
xflag2 = info.executable_real?


可以通过比较当前进程的有效用户ID（和组ID）来测试文件的所有权,File::Stat类有实例方法 owned?和grpowned?

注意这些方法，很多在FileTest里面也有:

Ruby代码 
  1. rflag = FileTest::readable?("pentagon_files")  
  2.     # Other methods are: writable? executable? readable_real?  
  3. writable_real?  
  4.     # executable_real? owned? grpowned?  
  5.     # Not found here: uid gid mode  
rflag = FileTest::readable?("pentagon_files")
    # Other methods are: writable? executable? readable_real?
writable_real?
    # executable_real? owned? grpowned?
    # Not found here: uid gid mode


和进程联系在一起的umask方法决定了一个新的文件的初始权限.(unmask的具体含义去网上搜索搜索就有了).

可以通过File的类方法unmask方法来获取umask。如果指定一个参数，则umask将会被设置为这个，并且将会返回原来的umask:

Ruby代码 
  1. File.umask(0237)             # Set the umask  
  2. current_umask = File.umask   # 0237  
File.umask(0237)             # Set the umask
current_umask = File.umask   # 0237


10 得到和设置时间戳信息

ruby所能理解的时间戳分三种,修改时间，访问时间和改变时间.

mtime, atime和ctim分别返回这三种时间:

Ruby代码 
  1. t1 = File.mtime("somefile")  
  2. # Thu Jan 04 09:03:10 GMT-6:00 2001  
  3. t2 = File.atime("somefile")  
  4. # Tue Jan 09 10:03:34 GMT-6:00 2001  
  5. t3 = File.ctime("somefile")  
  6. # Sun Nov 26 23:48:32 GMT-6:00 2000  
t1 = File.mtime("somefile")
# Thu Jan 04 09:03:10 GMT-6:00 2001
t2 = File.atime("somefile")
# Tue Jan 09 10:03:34 GMT-6:00 2001
t3 = File.ctime("somefile")
# Sun Nov 26 23:48:32 GMT-6:00 2000


如果正好创建了file实例或者File:;Stat实例，则可以使用实例方法：
Ruby代码 
  1. myfile = File.new("somefile")  
  2. t1 = myfile.mtime  
  3. t2 = myfile.atime  
  4. t3 = myfile.ctime  
  5.   
  6. info = myfile.stat  
  7.   
  8. t1 = info.mtime  
  9.   
  10. t2 = info.atime  
  11.   
  12. t3 = info.ctime  
myfile = File.new("somefile")
t1 = myfile.mtime
t2 = myfile.atime
t3 = myfile.ctime

info = myfile.stat

t1 = info.mtime

t2 = info.atime

t3 = info.ctime


文件的访问和修改时间能够通过utime来修改:
Ruby代码 
  1. today = Time.now  
  2. yesterday = today - 86400  
  3. File.utime(today, today, "alpha")  
  4. File.utime(today, yesterday, "beta", "gamma")  
today = Time.now
yesterday = today - 86400
File.utime(today, today, "alpha")
File.utime(today, yesterday, "beta", "gamma")


由于他是同时改变两个时间，因此如果你想只改变一个的话，就要先保存:

Ruby代码 
  1. mtime = File.mtime("delta")  
  2.   
  3. File.utime(Time.now, mtime, "delta")
]]>