巷尾的酒吧

  BlogJava :: 首页 :: 联系 :: 聚合  :: 管理
  64 Posts :: 0 Stories :: 5 Comments :: 0 Trackbacks

#

oracle 截取字符(substr),检索字符位置(instr) case when then else end语句使用 收藏
常用函数:substr和instr
1.SUBSTR(string,start_position,[length])    求子字符串,返回字符串
解释:string 元字符串
       start_position   开始位置(从0开始)
       length 可选项,子字符串的个数
For example:
substr("ABCDEFG", 0); //返回:ABCDEFG,截取所有字符
substr("ABCDEFG", 2); //返回:CDEFG,截取从C开始之后所有字符
substr("ABCDEFG", 0, 3); //返回:ABC,截取从A开始3个字符
substr("ABCDEFG", 0, 100); //返回:ABCDEFG,100虽然超出预处理的字符串最长度,但不会影响返回结果,系统按预处理字符串最大数量返回。
substr("ABCDEFG", 0, -3); //返回:EFG,注意参数-3,为负值时表示从尾部开始算起,字符串排列位置不变。

2.INSTR(string,subString,position,ocurrence)查找字符串位置
解释:string:源字符串
      subString:要查找的子字符串
      position:查找的开始位置
      ocurrence:源字符串中第几次出现的子字符串
For example:
INSTR('CORPORATE FLOOR','OR', 3, 2)中,源字符串为'CORPORATE FLOOR', 目标字符串为'OR',起始位置为3,取第2个匹配项的位置;返回结果为 14 '




oracle中length()与lengthb()区别

oracle中length()与lengthb()区别

 

OracleSQL.oracle中length()与lengthb()区别
SQL> select length('阿猪') from dual;
LENGTH('阿猪')
--------------
             2

SQL> select lengthb('阿猪') from dual;

LENGTHB('阿猪')
---------------
              4


区别:length求得是字符长度,lengthb求得是字节长度。

----------------------------------------------------------------------------------------------------

SQL> select sysdate from dual;

SYSDATE
--------------
26-9月 -05

SQL> select length(sysdate) from dual;

LENGTH(SYSDATE)
---------------
              9

SQL> select lengthb(sysdate) from dual;

LENGTHB(SYSDATE)
----------------
              10

length返回的是字符数
lengthb返回的是字节数
汉字“月”在length时,返回的时1
而在lengthb时返回的时2

 

 length指的是字符个数,lengthb指的是字节数。字符个数跟数据库字符集有很大关系。length和lengthb的参数都为varchar2型,因此length(sysdate)有一个隐式的类型转换,实际上等同于length(to_char(sysdate)),ORACLE安装好后默认的NLS_DATE_FORMAT参数值为DD-MON-RR,结果就相当于length('28-9月 -05')和
lengthb('28-9月 -05')了,其结果就是9和10

posted @ 2012-10-25 13:53 abing 阅读(775) | 评论 (1)编辑 收藏

一、引言

 

忙里偷闲,终于动笔了。命令模式是从界面设计中提取出来的一种分离耦合,提高重用的方法。被认为是最优雅而且简单的模式,它的应用范围非常广泛。让我们一起来认识下它吧。

 

先从起源说起。在设计界面时,大家可以注意到这样的一种情况,同样的菜单控件,在不同的应用环境中的功能是完全不同的;而菜单选项的某个功能可能和鼠标右键的某个功能完全一致。按照最差、最原始的设计,这些不同功能的菜单、或者右键弹出菜单是要分开来实现的,你可以想象一下,word文档上面的一排菜单要实现出多少个“形似神非”的菜单类来?这完全是行不通的。这时,就要运用分离变化与不变的因素,将菜单触发的功能分离出来,而制作菜单的时候只是提供一个统一的触发接口。这样修改设计后,功能点可以被不同的菜单或者右键重用;而且菜单控件也可以去除变化因素,很大的提高了重用;而且分离了显示逻辑和业务逻辑的耦合。这便是命令模式的雏形。

 

