Class c1 = new ArrayList().getClass();
Class c2 = new ArrayList().getClass();
System.out.println(c1 == c2); //true

“The cold truth is:There’s no information about generic parameter types available inside generic code”–对于List 和 List 这两种泛型类型来说, 他们的运行时类型是一样的, 事实上，jvm并不知道泛型，所有的泛型在编译阶段就已经被处理成了普通类和方法。jvm会认为都是List类型, List中的元素的”String”类型和”Integer”类型就给擦除(erased)掉了. 虽然擦除掉了, 但我们知道, java是强类型语言, 不管什么元素, 你总得有一个类型才行, 否则jvm就没法处理, 编译器也不会过. 那List里的元素被认为成什么类型呢?
一般说来, 泛型的类型尖括号里面的泛型类型, 在编译时会被处理成一个原始类型.
如果有限定()，jvm就A作为原始类型
如果有多个限定()，jvm就用第一个边界的类型变量A类作为原始类型
如果泛型类型的类型变量没有限定() ，等同于(), 所以就用Object作为原始类型

class Gener {
T data = null;
void print(T t) {
System.out.println(t);
}
}
编译器会擦除掉类型变量T, 并且把T用原始类型A来替代,
class Gener{
A data = null;
void print(A t) {
System.out.println(t);
}
}
为什么说java泛型是被阉割了的? 我们来看看c++的泛型使用.
#include
using namespace std;
template class Manipulator {
T obj;
public:
Manipulator(T x) { obj = x; }
void manipulate() { obj.f(); }
};
class HasNoF{}
class HasF {
public:
void f() { cout << "HasF::f()" << endl; }
};
int main() {
HasF hf;
Manipulator manipulator(hf);
manipulator.manipulate();

// HasNoF hnf;
// Manipulator manipulator(hnf);
}
Output:
HasF::f()

看出蹊跷来了么?泛型类Manipulator里面居然可以直接对obj调用f方法(obj.f()), 他怎么能够知道泛型参数T所对应的类有f()这样一个方法呢??? 答案就是c++的编译器. 当我们在代码里用HasF类来实例化Manipulator时, 编译器进行检查并发现了HasF类是有一个方法f()的. 编译器就会同意你在Manipulator类型中调用T的f()方法. 反之, 如果在所有实例化Manipulator的类中, 只要有一个没有方法f(), 则编译器报错. 你可以仿照这个写出java代码, 然后就会发现, 在java中, 我们只能调用Object的方法(的情况).

一些隐含的问题: 桥方法(bridge method), 看下面的例子
public class Gener {
void print(T t) {
System.out.println(“parent: ” + t);
}
public static void main(String[] args) {
Gener s = new SonGener();
s.print(new Object());
}
}

class SonGener extends Gener {
void print(String s) {
System.out.println(“son: ” + s);
}
}
输出->
Exception in thread “main” java.lang.ClassCastException: java.lang.Object cannot be cast to java.lang.String
at SonGener.print(Gener.java:1)
at Gener.main(Gener.java:15)
为啥??
首先, 这个代码编译是通过的, 说明在编译器认为这个代码的是o的. 不是废话的废话, 埋笔.
我们先来梳理下这个代码. 首先声明了一个Gener类型的s变量, 然后让这个变量指向了一个SonGen类型的对象, 最后通过变量s调用print方法. 前面讲过, java的泛型在编译的时候会被处理成一个原始类型, 例子中Gen的T就被处理成了Object. 那么代码实际上就变成了这样的:
public class Gener {
void print(Object t) {
System.out.println(“parent: ” + t);
}
public static void main(String[] args) {
Gener s = new SonGener();
s.print(new Object());
}
}
class SonGener extends Gener {
void print(String s) {
System.out.println(“son: ” + s);
}
}
基于以上的分析, 这个变化后的代码没有任何问题. 运行这个代码, 可以得到输出: “parent: java.lang.Object@1690726″. fk, 这是怎么回事? 我们基于原型的分析是错误的? 再回头来, 我们看下报的错误, “java.lang.ClassCastException: java.lang.Object cannot be cast to java.lang.String”
代码中只有SonGener的print方法需要String类型的参数, 并且直觉上感觉, 这个错误的发生是因为向SonGener的print方法中传递了一个Object类型的参数, 在把Object cast to String的时候, 喀嚓了
同时, 回想下前面的那句废话, 说明这个因调用引起的cast过程是在运行时发生的, 即编译的时候, 编译器还不知道s.print(new Object())会调用print(String s), 否则编译器就直接”出红”了. 不玩虚了, 我们还是看下SonGener的字节码吧.

