关于大端和小端，自己已经记了很多次了，可每次都忘，今天创新工场笔试，第一道题就是关于大端小端的知识，可惜，自己又忘了，怎么回事，说到底，是自己同时记大端和小端，导致容易混淆，现在只记小端了：小端，是数的高位存在内存地址的高位，小高高！

下面是从网上摘抄的一些东东，帮助理解和记忆，来自http://www.52rd.com/Blog/Detail_RD.Blog_imjacob_14837.html：

端模式（Endian）的这个词出自Jonathan Swift书写的《格列佛游记》。这本书根据将鸡蛋敲开的方法不同将所有的人分为两类，从圆头开始将鸡蛋敲开的人被归为Big Endian，从尖头开始将鸡蛋敲开的人被归为Littile Endian。小人国的内战就源于吃鸡蛋时是究竟从大头（Big-Endian）敲开还是从小头（Little-Endian）敲开。在计算机业Big Endian和Little Endian也几乎引起一场战争。在计算机业界，Endian表示数据在存储器中的存放顺序。下文举例说明在计算机中大小端模式的区别。

如果将一个32位的整数0x12345678存放到一个整型变量（int）中，这个整型变量采用大端或者小端模式在内存中的存储由下表所示。为简单起见，本书使用OP0表示一个32位数据的最高字节MSB（Most Significant Byte），使用OP3表示一个32位数据最低字节LSB（Least Significant Byte）。

地址偏移	大端模式	小端模式
0x00	12（OP0）	78（OP3）
0x01	34（OP1）	56（OP2）
0x02	56（OP2）	34（OP1）
0x03	78（OP3）	12（OP0）

如果将一个16位的整数0x1234存放到一个短整型变量（short）中。这个短整型变量在内存中的存储在大小端模式由下表所示。

地址偏移	大端模式	小端模式
0x00	12（OP0）	34（OP1）
0x01	34（OP1）	12（OP0）

由上表所知，采用大小模式对数据进行存放的主要区别在于在存放的字节顺序，大端方式将高位存放在低地址，小端方式将 高位存放在高地址。采用大端方式进行数据存放符合人类的正常思维，而采用小端方式进行数据存放利于计算机处理。到目前为止，采用大端或者小端进行数据存 放，其孰优孰劣也没有定论。

有的处理器系统采用了小端方式进行数据存放，如Intel的奔腾。有的处理器系统采用了大端方式进行数据存放，如IBM半导体和Freescale的PowerPC处理器。不仅对于处理器，一些外设的设计中也存在着使用大端或者小端进行数据存放的选择。

因此在一个处理器系统中，有可能存在大端和小端模式同时存在的现象。这一现象为系统的软硬件设计带来了不小的麻烦，这要求系统设计工程师，必须深入理解大端和小端模式的差别。大端与小端模式的差别体现在一个处理器的寄存器，指令集，系统总线等各个层次中。

转自：http://jaskell.blogbus.com/logs/3249971.html

一、同余

    我们来了解一下什么是“同余”。简单来说就是，如果两个数都除以某个数能够有相同的余数，那么我们就说这两个数“同余”。不过这次我们用严谨的数学概念来表述：

    两个整数 a，b，若它们除以整数 m 所得的余数相等，则称 a，b 对于模 m 同余

    记作

    读作 a 同余于 b 模 m ，或读作 a 与 b 关于模 m 同余。

    比如

    我们再来了解一下相关的性质：

1. 如果 ，那么 m | (a − b) ，这里 m | (a − b) 表示 (a − b) 能被 m 整除
2. 如果 ，, 那么
3. 如果 ，, 那么，，，
4. 如果 ， 那么  

    有了这些性质，判断两个数是否同余就可以用更简单的方法了。根据性质一，原来我们需要判断 (a mod m) == (b mod m) 是否为真，现在就可以直接判断 (a - b) mod m == 0 是否为真了。这样就把其中一次求余运算变为减法运算了。一般来说减法要比除法更容易在计算机上实现，运算速度也更快。

二、求余 (a * b * c * d) mod m = ?

    由于计算机表示一个整数通常用 32bit 。而大量连乘运算则可能会导致整数溢出，这时我们就要利用求余一些性质来进行处理了。把以上式子转换为：

    已知： (a * b) mod m == ((a mod m) * b) mod m

    所以： (a * b * c * d) mod m = ((((((a mod m) * b) mod m) * c) mod m) * d) mod m

    这样就把连乘运算分解了，每次可以先进行求余运算然后再进行乘法运算。

使用的是Ubuntu 9.10发行版，找了好半天中文输入法，发现目前最好/最新的是ibus（前身是鼎鼎大名的scim-python，对于我这个linux小白来说，并不是鼎鼎大名的...），严格来说它不是一个输入法，而是一个输入法框架，9.10自带的ibus里有N多国家的输入法（基于ibus框架）。ubuntu9.10里面ibus自带的中文PinYin输入法好像一开始不能用...（拿不准...），必须去Preferences里面的IBus Preferences里面的Input Method中自己添加“汉语-PinYin”输入法，如果开始没有，需要安装ibus-pinyin，见下面的第4步。

在网上找了点资料，在ibus已经加入到Ubuntu的源了，如果需要，使用下面的命令进行安装：

1. sudo apt-get update                                   更新软件包列表
2. sudo apt-get install ibus                            安装ibus框架
3. sudo apt-get install ibus ibus-table        安装某些输入法引擎基础，如果仅仅想使用拼音输入法，可以跳过此步，拼音输入法不需要依赖ibus-table。某些输入法，如五笔，依赖ibus-table。
4. sudo apt-get install ibus ibus-pinyin       安装拼音输入法引擎，发现很好用啊，哈哈

由于安装和卸载软件是使用的必须前提，所以这里对apt命令进行一些总结。在总结之前，还得对ubuntu的软件源的地址进行说明，为了达到好的下载源的速度，最好选一个最快的软件源，目前来说http://ubuntu.srt.cn是最快的，ubuntu自己提供了检测的功能，可以自动检测（choose a download server -> select best server）。

关于apt-get命令的详细而简单的说明，是《AptGetHowTo》。注意，使用apt-get命令必须要用root权限。这里，摘抄了最常用的命令....如下

Installation commands

• apt-get install <package_name> 

  This command installs a new package.

• apt-get build-dep <package_name> 

  This command searches the repositories and installs the build dependencies for <package_name>. If the package is not in the repositories it will return an error.

• aptitude install <package_name>

  Aptitude is a [http://en.wikipedia.org/wiki/Ncurses Ncurses] viewer of packages installed or available. Aptitude can be used from the command line in a similar way to apt-get. See man aptitude for more information.

• APT and aptitude will accept multiple package names as a space delimited list. For example:

  apt-get install <package1_name> <package2_name> <package3_nam
  
  
  

Search commands

• apt-cache search <search_term>

  This command will find packages that include <search_term>.

• dpkg -l *<search_term>*

  This will find packages whose names contain <search_term>. Similar to apt-cache search, but also shows whether a package is installed on your system by marking it with ii (installed) and un (not installed).

• apt-cache show <package_name>

  This command shows the description of package <package_name> and other relevant information including version, size, dependencies and conflicts.

 

Typical usage example

I want to feel the wind in my hair, I want the adrenaline of speed. So lets install a racing game. But what racing games are available?

apt-cache search racing game

It gives me a lot of answers. I see a game named "torcs". Lets get some more information on this game.

apt-cache show torcs

Hmmm... it seems interesting. But is this game not already installed on my computer? And what is the available version? Is it from Universe or main?

apt-cache policy torcs

Ok, so now, let's install it!

apt-get install torcs

What is the command I must type in the console to launch this game? In this example, it's straightforward ("torcs"), but that's not always the case. One way of finding the name of the binary is to look at what files the package has installed in "/usr/bin". For games, the binary will be in "/usr/games". For administrative programs, it's in "/usr/sbin".

dpkg -L torcs | grep /usr/games/

The first part of the command display all files installed by the package "torcs" (try it). With the second part, we ask to only display lines containing "/usr/games/".

Hmmm, that game is cool. Maybe there are some extra tracks?

apt-cache search torcs

But I'm running out of space. I will delete the apt cache!

apt-get clean

Oh no, my mother asked me to remove all games from this computer. But I want to keep the configuration files so I can simply re-install it later.

apt-get remove torcs

If I want to also remove config files :

apt-get purge torcs

文章来源:http://localhost/wp2/?p=180

由于宿舍网络情况比较复杂，想为tattoo搭建一个proxy，没想到在android中没有找到设置proxy的地方。上网查了一篇文章，可以解决这个问题。

转自 http://alexmogurenko.com/blog/programming/android-how-to-set-proxy-for-android-browser/

下面是原文

There are many reasons to make browser serf pages through proxy server:

• someone wanna catch http requests/responses
• someone wanna hide his IP
• so on

What to do if you want set proxy for android browser? there some ways:

• add record to database: /data/data/com.android.providers.settings/databases/settings.db

1. pull database to pc add record (using for example sdk tool sqlite3) and replace existing db
2. make changes in database directly on device

but as for me there exist simplier way, do it by your Java application using Settings provider:

Settings.System.putString(getContentResolver(), Settings.System.HTTP_PROXY, "proxy_ip:proxy_port");

where proxy_ip/proxy_port = IP/port of proxy that you going to use.

there left one problem, it will not work if we will not add one string to manifest file, here it is:

<uses-permission android:name=”android.permission.WRITE_SETTINGS” />

Thats all, now it works, here is code:

package com.BrowserSettings;

import android.app.Activity;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.provider.Settings;

public class BrowserSettingsUI extends Activity {
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);

final Button button = (Button) findViewById(R.id.Button01);
button.setOnClickListener(new Button.OnClickListener() {
public void onClick(View v) {
try
{
Settings.System.putString(getContentResolver(), Settings.System.HTTP_PROXY, "127.0.0.1:100");//enable proxy
}catch (Exception ex){
}
}
});

final Button button2 = (Button) findViewById(R.id.Button02);
button2.setOnClickListener(new Button.OnClickListener() {
public void onClick(View v) {

try
{
Settings.System.putString(getContentResolver(), Settings.System.HTTP_PROXY, "");//disable proxy
}catch (Exception ex){
}
}
});

}
}