下面我们将仔细的讨论下命令模式。

 

 

二、定义与结构

 

《设计模式》中命令模式的定义为:将一个请求封装为一个对象,从而使你可用不同的请求对客户进行参数化;对请求排队或记录请求日志,以及支持可撤消的操作。

 

看起来,命令模式好像神通广大。其实命令模式的以上功能还要看你是怎么写的——程序总是程序员写出来的,你写啥它才能干啥:)

 

       在我看来,其实命令模式像很多设计模式一样——通过在你的请求和处理之间加上了一个中间人的角色,来达到分离耦合的目的。通过对中间人角色的特殊设计来形成不同的模式。当然命令模式就是一种特殊设计的结果。

 

       看下命令模式是有哪些角色来组成的吧。             

 

1)        命令角色(Command):声明执行操作的接口。有java接口或者抽象类来实现。

 

2)        具体命令角色(Concrete Command):将一个接收者对象绑定于一个动作;调用接收者相应的操作,以实现命令角色声明的执行操作的接口。

 

3)        客户角色(Client):创建一个具体命令对象(并可以设定它的接收者)。

 

4)        请求者角色(Invoker):调用命令对象执行这个请求。

 

5)        接收者角色(Receiver):知道如何实施与执行一个请求相关的操作。任何类都可能作为一个接收者。

 

 

以下是命令模式的类图,从中可以大致的了解到各个角色之间是怎么来协调工作的。

 

 

 

三、举例

 

本来想接着我的JUnit分析来讲解命令模式。但是由于在JUnit中,参杂了其它的模式在里面,使得命令模式的特点不太明显。所以这里将以命令模式在Web开发中最常见的应用——Struts中Action的使用作为例子。

 

在Struts中Action控制类是整个框架的核心,它连接着页面请求和后台业务逻辑处理。按照框架设计,每一个继承自Action的子类,都实现execute方法——调用后台真正处理业务的对象来完成任务。

 

注:继承自DispatchAction的子类,则可以一个类里面处理多个类似的操作。这个在这不做讨论。

 

       下面我们将Struts中的各个类与命令模式中的角色对号入座。

 

       先来看下命令角色——Action控制类

 

public class Action {

       ……

         /*

         *可以看出,Action中提供了两个版本的执行接口,而且实现了默认的空实现。

       
*/

public ActionForward execute( ActionMapping mapping,

                                                  ActionForm form,

                                                  ServletRequest request,

                                                  ServletResponse response)

        throws Exception {

        try {

            return execute(mapping, form, (HttpServletRequest) request,

                                     (HttpServletResponse) response);

        } catch (ClassCastException e) {

            return null;

        }

    }

 

public ActionForward execute( ActionMapping mapping,

                                                  ActionForm form,

                                                   HttpServletRequest request,

                                                  HttpServletResponse response)

        throws Exception {

        return null;

    }

}

 

下面的就是请求者角色,它仅仅负责调用命令角色执行操作。

public class RequestProcessor {

……

protected ActionForward processActionPerform(HttpServletRequest request,

                                                        HttpServletResponse response,

                                                       Action action,

                                                       ActionForm form,

                                                       ActionMapping mapping)

        throws IOException, ServletException {

        try {

            return (action.execute(mapping, form, request, response));

        } catch (Exception e) {

            return (processException(request, response,e, form, mapping));

        }

}

}

 

Struts框架为我们提供了以上两个角色,要使用struts框架完成自己的业务逻辑,剩下的三个角色就要由我们自己来实现了。步骤如下:

1)        很明显我们要先实现一个Action的子类,并重写execute方法。在此方法中调用业务模块的相应对象来完成任务。

2)        实现处理业务的业务类。

3)        配置struts-config.xml配置文件,将自己的Action和Form以及相应页面结合起来。

4)        编写jsp,在页面中显式的制定对应的处理Action。