Compiled from “Gener.java”
class SonGener extends Gener{
SonGener();
Code:
0: aload_0
1: invokespecial #1; //Method Gener.”“:()V
4: return

void print(java.lang.String);
Code:
0: getstatic #2; //Field java/lang/System.out:Ljava/io/PrintStream;
3: new #3; //class java/lang/StringBuilder
6: dup
7: invokespecial #4; //Method java/lang/StringBuilder.”“:()V
10: ldc #5; //String son:
12: invokevirtual #6; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
15: aload_1
16: invokevirtual #6; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
19: invokevirtual #7; //Method java/lang/StringBuilder.toString:()Ljava/lang/String;
22: invokevirtual #8; //Method java/io/PrintStream.println:(Ljava/lang/String;)V
25: return

void print(java.lang.Object);
Code:
0: aload_0
1: aload_1
2: checkcast #9; //class java/lang/String
5: invokevirtual #10; //Method print:(Ljava/lang/String;)V
8: return
}
…汗了, 这个void print(java.lang.Object)是个什么鸟玩? 查了下, 这货就是桥方法(bridge method).
桥方法是编译器自己偷偷搞出的东西, 在java的source里面是看不出痕迹的. 我所知道的用了桥方法的地方有, 子类继承了带有泛型化参数的父类(正在说的这个), 还一个场景就是public的子类继承了非public的父类…
详细的介绍, 看这儿
接着来, 我们先别急着问编译器为什么要搞出这么个东西, 先来顺着编译器的桥方法的思路重新来梳理下代码. 如果SonGener里面生成了桥方法, 则代码应该是这样的:
public class Gener {
void print(Object t) {
System.out.println(“parent: ” + t);
}

public static void main(String[] args) {
Gener s = new SonGener();
s.print(new Object());
}
}
class SonGener extends Gener {
void print(String s) {
System.out.println(“son: ” + s);
}

void print(Object s){
// i’m the bridge method
print((String) s);
}
}
如果是这样的话, 则SonGener的print(Object s)方法就覆盖了父类的print, 请注意下面的话, 只是这个覆盖是由编译器偷偷生成的桥方法来覆盖的, 而不是print(String s)来覆盖的. 桥方法print(Object s)只是做了一个代理, 内部再次调用了print(String s), 而在调用之前需要有一个cast操作, 我们的错误就是在这里蹦出来的. 小结下: 1. 本意应该调用父类Gener的print方法, 由于子类SonGener中桥方法的存在, 使得print方法被覆盖, 所以会调用子类SonGener的print方法; 2. 桥方法只是做一个代理, 会调用真实的print(String s)方法. 其实, 细心的人可以发现, 在eclipse中编译代码时, 那个覆盖方法的绿色小三角会出现在print(String s)的方法旁边.
话说回来了, 为么子要搞这个桥方法出来呢? 下面只是我个人的想法. 因为java泛型的阉割, 导致jvm中的编译是将泛型蜕化成了原始类型, 这就会导致一个问题, 就是在泛型中定义的一些函数无法被覆盖, 比如Gener的print(T t), 对于编码的人来说, 当SonGener继承Gener时, 自然不会考虑到其父类会存在一个print(String s); 即使有, 我重写一个覆盖你总可以吧. 而在尝试重写print(String s)时, 却发现怎么都覆盖不了, 因为父类有一个print(Object o)罩着呢. 所以, 为了兼容也好, 对泛型阉割的补救也罢, 桥方法诞生了.
class SonGener extends Gener {
void print(String s) {
System.out.println(“son: ” + s);
}
}

关于泛型蜕化成什么类型的问题, 我还有点没想透, 想清楚了再补上.

bridge method详解: http://stas-blogspot.blogspot.com/2010/03/java-bridge-methods-explained.html

http://hxraid.iteye.com/blog/549509

http://wen66.iteye.com/blog/730995

今天给开机之后ubuntu更新, 竟然提示说磁盘空间满. df一看, 根目录只有不到190MB. 但是根目录没道理用的这么快, 于是检查下, 看看是哪个文件占用了大量的磁盘. 如果有必要, 以下命令可能需要加上sudo.