manifest file:

<?xml version=”1.0″ encoding=”utf-8″?>
<manifest xmlns:android=”http://schemas.android.com/apk/res/android”
package=”com.BrowserSettings”
android:versionCode=”1″
android:versionName=”1.0.0″>
<application android:icon=”@drawable/icon” android:label=”@string/app_name”>
<activity android:name=”.BrowserSettingsUI”
android:label=”@string/app_name”>
<intent-filter>
<action android:name=”android.intent.action.MAIN” />
<category android:name=”android.intent.category.LAUNCHER” />
</intent-filter>
</activity>
</application>
<uses-permission android:name=”android.permission.WRITE_SETTINGS” />
</manifest>

文章来源:http://localhost/wp2/?p=172

最近在学习《算法导论》时，发现很多证明都用到了数学归纳法，这里查了点资料，把数学归纳法复习一下：

数学归纳法用来在数学上证明与自然数N有关的命题的一种特殊方法，它主要用来研究与正整数有关的数学问题，在高中数学中常用来证明等式成立和数列通项公式成立。

用的最多的是第一数学归纳法和第二数学归纳法，下面详细说明。

第一数学归纳法

1. 证明当n（n为自然数）取第一个值时命题成立
2. 假设当n=k（k为自然数）时命题成立，证明当n=k+1时命题也成立

由1，2步，可证明命题成立。

 

第二数学归纳法

对第一数学归纳法进行了扩充

1. 证明当n=0时命题成立
2. 假设当n<=k（k为自然数）时命题成立，证明当n=k+1时命题也成立

有1，2步，可证明命题成立。

在算法时间复杂度的证明上，由于n取值是一个自然数，所以多用数学归纳法原理进行证明。其实，证明循环正确性的循环不变式就是直接利用的第一数学归纳法。

 

参考：

 

百度百科，数学归纳法

文章来源:http://localhost/wp2/?p=165

如题，经典问题，记录于此...

递归实现

思路：如果只有一个节点，则什么都不做。否则，将当前链表（a1,a2...a3）的子链表（a2,...an）进行逆转，返回逆转后的第一个节点的指针，再将a1节点加到a2节点后面。

代码：(这里没有使用头节点)

node * reverse(node * p){
    if(p->next == null){
        return p;
    }
    node * q = p->next;
    node * head = reverse(q);
    p->next = null;
    q->next = p;
    return head;
}

非递归实现

思路：一个指针进行链表的遍历，一个指针指向逆转后的链表的第一个节点，在遍历的过程中，将当前节点加入逆转后的链表第一个元素即可。返回逆转后的链表的第一个节点的指针。

代码：（这里没有使用头节点）

node * reverse(node * p){
    node * p_reverse;
    if(p != null){    
        p_reverse = p;
        node * q = p->next;
        p->next = null;    
    }
    while(q != null){
        p = q->next;
        q->next = p_reverse;
        p_reverse = q;
        q = p;
    }
}

对C语言用的太少，上面的代码实现可能有点恶心，不过可以实现功能....

文章来源:http://localhost/wp2/?p=150

     摘要: Normal 0 7.8 磅 0 2 false false false EN-US ZH-CN X-NONE ...  阅读全文

对eclipse是用的多，学的少，用了都半年了，连插件都不知道怎么装，搜索了一篇文章《Eclipse 3.4插件安装方式》作为参考吧...

以前安装Eclipse插件无非两种方式, 直接copy插件到features/plugins目录或者在links目录下创建链接文件. 刚刚发布的Eclipse 3.4又推出另一种新的安装途径, 更加灵活。Eclipse 3.4下有个dropins目录, 只要把插件放到该目录下就可以加载, 有几种格式可以选择。

1. 最简单的，直接将jar包放到dropins目录:

    eclipse/
          dropins/
               com.essiembre.eclipse.i18n.resourcebundle_0.7.7

2. 传统格式，统一放到一个eclipse目录下:
      eclipse/ 
          dropins/ 
               eclipse/ 
                    features/ 
                    plugins/

3. 按照插件名称区分:
    eclipse/
          dropins/
               resourcebundleeditor/
                    features/
                    plugins/               
               m2eclipse/
                    features/
                    plugins/

4. 类似links方式添加链接:

    eclipse/
          dropins/ 
               xfire.link

 

如果只安装一个Eclipse的话建议采用第三种，否则采用第四种。

如果发现安装了没有效果，可以删除eclipse主目录下的\configuration\org.eclipse.update后，再执行eclipse -clean试试。