一个完整的命令模式就介绍完了。当你在页面上提交请求后,Struts框架会根据配置文件中的定义,将你的Action对象作为参数传递给RequestProcessor类中的processActionPerform()方法,由此方法调用Action对象中的执行方法,进而调用业务层中的接收角色。这样就完成了请求的处理。

 

四、Undo、事务及延伸

 

在定义中提到,命令模式支持可撤销的操作。而在上面的举例中并没有体现出来。其实命令模式之所以能够支持这种操作,完全得益于在请求者与接收者之间添加了中间角色。为了实现undo功能,首先需要一个历史列表来保存已经执行过的具体命令角色对象;修改具体命令角色中的执行方法,使它记录更多的执行细节,并将自己放入历史列表中;并在具体命令角色中添加undo方法,此方法根据记录的执行细节来复原状态(很明显,首先程序员要清楚怎么来实现,因为它和execute的效果是一样的)。

 

同样,redo功能也能够照此实现。

 

命令模式还有一个常见的用法就是执行事务操作。这就是为什么命令模式还叫做事务模式的原因吧。它可以在请求被传递到接收者角色之前,检验请求的正确性,甚至可以检查和数据库中数据的一致性,而且可以结合组合模式的结构,来一次执行多个命令。

 

使用命令模式不仅仅可以解除请求者和接收者之间的耦合,而且可以用来做批处理操作,这完全可以发挥你自己的想象——请求者发出的请求到达命令角色这里以后,先保存在一个列表中而不执行;等到一定的业务需要时,命令模式再将列表中全部的操作逐一执行。

 

哦,命令模式实在太灵活了。真是一个很有用的东西啊!

 

 

五、优点及适用情况

 

由上面的讲解可以看出命令模式有以下优点:

1)        命令模式将调用操作的请求对象与知道如何实现该操作的接收对象解耦。

2)        具体命令角色可以被不同的请求者角色重用。

3)        你可将多个命令装配成一个复合命令。

4)        增加新的具体命令角色很容易,因为这无需改变已有的类。

GOF总结了命令模式的以下适用环境。

1)        需要抽象出待执行的动作,然后以参数的形式提供出来——类似于过程设计中的回调机制。而命令模式正是回调机制的一个面向对象的替代品。

2)        在不同的时刻指定、排列和执行请求。一个命令对象可以有与初始请求无关的生存期。

3)        需要支持取消操作。

4)        支持修改日志功能。这样当系统崩溃时,这些修改可以被重做一遍。

5)        需要支持事务操作。

 

六、总结

 

命令模式是一个很有用的模式,希望这篇文章能给你实质性的帮助。谢谢大家指正。 v

 
posted @ 2012-10-24 18:04 abing 阅读(252) | 评论 (0)编辑 收藏

create table ABING1
(
  ID1   NVARCHAR2(100),
  NAME1 NVARCHAR2(100)
)


create table ABING2
(
  ID2   NVARCHAR2(100),
  NAME2 NVARCHAR2(100)
)


merge into abing1 t 
using abing2 s
on(t.id1=s.id2)
when matched then update set t.name1=s.name2
when not matched then insert values (s.id2,s.name2);
commit
posted @ 2012-10-19 14:58 abing 阅读(192) | 评论 (0)编辑 收藏

这个可能是最好的对比volatile 和synchronized 作用的文章了。volatile 是一个变量修饰符,而synchronized 是一个方法或块的修饰符。所以我们使用这两种关键字来指定三种简单的存取变量的方式。

         int i1;                       int geti1() {return i1;}

volatile int i2;                        int geti2() {return i2;}

     int i3;          synchronized int geti3() {return i3;}