du -m –max-depth=1 | sort -g
du -h –max-depth=1 /var/*

层层递进之后发现是因为mysql目录下的ibdata文件太大, 竟然就占用了5G大小, 用了很长时间, 也是该清理下了. 思路很简单, 就是先备份数据库, 然后删除, 再还原数据库就行了.

# 备份数据库
mysqldump -uDBuser -pPassword –quick –force –routines –add-drop-database –all-databases –add-drop-table > /home/liubida/backup.sql

# 关闭mysql服务
sudo service mysql stop

# 手动删除除mysql之外所有文件
sudo rm /var/lib/mysql/ib*
sudo rm /var/lib/mysql/armory -rf
…

# 启动mysql服务
sudo service mysql start

# 还原数据库
mysql -uDBuser -pPassword < /home/liubida/backup.sql

最后, 看看根目录的变化吧.

liubida@liubida-office:/var/lib/mysql$ df -h
Filesystem Size Used Avail Use% Mounted on
/dev/sda6 9.4G 4.5G 4.5G 51% /
none 1.6G 664K 1.6G 1% /dev
none 1.6G 3.7M 1.6G 1% /dev/shm
none 1.6G 112K 1.6G 1% /var/run
none 1.6G 0 1.6G 0% /var/lock
/dev/sda7 93G 81G 7.3G 92% /home

附1:
mysqldump命令参数说明:

–quick, -q
在恢复数据的时候强制让mysqldump一行一行的恢复, 而不是把整个行数据缓存之后一次恢复.(我的理解: 尽快的恢复每一行数据, 能够尽可能的降低数据的不可读时间)

This option is useful for dumping large tables. It forces mysqldump to retrieve rows for a table from the server a
row at a time rather than retrieving the entire row set and buffering it in memory before writing it out.

–force, -f
强制执行完成, 如果遇到错误打印出错误信息, 继续执行后续的sql语句

Continue even if an SQL error occurs during a table dump.

One use for this option is to cause mysqldump to continue executing even when it encounters a view that has become
invalid because the definition refers to a table that has been dropped. Without –force, mysqldump exits with an
error message. With –force, mysqldump prints the error message, but it also writes an SQL comment containing the
view definition to the dump output and continues executing.

–routines, -R
对存储过程和事务也进行dump

Included stored routines (procedures and functions) for the dumped databases in the output. Use of this option
requires the SELECT privilege for the mysql.proc table. The output generated by using –routines contains CREATE
PROCEDURE and CREATE FUNCTION statements to re-create the routines. However, these statements do not include
attributes such as the routine creation and modification timestamps. This means that when the routines are reloaded,
they will be created with the timestamps equal to the reload time.

If you require routines to be re-created with their original timestamp attributes, do not use –routines. Instead,
dump and reload the contents of the mysql.proc table directly, using a MySQL account that has appropriate privileges
for the mysql database.

This option was added in MySQL 5.1.2. Before that, stored routines are not dumped. Routine DEFINER values are not
dumped until MySQL 5.1.8. This means that before 5.1.8, when routines are reloaded, they will be created with the
definer set to the reloading user. If you require routines to be re-created with their original definer, dump and
load the contents of the mysql.proc table directly as described earlier.

–add-drop-database

Add a DROP DATABASE statement before each CREATE DATABASE statement. This option is typically used in conjunction
with the –all-databases or –databases option because no CREATE DATABASE statements are written unless one of those
options is specified

–add-drop-table

Add a DROP TABLE statement before each CREATE TABLE statement

–all-databases, -A

Dump all tables in all databases. This is the same as using the –databases option and naming all the databases on
the command line

附2:
在ubuntu10.04系统下, mysql服务的操作命令
sudo /etc/init.d/mysql start/stop/restart
sudo service mysql start/stop/restart

参考:
http://hi.baidu.com/higkoo/blog/item/4d52f05241dab9050df3e3ce.html
http://www.lampblog.net/2011/01/linux%E4%B8%8B%E6%9F%A5%E7%9C%8B%E6%96%87%E4%BB%B6%E5%92%8C%E6%96%87%E4%BB%B6%E5%A4%B9%E5%A4%A7%E5%B0%8F%E7%9A%84df%E5%92%8Cdu%E5%91%BD%E4%BB%A4/

大致的环境:
eclipse: Indigo
os: ubuntu11.04(32bit)

需要预装的命令包:
git : sudo apt-get install git-core

1. 先到android source上下载源码包命令很简单, 照做就行.

“To check out a branch other than “master”, specify it with -b:
$ repo init -u https://android.googlesource.com/platform/manifest -b android-4.0.1_r1″

这个命令的意思是去下载android-4.0.1_r1分支, 而不是从主干(master)上下东西. 具体查看每个分支的名字, 可以这样点这里.
如果这个步骤还不是很清楚, 可以参看这个post http://android.yaohuiji.com/archives/2652

执行 “$ repo init -u https://android.googlesource.com/platform/manifest -b android-4.0.1_r1″时
要进入你要下载的目的文件夹($DEST)里面, 不然会载的满地都是. 下载的时候会提示你输入用户名, 邮箱之类的, 按部就班即可.

2.下载完成之后, 在你的$DEST目录下就会有若干的文件夹, dalvik, bootable之类的, 这些就是android的源文件了, 有底层的cpp, 也有应用层的java. 但是我们需要的java散落在各个目录下, 如何整理起来使之能够attach到eclipse上呢?
在这里, 作者写了个python脚本, 能够按照包名来抓取所需的java文件.

在你的$DEST目录下执行这个脚本, 就会生成source.zip文件. 然后在eclipse里面attach这个文件就可以看到source code了.

3. 为了避免每个项目都要attach这个文件, 把source.zip解压到eclipse默认的source位置: /android-sdk/platforms/android-14/sources, 就一劳永逸了.

公司的网速不坑爹, 源码一会就下载完成, 我把最后打包好的sources.zip放出来, 希望能给需要的朋友一点帮助.
android-14_sources.zip 对应的branch: android-4.0.1_r1
android-7_sources.zip 对应的branch: android-2.1_r1

对于一般的开发时看源码的需求来说, 这两个版本基本上就够用了, 如果的确有需求某个版本的, 可以到国内这个post去看看, 他提供了直接的源码压缩包下载, 如果需要自行编译android玩玩而网速又不行的朋友可以去看看, 我试了下, 速度30KB/s左右.

http://zhuwenhao.com/950/%E6%8A%80%E6%9C%AF/%E8%87%AA%E7%94%B1%E8%BD%AF%E4%BB%B6%E7%A4%BE%E5%8C%BA/android/%E6%8F%90%E4%BE%9B%E6%9C%80%E6%96%B0%EF%BC%8C%E6%9C%80%E5%AE%8C%E6%95%B4%E7%9A%84android%E6%BA%90%E4%BB%A3%E7%A0%81%E5%8E%8B%E7%BC%A9%E5%8C%85%E4%B8%8B%E8%BD%BD/

当然, 也可以留言给我, 帮你下载并打包出sources.zip的.


感谢这些朋友:
http://stuffthathappens.com/blog/2008/11/01/browsing-android-source-in-eclipse/
http://blog.michael-forster.de/2008/12/view-android-source-code-in-eclipse.html?showComment=1324861622343#c6560476551216066901
http://android.opensourceror.org/2010/01/18/android-source –这个网址的sources.zip下载失效了.

How can I view all available branches besides cupcake, i.e eclair, donut, etc…?
$ git clone git://android.git.kernel.org/platform/manifest.git
$ cd manifest
$ git branch -r

来自这里

执行的定时任务是对宿主机刷新数据. 任务由很多线程执行, 并且在涉及到数据库update的方法时, 使用了spring的@Transactional来标记为事务处理, 我们定义为事务A.
比较关键的几个sql语句,
1. select lock_state from server where id = ? for update
2. update server set lock_state = ? where id = ?
3. select s.*, d.*, s.id as server_id, ast.po_number as po, ast.in_service_date as buy_time, ast.cost_value as original_cost, v.host_id as host_id, v.vm_index as vm_index, v.vm_resource as vm_resource, v.state as vm_state, v.op_state as op_state, cpu.amount as cpu_amount, cpu.core_num as cpu_core, mssize as mem_size from server s left join device_base d on s.device_base_id = d.id left join device_base_asset ast on ast.tag_number = d.assets_num right join vmserver v on v.server_id = s.id left join cpu on s.id = cpu.server_id left join (select server_id,sum(size) mssize from memory_slot group by server_id) mstmp on mstmp.server_id = s.id where v.host_id in ( ? )
4. update vmserver set state = ? where host_id = ?
5. update server set lock_state = ? where id = ?

我们对着这几个简单的语句研究了半天也没发现有什么不妥, 只是语句1的”for update”有点点风险.
mysql中使用for update, 必须针对InnoDB, 并且在一个事务中, 才能起作用. 它会对查询的数据加上行锁,或者表锁. 在我们的场景中, 是加上了行锁.

后来通过查看show innodb status的输出,
------------------------
LATEST DETECTED DEADLOCK
------------------------
111123 13:30:02
*** (1) TRANSACTION:
TRANSACTION 3 4124628169, ACTIVE 0 sec, process no 3818, OS thread id 1184938304 starting index read
mysql tables in use 3, locked 3
LOCK WAIT 28 lock struct(s), heap size 6752, 429 row lock(s)
MySQL thread id 2015123, query id 2099159826 172.22.24.98 armory Sending data
update vmserver set op_state='UPDATE_FINISH' where host_id in ( select id from server where device_base_id in( select id from device_base where service_tag in ( '030JNA10A2000060' ) ) )
*** (1) WAITING FOR THIS LOCK TO BE GRANTED:
RECORD LOCKS space id 1857 page no 203 n bits 200 index `PRIMARY` of table `armory`.`server` trx id 3 4124628169 lock mode S locks rec but not gap waiting
Record lock, heap no 122 PHYSICAL RECORD: n_fields 19; compact format; info bits 0
0: len 4; hex 800001b9; asc ;; 1: len 6; hex 0003f5d8d4c5; asc ;; 2: len 7; hex 00000340021a01; asc @ ;; 3: len 4; hex 80000534; asc 4;; 4: len 6; hex 78636e2d7879; asc xcn-xy;; 5: SQL NULL; 6: len 4; hex 4bbc094b; asc K K;; 7: len 4; hex 4ecc84da; asc N ;; 8: len 5; hex 312e322e33; asc 1.2.3;; 9: len 13; hex 5550444154455f46494e495348; asc UPDATE_FINISH;; 10: len 1; hex 01; asc ;; 11: len 1; hex 08; asc ;; 12: len 7; hex 312e312e313135; asc 1.1.115;; 13: len 13; hex 5550444154455f46494e495348; asc UPDATE_FINISH;; 14: len 1; hex 88; asc ;; 15: len 10; hex 4e4f5f494e5354414c4c; asc NO_INSTALL;; 16: len 7; hex 6e6f4572726f72; asc noError;; 17: len 7; hex 6e6f4572726f72; asc noError;; 18: SQL NULL;

*** WE ROLL BACK TRANSACTION (2)

明确了问题的关键是这两条语句
a. update vmserver set op_state='UPDATE_FINISH' where host_id in ( select id from server where device_base_id in( select id from device_base where service_tag in ('030JNA10A2000060')))
b. update vmserver set state = 'unknown' where host_id = '441'
原来在这个刷新数据的方法后面, 还有一个更新操作状态(op_state)的sql, 可恶的它居然也是一个事务处理(叫事务B). 从输出的信息已经明确的发现死锁就是发生在这两个事务当中, 那么这两个事务是肿么就死锁了呢?
先来看语句b, 这个语句b就是方法里的语句4, 基本上是只会加行锁的, 除非vmserver中查不到host_id的的值的记录, 这种情况下该语句会由行锁上升到表锁, 但是问题不在这儿.

这里需要说明下, 虽然输出信息里报的是两个transaction的这两个语句死锁, 但是一般来说, 这只能表明这两个语句是这两个事务(A和B)死锁时的最后的语句. 因为事务B只有语句a, 自然就是语句a导致死锁, 而事务A的语句就多了, 见前面的语句1,2,3. 我们思考之后, 把嫌疑放在语句1上.
对事务B的语句a的分析:
) 这个语句写的很搓, 双层嵌套in查询, 会分别对device_base, server和vmserver分别查询之后再update
) vmserver表中host_id没有建索引, 对vmserver是表锁. (为什么vmserver是表锁, 而不是只对host_id的那几行加锁? 因为host_id in (…) 在查询前是无法确定到底是要锁哪几行; 并且server中的device_base_id没有加索引, 所以server是表锁, 这也导致vmserver直接表锁)
) 这个语句写的很搓, 双层嵌套in查询, 这会导致整条语句的锁会是这三个表的锁中最强的一个.
) 加锁的顺序是先对vmserver加表锁(意向锁), 然后对server表加表锁, 然后去做update

对事务B的语句1和语句4分析:
) 本来select是不需要锁的, 但是由于”for update”, 所以需要对server加上行锁
) 然后后面的语句4, 也就是语句b, 需要对vmserver加行锁

问题来了,
事务A的加锁顺序是vmserver(表锁)->server(表锁)
事务B的加锁顺序是server(行锁)->vmserver(行锁)
fk~!

死锁分析

可以看见, 死锁的原因:
1. 事务A和B中对vmserver和server表加锁的相反顺序
2. 本来多线程之间都是各自锁自己相关的行, 由于事务B的sql写法不规范, 导致线程在事务B时升级为表锁

修正方法:
1. 修改事务B的update语句
update vmserver vms
left join server s on s.id = vms.host_id
left join device_base db on db.id = s.device_base_id
set vms.op_state= ?
where db.service_tag in (?,?,?...)
这样, 事务B的锁就退化为行锁, 那么多个线程就是各自锁各自的行, 应该不会死锁了.

tips:
1. 假设有表A(id, sid, name, comment), id是主键, sid建有索引, 表数据100条, 一个sid可能对应多个id.
那么当使用sid来对表进行update时, update A set comment = ? where sid = ?
sid=0, 有20条记录,
sid=1, 有30条记录,
sid=2, 有40条记录,
sid=3, 有10条记录,
这时候, 就有可能在sid=2或sid=3时就是对整张表加锁
2. “show innodb status”的输出信息里报的是两个transaction的两个语句死锁, 但是这只能表明这两个语句是这两个事务(A和B)死锁时的最后的语句, 并不能说明死锁一定是由这两个语句造成.
3. update的逻辑代码要加事务, sql语句不能用in
4. 由于对mysql的不熟悉, 导致我们刚开始一直没有找到问题的根源在哪里..工具很重要

后话:
有人问我为什么要在事务A中的select后面加for update, 其实这里是为了防止, 在对某台宿主机刷新数据时有用户会对用户执行操作而导致的状态异常, 和多线程之间的刷新没有关系.

筛选法–Sieve of Eratosthenes

In mathematics, the Sieve of Eratosthenes ancient algorithm for finding all prime numbers up to a specified integer. It works efficiently for the smaller primes (below 10 million). It was created by Eratosthenes, an ancient Greek mathematician. However, none of his mathematical works survived—the sieve was described and attributed to Eratosthenes in the Introduction to Arithmetic by Nicomachus.
–摘自wiki: http://en.wikipedia.org/wiki/Sieve_of_Eratosthenes

筛选法说起来还是比较简单的,它的具体过程可以看图



 
目的:列出<=n的所有质数
算法描述:
1. 创建一个从2到n的顺序列表List:[2,3,4,...,n]
2. 2是第一个质数,初始时让p=2
3. 从p开始,在List中标记出p的倍数(2倍开始,2p,3p,4p…)
4. 找出List中p之后的没有被标记的那个数,将其值赋给p
5. 重复步骤3,步骤4,直到List中p之后的所有数都被标记
6. List中未被标记的数就是质数
java代码:
    static void ListPrime2(int n) {
        /**
         * 标记0为质数,1为合数
         */
        int[] primeList = new int[n + 1];
        for (int i = 2; i <= n; i++) {
            if (primeList[i] == 0) {
                // 加法版
                int j = i + i;
                while (j <= n) {
                    primeList[j] = 1;
                   j = j + i;
                }
            }
        }
        List<Integer> ret = new ArrayList<Integer>(10000);
        for (int i = 2; i <= n; i++) {
            if (primeList[i] == 0) {
//                System.out.print(i + " ");
                ret.add(i);
            }
        }
    }

