在CentOS6虚拟机上安装VirtualBox增强功能

1. 安装编译需要的库和头文件

yum install gcc -y

yum install kernel sources -y

yum install kernel-devel -y

2. 安装VirtualBox增强功能

3. 重新启动系统

安装Vertica数据库

1. 安装Vertica rpm包
2. 创建Vertica用户并设置密码
# useradd dbadmin -d /opt/dbadmin -b /opt/dbadmin
# passwd dbadmin
3. 安装Vertica数据库
# /opt/vertica/sbin/install_vertica -u dbadmin -l /opt/dbadmin -d /opt/dbadmin
4. 管理Vertica数据库。
首先以dbadmin用户登录系统
$ /opt/vertica/bin/admintools

你，死定了！

　　昨天傍晚带儿子出去玩，回家的时候路过烤肉摊，儿子想吃烤肉，于是乎我就带儿子找了个地方坐下了，要了几个烤鸡翅和一些烤肉，当然还有两瓶冰封没有王座，然后就是无止境的等......

　　儿子：爸爸，我回去要告诉姥姥。

　　爸爸：你告诉姥姥啥？

　　儿子：我告诉姥姥你请我吃烤肉了。（姥姥一直反对我们老带他吃这些东西）

　　爸爸：不会吧，你告诉姥姥我怎么办？

　　儿子诡异的笑着说：你，死定了！

Create multipul vertica database with different port number

最近在用Vertica数据库，想同时启动多个数据库实例，但是在启动的时候发现所有数据库实例都是使用的同一个端口：5433，这样在同一时间就只能使用一个数据库实例，这对我来说用起来就有太多限制了。于是今天下午搞了半天总算发现Vertica的端口定义文件，对于不同的数据库实例定义不同的端口就可以解决上面的问题了。步骤如下：

1. Create multipul database instances through "admintools". For example: mydb1 and mydb2;
2. Shutdown all database instances through "admintools";
3. Change port number for database instances.
Backup ${VERTICA_TOP}/config/share/portinfo.dat file, and change port number for some database instances.
For example: mydb1 uses 5433, mydb2 uses 5444.
4. Restart verticad service
$ sudo /etc/init.d/verticad restart

优美与忧郁

周六晚上，儿子想和我一起洗澡，于是就开始说好听的哄我：

儿子：爸爸，我想和你一起洗澡，晚上我和你一起睡觉。

爸爸：你又哄我，每次你都这样说，可一到睡觉的时候你就跑你妈那里去了。

儿子：那当然了，因为妈妈长的太优美了，你长的太忧郁了。

爸爸：&%……￥*&（*&%……&*

Java文件流关闭和垃圾回收问题

周末碰到一段代码，是关于Java IO流的，代码中出现在一个多线程的系统中，其中一段代码在打开一个文件操作流用完以后没有及时关闭，开始以为很快会出现打开文件太多或者导致内存溢出，但是在运行了很长时间以后仍然没有出现问题，后来自己写了个小程序测试了一下，总算似乎搞清楚为啥了。

先看以下一段代码

import java.io.FileInputStream;
public class TTT {
    public static void main(String[] args) throws Exception {
        for (int i = 0; i < 10; i++) {
            final String threadId = "thread_" + i;
            Thread thread = new Thread(new Runnable() {
                public void run() {
                    System.out.println(threadId + " started!");
                    try {
                        FileInputStream fis = new FileInputStream("/opt/test.log");
                        Thread.sleep(60 * 1000);
                    } catch (Exception ex) {
                        ex.printStackTrace();
                    }
                    System.out.println(threadId + " stopped!");
                }
            });
            thread.start();
        }
        Thread.sleep(10 * 60 * 1000);
    }
}

在linux上编译并运行这个类，然后使用linux的命令/usr/sbin/lsof -p 来查看这个程序打开的文件信息