geti1() 当前线程 中立即获取在i1 变量中的值。线程可以获得变量的本地拷贝,而所获得的变量的值并不一定与其他线程所获得的值相同。特别是,如果其他的线程修改了i1 的值,那么当前线程获得的i1 的值可能与修改后的值有所差别。实际上,Java 有一种主内存的机制,使用一个主内存来保存变量当前的正确的值。线程将变量的值拷贝到自己独立的内存中,而这些线程的内存拷贝可能与主内存中的值不同。所以实际当中可能发生这样的情况,在主内存中i1 的值为1 ,线程1 和线程2 都更改了i1 ,但是却没把更新的值传回给主内存或其他线程中,那么可能在线程1 中i1 的值为2,线程2 中i1 的值却为 3 。

另一方面,geti2() 可以有效的从主内存中获取i2 的值。一个volatile 类型的变量不允许线程从主内存中将变量的值拷贝到自己的存储空间。因此,一个声明为volatile 类型的变量将在所有的线程中同步的获得数据,不论你在任何线程中更改了变量,其他的线程将立即得到同样的结果。由于线程存取或更改自己的数据拷贝有更高的效率,所以volatile 类型变量在性能上有所消耗。

那么如果volatile 变量已经可以使数据在线程间同步,那么synchronizes 用来干什么呢?两者有两方面的不同。首先,synchronized 获取和释放由监听器控制的锁,如果两个线程都使用一个监听器( 即相同对象锁) ,那么监听器可以强制在一个时刻只有一个线程能处理代码块,这是最一般的同步。另外,synchronized 还能使内存同步。在实际当中,synchronized 使得所有的线程内存与主内存相同步。所以geti3() 的执行过程如下:

1.    线程从监听器获取对象的锁。( 这里假设监听器非锁,否则线程只有等到监听器解锁才能获取对象锁)

2.    线程内存更新所有 的变量,也就是说他将读取主内存中的变量使自己的变量保证有效。(JVM 会使用一个“脏”标志来最优化过程,使得仅仅具有“脏”标志变量被更新。详细的情况查询JAVA规范的17.9)

3.    代码块被执行( 在这个例子中,设置返回值为刚刚从主内存重置的i3 当前的值。)

4.    任何变量的变更将被写回到主内存中。但是这个例子中geti3() 没有什么变化。

5.    线程释放对象的锁给监听器。

所以volatile 只能在线程内存和主内存之间同步一个变量的值,而synchronized 则同步在线程内存和主内存之间的所有变量的值,并且通过锁住和释放监听器来实现。显然,synchronized 在性能上将比volatile 更加有所消耗。

 

=============关于两者的区别===================

1.volatile本质是在告诉jvm当前变量在寄存器(工作内存)中的值是不确定的,需要从主存中读取;synchronized则是锁定当前变量,只有当前线程可以访问该变量,其他线程被阻塞住。 
2.volatile仅能使用在变量级别;synchronized则可以使用在变量、方法、和类级别的 
3.volatile仅能实现变量的修改可见性,不能保证原子性 ;而synchronized则可以保证变量的修改可见性和原子性 
4.volatile不会造成线程的阻塞;synchronized可能会造成线程的阻塞。 
5.volatile标记的变量不会被编译器优化;synchronized标记的变量可以被编译器优化

 

红字体部分的原因如下:
线程A修改了变量还没结束时,另外的线程B可以看到已修改的值,而且可以修改这个变量,而不用等待A释放锁,因为Volatile 变量没上锁

posted @ 2012-10-19 13:36 abing 阅读(296) | 评论 (0)编辑 收藏

匹配数字和字母组合,数字和字母至少出现一次,只匹配1a,1q1,a1,a1a,1q2q2ws,w1w2e3r4r之类的,不匹配11,aa,a,1,"",这种的。
package com.abin.lee.servlet.regex;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class MyRegex {
public static boolean StringResult(String str)throws Exception{
String regex="^(\\d+[a-z]+[0-9a-z]*)|([a-z]+\\d[0-9a-z]*)$";
// String regex="^(\\d+[a-z]{1}[0-9a-zA-Z]*)|([a-z]+\\d[0-9a-zA-Z]*)$";
Pattern pattern=Pattern.compile(regex);
Matcher matcher=pattern.matcher(str);
boolean flag=matcher.matches();
return flag;
}
public static void main(String[] args) throws Exception{
String str="aa1as12ds3232ds2d22";
boolean result=StringResult(str);
System.out.println("result="+result);
}
}
posted @ 2012-10-18 23:17 abing 阅读(1067) | 评论 (1)编辑 收藏