对于这个算法有几点可以优化:
a. step3: 开始比较p的倍数可以从p^2开始标记. 因为p*(p-1),p*(p-2),p*(p-3),…这些已经在前面被(p-i)标记过了,即p^2之前的都已经被判定标记过了.
b. step5: 由上面可知,p^2之前的都已经被判定标记过,则当p^2>=n时,说明n之前的都被判定标记过,筛选结束.
c. 当p=2时,所有的偶数都会被标记;则当p>2时,p的偶数倍可以直接被忽略(已经被p=2标记过).p=1p,每次标记的步长为2p, 则标记的index依次为1p,3p,5p,…
java代码:
static void ListPrime3(int n) {
        /**
         * 标记0为质数,1为合数
         */
        int[] primeList = new int[n + 1];
        for (int i = 2; i <= n; i++) {
            if (primeList[i] == 0) {
                int j = i * i;    //从p^2开始标记
                if (j > n) break; //如果p^2>n,则列表中的数已经被标记完
                if (i > 2) {
                    //当p>2时,步长为2p
                    while (j <= n) {
                        primeList[j] = 1;
                        j = j + i + i;
                    }
                } else {
                    while (j <= n) {
                        primeList[j] = 1;
                        j = j + i;
                    }
                }
            }
        }
        List<Integer> ret = new ArrayList<Integer>(10000);
        for (int i = 2; i <= n; i++) {
            if (primeList[i] == 0) {
//                System.out.print(i + " ");
                ret.add(i);
            }
        }
    }