$ /usr/sbin/lsof -p `ps -ef | grep java | grep TTT | awk '{print $2}'` | grep "test.log"
java    21562 fkong    3r   REG  253,0        0 35471424 /opt/test.log
java    21562 fkong    4r   REG  253,0        0 35471424 /opt/test.log
java    21562 fkong    5r   REG  253,0        0 35471424 /opt/test.log
java    21562 fkong    6r   REG  253,0        0 35471424 /opt/test.log
java    21562 fkong    7r   REG  253,0        0 35471424 /opt/test.log
java    21562 fkong    8r   REG  253,0        0 35471424 /opt/test.log
java    21562 fkong    9r   REG  253,0        0 35471424 /opt/test.log
java    21562 fkong   10r   REG  253,0        0 35471424 /opt/test.log
java    21562 fkong   11r   REG  253,0        0 35471424 /opt/test.log
java    21562 fkong   12r   REG  253,0        0 35471424 /opt/test.log

不管是在10个线程运行过程中还是运行完，使用lsof命令查看的结果都一样，都可以看到有10个文件流没有关闭。

下面我把这个代码做了一些改动，就是在线程执行完之后，将所有线程置为null，如下

import java.io.FileInputStream;
import java.util.ArrayList;
import java.util.List;
public class TTT {
    public static void main(String[] args) throws Exception {
        List threads = new ArrayList();
        for (int i = 0; i < 10; i++) {
            final String threadId = "thread_" + i;
            Thread thread = new Thread(new Runnable() {
                public void run() {
                    System.out.println(threadId + " started!");
                    try {
                        FileInputStream fis = new FileInputStream("/opt/test.log");
                        Thread.sleep(60 * 1000);
                    } catch (Exception ex) {
                        ex.printStackTrace();
                    }
                    System.out.println(threadId + " stopped!");
                }
            });
            thread.start();
            threads.add(thread);
        }
        Thread.sleep(2 * 60 * 1000);
        for (Thread thread : threads) {
            thread = null;
        }
        System.out.println("Clean up threads!");
        Thread.sleep(10 * 60 * 1000);
    }
}

再次在10个线程运行过程中和运行完毕后使用lsof查看，结果仍然类似，还是有10个文件流没有关闭。

我再次做了一些改动，在将所有线程置为null以后，增加(或者说是催促JVM)做几次gc操作，如下：

import java.io.FileInputStream;
import java.util.ArrayList;
import java.util.List;
public class TTT {
    public static void main(String[] args) throws Exception {
        List threads = new ArrayList();
        for (int i = 0; i < 10; i++) {
            final String threadId = "thread_" + i;
            Thread thread = new Thread(new Runnable() {
                public void run() {
                    System.out.println(threadId + " started!");
                    try {
                        FileInputStream fis = new FileInputStream("/opt/test.log");
                        Thread.sleep(60 * 1000);
                    } catch (Exception ex) {
                        ex.printStackTrace();
                    }
                    System.out.println(threadId + " stopped!");
                }
            });
            thread.start();
            threads.add(thread);
        }
        Thread.sleep(2 * 60 * 1000);
        for (Thread thread : threads) {
            thread = null;
        }
        System.out.println("Clean up threads!");
        
        System.gc();
        System.gc();
        System.gc();
        System.out.println("Finished GC!");
        
        Thread.sleep(10 * 60 * 1000);
    }
}

再次使用lsof查看，在运行中仍然还是可以看到那有10个文件流打开着，但是在“Finished GC!”之后，看到的结果是那10个打开的文件流都被关闭了。

最后，我干脆把那些设置thread为null的语句删除了，运行的结果也和上面执行gc操作的结果一致。

最终，JVM中对于那些打开了没有关闭的IO文件流，会在不再被使用的情况下，等到下次做Full GC的时候把他们全部回收，但是让JVM去干这些事总归还是不好的，还是那句老话，自己的事情自己做。

不使用临时变量的变量交换算法