死锁     死锁是这样一种情形:多个线程同时被阻塞,它们中的一个或者全部都在等待某个资源被释放。由于线程被无限期地阻塞,因此程序不可能正常终止。     导致死锁的根源在于不适当地运用“synchronized”关键词来管理线程对特定对象的访问。“synchronized”关键词的作用是,确保在某个时刻只有一个线程被允许执行特定的代码块,因此,被允许执行的线程首先必须拥有对变量或对象的排他性的访问权。当线程访问对象时,线程会给对象加锁,而这个锁导致其它也想访问同一对象的线程被阻塞,直至第一个线程释放它加在对象上的锁。     由于这个原因,在使用“synchronized”关键词时,很容易出现两个线程互相等待对方做出某个动作的情形。代码一是一个导致死锁的简单例子。   //代码一 class Deadlocker {  int field_1;  private Object lock_1 = new int[1];  int field_2;  private Object lock_2 = new int[1];   public void method1(int value) {   “synchronized” (lock_1) {    “synchronized” (lock_2) {     field_1 = 0; field_2 = 0;    }   }  }   public void method2(int value) {   “synchronized” (lock_2) {    “synchronized” (lock_1) {     field_1 = 0; field_2 = 0;    }   }  } }       参考代码一,考虑下面的过程:     ◆ 一个线程(ThreadA)调用method1()。     ◆ ThreadA在lock_1上同步,但允许被抢先执行。     ◆ 另一个线程(ThreadB)开始执行。     ◆ ThreadB调用method2()。     ◆ ThreadB获得lock_2,继续执行,企图获得lock_1。但ThreadB不能获得lock_1,因为ThreadA占有lock_1。     ◆ 现在,ThreadB阻塞,因为它在等待ThreadA释放lock_1。     ◆ 现在轮到ThreadA继续执行。ThreadA试图获得lock_2,但不能成功,因为lock_2已经被ThreadB占有了。     ◆ ThreadA和ThreadB都被阻塞,程序死锁。     当然,大多数的死锁不会这么显而易见,需要仔细分析代码才能看出,对于规模较大的多线程程序来说尤其如此。好的线程分析工具,例如JProbe Threadalyzer能够分析死锁并指出产生问题的代码位置。     隐性死锁     隐性死锁由于不规范的编程方式引起,但不一定每次测试运行时都会出现程序死锁的情形。由于这个原因,一些隐性死锁可能要到应用正式发布之后才会被发现,因此它的危害性比普通死锁更大。下面介绍两种导致隐性死锁的情况:加锁次序和占有并等待。     加锁次序     当多个并发的线程分别试图同时占有两个锁时,会出现加锁次序冲突的情形。如果一个线程占有了另一个线程必需的锁,就有可能出现死锁。考虑下面的情形,ThreadA和ThreadB两个线程分别需要同时拥有lock_1、lock_2两个锁,加锁过程可能如下:     ◆ ThreadA获得lock_1;     ◆ ThreadA被抢占,VM调度程序转到ThreadB;     ◆ ThreadB获得lock_2;     ◆ ThreadB被抢占,VM调度程序转到ThreadA;     ◆ ThreadA试图获得lock_2,但lock_2被ThreadB占有,所以ThreadA阻塞;     ◆ 调度程序转到ThreadB;     ◆ ThreadB试图获得lock_1,但lock_1被ThreadA占有,所以ThreadB阻塞;     ◆ ThreadA和ThreadB死锁。     必须指出的是,在代码丝毫不做变动的情况下,有些时候上述死锁过程不会出现,VM调度程序可能让其中一个线程同时获得lock_1和lock_2两个锁,即线程获取两个锁的过程没有被中断。在这种情形下,常规的死锁检测很难确定错误所在。     占有并等待     如果一个线程获得了一个锁之后还要等待来自另一个线程的通知,可能出现另一种隐性死锁,考虑代码二。   //代码二 public class queue {  static java.lang.Object queueLock_;  Producer producer_;  Consumer consumer_;   public class Producer {   void produce() {    while (!done) {     “synchronized” (queueLock_) {      produceItemAndAddItToQueue();      “synchronized” (consumer_) {       consumer_.notify();      }     }    }   }    public class Consumer {    consume() {     while (!done) {      “synchronized” (queueLock_) {       “synchronized” (consumer_) {        consumer_.wait();       }       removeItemFromQueueAndProcessIt();      }     }    }   }  } }       在代码二中,Producer向队列加入一项新的内容后通知Consumer,以便它处理新的内容。问题在于,Consumer可能保持加在队列上的锁,阻止Producer访问队列,甚至在Consumer等待Producer的通知时也会继续保持锁。这样,由于Producer不能向队列添加新的内容,而Consumer却在等待Producer加入新内容的通知,结果就导致了死锁。     在等待时占有的锁是一种隐性的死锁,这是因为事情可能按照比较理想的情况发展—Producer线程不需要被Consumer占据的锁。尽管如此,除非有绝对可靠的理由肯定Producer线程永远不需要该锁,否则这种编程方式仍是不安全的。有时“占有并等待”还可能引发一连串的线程等待,例如,线程A占有线程B需要的锁并等待,而线程B又占有线程C需要的锁并等待等。     要改正代码二的错误,只需修改Consumer类,把wait()移出“synchronized”()即可。
posted @ 2012-10-17 15:48 abing 阅读(314) | 评论 (0)编辑 收藏