结合前面的根号n(只筛选根号n之前的数), 下面的应该更快!
经过实际测试,Prime4和Prime3其实差不多…为什么呢?因为if (j > n) break;这一句使两者的实际循环次数一样
java代码:
    static void ListPrime4(int n) {
        /**
         * 标记0为质数,1为合数
         */
        int[] primeList = new int[n + 1];
        int sqrt = (int)Math.sqrt(n);
        for (int i = 2; i <= sqrt; i++) {
            if (primeList[i] == 0) {
                int j = i * i;    //从p^2开始标记
                //if (j > n) break; //如果p^2>n,则列表中的数已经被标记完
                if (i > 2) {
                    //当p>2时,步长为2p
                    while (j <= n) {
                        primeList[j] = 1;
                        j = j + i + i;
                    }
                } else {
                    while (j <= n) {
                        primeList[j] = 1;
                        j = j + i;
                    }
                }
            }
        }
        List<Integer> ret = new ArrayList<Integer>(10000);
        for (int i = 2; i <= n; i++) {
            if (primeList[i] == 0) {
//                System.out.print(i + " ");
                ret.add(i);
            }
        }
    }

 
 
wiki链接：
http://en.wikipedia.org/wiki/Prime_number
http://en.wikipedia.org/wiki/Sieve_of_Eratosthenes