最近无聊写的一段小程序

#include

void swap(int *px, int *py);

int main() {

int x = 1, y = 2;

printf("x=%d, y=%d\n", x, y);

swap(&x, &y);

printf("x=%d, y=%d\n", x, y);

return 0;

}

void swap(int *px, int *py) {

*px = *px + *py;

*py = *px - *py;

*px = *px - *py;

}

深入探讨 java.lang.ref 包

深入探讨 java.lang.ref 包

Java 序列化的高级认识

Java 序列化的高级认识

JMeter利用http代理服务器组件录制测试脚本

1. 在“WorkBench”右键 -> “Add” -> “Non-Test Elements” -> “HTTP Proxy Server”；
2. 在“HTTP Proxy Server”窗口的的“Test plan content” -> “Target controller:”选项中选择“Use Recording Controller”；
3. 在“HTTP Proxy Server”窗口的的“Test plan content” -> “Grouping:”选项中选择“Do not group samplers”；
4. 在“Test Plan”下新建一个“Thread Group”；
5. 在“HTTP Proxy Server”窗口底部，启动代理；
6. 设置自己的浏览器使用代理，地址是localhost:8080，其中的端口可以在“HTTP Proxy Server”窗口中修改；
7. 用浏览器访问需要测试的站点，做一些操作，然后就可以在新建的“Thread Group”下看到每一个请求的情况，当然也可以通过修改“HTTP Proxy Server”的配置参数来设置过滤条件。

JMeter压力测试需要认证的站点

通常在用JMemter做压力测试的时候都需要正对已登录的用户来做，这时就需要对创建的测试线程组做一些修改，需要添加一个“HTTP Cookie Manager”的测试组件，这个组件可以通过在 “Thread Group”上右键->Config Element->HTTP Cookie Manager来添加，然后就可以像通常测试步骤一样，先访问登录页，发送登录参数(username/password)，登录后就会通过“HTTP Cookie Manager”记住状态，然后就可以继续测试登录后的页面了。

Windows7 VPN设置

原来家里的机器是XP,使用Cisco VPN Client连公司,最近把机器系统装成Windows7以后,发现原来用的Cisco VPN Client不能使用了,具体原因不清楚,后来试着使用Windows自带的VPN工具连了一下,发现居然可以连接了,现在就把我的配置分享出来,如下:
1. 进入 "控制面板 -> 网络和 Internet -> 网络和共享中心";
2. 选择 "设置新的连接或网络";
3. 在弹出的"设置连接或网络"窗口中选择"连接到工作区",然后选择下一步;
4. 在弹出的"连接到工作区"窗口,选择"否,创建新连接",然后选择下一步;
5. 在新窗口中选择"使用我的Internet连接(VPN)";
6. 在"键入要连接的Internet地址"中,输入
Internet地址: <需要连接的公司IP地址>
目标名称: <自己随便起个名字>
然后选择下一步;
7. 在"键入您的用户名和密码"窗口中,输入用户名和密码,如果要连接的VPN是在域中,域那一项也要填写,然后选择连接;
8. 如果不能连接上VPN,打开上面新建的连接的"属性"窗口，选择“安全”选项卡
* 将“VPN类型”改成“点对点隧道协议(PPTP)”
* 将“数据加密”改成“可选加密（没有加密也可以连接）”
然后“确定”，重新连接VPN，应该就可以连上了。

祝好运!

论项目经营之道

　　龟门师徒聚而论项目经营之道。

　　师曰：论项目经营，何谓成者？

　　大子曰：成者，君上悦之，国府殷实。

　　师曰：败者若何？

　　大子曰：败者，若家破人亡，妻离子散。

　　师曰：然，成者几何，败者几何？

　　大子曰：吾之皆成，余者不足论也。

　　师喟然曰：若皆如斯，夫复何求矣！

　　众弟子默然，曰：夫复何言？