文章来源:http://localhost/wp2/?p=127

     Oracle支持的数据类型可以分为三个基本种类：字符数据类型、数字数据类型以及表示其它数据的数据类型。

    字符数据类型

    CHAR数据类型存储固定长度的字符值。一个CHAR数据类型可以包括1到2000个字符。如果对CHAR没有明确地说明长度，它的默认长度则设置为1.如果对某个CHAR类型变量赋值，其长度小于规定的长度，那么Oracle自动用空格填充。

    VARCHAR2存储可变长度的字符串。虽然也必须指定一个VARCHAR2数据变量的长度，但是这个长度是指对该变量赋值的的最大长度而非实际赋值长度。不需要用空格填充。最多可设置为4000个字节。所以如果存储中文的时候，就不能存储到4000个字符了，因为一个汉字会占有多个字节。

    因为VARCHAR2数据类型只存储为该列所赋的字符（不加空格），所以VARCHAR2需要的存储空间比CHAR数据类型要小。

 

    Oracle推荐使用VARCHAR2

    NCHAR和NVARCHAR2数据类型分别存储固定长度与可变长度的字符数据，但是它们使用的是和数据库其他类型不同的字符集。在创建数据库时，需要指定所使用的字符集，以便对数据库中数据进行编码。还可以指定一个辅助的字符集［即本地语言集（National Language Set，简称NLS）］。NCHAR和NVARCHAR2类型的列使用辅助字符集。

    在Oracle9i中，可以以字符而不是字节为单位来表示NCHAR和NVARCHAR2列的长度。

    LONG数据类型可以存放2GB的字符数据，它是从早期版本中继承来的。现在如果想存储大容量的数据，Oracle推荐使用CLOB和NCLOB数据类型。在表和SQL语句中使用LONG类型有许多限制。

    CLOB和NCLOB数据类型可以存储多达4GB的字符数据。NCLOB数据类型可存储NLS数据。

 

    数字数据类型

    Oracle使用标准、可变长度的内部格式来存储数字。这个内部格式精度可以高达38位。

    NUMBER数据类型可以有两个限定符，如：

    column NUMBER （ precision， scale）

    precision表示数字中的有效位。如果没有指定precision的话，Oracle将使用38作为精度。

    scale表示数字小数点右边的位数，scale默认设置为0。如果把scale设成负数，Oracle将把该数字取舍到小数点左边的指定位数。

 

    日期数据类型

    Oracle标准日期格式为：DD-MON-YY  HH：MI：SS

    通过修改实例的参数NLS_DATE_FORMAT，可以改变实例中插入日期的格式。在一个会话期间，可以通过ALTER SESSION SQL命令来修改日期，或者通过使用SQL语句的TO_DATE表达式中的参数来更新一个特定值。

 

    其它的数据类型

    RAW和LONG RAW数据类型主要用于对数据库进行解释。指定这两种类型时，Oracle以位的形式来存储数据。RAW数据类型一般用于存储有特定格式的对象，如位图。 RAW数据类型可占用2KB的空间，而LONG RAW数据类型则可以占用2GB大小。

    ROWID ROWID是一种特殊的列类型，称之为伪列（pseudocolumn）。ROWID伪列在SQL SELECT语句中可以像普通列那样被访问。Oracle数据库中每行都有一个伪列。ROWID表示行的地址，ROWID伪列用ROWID数据类型定义。

    ROWID与磁盘驱动的特定位置有关，因此，ROWID是获得行的最快方法。但是，行的ROWID会随着卸载和重载数据库而发生变化，因此建议不要在事务 中使用ROWID伪列的值。例如，一旦当前应用已经使用完记录，就没有理由保存行的ROWID.不能通过任何SQL语句来设置标准的ROWID伪列的值。

    列或变量可以定义成ROWID数据类型，但是Oracle不能保证该列或变量的值是一个有效的ROWID.

    LOB

    LOB（大型对象）数据类型，可以保存4GB的信息。LOB有以下3种类型：

    。CLOB，只能存储字符数据

    。NCLOB，保存本地语言字符集数据

    。BLOB，以二进制信息保存数据

    可以指定将一个LOB数据保存在Oracle数据库内，还是指向一个包含次数据的外部文件。

    LOB可以参与事务。管理LOB中的数据必须通过DBMS_LOB PL/SQL内置软件包或者OCI接口。

    为了便于将LONG数据类型转换成LOB，Oracle9i包含许多同时支持LOB和LONG的函数，还包括一个ALTER TABLE语句的的新选择，它允许将LONG数据类型自动转换成LOB.

    BFILE

    BFILE数据类型用做指向存储在Oracle数据库以外的文件的指针。

    XMLType

    作为对XML支持的一部分，Oracle9i包含了一个新的数据类型XMLType.定义为XMLType的列将存储一个在字符LOB列中的XML文档。有许多内置的功能可以使你从文当中抽取单个节点，还可以在XMLType文档中对任何节点创建索引。

    用户自定义数据

    从Oracle8以后，用户可以定义自己的复杂数据类型，它们由Oracle基本数据类型组合而成。

    AnyType、AnyData和AnyDataSet

    Oracle包括3个新的数据类型，用于定义在现有数据类型之外的数据结构。其中每种数据类型必须用程序单元来定义，以便让Oracle9i知道如何处理这些类型的特定实现。

    额外的：

    类型转换

    Oracle会自动将某些数据类型转换成其他的数据类型，转换取决于包括该值的SQL语句。

    数据转换还可以通过Oracle的类型转换函数显示地进行。

 

    连接与比较

    在大多数平台上Oracle SQL中的连接操作符用两条竖线（||）表示。连接是将两个字符值连接。Oracle的自动类型转换功能使得两个数字值也可以进行连接。

 

    NULL

    NULL值是关系数据库的重要特征之一。实际上，NULL不代表任何值，它表示没有值。如果要创建表的一个列，而这个列必须有值，那么应将它指定为NOT NULL，这表示该列不能包含NULL值。

    任何数据类型都可以赋予NULL值。NULL值引入了SQL运算的三态逻辑。如果比较的一方是NULL值，那么会出现3种状态：TURE、FALSE以及两者都不是。

    因为NULL值不等于0或其他任何值，所以测试某个数据是否为NULL值只能通过关系运算符IS NULL来进行。

    NULL值特别适合以下情况：当一个列还未赋值时。如果选择不使用NULL值，那么必须对行的所有列都要赋值。这实际上也取消了某列不需要值的可能性，同时对它赋的值也很容易产生误解。这种情况则可能误导终端用户，并且导致累计操作的错误结果。

参考：

《Oracle数据类型》，http://www.cnblogs.com/cxd4321/archive/2008/04/14/1153201.html

文章来源:http://localhost/wp2/?p=122

如果一个方法后面有“throws InterruptedException”（即会抛出InterruptedException异常的方法），表示这个方法内（或是这个方法中所调用的方法内），可能会抛出InterruptedException异常。在多线程程序设计中，这通常告诉我们两点：

1. 这是“需要时间”的方法
2. 这是“可以取消”的方法

即，如果一个方法后面有“thorws InterruptedException”表示这个方法可能会花点时间，但是可以取消。 Java中会抛出InterruptException异常的有下面三个方法：

1. java.lang.Object类（及其子类）实例的wait方法
2. java.lang.Object类（及其子类）实例的sleep方法
3. java.lang.Thread类（及其子类）实例的join方法

根据上面的两点，首先，这三个方法都是需要花点时间的方法，这个很好理解。其次，他么都可以被取消，具体怎么取消，下面分别说明。 取消wait 可以调用interrupt方法（这个方法是java.lang.Thread类（及其子类）实例的方法，某个线程都可以在任何时候调用其他线程的interrupt方法）来取消wait方法的等待。即不用再等待notify/notifyAll方法的“通知”了。当对某个wait的线程调用interrupt方法的时候，这个线程会从wait set中出来，先重新获得锁定，再抛出InterruptedException。注意，在获得锁定前，是不会抛出InterruptedException异常的。 为了加深理解，这里对比一下notify/notifyAll方法和interrupt方法。首先，notify/notifyAll方法是java.lang.Object类（及其子类）实例的方法，而interrupt方法是java.lang.Thread类（及其子类）实例的方法。其次，notify/notifyAll方法调用时需要获得锁定，而interrupt方法不用，如前所述，interrupt方法可以在任何时候被调用。最后，被notify/notifyAll方法唤醒的线程是（重新获得锁定后）继续执行wait方法之后的方法，而被interrupt方法唤醒的线程则满足前面所的第二条“可以被取消”，即让被唤醒的线程（重新获得锁定后）在wait方法上抛出InterruptedException。 取消sleep 当sleep中的线程被调用interrupt方法时，会马上（不用想取消wait一样，还要获得锁定）放弃sleep状态，并抛出InterruptedException异常。 取消join 当线程以join方法等待其他线程结束时，可以被调用interrupt方法来马上取消等待其他线程结束。 下面是关于java内部是怎么实现取消上面三个方法的等待的。在线程内部，有一个标志位表示线程的中断状态。有两个方法可以设置这个状态，interrupt方法和interrupted方法，interrupted方法属于java.lang.Thread类（及其子类）的静态方法，用来返回当前线程的中断状态，并清除这个状态。调用interrupt方法将设置此标志位（表示让被调用线程处于中断状态），调用interrupted方法返回值是当前线程是否被中断，并取消此标志位（表示让当前线程处于非中断状态）。在实现细节上，会抛出InterruptedException异常的sleep，wait和join方法在内部不断的检测这个中断状态，如果发现被设置了，则抛出InterruptedException异常。java.lang.Thread类（及其子类）实例还有一个isInterrupted方法来检测这个标志位，如果被设置了返回true，否则返回false。还需要进一步补充的是：interrupt方法和interrupted方法的区别。可以对任意的一个线程调用interrupt方法，但是只能对当前的线程（即正在运行的线程）调用interrupted方法（此方法是静态方法），所以，在程序中无法清除其他线程的中断状态了。 参考： 《Java多线程设计模式》，中国铁道出版社，2005，结城浩
文章来源:http://localhost/wp2/?p=99

前面的Guarded Suspension Pattern和Balking Pattern都比较极端。一个是“不让？爷不玩了”，另一个是“不行！我一定要玩！”。而，Guarded Timeout Patter就中庸的多了，是“现在不让玩？那我等等吧。如果超过我等待的时间了，我就不玩了”。 还是以代码说话：