今天小猪跑来要和我比.虽然败了但是他用了个讨巧的方法, 我也借鉴来. 果然快了许多. 2000w 668ms
Java代码:
static void ListPrime(int n) {  
        /**
         * false为质数,true为合数
         */  
        boolean[] primeList = new boolean[n + 1];  
  
        for (int i = 2; i <= n; i++) {  
            if (!primeList[i]) {  
                int j = i * i;  
                if (j > n)  
                    break;  
                if (i > 2) {  
                    while (j <= n) {  
                        primeList[j] = true;  
                        j = j + i + i;  
                    }  
                } else {  
                    while (j <= n) {  
                        primeList[j] = true;  
                        j = j + i;  
                    }  
                }  
            }  
        }  
        List<Integer> ret = new ArrayList<Integer>(10000);  
        ret.add(2);  
        for (int i = 3; i <= n;) {  
            if (!primeList[i]) {  
                //System.out.print(i + " ");    
                ret.add(i);  
            }  
            i += 2;  
        }  
    }  

没接触过lucene的童鞋可以看看 这篇文章, 算是lucence入门比较好的文章, 读完之后可以对lucene有个简单的认识. 我也是最近有项目用到了lucene, 具体实践是对数据库的某个字段做索引, 实现了一个针对该字段匹配查询. 有点意思. 然后就趁机看了下lucene中分析器(Analyzer)的一些代码, 觉得它的分词和过滤的设计还是蛮有意思的.

lucene的分析器的功能就是对输入的数据进行分词(对文本资源进行切分, 将文本按规则切分为一个个可以进入索引的最小单位)和过滤(对最小单位进行预处理, 比如大写转小写). 在lucene中, 所有的分析器都继承自抽象类Analyzer(org.apache.lucene.analysis.Analyzer). Analyzer的代码里只定义了两个毫无意义的方法. 如下所示:

分析器的分词功能由Tokenizer的子类来完成, 过滤功能由TokenFilter的子类来完成. 同样的, 这也是两个虚无飘渺的抽象类. 下面我直接以StandardAnalyzer为实例来讲述分词和过滤的过程.
StandardAnalyzer是lucene开发包中内置的一种Analyzer的实现, 这个分析器是最容易使用也是使用很频繁的一种Analyzer, 它使用了lucene内部自带的几种分词器和过滤器.
在其代码中, 可以看到StandardAnalyzer也是继承了Analyzer, 并且实现了抽象类Analyzer的tokenStream方法. 我们注意到在这个方法里, reader首先是作为参数创建了一个分词器StandardTokenizer, 然后用这个分词器依次创建了LowerCaseFilter(大写转小写)和StopFilter(停止词过滤器)这两个过滤器. 目前为止, 基本还是一头雾水, 完全不知道分词和过滤是怎样一个过程? 其实, 到目前为止, tokenStream方法只是利用分词器, 过滤器在reader这个读入流后面铺设了一个管道而已, 真正的分词和过滤过程是在另一个地方执行的. 打个比方, reader就好像是自来水管道, tokenStream所做的只是接着这个管道又铺设了一段管道, 并且这一段的管道是用StandardTokenizer这种材质制造的, 能够对流过的文本进行切分, 然后又加上了LowerCaseFilter和StopFilter这两个过滤网.