一.下载JDK
1.登录Sun的JDK官方下载网址:http://java.sun.com/javase/downloads/index.jsp
2.下载jdk-1_5_0_07-linux-i586-rpm.bin文件
 
二.安装JDK
1.增加jdk-1_5_0_07-linux-i586-rpm.bin文件的可执行权限
#root> chmod 755 jdk-1_5_0_07-linux-i586-rpm.bin
2.执行jdk-1_5_0_07-linux-i586-rpm.bin
#root> ./ jdk-1_5_0_07-linux-i586-rpm.bin
3.安装PRM包文件
#root> rpm -ivh jdk-1_5_0_07-linux-i586.rpm
 
三.配置环境变量PATH,JAVA_HOME,CLASSPATH
配置环境变量有三种:
1.修改/etc/profile文件(系统有效)
(1)#root > vi /etc/profile
(2)使用VI编辑器在profile文件中添加以下语句:
JAVA_HOME=/opt/jdk1.5
PATH=$JAVA_HOME/bin:$PATH
CLASSPATH=.$JAVA_HOME/lib/dt.jar:JAVA_HOME/lib/tools.jar export JAVA_HOME,PATH,CLASSPATH
(3)重新登录
 
[注意]
<1>Linux下环境变量使用:分隔路径,不同于Windows下的;
<2>Linux使用($+环境变量名)来引用原来变量的值,Windows则是使用%+环境变量名+%.比如$PATH和%PATH%
<3>CLASSPATH中不能存在空格,如Windows下的C:\Documents and Settings\seagar\jdk1.5将是不合法的路径名
<4>CLASSPATH中的当前目录"."不能忽略
<5>export把环境变量导出为全局变量
<6>大小写严格区分
 