class A{     
    private long timeout; //等待的最长时间 
    public synchronized void changeState(){ 
        改变状态 通知等待的线程不同再等了(notify/notifyAll) 
    } 
    public synchronized void guardedMethod() throws InterruptedException{ 
        long start = System.currentTimeMillis(); //开始时刻 
        while(条件成立不成立){ 
            long now = System.currentTimeMillis(); //现在时刻 
            long rest = timeout - (now -start); //还需要等待的时间 
            if(rest <= 0){throw new InterruptedException("...");} //如果为等待时间为0或者为负数，就不等了。 
            等着一段时间吧，如果超过我等待的最长时间了，我就不玩了（wait（rest）） //当wait的时间超过rest时，也会抛出InteruptedException。 
        } 
        进行处理 
    } 
} 

在通常情况下，会对if(rest<=0){...}中抛出的异常进行一下包装，即继承InterruptedException异常，是得调用者知道是超时了（wait(rest)，interrupt方法都可能会抛出InterruptedException，所以必须包装一下，让上层程序识别）。

参考： 《Java多线程设计模式》，中国铁道出版社，2005，结城浩

文章来源:http://localhost/wp2/?p=88

Balking Pattern重在“balking”，balking的意思是“退缩不前”，在棒球运动的意思是“当跑垒员在垒时，投手在投手板但’中途放弃‘投球的动作”（呵呵，对棒球不懂...）。另外，这种模式和Guarded Suspension Pattern有点类似，也是有要检测警戒条件是否成立，不过，如果不成立，就不用等待了，直接就放弃了。呵呵，这种模式还是想的比较开啊（不行？那爷不赔你玩了:)），相比之下，Guarded Suspension Pattern就执着的多了:)。 从代码的角度看，如下： class A{ public synchronized void guardedMethod(){ if(警戒条件不成立){ return; } 进行处理 改变状态 } } 下面给出参考书中列出的一个使用Balking Pattern的实例：即文本编辑器的自动保存功能。当在编辑文件的时候，后台有个线程会定期的对文件进行保存，防止程序崩溃时文件内容的丢失。那么，文件是否被修改就是这里的警戒条件。当然，还得有另外一个字段，就是当前的数据。编辑程序会调用synchronized的方法对文件数据进行修改，并设置警戒条件（为什么用synchronized?是因为防止更改操作和保存的冲突，否则，可能保存的不是最新的数据）。那么，后台的定时保存线程，会定时调用保存文件这个guardedMethod()，如果文件已经被（编辑程序）保存了，那么就balking了，否则，就保存。下面是代码：

class Data{ 
    public synchronized void changeData(String content){ 
        this.content = content; changed = true; 
    }   
    public synchronized void guardedMethod(){ 
        if(!changed){ return; } 
            doSave(); 
            changed = false; 
    } 
    private vodi doSave(){} 
}

注意上面的doSave方法不是synchronized。 Balking Patter的适用场合：

1. 不需要可以去执行的时候。如上面说的自动保存的例子。
2. 不想等待警戒条件成立时。
3. 警戒条件只有一次成立时。比如仅仅需要进行一次初始化（不是在构造函数中）的共享资源类。

参考： 《Java多线程设计模式》，中国铁道出版社，2005，结城浩

文章来源:http://localhost/wp2/?p=86

Guarded Suspension Pattern就是“当访问的共享资源被保护（防卫）时，那么线程就挂起”，生活中的例子就是当你和女朋友准备出去玩，你给女朋友打电话说该走了，女朋友说还没准备好，那你只能等在那里知道你女朋友收拾好了才能出去:)。 相对Single Threaded Pattern的任何线程对共享资源的访问仅仅是多个线程不能同时访问unsafeMethod，Guared Suspension Pattern就稍微复杂点了，它有个概念就是“条件”。当共享资源的条件准备好时，才能让其他线程进行访问，如果条件没有准备好，对不起，先等着吧。所以，这个模式里面还必须有一个改变“条件”使其成立的方法，还得有一个通知等待的线程不用再等的方法，否则，那些线程就在那里死等了...。 Guarded Suspension Pattern中对共享资源叫做Guarded Object（被防卫的对象），unsafeMethod方法称之为guardedMethod。当线程执行guardedMethod方法时，只要满足警戒条件，就会马上执行。当警戒条件不成立时，就要开始等待。警戒条件的成立与否，会随着Guarded Object状态的变化而变化。 从代码的角度看，如下：

class A{ 
    public synchronized void changeState(){ 
        改变状态 通知等待的线程不同再等了(notify/notifyAll) 
    } 
    public synchronized void guardedMethod(){ 
        while(条件成立不成立){ 
            //这里不能是if，至于原因就好好想想吧:)（需要重点理解wait/notify/notifyAll的处理过程） 
            等着吧（wait） 
        } 进行处理 
    } 
} 

这种模式有一些变形： busy wait，即忙碌的等待。即在while循环中不用wait，而用yield；在changeState中不用notify/notifyAll。但是，这种变形的缺点是等待的线程仍然在运行，只不过一直在检测运行时间是否满足。

参考： 《Java多线程设计模式》，中国铁道出版社，2005，结城浩

文章来源:http://localhost/wp2/?p=82

Immutable Pattern的关键在于共享资源是immutable（不会改变的）。即在实例产生后，没有改变字段的方法了，即只有只读的方法（所有的方法都是safeMethod），那么任何线程对共享资源的访问就不可造成冲突了。就算想破坏这个共享资源都没有办法，呵呵。 String类就是Immutable Pattern的典型。String类没有提供任何改变字符串属性的方法。当然就是Immutable Pattern了。 从代码上来看，Immutable Pattern的形式如下：

class A{ 
    public void safeMethod1(){} 
    publi c void safeMethod2(){} 
} 

由于没有用到synchronized关键字，那么访问共享资源的效率是很高的。在某些情况下，如果某个共享资源用到了synchronized关键字，即不是immtable。那么，可以根据这个类的具体用处，分为两个类，一个是immutable，另一个是mutable（可变的），如果这两个类可以互相转化，那么在不同的场合用不同的类就可以提高程序的效率了。Java中对字符串这个共享资源提供了两个类：String类和StringBuffer类。他们就是对应的immutable和mutable，两者可以通过构造函数（String有个构造函数的参数是StringBuffer，StringBuffer有个构造函数的参数String）转化。

参考： 《Java多线程设计模式》，中国铁道出版社，2005，结城浩

文章来源:http://localhost/wp2/?p=75

Single Threaded Execution模式的核心就是single，即某个共享资源同时只能被某一个线程访问。可以做如下比喻来理解这个模式：门（共享资源），人（线程）。一个门一次只能由一个人通过。如果一个人正在通过这个门，那么其他人只能等待了。 当然，共享资源中某些方法是线程安全的（SafeMethod），就不用考虑多个线程同时调用的情况了。只有对不安全的方法（UnsafeMethod）才需要考虑多线程访问的问题。 可以对Single Thread Execution模式这样理解：如果另外的线程也行执行被保护的UnsafeMethod，那么就需要判断是否有其他线程正在执行被保护的UnsafeMethod。如果有，则等待；没有，则执行。 对Single Threaded Execution Pattern来说，代码的典型表现形式就是对所有的UnsafeMethod方法加上synchronized关键字。如：

class A{ 
    public void safeMethod(){ } 
    public synchronized void unsafeMethod1(){ } 
    publi synchronized void unsafeMethod2(){ } 
}

当下面的情况发生时，可能会出现死锁

1. 有多个共享资源
2. 线程锁定了一个共享资源，但还没有解除锁定就锁定了另外一个共享资源
3. 各个线程获取共享资源的顺序不固定

也就是说，打破上面的三个情况的任何一个，就可以避免死锁的发生。 参考： 《Java多线程设计模式》，中国铁道出版社，2005，结城浩

文章来源:http://localhost/wp2/?p=70