分词和过滤的操作到底是从哪里开始的呢? 以车东blog上的一段代码为例

debug进入writer.addDocument(doc), 最后发现它实际最终调用的是index包下DocumentWriter.java中的DocumentWriter类的private final void invertDocument(Document doc) throws IOException方法. 方法中这样一段代码, for循环中每次都会调用TokenStream的next()方法. 这个next()方法就是在不断的读取文本流的下一个token, 但是这个next()可并不那么简单.

TokenStream stream = analyzer.tokenStream(fieldName, reader); 这一句就是调用了StandardAnalyzer的tokenStream方法, 根据前面的描述, 在这个方法中依次创建分词器和过滤器. tokenStream方法最终返回的result的类型其实是StopFilter, 所以invertDocument方法的for循环里调用的是StopFilter的next()方法, 如下代码所示:

我们看到, StopFilter的next()方法的for循环里又调用了input的next()方法, 分析代码(此处略)可以发现这个input其实是传入参数result的类型, 也就是LowerCaseFilter. LowerCaseFilter的代码如下所示:

LowerCaseFilter的next()方法里又再次调用了input的next()方法, 而此时的input其实就是构造器的in参数, 所以input和in的类型是StandardFilter. 继续进入StandardFilter的next()方法, 代码如下所示:

好吧, 第一行又调用了input的next()方法, 这里的input是传入参数result的类型->StandardTokenizer, 继续进入StandardTokenizer的next()方法.

终于, 在这里, 我们没有继续看到next()方法. 在StandardTokenizer的next()方法里, 我们看到了深藏其中的分词功能代码. StandardTokenizer其实就是JavaCC为lucene生成的分词器, 它的next()方法则是从reader对象中取出下一个词. 这个代码的分析我就不细谈了, 水太深, 暂时也用不太着.

我们来回顾下, 源头是DocumentWriter类的invertDocument()方法中for循环, 每次循环都会调用一次next()方法, 就好像自来水管道的口, 每一次调用就好像是从管道里吸水, 调用一次就吸一次. 这里需要注意的是StopFilter的next()方法, 里面也有一个for循环, 但是注意, 这里的for循环的目的是不停的寻找停止词, 也就是说invertDocement()方法中每次调用next(), 就是一次从管道里吸水的过程, 而从管道里吸多少水是由StopFilter中next()决定的, 一旦遇到停止词就返回本次next()调用提取的词.

为了更加清晰的理解这个过程, 这几个类的关系如下图所示:

好了, 就这样吧.



——————我是分割线—————-
停止词, 指的就是如英文中的a, an, the这样的小单词, 它们在建立索引的过程中并无实际的意义, 因此需要被过滤掉, 不能加入索引.
“StopAnalyzer.ENGLISH_STOP_WORDS;” 定义了这些停止词的集合.

车东的blog: http://www.chedong.com/tech/lucene.html
lucene细致深入的分析: http://forfuture1978.iteye.com/category/89151
书: 《Ajax+Lucene构建搜索引擎》

启动APACHE时出现的提示:
httpd: Could not reliably determine the server’s fully qualified domain name, using 127.0.0.1 for ServerName

解决办法：只要把/conf/httpd.conf文件的#ServerName 前的#去掉，然后重启下服务就好了。

httpd.conf的内容:
# ServerName gives the name and port that the server uses to identify itself.
# This can often be determined automatically, but we recommend you specify
# it explicitly to prevent problems during startup.
#
# If your host doesn’t have a registered DNS name, enter its IP address here.
#
ServerName 127.0.0.1:80

感谢他们:
http://yinqingsong520.blog.163.com/blog/static/3921002009663949562
http://hi.baidu.com/zeldady/blog/item/93153533a64fe9f41a4cffe9.html

回车符与换行符的起源 转自这里
计算机还没有出现之前，有一种叫做电传打字机（Teletype Model 33）的玩意，每秒钟可以打10个字符。但是它有一个问题，就是打完一行换行的时候，要用去0.2秒，正好可以打两个字符。要是在这0.2秒里面，又有新的字符传过来，那么这个字符将丢失。于是，研制人员想了个办法解决这个问题，就是在每行后面加两个表示结束的字符。
一个叫做“回车”，‘\r’，ASCII（13），告诉打字机把打印头定位在左边界；
一个叫做“换行”，‘\n’，ASCII（10）告诉打字机把纸向下移一行。
这就是“回车”和“换行”的来历。
后来，计算机发明了，这两个概念也就被般到了计算机上。但是在初期，存储器很贵，在每行结尾加两个字符太浪费了，只加一个也可以实现相应的功能。于是，不同的系统就出现了分歧。
Unix系统里，每行结尾只有“<换行>”，即’\n‘，’10‘；
Windows系统里面，每行结尾是“<回车><换行>”，即“\r\n”，“13 10”；
Mac系统里，每行结尾是“<回车>”，即’\r‘，’13‘。
一个直接后果是，Unix/Mac系统下的文件在Windows里打开的话，所有文字会变成一行；而Windows里的文件在Unix/Mac下打开的话，在每行的结尾可能会多出一个^M符号。