2.修改.bashrc文件(个人用户有效)
(1)#root > vi /home/seagar/.bashrc
(2)使用VI编辑器在.bashrc文件中添加以下语句:
JAVA_HOME=/opt/jdk1.5
PATH=$JAVA_HOME/bin:$PATH
CLASSPATH=.$JAVA_HOME/lib/dt.jar:JAVA_HOME/lib/tools.jar
export JAVA_HOME,PATH,CLASSPAT
3.直接在shell修改(当前Shell有效)
export JAVA_HOME=/opt/jdk1.5
export PATH=$JAVA_HOME/bin:$PATH
export CLASSPATH=.$JAVA_HOME/lib/dt.jar:JAVA_HOME/lib/tools.jar
 
四.测试安装情况
1.java -version查看版本号
2.使用VI编辑器编写一个Java程序
(1)#root > vi Hello.java
(2)编写程序
public class Hello
{
     public static void main(String[] args)
     {
          System.out.println("Hello");
     }
}
3.编译:javac Hello.java
4.执行:java Hello


五.卸载jdk

 

 

   卸载rpm版的jdk:

   #rpm -qa|grep jdk

   显示:jdk-1.6.0_10-fcs

   这就说明了你安装了jdk,下面卸载了它,
   卸载:#rpm -e  --nodeps  jdk-1.6.0_10-fcs 

 

posted @ 2012-10-17 00:10 abing 阅读(237) | 评论 (0)编辑 收藏

fedora使用rpm包怎么安装到指定文件夹:
rpm -ivh --prefix=路径 FILE.rpm
需要注意的是:“路径”必须是/home/abin/java这种的,不能为~/java

fedora使用tar.gz包怎么安装到指定文件夹:
tar -zxvf abin.tar.gz -C /home/abin/java
posted @ 2012-10-17 00:05 abing 阅读(201) | 评论 (0)编辑 收藏

http://hbase.apache.org/book/quickstart.html
posted @ 2012-10-16 16:03 abing 阅读(119) | 评论 (0)编辑 收藏

系统
  # uname -a #查看内核/操作系统/CPU信息
  # head -n 1 /etc/issue #查看操作系统版本
  # cat /proc/cpuinfo #查看CPU信息
  # hostname #查看计算机名
  # lspci -tv #列出所有PCI设备
  # lsusb -tv #列出所有USB设备
  # lsmod #列出加载内核模块
  # env #查看环境变量
  资源
  # free -m #查看内存使用量和交换区使用量
  # df -h #查看各分区使用情况
  # du -sh <目录名> #查看指定目录大小
  # grep MemTotal /proc/meminfo #查看内存总量
  # grep MemFree /proc/meminfo #查看空闲内存量
  # uptime #查看系统运行时间、用户数、负载
  # cat /proc/loadavg #查看系统负载
  磁盘和分区
  # mount | column -t #查看挂接分区状态
  # fdisk -l #查看所有分区
  # swapon -s #查看所有交换分区
  # hdparm -i /dev/hda #查看磁盘参数(仅适用于IDE设备)
  # dmesg | grep IDE #查看启动时IDE设备检测状况
  网络
  # config #查看所有网络接口属性
  # iptables -L #查看防火墙设置
  # route -n #查看路由表
  # netstat -lntp #查看所有监听端口
  # netstat -antp #查看所有已经建立连接
  # netstat -s #查看网络统计信息
  进程
  # ps -ef #查看所有进程
  # top #实时显示进程状态
  用户
  # w #查看活动用户
  # id <用户名> #查看指定用户信息
  # last #查看用户登录日志
  # cut -d: -f1 /etc/passwd #查看系统所有用户
  # cut -d: -f1 /etc/group #查看系统所有组
  # crontab -l #查看当前用户计划任务
  服务
  # chkconfig --list #列出所有系统服务
  # chkconfig --list | grep on #列出所有启动系统服务
  
  # rpm -qa #查看所有安装软件Software包 
posted @ 2012-10-15 23:59 abing 阅读(155) | 评论 (0)编辑 收藏

仅列出标题
共7页: 上一页 1 2 3 4 5 6 7 下一页