Oracle的数据库驱动有两种，oci和thin，没有用过oci，这里用的是thin。 问题描述： 有一张表MESSAGE，里面有个字段是content varchar2(4000)。 如果直接用Statement来更新这个字段，是不会用任何问题的。因为Statement的原理就是直接将整个sql语句发到数据库执行。 但是，如果用PreparedStatement的setString(）方法来设置这个字段，就有问题了，当设置的字符串长度大于2000时，就会报错：”java.sql.SQLException: 数据大小超出此类型的最大值“。 问题分析： 这些天学着用iBatis，就遇到了上面的这个问题。因为如果在iBatis中使用内联参数（#做占位符），底层实现的时候就是用的PreparedStatement来实现的，所以就遇到了上面的问题。 至于为什么用PreparedStatement会出先这个问题，JavaEye上的一篇文章《当PreparedStatement中的参数遇到大字符串》给出了很好的解释（牛逼啊！）

(1)Using the JDBC thin driver (2)Using binds (not defines) (3)Using SQL CHAR datatypes (4)Connecting to a database whose character set is neither ASCII (US7ASCII) nor ISO Latin1 (WE8ISO8859P1) When the database character set is neither US7ASCII nor WE8ISO8859P1, the JDBC thin driver converts Java UTF-16 characters to UTF-8 encoding bytes for SQL CHAR binds. The UTF-8 encoding bytes are then transferred to the database, and the database converts the UTF-8 encoding bytes to the database character set encoding.” 原来是JDBC在转换过程中对字符串的长度做了限制。这个限制和数据库中字段的实际长度没有关系。 所以，setCharacterStream()方法可以逃过字符转换限制，也就成为了解决此问题的方案之一。 而JDBC对转换字符长度的限制是为了转换过程中的数据扩展。 问题解决： 根据上面的分析，可以用PreparedStatement的setCharacterStream()方法来解决问题。 在iBatis中，可以使用下面的自定义类型处理器来处理（参考文章《用ibatis向oracle数据库的varchar2(4000)列写值的问题》）

/**
 * String implementation of TypeHandler
 */
public class StringTypeHandler extends BaseTypeHandler implements TypeHandler {
 /**
 * 在使用oracle时，如果在一个varchar2(4000)的字段上插入的字符过长（一般只能插入666个汉字，视字符集不同会有所不同），
 * 会导致失败，具体报错会因驱动版本不同而不同。
 * 如果使用setCharacterStream则可以插入最多的字符。因此，我将这个方法改了一下。
 */
 public void setParameter(PreparedStatement ps, int i, Object parameter,
 String jdbcType) throws SQLException {
 //原来的代码
 //ps.setString(i, ((String) parameter));

 //以下是我加的代码，为了尽量提高效率，作了一下判断
 String s = (String) parameter;
 if (s.length() < 667) { //以字符中全是汉字为底线。
 ps.setString(i, s);
 } else {
 ps.setCharacterStream(i, new StringReader(s), s.length());
 }
 }

 public Object getResult(ResultSet rs, String columnName) throws
 SQLException {
 Object s = rs.getString(columnName);
 if (rs.wasNull()) {
 return null;
 } else {
 return s;
 }
 }

 public Object getResult(ResultSet rs, int columnIndex) throws SQLException {
 Object s = rs.getString(columnIndex);
 if (rs.wasNull()) {
 return null;
 } else {
 return s;
 }
 }

 public Object getResult(CallableStatement cs, int columnIndex) throws
 SQLException {
 Object s = cs.getString(columnIndex);
 if (cs.wasNull()) {
 return null;
 } else {
 return s;
 }
 }

 public Object valueOf(String s) {
 return s;
 }
 }

 

其实，上面的解决方案是比较麻烦的，今天发现了一个更好的解决方案，就是将oracle jdbc驱动换成用于oracle10g第二版的驱动ojdbc14.jar。就行了，唉，前面折腾了几天的问题竟然可以这么容易地解决...

文章来源:http://localhost/wp2/?p=63

这里对final关键字进行总结。 final类 当类声明为final时，就不能定义这个类的子类。因为final类的类无法定义子类，所以final类声明的所有方法不会被覆盖（override）。 final方法 若将实例方法声明为final时，这个方法无法被子类所覆盖（override）。 若将类方法（static方法）声明为final时，这个方法无法被子类所隐藏（hide）。对隐藏这个术语不熟，本文最后会加上。 final字段（final属性） final字段的值只能指定一次。 final实例字段的值只能在定义时或者在构造器中指定。 如： class A{

final int i = 1;

} class A{

final int i;

public A(){

this.i = 2;

}

} final类字段的值只能在定义是或者在static块（静态初始化块）中指定。 class A{

static final int i = 12;

} class A{

static final int i;

static{

i = 12;

}

} final局部变量和final参数 final局部变量的值只能指定一次。 final参数的值在方法被调用时，由实参指定，不能再次指定（实际上也满足被指定一次的原则）。 下面对java中类的继承中的覆盖（override）和隐藏（hide）进行总结。 在《Java核心技术卷一》中对隐藏是采用的访问限定符（如public，private，protected）来实现的。这里的隐藏不是采用访问限定符来实现的，而是采用子类和父类有同名的类方法和字段（实例字段和静态字段）来实现的。在实际编程中，隐藏一般只用于类方法，即父类的类方法被子类中同名（这里的同名指方法名和参数都一样，其实返回值也必须一样，可以试一试）的类方法隐藏。 这里继续总结一下：

1. 子类可以覆盖父类的实例方法（方法名、参数和返回值都一样），另外，这里还有一个重载（overload）的概念，重载是一个静态的概念，是在编译时根据方法名和参数来确定的，重载是一个类自身的一个属性，和继承没有关系。
2. 子类可以隐藏父类的类方法（方法名、参数和返回值都一样）
3. 子类可以隐藏父类的字段（实例字段和静态字段）（通过在子类中定义字段名相同（类型可和父类不一样）的字段即可）。

覆盖是动态的概念，是在运行时决定的。重载和隐藏是静态的概念，是在编译时决定的。 参考：

1. 《Java多线程设计模式》中国铁道出版社 2005

文章来源:http://localhost/wp2/?p=61

编程时你需要考虑的不是内存的物理地址(memory address)，而是一种逻辑上的内存模型。 Java虚拟机将其管辖的内存大致分三个逻辑部分：

1. 方法区(Method Area)、
2. Java栈
3. Java堆。

方法区是静态分配(static allocation)的，编译器将变量在绑定在某个存储位置上，而且这些绑定不会在运行时改变。Java方法区的一个重要部分，也是静态分配最典型的例子，是常数池，源代码中的命名常量、String常量和static 变量保存在其中。 Java Stack是一个逻辑概念，特点是后进先出，此外没有特别的要求。Java Stack并不代表任何特定的内存区间，也不限制它的实现方式。一个栈的空间可能是连续的，也可能是不连续的。最典型的Stack应用是方法的调 用，Java虚拟机每调用一次方法就创建一个方法帧（frame），退出该方法则对应的方法帧被弹出(pop)。栈分配存在一些局限：Java栈所处理的方法帧和局部变量，都将随着方法帧弹出而结束，显然局部变量无法从一个帧保持到下一个帧，被调方法的帧不可能比调用方法的寿命更长。因此，从数据保存来看，栈分配适用于由作用域决定生命周期的局部变量。 Java堆(Heap)堆分配(heap allocation)意味着以随意的顺序，在运行时进行存储空间分配和收回的内存管理模型。堆中存储的数据常常是大小、数量和生命期在编译时无法确定的。Java对象的内存总是在heap中分配。
文章来源:http://localhost/wp2/?p=59

在Java中，为了生成一个线程，有两种方法：

1. 继承Thread类，覆盖run方法。在使用时，调用Thread实例的start方法即可启动一个线程，此线程将执行run方法里面的代码。
2. 实现Runnable接口，实现run方法。在使用时，调用Thread实例（传入实现Runnable接口的类实例）的start方法，此线程将执行run方法里面的代码。

启动线程的方法只能用start方法，不能用run方法...start方法才会启动一个线程去执行run方法，而run方法仅仅是一个类实例的方法！！！

在此，需要强调的是，线程和Thread类的区别。线程是一个动态的概念，而Thread类（或其实例）是静态的概念。虽然说从代码上看，执行Thread实例的start方法或者run方法（只能在实现Runnable接口时）好像把Thread实例当作了一个线程，当事实上，应该这样理解：Thread类就是一个普通的类，和其他类没有什么两样，但是他的start方法或者run方法比较特殊，可以启动一个新的线程。当新线程启动后，就马上执行Thread类里面run方法的代码或者Runnable接口的run方法。 在Java中，为了实现多线程之间的同步和互斥，提供了一个关键字，synchronized。这个关键字有两个用法：

1. 用于方法声明中。如： public synchronized void methd(){ .... } 把这种用法称之为synchronized方法。
2. 用于方法体中。如： public void method(){ synchronized(this){ .... } }把这种方法称为synchronized语句。

当不同的线程运行synchronized方法或者synchronized语句时，首先会获得锁，然后再执行，当退出时，会释放锁。当锁还没有被释放时，如果有其他线程访问，那么这些线程会阻塞。如果锁被释放，那么jvm会让所有在此锁上阻塞的所有线程竞争，将有一个线程得到锁，其他线程将继续阻塞。 其实，synchronized方法就是在方法体的最前面加了一个锁，在方法体的最后面释放掉了这个锁。synchronized语句就是在被包含的语句 前加了一个锁，在被包含的语句后释放掉了锁。这里需要强调锁的概念，可以这么认为，Java中每一个对象都有一个锁的，可以使用synchronized 方法和synchronized语句来获得这些锁。 下面通过实例来理解synchronized方法和synchronized语句。 1，下面的两个方法是等价的： public synchronized void methd(){ .... } public void method(){ synchronized(this){ .... } } 怎么理解上面的等价？ synchronized方法（只能）获得当前对象的锁，那么，在synchronized语句中显示的指明要获得锁的对象为this就可以使两者等价了。 在synchronized方法中，多个线程同时只能访问某个对象（可能含多个synchronized方法）的一个synchonized方法。 对下面这个银行类来说，使用synchronized方法就可以达到线程的互斥。多个线程同时只能有一个线程访问一个synchronized方法。 public class Bank{ public synchronized void deposite(){ 对某个帐户进行增加 } public synchronized void withdraw(){ 对某个帐户进行减少 } } 如果，我们想对某个对象的方法进行更灵活的线程互斥访问，可以使用synchornized语句，显示的声明要获得的锁的对象。 2， public synchronized static  void methd(){ .... } 上面的方法都可以防止多个线程同时访问这个类中的method方法。它可以对类的所有对象实例起作用。他等价于下面的方法。 public static  void method(){ synchronized(this.getClass()){ .... } } 这里还需要补充一下，synchronized方法被继承后就不是synchronized的了，除非在子类中再次声明方法为synchronized的。 Object类是Java所有对象的基类，Object类中有几个方法，提供了对多线程编程的支持：

1. wait()方法将当前运行的线程阻塞，放置于当前线程锁执行的对象的wait set中，然后取消此线程对锁的获得。
2. notify()/notifyAll()方法将把当前线程执行的对象的wait set中的某一个/所有线程拿出来。

注意，wait和notify/notifyAll方法只能在线程已获得对象实例的锁时才能调用，否则，将抛出java.lang.IllegalMonitorStateException。 这篇文章写的好累啊，语言组织能力咋这么弱...

文章来源:http://localhost/wp2/?p=52

由于需要，学习了Oracle日志分析工具LogMiner的使用，在此记录一下： 1，确定你的Oracle安装的目录，下面用%ORALCE_HOME%表示。 2，必须以DBA角色登录，命令如下 SQL>sqlplus /nolog SQL>conn sys/manager@wymis as sysdba 3，（如果第一次做日志分析）安装LogMiner SQL> @%ORALCE_HOME%\ora90\rdbms\admin\dbmslm.sql SQL> @%ORALCE_HOME%\ora90\rdbms\admin\dbmslmd.sql 4，设置UTL_FILE_DIR值，这个值表示存放日志分析相关文件的目录，设置方法可以到Oracle的企业管理器下面设置，这个值的例子如c:\log，注意，最后没有\符号。设置完后，需要重新启动数据库。 5，生成数据字典 SQL> execute dbms_logmnr_d.build(- > dictionary_filename => 'logminer_dict.dat',- > dictionary_location => 'c:\import'); 注意上面每行代码后有一个'-'符号，表示输入还没有结束。 注意，dictionary_location的值必须与第4步中UTL_FILE_DIR的值一样。 6，创建要分析的日志文件列表， 创建列表 SQL> EXECUTE dbms_logmnr.add_logfile(- LogFileName=>' e:\Oracle\oradata\sxf\redo01.log',- Options=>dbms_logmnr.new); 添加其他日志文件到列表 SQL> EXECUTE dbms_logmnr.add_logfile( LogFileName=>' e:\Oracle\oradata\sxf\redo02.log', Options=>dbms_logmnr.addfile); 注意，LogFileName的值可以到相应的数据库实例文件夹下面的实例获得。 7，使用LogMiner进行日志分析 SQL> execute dbms_logmnr.start_logmnr(- > dictfilename => 'c:\import\logminer_dict.dat',- > starttime => to_date('2001-9-18 00:00:00','YYYY-MM-DD HH24:MI:SS'),- > endtime => to_date('2009-10-30 00:00:00','YYYY-MM-DD HH24:MI:SS')); 注意，这里的starttime和endtime的范围必须是你的日志文件涉及的范围。如果实在拿不准，可以不用这两个参数。 8，分析结果 LogMiner分析的结果存放在v$LogMnr_Contents表里面。具体的分析，网上有很多好的文章，就不再写了。 再转一篇比较好的文章，来自http://www.oracle.com.cn/viewthread.php?tid=22975的 robertmao_2003 作为Oracle DBA，我们有时候需要追踪数据误删除或用户的恶意操作情况，此时我们不仅需要查出执行这些操作的数据库账号，还需要知道操作是由哪台客户端（IP地址 等）发出的。针对这些问题，一个最有效实用而又低成本的方法就是分析Oracle数据库的日志文件。本文将就Oracle日志分析技术做深入探讨。 一、如何分析即LogMiner解释 从目前来看，分析Oracle日志的唯一方法就是使用Oracle公司提供的LogMiner来进行， Oracle数据库的所有更改都记录在日志中，但是原始的日志信息我们根本无法看懂，而LogMiner就是让我们看懂日志信息的工具。从这一点上看，它 和tkprof差不多，一个是用来分析日志信息，一个则是格式化跟踪文件。通过对日志的分析我们可以实现下面的目的： 1、查明数据库的逻辑更改； 2、侦察并更正用户的误操作； 3、执行事后审计； 4、执行变化分析。 不仅如此，日志中记录的信息还包括：数据库的更改历史、更改类型（INSERT、UPDATE、DELETE、DDL等）、更改对应的SCN号、以及执行 这些操作的用户信息等，LogMiner在分析日志时，将重构等价的SQL语句和UNDO语句（分别记录在V$LOGMNR_CONTENTS视图的 SQL_REDO和SQL_UNDO中）。这里需要注意的是等价语句，而并非原始SQL语句，例如：我们最初执行的是“delete a where c1 <>'cyx';”，而LogMiner重构的是等价的6条DELETE语句。所以我们应该意识到V$LOGMNR_CONTENTS视图中 显示的并非是原版的现实，从数据库角度来讲这是很容易理解的，它记录的是元操作，因为同样是“delete a where c1 <>'cyx';”语句，在不同的环境中，实际删除的记录数可能各不相同，因此记录这样的语句实际上并没有什么实际意义，LogMiner重 构的是在实际情况下转化成元操作的多个单条语句。 另外由于Oracle重做日志中记录的并非原始的对象（如表以及其中的列）名称，而只是它们在Oracle数据库中的内部编号（对于表来说是它们在数据库 中的对象ID，而对于表中的列来说，对应的则是该列在表中的排列序号：COL 1, COL 2 等），因此为了使LogMiner重构出的SQL语句易于识别，我们需要将这些编号转化成相应的名称，这就需要用到数据字典（也就说LogMiner本身 是可以不用数据字典的，详见下面的分析过程），LogMiner利用DBMS_LOGMNR_D.BUILD()过程来提取数据字典信息。 LogMiner包含两个PL/SQL包和几个视图： 1、dbms_logmnr_d包，这个包只包括一个用于提取数据字典信息的过程，即dbms_logmnr_d.build()过程。 2、dbms_logmnr包，它有三个过程： add_logfile(name varchar2, options number) - 用来添加/删除用于分析的日志文件； start_logmnr(start_scn number, end_scn number, start_time number,end_time number, dictfilename varchar2, options number) - 用来开启日志分析，同时确定分析的时间/SCN窗口以及确认是否使用提取出来的数据字典信息。 end_logmnr() - 用来终止分析会话，它将回收LogMiner所占用的内存。 与LogMiner相关的数据字典。 1、v$logmnr_dictionary，LogMiner可能使用的数据字典信息，因logmnr可以有多个字典文件，该视图用于显示这方面信息。 2、v$logmnr_parameters，当前LogMiner所设定的参数信息。 3、v$logmnr_logs，当前用于分析的日志列表。 4、v$logmnr_contents，日志分析结果。 二、Oracle9i LogMiner的增强： 1、支持更多数据/存储类型：链接/迁移行、CLUSTER表操作、DIRECT PATH插入以及DDL操作。在V$LOGMNR_CONTENTS的SQL_REDO中可以看到DDL操作的原句（CREATE USER除外，其中的密码将以加密的形式出现，而不是原始密码）。如果TX_AUDITING初始化参数设为TRUE，则所有操作的数据库账号将被记录。 2、提取和使用数据字典的选项：现在数据字典不仅可以提取到一个外部文件中，还可以直接提取到重做日志流中，它在日志流中提供了操作当时的数据字典快照，这样就可以实现离线分析。 3、允许对DML操作按事务进行分组：可以在START_LOGMNR()中设置COMMITTED_DATA_ONLY选项，实现对DML操作的分组，这样将按SCN的顺序返回已经提交的事务。 4、支持SCHEMA的变化：在数据库打开的状态下，如果使用了LogMiner的DDL_DICT_TRACKING选项，Oracle9i的 LogMiner将自动对比最初的日志流和当前系统的数据字典，并返回正确的DDL语句，并且会自动侦察并标记当前数据字典和最初日志流之间的差别，这样 即使最初日志流中所涉及的表已经被更改或者根本已经不存在，LogMiner同样会返回正确的DDL语句。 5、在日志中记录更多列信息的能力：例如对于UPDATE操作不仅会记录被更新行的情况，还可以捕捉更多前影信息。 6、支持基于数值的查询：Oracle9i LogMiner在支持原有基于元数据（操作、对象等）查询的基础上，开始支持基于实际涉及到的数据的查询。例如涉及一个工资表，现在我们可以很容易地查 出员工工资由1000变成2000的原始更新语句，而在之前我们只能选出所有的更新语句。 三、Oracle8i/9i的日志分析过程 LogMiner只要在实例起来的情况下都可以运行，LogMiner使用一个字典文件来实现Oracle内部对象名称的转换，如果没有这个字典文件，则直接显示内部对象编号，例如我们执行下面的语句： delete from "C"."A" where "C1" = ‘gototop’ and ROWID = 'AAABg1AAFAAABQaAAH'; 如果没有字典文件，LogMiner分析出来的结果将是： delete from "UNKNOWN"."OBJ# 6197" where "COL 1" = HEXTORAW('d6a7d4ae') and ROWID = 'AAABg1AAFAAABQaAAH'; 如果想要使用字典文件，数据库至少应该出于MOUNT状态。然后执行dbms_logmnr_d.build过程将数据字典信息提取到一个外部文件中。下面是具体分析步骤： 1、确认设置了初始化参数：UTL_FILE_DIR，并确认Oracle对改目录拥有读写权限，然后启动实例。示例中UTL_FILE_DIR参数如下： SQL> show parameter utl NAME                         TYPE        VALUE ------------------------ ----------- ------------------------------ utl_file_dir                 string      /data6/cyx/logmnr 这个目录主要用于存放dbms_logmnr_d.build过程所产生的字典信息文件，如果不用这个，则可以不设，也就跳过下面一步。 2、生成字典信息文件： exec dbms_logmnr_d.build(dictionary_filename =>' dic.ora',dictionary_location => '/data6/cyx/logmnr'); 其中dictionary_location指的是字典信息文件的存放位置,它必须完全匹配UTL_FILE_DIR的值，例如：假设 UTL_FILE_DIR=/data6/cyx/logmnr/，则上面这条语句会出错，只因为UTL_FILE_DIR后面多了一个“/”，而在很多 其它地方对这一“/”是不敏感的。 dictionary_filename指的是放于字典信息文件的名字，可以任意取。当然我们也可以不明确写出这两个选项，即写成： exec dbms_logmnr_d.build('dic.ora','/data6/cyx/logmnr'); 如果你第一步的参数没有设，而直接开始这一步，Oracle会报下面的错误： ERROR at line 1: ORA-01308: initialization parameter utl_file_dir is not set ORA-06512: at "SYS.DBMS_LOGMNR_D", line 923 ORA-06512: at "SYS.DBMS_LOGMNR_D", line 1938 ORA-06512: at line 1 需要注意的是，在oracle817 for Windows版中会出现以下错误： 14:26:05 SQL> execute dbms_logmnr_d.build('oradict.ora','c:\oracle\admin\ora\log'); BEGIN dbms_logmnr_d.build('oradict.ora','c:\oracle\admin\ora\log'); END; * ERROR at line 1: ORA-06532: Subscript outside of limit ORA-06512: at "SYS.DBMS_LOGMNR_D", line 793 ORA-06512: at line 1 解决办法： 编辑"$ORACLE_HOME/rdbms/admindbmslmd.sql"文件，把其中的 TYPE col_desc_array IS VARRAY(513) OF col_description; 改成： TYPE col_desc_array IS VARRAY(700) OF col_description; 保存文件，然后执行一遍这个脚本： 15:09:06 SQL> @c:\oracle\ora81\rdbms\admin\dbmslmd.sql Package created. Package body created. No errors. Grant succeeded. 然后重新编译DBMS_LOGMNR_D包： 15:09:51 SQL> alter package DBMS_LOGMNR_D compile body; Package body altered. 之后重新执行dbms_logmnr_d.build即可： 15:10:06 SQL> execute dbms_logmnr_d.build('oradict.ora','c:\oracle\admin\ora\log'); PL/SQL procedure successfully completed. 3、添加需要分析的日志文件 SQL>exec dbms_logmnr.add_logfile( logfilename=>' /data6/cyx/rac1arch/arch_1_197.arc', options=>bms_logmnr.new); PL/SQL procedure successfully completed. 这里的options选项有三个参数可以用： NEW - 表示创建一个新的日志文件列表 ADDFILE - 表示向这个列表中添加日志文件，如下面的例子 REMOVEFILE - 和addfile相反。 SQL> exec dbms_logmnr.add_logfile( logfilename=>' /data6/cyx/rac1arch/arch_2_86.arc', options=>bms_logmnr.addfile); PL/SQL procedure successfully completed. 4、当你添加了需要分析的日志文件后，我们就可以让LogMiner开始分析了： SQL> exec dbms_logmnr.start_logmnr(dictfilename=>'/data6/cyx/logmnr/dic.ora'); PL/SQL procedure successfully completed. 如果你没有使用字典信息文件（此时我们只需要启动实例就可以了），那么就不需要跟dictfilename参数： SQL> exec dbms_logmnr.start_logmnr(); PL/SQL procedure successfully completed. 当然dbms_logmnr.start_logmnr()过程还有其它几个用于定义分析日志时间/SCN窗口的参数，它们分别是： STARTSCN / ENDSCN - 定义分析的起始/结束SCN号， STARTTIME / ENDTIME - 定义分析的起始/结束时间。 例如下面的过程将只分析从 '2003-09-21 09:39:00'到'2003-09-21 09:45:00'这段时间的日志： SQL> exec dbms_logmnr.start_logmnr(dictfilename=>'/data6/cyx/logmnr/dic.ora' , - starttime => '2003-09-21 09:39:00',endtime => '2003-09-21 09:45:00'); PL/SQL procedure successfully completed. 上面过程第一行结尾的“-”表示转行，如果你在同一行，则不需要。我们可以看到有效日志的时间戳： SQL> select distinct timestamp from v$logmnr_contents; TIMESTAMP ------------------- 2003-09-21 09:40:02 2003-09-21 09:42:39 这里需要注意的是，因为我之前已经设置NLS_DATE_FORMAT环境变量，所以上面的日期可以直接按这个格式写就行了，如果你没有设，则需要使用to_date函数来转换一下。 SQL> !env|grep NLS NLS_LANG=american_america.zhs16cgb231280 NLS_DATE_FORMAT=YYYY-MM-DD HH24:MI:SS ORA_NLS33=/oracle/oracle9/app/oracle/product/9.2.0/ocommon/nls/admin/data 使用to_date的格式如下： exec dbms_logmnr.start_logmnr(dictfilename=>'/data6/cyx/logmnr/dic.ora',- starttime => to_date('2003-09-21 09:39:00','YYYY-MM-DD HH24:MI:SS'),- endtime => to_date('2003-09-21 09:45:00','YYYY-MM-DD HH24:MI:SS')); STARTSCN 和ENDSCN参数使用方法类似。 5、好了，在上面的过程执行结束之后，我们就可以通过访问与LogMiner相关的几个视图来提取我们需要的信息了。其中在v$logmnr_logs中 可以看到我们当前分析的日志列表，如果数据库有两个实例（即OPS/RAC），在v$logmnr_logs中会有两个不同的THREAD_ID。 而真正的分析结果是放在v$logmnr_contents中，这里面有很多信息，我们可以根据需要追踪我们感兴趣的信息。后面我将单独列出来讲常见的追踪情形。 6、全部结束之后，我们可以执行dbms_logmnr.end_logmnr过程退出LogMiner分析过程，你也可以直接退出SQL*PLUS，它会自动终止。 四、如何利用LogMiner分析Oracle8的日志文件 虽然说LogMiner是Oracle8i才推出来，但我们同样可以用它来分析Oracle8的日志文件，只不过稍微麻烦了一点，并且有一定的限制，下面是具体做法： 我们首先复制Oracle8i的$ORACLE_HOME/rdbms/admin/dbmslmd.sql脚本到Oracle8数据库所在主机的同样目 录；这个脚本用于创建dbms_logmnr_d包（注意，Oracle9i中还将创建dbms_logmnr包），如果是8.1.5脚本名字为 dbmslogmnrd.sql。然后在Oracle8的数据库上运行这个脚本，之后使用dbms_logmnr_d.build过程创建字典信息文件。 现在我们就可以把Oracle8的归档日志连同这个字典信息文件复制到Oracle8i数据库所在的主机上，之后在Oracle8i数据库中从上面分析过 程的第三步开始分析Oracle8的日志，不过 dbms_logmnr.start_logmnr()中使用的是Oracle8的字典信息文件。 按照我前面所说的那样，如果不是字典文件，我们则可以直接将Oracle8的归档日志复制到Oracle8i数据库所在主机，然后对它进行分析。 其实这里涉及到了一个跨平台使用LogMiner的问题，笔者做过试验，也可以在Oracle9i中来分析Oracle8i的日志。但这些都是有所限制的，主要表现在： 1、LogMiner所使用的字典文件必须和所分析的日志文件是同一个数据库所产生的，并且该数据库的字符集应和执行LogMiner数据库的相同。这很好理解，如果不是同一个数据库所产生就不存在对应关系了。 2、生成日志的数据库硬件平台和执行LogMiner数据库的硬件平台要求一致，操作系统版本可以不一致。笔者做试验时（如果读者有兴趣可以到我网站http://www.ncn.cn上下载试验全过程，因为太长就不放在这里了），所用的两个数据库操作系统都是Tru64 UNIX，但一个是 V5.1A，另一个则是V4.0F。如果操作系统不一致则会出现下面的错误： ORA-01284: file /data6/cyx/logmnr/arch_1_163570.arc cannot be opened ORA-00308: cannot open archived log '/data6/cyx/logmnr/arch_1_163570.arc' ORA-27048: skgfifi: file header information is invalid ORA-06512: at "SYS.DBMS_LOGMNR", line 63 ORA-06512: at line 1 五、分析v$logmnr_contents 前面我们已经知道了LogMiner的分析结果是放在v$logmnr_contents中，这里面有很多信息，我们可以根据需要追踪我们感兴趣的信息。那么我们通常感兴趣的有哪些呢？ 1、追踪数据库结构变化情况，即DDL操作，如前所述，这个只有Oracle9i才支持： SQL> select timestamp,sql_redo from v$logmnr_contents2 where upper(sql_redo) like '%CREATE%'; TIMESTAMP ------------------- SQL_REDO ------------------------- 2003-09-21 10:01:55 create table t (c1 number); 2、追踪用户误操作或恶意操作： 例如我们现实中有这样需求，有一次我们发现一位员工通过程序修改了业务数据库信息，把部分电话的收费类型改成免费了，现在就要求我们从数据库中查出到底是 谁干的这件事？怎么查？LogMiner提供了我们分析日志文件的手段，其中v$logmnr_contents的SESSION_INFO列包含了下面 的信息： login_username=NEW_97 client_info= OS_username=oracle8 Machine_name=phoenix1 OS_terminal=ttyp3 OS_process_id=8004 OS_program name=sqlplus@phoenix1 (TNS V1-V3) 虽然其中信息已经很多了，但在我们的业务数据库中，程序是通过相同的login_username登录数据库的，这样单从上面的信息是很难判断的。 不过我们注意到，因为公司应用服务器不是每个人都有权限在上面写程序的，一般恶意程序都是直接通过他自己的PC连到数据库的，这就需要一个准确的定位。 IP追踪是我们首先想到的，并且也满足我们的实际要求，因为公司内部IP地址分配是统一管理的，能追踪到IP地址我们就可以准确定位了。但从面的 SESSION_INFO中我们并不能直接看到IP，不过我们还是有办法的，因为这个SESSION_INFO里面的内容其实是日志从V$SESSION 视图里提取的，我们可以在生产数据库中创建一个追踪客户端IP地址的触发器： create or replace trigger on_logon_trigger after logon on database begin dbms_application_info.set_client_info(sys_context('userenv', 'ip_address')); end; / 现在，我们就可以在V$SESSION视图的CLIENT_INFO列中看到新登录的客户端IP地址了。那么上面的提出的问题就可以迎刃而解了。假如被更新的表名为HMLX，我们就可以通过下面的SQL来找到所需信息： SQL > select session_info ,sql_redo from v$logmnr_contents 2 where upper(operation) = 'UPDATE'  and upper(sql_redo) like '%HMLX%' 3 / SESSION_INFO ----------------------------------------- SQL_REDO ----------------------------------------- login_username=C client_info=10.16.98.26 OS_username=sz-xjs-chengyx Machine_name =GDTEL\SZ-XJS-CHENGYX update "C"."HMLX" set "NAME" = 'free' where "NAME" = 'ncn.cn' and ROWID = 'AAABhTAA FAAABRaAAE'; 好了，到此为止，这篇文章就要结束了，如果读者朋友还有什么疑问，可以登录我的个人网站（www.ncn.cn）来获得最新消息，也可以通过MSN（gototop_ncn@hotmail.com）直接和我联系。 六、参考资料： 1、Technical White Paper Oracle9i LogMiner 2、Metalink文档：How to Setup LogMiner（文档ID：111886.1）
文章来源:http://localhost/wp2/?p=50

昨天，遇到一件让自己胆战心惊的事情，就是数据库导出的DMP文件由原来的800多M变为了现在的300多M，整整少了500M！ 仔细回想，自己平时操作数据库还是很小心的，就算有失误，也不可能造成那么大的损失啊！ 在这里记录一下解决过程： 1，首先当然想到了Oracle的重做日志功能，也学习了Oracle自带的日志分析工具LogMiner的使用方法，等会在另外一篇文章里记录一下这个工具的使用方法。 2，在使用LogMiner之前，突然想到，能不能把800M的数据库和300M的数据库的每张表都单独导出为DMP文件，进行一下大小的对比 3，在用exp导出时，有一个log选项设定导出日志的文件路径，此文件记录了所有导出的数据库表名和记录数，用UltraEdit32的正则表达式功能去除了除开表名的其他不相关数据。 4，用Java编写了一个小程序，读入所有表名，对每个表名单独进行exp操作。 5，果然不出所料，其中有一个表被某个管理员清理过，那个表本来就很大，占到了500多M！ 至此，问题解决，总结一下，不管碰到什么意外的问题，不要慌张，冷静分析才是王道！ PS:被删除数据的那张表竟然占到了500多M，而整个数据库才800M，很不解，然后看了一下这张表的模式，发现设计的很有问题，这张表里面表达了多对多的关系，所以数据冗余太大，而且这些冗余根本就不是必须的，反而影响了性能！找常理来说，针对多对多的关系应该转化为两个多对一的关系。
文章来源:http://localhost/wp2/?p=48