实践小例:
Linux系统下test.o文件的信息:
aaa
bbb
ccc

输出结果:
97#97#97#10#98#98#98#10#99#99#99#10#
说明Unix系统中，文件只用换行符’10‘来换行。

在ipmitool使用中遇到的回车, 换行的问题分析.
输出A: 通过ipmitool进入sol模式, 进入os交互, 键入ls, 在shell中得到返回的信息.
“ipmitool -Ilanplus -Uroot -H192.168.1.100 -Ppassword sol activate”
输出B和C是我们用Process对象执行ls命令返回的输出流信息. B是用readline()读入的文本信息; C是用read()读入的byte信息, 10进制, 在C中我们发现了”13 10″这样的”\r\n”行结尾, 比较奇怪(Linux系统中不是用’\n’来换行的么?)

A
[Intranet root@ipmi-test /root]
01: #ls
02: backup install.log local_hw_oob_init_dhcp.sh ph_create.log rc.local
03: dig_test JKYYG2X ngis_post.sh post.log
04:
05: [Intranet root@ipmi-test /root]
06: #

B
01: #ls
02: backup install.log local_hw_oob_init_dhcp.sh ph_create.log rc.local
03: dig_test JKYYG2X ngis_post.sh post.log
04:
05:
06: [Intranet root@ipmi-test /root]
07:

C
01: 108 115 13 10
02: 98 97 99 107 117 112 9 32 32 105 110 115 116 97 108 108 46 108 111 103 32 32 108 111 99 97 108 95 104 119 95 111 111 98 95 105 110 105 116 95 100 104 99 112 46 115 104 32
32 112 104 95 99 114 101 97 116 101 46 108 111 103 32 32 114 99 46 108 111 99 97 108 13 10
03: 100 105 103 95 116 101 115 116 32 32 74 75 89 89 71 50 88 32 32 32 32 32 32 110 103 105 115 95 112 111 115 116 46 115 104 9 9 32 32 112 111 115 116 46 108 111 103 13 10
04: 13 13 10
05: 27 91 49 59 51 55 109 91 27 91 49 59 51 53 109 73 110 116 114 97 110 101 116 32 27 91 109 27 91 49 59 51 50 109 114 111 111 116 27 91 109 27 91 49 59 51 51 109 64 27 91 109 27 91
49 59 51 49 109 105 112 109 105 45 116 101 115 116 27 91 109 32 27 91 52 109 47 114 111 111 116 27 91 109 27 91 49 59 51 55 109 93 27 91 109 27 91 49 59 51 54 109 27 91 109 13 13 10
06: 35

注释1: 为什么B是7行?
答: 因为B是用readline()来读取的, readline()在遇到'\r','\n','\r\n'时都认为是一个行的结束. 那么在在C的03行末和04行首的"13 10 13 13 10", 这时候readline()理解就是:
1行: 13 10
2行: 13
3行: 13 10
这就导致了B多出了一行, 而A是由shell来解释的, 具体的解释方法我就不清楚了.

注释2: 如果"13 10"的确是作为结果换行的话, 那04行的"13 13 10"是有特别的解释, 还是就是普通的"回车符 回车符 换行符"来作为空行?
答: 不得而知.

注释3: 注意到A和C中最后都是有个'35'('#')输出的, 而B的最后却没有.
答: 仔细观察, C的05行就是对应的A的05行, B的06行, 表示的就是shell提示符, 只不过因为shell的提示符是有颜色的, 所以需要有字节来表示linux提示符的颜色(这是由shell去解析的)所以有一些多余的字符我们从文本上是不能进行一一映射的. 这也是B中06行有乱码的原因.
但是B中为什么会少掉最后的'#', 其实没少, B的开头第一个字符是'#', 这个'#'是上一次B的输出流中遗留下来的. 为什么会遗留? 是因为我们的B的读取线程是用的readline()来读取的, 而每次输出中的'#'后面没有回车或者换行符, 所以'#'就没有被读出来, readline()也是被这个没有回车/换行符的'#'给阻塞着.

注释4:在Java的BufferedReader中，readLine方法其实是将\r，\n以及\r\n统统认为是一行的分隔符的
答:

想蛋痛不? 把下面代码的1行和2行换下位置之后再看看输出(linux系统)? 唉, 求个解释…

校长说是编译器做了一个善意的解释,
‘\r’, 它认为是1行
‘\n’, 它认为是1行
“\n\r”, 它认为是2行
“\n\r\r”, 它认为是3行
但是一旦”\r\n”,或’\r’和’\n’连续输出, 它就把这个挨在一起’\r’和’\n’作为一行来解释, 具体为什么我就不知道了,
可能编译器认为, 一般情况下, 你要多行就直接多个’\r’或者’\n’吧, 结合着windows的’\r\n’是换行标志, 那么连续’\r’和’\n’的意思更多的可能是换一行吧.
“\n\r\n”, 它认为是2行
“\n\n\r\n\r\n\r\n\r\r\n”, 你数数是几行?