在逛论坛的看到很多的朋友在讨论staic块，进去瞧瞧，感觉有点雾里看花。我也不知道static块到底有什么用，何时用。学习下吧，好象JDBC就用到这些东西。

    一般情况下,如果有些代码必须在项目启动的时候就要被执行,这种情况上就需要使用静态代码块,这种代码是主动执行的，写个例子看看static块什么时候被执行

1.StaticTest

package com.test.statictest;

public class StaticTest {
	/** 构造方法*/
	public StaticTest() {
		System.out.println("构造函数被执行了!");
	}
	/** 静态代码快*/
	static {
		System.out.println("静态代码块被执行了!");
		//show();
	}
	/** 静态方法*/
	public static void show(){
		System.out.println("静态方法被执行了!");
	}
}

2.Main

package com.test.statictest;

public class Main {
	public static void main(String[] args) throws ClassNotFoundException {
		Main main = new Main();
		//加载类
		Class.forName("com.test.statictest.StaticTest");
		Class.forName("com.test.statictest.StaticTest");
		
	}
}

 结果输出

    静态代码块被执行了!

在测试类里我加载了2次StaticTest类，按理说"静态代码块被执行了!"这句话应执行二次,但只输出了一次。

再看看别的

package com.test.statictest;

public class Main {
	public static void main(String[] args) throws ClassNotFoundException {
		Main main = new Main();
		//加载类
		Class.forName("com.test.statictest.StaticTest",true,Main.class.getClassLoader());
		//Class.forName("com.test.statictest.StaticTest");		
	}
}

 结果：

    静态代码块被执行了!

这两个语句是等价的，执行的结果相同。

把Class.forName("com.test.statictest.StaticTest",true,Main.class.getClassLoader())中的true改为false，代表加载类的时候不初始化静态代码块的内容，只能在这个类被实例化的时候才能初始化

   Class.forName(xxx.xx.xx)的作用是要求JVM查找并加载指定的类，也就是说JVM会执行该类的静态代码块.

看看JDBC是怎么对Class.forName解释的:

      we just want to load the driver to jvm only, but not need to user the instance of driver, so call Class.forName(xxx.xx.xx) is enough, if you call Class.forName(xxx.xx.xx).newInstance(), the result will same as calling Class.forName(xxx.xx.xx), because Class.forName(xxx.xx.xx).newInstance() will load driver first, and then create instance, but the instacne you will never use in usual, so you need not to create it.

翻译：

• 搜狐网站诚聘Java、PHP和C++工程师
• Windows7在微软WinHEC 2008上揭开神秘面纱

   观察者模式在软件编程中用的较多，我不善于表达我就用在网上看到的故事，和生活的例子说下基本思想 

故事：

   小雪是一个非常漂亮的女孩，漂亮的女孩总是有很多的追求者，而且追求者的队伍在不断的变动，随时有人进入这个队伍，也有人退出。男孩们追求女孩时总是表现出120%的关心，当小雪私自游玩时总是不断收到追求者询问小雪位置变动的消息，小雪也不胜其烦，但小雪是如此的一个善良的女孩，她总是打断自己正常的生活回复男孩们的消息。而男孩们由于要不断的关心小雪的位置变化也弄的精疲力竭，而且还影响正常的工作。在这样一个简单的故事场景中我们发现了什么？来看看小雪和男孩们的烦恼：
  1.男孩们必须不断的询问小雪的位置变化，从而打断正常的工作; 
  2.小雪也要不断的接受男孩们的询问，有的时候小雪的位置并没有发生变化，还是要不断的回复男孩们的询问，也影响正常的工作。

  3.如果给各个男孩们回复问题的方式都不尽相同，小雪还要知道不同的回复方式，而且不断的有新的男孩们增加进来，还不知道未来有什么新的回复方式。

    看到这么多烦恼，我们创意无限的Nokia公司给小雪和男孩们提出了解决方案：
    Nokia公司荣誉出品了一款带有GPRS功能的手机，该手机保存着一个订阅位置变化短信通知的电话列表，当该手机检测到位置发生变化就会向这个订阅列表里的所有手机发送短信。看到Nokia这个解决方案，男孩们和小雪都应该松一口气，他们各自都可以按照自己正常的生活习惯，只有状态发生变化时候各自才会进行通信。

   观察者模式还可以用生活中一个例子来表达，就是从邮局订杂志。假如有一个叫 妮妮 的女孩在A邮局订了《时尚女孩》的杂志，又在B邮局订了《知音》杂志，并且告诉这两家邮局，如果杂志到了就给我打电话我自己来拿，然后邮局就在系统中注册下这个女孩姓名，电话等信息。妮妮剩下的就是等邮局的电话来取杂志了。如果杂志到了，邮局打电话给妮妮说,您的杂志到了，请到某某邮局来取（这相当于程序中把对象的引用——邮局名，传给观察者），如果只说您的杂志到了，请到邮局来取，妮妮怎么知道去哪个邮局拿杂志呀。

下面的程序模仿上面的情形，一个随机数产生对象和两个观察者，这两个观察者都在随机数产生对象那里注册了，意思说如果你产生了新的数字，就通知我一声。

结构图:

类说明

名称	功能说明
Observer	表示观察者的接口，要成为观察者必须实现此接口才行
NumberGenerator	表示产生数值的抽象类
RandomNumberGenerator	产生随机数的类，继承于NumberGenerator
NumberObserver	数字观察者，会打印出变化的数字
SymbolObserver	符号观察者,打印N 个符号,打印多少个符号，由接受到的数值确定

1.Observer

package com.pattern.observer;

public interface Observer {
	public abstract void update(NumberGenerator generator);
}

2.NumberGenerator

package com.pattern.observer;

import java.util.ArrayList;
import java.util.Iterator;

/**
 * @project JavaPattern
 * @author sunnylocus	
 * @verson 1.0.0
 * @date   Aug 27, 2008 1:35:34 PM
 * @description 产生数值的抽象类
 */
public abstract class NumberGenerator {
	private ArrayList observers = new ArrayList();  //存储Observer
	/** 添加观察者*/
	public void addObserver(Observer observer) {
		observers.add(observer);
	}
	/** 删除观察者*/
	public void delObserver(Observer observer) {
		observers.remove(observer);
	}
	/** 通知所有观察者*/
	public void notifyObservers() {
		Iterator it = observers.iterator();
		while(it.hasNext()) {
			Observer o =(Observer) it.next();
			o.update(this);//this相当于上面提到的邮局名
		}
	}
	public abstract int getNumber();//获取数字
	public abstract void generate();//产生数字
}

3.RandomNumberGenerator

package com.pattern.observer;

import java.util.Random;

/**
 * @project JavaPattern
 * @author sunnylocus	
 * @verson 1.0.0
 * @date   Aug 27, 2008 1:48:03 PM
 * @description 用于产生随机数及通知观察者的类
 */
public class RandomNumberGenerator extends NumberGenerator{
	private Random random = new Random();//随机数产生器
	private int number;   //用于存放数字

	public void generate() {
		for(int i=0 ; i < 5; i++) {
			number = random.nextInt(10);//产生10以内的随机数
			notifyObservers();  //有新产生的数字，通知所有注册的观察者
		}
	}
    /** 获得数字*/
	public int getNumber() {
		return number;
	}
	
}

4.NumberObserver

package com.pattern.observer;

/** 以数字表示观察者的类*/
public class NumberObserver implements Observer{
	public void update(NumberGenerator generator) {
		System.out.println("NumberObserver:"+ generator.getNumber());
		try {
			Thread.sleep(1000 * 3); //为了能清楚的看到输出，休眠3秒钟。
		}catch(InterruptedException e) {
			e.printStackTrace();
		}
	}
	
}

5.SymbolObserver

package com.pattern.observer;

/** 以符号表示观察者的类*/
public class SymbolObserver implements Observer{
	public void update(NumberGenerator generator) {
		System.out.print("SymbolObserver:");
		int count = generator.getNumber();
		
		for(int i = 0 ; i < count; i ++) {
			System.out.print("*^_^*  ");
		}
		System.out.println("");
		try {
			Thread.sleep(1000 * 3);
		}catch(InterruptedException e){
			e.printStackTrace();
		}
	}
}

6.Main(测试类)

package com.pattern.observer;

public class Main {
	public static void main(String[] args) {
		//实例化数字产生对象
		NumberGenerator generator = new RandomNumberGenerator();
		//实例化观察者
		Observer observer1 = new NumberObserver();
		Observer observer2 = new SymbolObserver();
		//注册观察者
		generator.addObserver(observer1);
		generator.addObserver(observer2);
		
		generator.generate(); //产生数字
	}
}

 7.结果输出

设计思想：

     观察者模式定义了对象之间的一对多的依赖关系，当一个对象的状态发生改变时，所有它的依赖对象将被自动通知并更新

• 搜狐网站诚聘Java、PHP和C++工程师
• Windows7在微软WinHEC 2008上揭开神秘面纱

  Template Method Pattern是在父类建立处理逻辑的大纲骨架，而在子类补充具体的处理内容，如果把模板方法用在产生对象实例方面，就是式厂方法模式
      Factory Method Pattern在父类规定对象的创建方法，但并没有深入到较具体的类名。所有具体的完整内容都放在子类，根据这个原则，我们可以大致分成产生对象实例的框架和实际产生对象实例的类两方面

    1.框架类

package com.pattern.factorymethod;

public abstract class Factory {
	public final Cup make(String shape,String color) {//产生对象的方法，用final修饰把保证在子类中不会被修改
		Cup cup = makeCup(shape);
		smearColor(cup,color);
		return cup;
	}
	protected abstract Cup makeCup(String shape); //抽象方法，制作水杯，shape参数指定水杯的外形
	protected abstract void smearColor(Cup cup,String color);  //抽象方法，给水杯涂上颜色
	
}

 2.实现类

package com.pattern.factorymethod;

public class CupFactory extends Factory {

	protected Cup makeCup(String shape) {
		Cup cup = new Cup();
		cup.setShape(shape);
		return cup;
	}
	protected void smearColor(Cup cup, String color) {//涂颜色
		cup.setColor(color);
	}

}

 3.水杯(实体类)

package com.pattern.factorymethod;

public  class Cup {
	private String shape;
	private String color;

	public String getColor() {
		return color;
	}

	public void setColor(String color) {
		this.color = color;
	}

	public String getShape() {
		return shape;
	}

	public void setShape(String shape) {
		this.shape = shape;
	}	
	
}

4.测试

package com.pattern.factorymethod;

public class Main {
	public static void main(String[] args) {
		//创建一个水杯工厂
		CupFactory factory = new CupFactory();
		Cup cup1 = factory.make("圆形", "红色");//我要一个圆形，红色的杯子 
		System.out.println("杯子造好了");
		System.out.println("形状："+cup1.getShape());
		System.out.println("颜色："+cup1.getColor());
		
		Cup cup2 = factory.make("方形", "蓝色");//我要一个方形，蓝色的杯子 
		System.out.println("杯子造好了");
		System.out.println("形状："+cup2.getShape());
		System.out.println("颜色："+cup2.getColor());
	}
}

结果：

    杯子造好了
    形状：圆形
    颜色：红色
    杯子造好了
    形状：方形
    颜色：蓝色

• 搜狐网站诚聘Java、PHP和C++工程师
• Windows7在微软WinHEC 2008上揭开神秘面纱

修改配置文件，使tomcat自动启动

(假设tomcat的安装路径位于 /opt/apache-tomcat5.5.26目录下)

1. 在root根目录下，输入 vi /etc/profile
2. 在profile文件中加入下面几句话
3.    cd /opt/apache-tomcat5.5.26/bin
4.    chmod 777 *  // 把bin目录下的所有文件的权限设置最大，否则将不能运行
5.    ./startup.sh
6. 保存退出

• Windows7在微软WinHEC 2008上揭开神秘面纱
• 搜狐网站诚聘Java、PHP和C++工程师

1. 修改/etc/profile文件

　　　　如果你的计算机仅仅作为开发使用时推荐使用这种方法，因为所有用户的shell都有权使用这些环境变量，可能会给系统带来安全性问题。

　　　　·用文本编辑器打开/etc/profile
　　　　·在profile文件末尾加入：

　          JAVA_HOME=/usr/share/jdk1.5.0_05
　　　　　　PATH=$JAVA_HOME/bin:$PATH
　　        CLASSPATH=.:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
　　　　　　export JAVA_HOME
　　　　　　export PATH
　　　　　　export CLASSPATH

　　　　·重新登录
　　　　·提示
　　　　　　CLASSPATH中的“.”不能丢！
　　　　

　　2. 修改.bashrc文件
　　　　这种方法更为安全，它可以把使用这些环境变量的权限控制到用户级别，如果你需要给某个用户权限使用这些环境变量，你只需要修改其个人用户主目录下的.bashrc文件就可以了。

　　　　·用文本编辑器打开用户目录下的.bashrc文件
　　　　·在.bashrc文件末尾加入：
　　　　

                  set JAVA_HOME=/usr/share/jdk1.5.0_05
　　　　　　export JAVA_HOME
　　　　　　set PATH=$JAVA_HOME/bin:$PATH
            　　export PATH
            　　set CLASSPATH=.:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
            　　export CLASSPATH

　　　　·重新登录

　　3. 直接在shell下设置变量

            一次性设置，因为换个shell 你的设置就失效了.

　　　　只需在shell终端执行下列命令：

            export JAVA_HOME=/usr/share/jdk1.5.0_05
　　　　export PATH=$JAVA_HOME/bin:$PATH
　　　　export CLASSPATH=.:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar

• 搜狐网站诚聘Java、PHP和C++工程师
• Windows7在微软WinHEC 2008上揭开神秘面纱

管理员密码修改过程：

1.    启动Linux系统
2.    出现蓝色的Grub界面
3.    选择Red Hat操作系统
4.    按e
5.    选择第二行,按e
6.    在行尾加上 1或s ,回车
7.    按b启动
8.    在提示符后面输入 passwd root
9.    输入两次一样的新密码
10.    init 3 或init 5

• Windows7在微软WinHEC 2008上揭开神秘面纱
• 搜狐网站诚聘Java、PHP和C++工程师

package com.sunnylocus.util;

import java.security.MessageDigest;

/** 
 * 对密码进行加密和验证的类
 */
public class CipherUtil{
    
    //十六进制下数字到字符的映射数组
    private final static String[] hexDigits = {"0", "1", "2", "3", "4",
        "5", "6", "7", "8", "9", "a", "b", "c", "d", "e", "f"};
    
    /** * 把inputString加密     */
    public static String generatePassword(String inputString){
        return encodeByMD5(inputString);
    }
    
      /**
       * 验证输入的密码是否正确
     * @param password    加密后的密码
     * @param inputString    输入的字符串
     * @return    验证结果，TRUE:正确 FALSE:错误
     */
    public static boolean validatePassword(String password, String inputString){
        if(password.equals(encodeByMD5(inputString))){
            return true;
        } else{
            return false;
        }
    }
    /**  对字符串进行MD5加密     */
    private static String encodeByMD5(String originString){
        if (originString != null){
            try{
                //创建具有指定算法名称的信息摘要
                MessageDigest md = MessageDigest.getInstance("MD5");
                //使用指定的字节数组对摘要进行最后更新，然后完成摘要计算
                byte[] results = md.digest(originString.getBytes());
                //将得到的字节数组变成字符串返回
                String resultString = byteArrayToHexString(results);
                return resultString.toUpperCase();
            } catch(Exception ex){
                ex.printStackTrace();
            }
        }
        return null;
    }
    
    /** 
     * 转换字节数组为十六进制字符串
     * @param     字节数组
     * @return    十六进制字符串
     */
    private static String byteArrayToHexString(byte[] b){
        StringBuffer resultSb = new StringBuffer();
        for (int i = 0; i < b.length; i++){
            resultSb.append(byteToHexString(b[i]));
        }
        return resultSb.toString();
    }
    
    /** 将一个字节转化成十六进制形式的字符串     */
    private static String byteToHexString(byte b){
        int n = b;
        if (n < 0)
            n = 256 + n;
        int d1 = n / 16;
        int d2 = n % 16;
        return hexDigits[d1] + hexDigits[d2];
    }
}

package com.sunnylocus.util;

public class Main {
	public static void main(String[] args) {
		String pwd1="123";
		String pwd2="";
		CipherUtil cipher = new CipherUtil();
		System.out.println("未加密的密码:"+pwd1);
		//将123加密
		pwd2 = cipher.generatePassword(pwd1);
		System.out.println("加密后的密码:"+pwd2);
		
		System.out.print("验证密码是否下确:");
		if(cipher.validatePassword(pwd2, pwd1)) {
			System.out.println("正确");
		}
		else {
			System.out.println("错误");
		}
	}
}

结果输出：

未加密的密码:123
加密后的密码:202CB962AC59075B964B07152D234B70
验证密码是否下确:正确

• Windows7在微软WinHEC 2008上揭开神秘面纱
• 搜狐网站诚聘Java、PHP和C++工程师

  单态模式(也有叫单例模式)表示一个类只有一个实例存在，生成用单态模式设计类不能用new 关键字来获得。可用简单的一句话来概括单态模式：

      构造方法私有化，通过共有的静态方法返回类的实例。

    最近在项目开发中，程序用到的各个参数被单独拿出来做成一个配置文件，程序接收到用户的定位请求就从配置文件读取出对应的参数和客户端中请求的参数比对，然后把定位请求发送到不同的定位平台，但问题来了，每次读取文件就要new 一个文件对象，而定位请求每秒可能有几个至几十个，频繁的文件读取导致服务器性能下降(读取文件，要生成文件对象，打开文件流，读取，关闭文件流)。就种情况就要用到单态模式，程序一启动就生成唯一的一个文件对象，这样每次读取文件不再与文件物理的建立I/O流，直接从内存中读取即可。

1.单态类

package com.sunnylocus.singleton;

import java.io.File;

public class Singleton {
	private static Singleton instance;
	private static File configFile;
	private Singleton() { //构造方法私有化
	}
	/** 获得配置文件对象*/
	public File getConfigFile() {
		return configFile;
	}
	/** 获得Singleton类的实例*/
	public static Singleton getInstance() {//通过公有的静态方法返回类的实例
		if(instance == null) {
			configFile = new File("src/com/sunnylocus/singleton/locationConfig.xml"); 
			instance = new Singleton();
		}
		
		return instance;
	}
}

2.Test

package com.sunnylocus.singleton;

import java.io.File;

public class Main {
	public static void main(String[] args) {
		Singleton s1 = Singleton.getInstance();
		Singleton s2 = Singleton.getInstance();
		
		if(s1 == s2) { //比较地址
			System.out.println("s1和s2是同一个对象的实例");
		}
		else {
			System.out.println("s1和s2不是同一个对象的实例");
		}
		
		File f1 = s1.getConfigFile();
		File f2 = s1.getConfigFile();
		if(f1 == f2) {
			System.out.println("来自同一个文件对象");
		}
		else {
			System.out.println("不是来自同一个文件对象");
		}
	}
}

3.output:

s1和s2是同一个对象的实例
来自同一个文件对象

• Windows7在微软WinHEC 2008上揭开神秘面纱
• 搜狐网站诚聘Java、PHP和C++工程师

线程池的作用:

     线程池作用就是限制系统中执行线程的数量。
     根据系统的环境情况，可以自动或手动设置线程数量，达到运行的最佳效果；少了浪费了系统资源，多了造成系统拥挤效率不高。用线程池控制线程数量，其他线程排队等候。一个任务执行完毕，再从队列的中取最前面的任务开始执行。若队列中没有等待进程，线程池的这一资源处于等待。当一个新任务需要运行时，如果线程池中有等待的工作线程，就可以开始运行了；否则进入等待队列。

为什么要用线程池:

1. 减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务
2. 可以根据系统的承受能力，调整线程池中工作线线程的数目，防止因为因为消耗过多的内存，而把服务器累趴下(每个线程需要大约1MB内存，线程开的越多，消耗的内存也就越大，最后死机)

线程池类

package com.tdt.impl.ls;

import java.util.LinkedList;

/**
 * @project LocationGateway
 * @author sunnylocus	
 * @verson 1.0.0
 * @date   Aug 2, 2008
 * @jdk    1.4.2
 */
public class ThreadPool extends ThreadGroup {
	private boolean isClosed = false;  //线程池是否关闭 
	private LinkedList workQueue;      //工作队列
	private static int threadPoolID = 1;  //线程池的id
	public ThreadPool(int poolSize) {  //poolSize 表示线程池中的工作线程的数量

		super(threadPoolID + "");      //指定ThreadGroup的名称
		setDaemon(true);               //继承到的方法，设置是否守护线程池
		workQueue = new LinkedList();  //创建工作队列
		for(int i = 0; i < poolSize; i++) {
			new WorkThread(i).start();   //创建并启动工作线程,线程池数量是多少就创建多少个工作线程
		}
	}
	
	/** 向工作队列中加入一个新任务,由工作线程去执行该任务*/
	public synchronized void execute(Runnable task) {
		if(isClosed) {
			throw new IllegalStateException();
		}
		if(task != null) {
			workQueue.add(task);//向队列中加入一个任务
			notify(); 			//唤醒一个正在getTask()方法中待任务的工作线程
		}
	}
	
	/** 从工作队列中取出一个任务,工作线程会调用此方法*/
	private synchronized Runnable getTask(int threadid) throws InterruptedException {
		while(workQueue.size() == 0) {
			if(isClosed) return null;
			System.out.println("工作线程"+threadid+"等待任务...");
			wait();				//如果工作队列中没有任务,就等待任务
		}
		System.out.println("工作线程"+threadid+"开始执行任务...");
		return (Runnable) workQueue.removeFirst(); //反回队列中第一个元素,并从队列中删除
	}
	
	/** 关闭线程池 */
	public synchronized void closePool() {
		if(! isClosed) {
			waitFinish();        //等待工作线程执行完毕
			isClosed = true;
			workQueue.clear();  //清空工作队列
			interrupt(); 		//中断线程池中的所有的工作线程,此方法继承自ThreadGroup类
		}
	}
	
	/** 等待工作线程把所有任务执行完毕*/
	public void waitFinish() {
		synchronized (this) {
			isClosed = true;
			notifyAll();			//唤醒所有还在getTask()方法中等待任务的工作线程
		}
		Thread[] threads = new Thread[activeCount()]; //activeCount() 返回该线程组中活动线程的估计值。
		int count = enumerate(threads); //enumerate()方法继承自ThreadGroup类，根据活动线程的估计值获得线程组中当前所有活动的工作线程
		for(int i =0; i < count; i++) { //等待所有工作线程结束
			try {
				threads[i].join();	//等待工作线程结束
			}catch(InterruptedException ex) {
				ex.printStackTrace();
			}
		}
	}

	/**
	 * 内部类,工作线程,负责从工作队列中取出任务,并执行
	 * @author sunnylocus
	 */
	private class WorkThread extends Thread {
		private int id;
		public WorkThread(int id) {
			//父类构造方法,将线程加入到当前ThreadPool线程组中
			super(ThreadPool.this,id+"");
			this.id =id;
		}
		public void run() {
			while(! isInterrupted()) {  //isInterrupted()方法继承自Thread类，判断线程是否被中断
				Runnable task = null;
				try {
					task = getTask(id);		//取出任务
				}catch(InterruptedException ex) {
					ex.printStackTrace();
				}
				//如果getTask()返回null或者线程执行getTask()时被中断，则结束此线程
				if(task == null) return;
				
				try {
					task.run();  //运行任务
				}catch(Throwable t) {
					t.printStackTrace();
				}
			}//  end while
		}//  end run
	}// end workThread
}

2.测试类

package com.tdt.test;

import com.tdt.impl.ls.ThreadPool;

public class ThreadPoolTest {
	
	public static void main(String[] args) throws InterruptedException {
		ThreadPool threadPool = new ThreadPool(3); //创建一个有个3工作线程的线程池
		Thread.sleep(500); //休眠500毫秒,以便让线程池中的工作线程全部运行
		//运行任务
		for (int i = 0; i <=5 ; i++) { //创建6个任务
			threadPool.execute(createTask(i));
		}
		threadPool.waitFinish(); //等待所有任务执行完毕
		threadPool.closePool(); //关闭线程池

	}

	private static Runnable createTask(final int taskID) {
		return new Runnable() {
			public void run() {
			//	System.out.println("Task" + taskID + "开始");
				System.out.println("Hello world");
			//	System.out.println("Task" + taskID + "结束");
			}
		};
	}
}

结果:

工作线程0等待任务...
工作线程1等待任务...
工作线程2等待任务...

工作线程0开始执行任务...
Hello world
工作线程0等待任务...

工作线程1开始执行任务...
Hello world
工作线程1等待任务...

工作线程2开始执行任务...
Hello world
工作线程2等待任务...

工作线程0开始执行任务...
Hello world
工作线程0等待任务...

工作线程1开始执行任务...
Hello world
工作线程1等待任务...

工作线程2开始执行任务...
Hello world
工作线程2等待任务...

• Windows7在微软WinHEC 2008上揭开神秘面纱
• 搜狐网站诚聘Java、PHP和C++工程师

       以前编程没有怎么接触过synchronized方法，不太了解，今天编程遇到了多个线程访问同一个共享资源的问题，google了下synchronized使用方法，网上有二种说法，第一种说法是当一个线程访问了某个对象中的synchronzied方法,其它线程可以继续访问其它的synchronized方法,第二个说法与第一种说法相反，不能访问。搞的我也不确定，更要命的是，这两种说法在网上一边又一边的转载，以讹传讹，要误导不少java新手。到底那一个是正确的，编个程序验证就清楚了。

   下面是一个示例程序，有三个角色,一个家庭中的父亲，母亲，和儿子,同时在ATM取款机上向同一个银行账号进行取钱和查询的操作
1.银行类

package com.sunnylocus.test;

public class Bank  {
	private int money = 100;
	//取钱
	public synchronized void takeMoney(int num) {
			Thread.sleep(1000 * 5);   //取钱需要5秒
			money -= num;
	}
	//存钱
	public synchronized void addMoney(int num) {
			Thread.sleep(1000 * 10); //存钱需要10秒
			money += money;
	}
	//查询
	public int queryMoney() {
		return money;
	}
}

2.父亲类

package com.sunnylocus.test;

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;

public class Father extends Thread{
	private Bank bank;
	private int num;
	
	DateFormat dateFormate = new SimpleDateFormat("a h:mm:ss");  //日期格式对象
	
	public Father(Bank bank,int num) {
		this.bank = bank;
		this.num = num;
	}

	public void run() {
		System.out.println("老爸正在取钱...      --"+dateFormate.format(new Date()));
		bank.takeMoney(num);
		System.out.println("老爸取走了"+num +"         --"+dateFormate.format(new Date()));
	}
	
}

3.母亲类

package com.sunnylocus.test;

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;

public class Monther extends Thread{
	private Bank bank;
	private int num;
	DateFormat dateFormate = new SimpleDateFormat("a h:mm:ss");  //日期格式对象
	
	public Monther(Bank bank,int num) {
		this.bank = bank;
		this.num = num;
	}

	public void run() {
		System.out.println("老妈正在取钱....         "+dateFormate.format(new Date()));
		bank.takeMoney(num);
		System.out.println("老妈取走了"+num+"         --"+dateFormate.format(new Date()));
	}
	
}

4.儿子类

package com.sunnylocus.test;

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;

public class Sun extends Thread{
	private Bank bank;
	DateFormat dateFormate = new SimpleDateFormat("a h:mm:ss");  //日期格式对象
	public Sun(Bank bank) {
		this.bank = bank;
	}

	public void run() {
		//查询余款
		System.out.println("儿子查询余额:"+bank.queryMoney() +"     --"+dateFormate.format(new Date()));
	}
}

5.测试类

package com.sunnylocus.test;

public class Main {
	public static void main(String[] args) {
		//银行
		Bank bank = new Bank();
		//老爸
		Father father = new Father(bank,50);
		//老妈
		Monther monther = new Monther(bank,100);
		//儿子
		Sun sun = new Sun(bank);
		
		new Thread(father).start();
		new Thread(monther).start();
		new Thread(sun).start();
		
	}
}

输出结果:

老爸正在取钱...               --上午 11:52:01
老妈正在取钱....              --上午 11:52:01
儿子查询余额:100           --上午 11:52:01

老爸取走了50                 --上午 11:52:06
老妈取了30                    --上午 11:52:11

   一共有三个线程，同时启动，父亲线程和母亲线程同时取款的操作，因为父亲线程已经占用了对象锁，所以母亲线程只能等到父亲执行完方法释放锁后，才能执行。即便父亲线程占用了对象锁，儿子线程也能调用非synchronzied方法
 

     我们把母亲类的取钱的方法改成存钱的操作，虽然不是同一个synchronized方法.也一样不能执行，必须等到父亲线程方法执行完毕后，才能进行存钱的操作

我的结论: 
     synchronized method(){}可以防止多个线程同时访问这个对象的synchronized方法,如果一个对象有多个synchronized方法，只要一个线 程访问了其中的一个synchronized方法，那么其它线程不能同时访问这个对象中的任何一个synchronized方法,但可以访问这个对象中的非synchronized方法。

• 搜狐网站诚聘Java、PHP和C++工程师
• Windows7在微软WinHEC 2008上揭开神秘面纱

     刚开始找工作那段时间，每天要面试好几家单位，不停的重复着面试,机试。有几家感觉希望挺大的,但最后也没有接到通知。我想可能是我没有工作经验，公司不信任吧。后来来到我现在这个公司，感觉这家公司很务实，面试主管只说，我们公司注重能力，能力高于学历。给了我三道题目,前两道不难,第一个题目是结合Oracle数据库建立一个登陆信息表,实现ajax登陆验证功能,第二个题目是用oracle语句实现jsp分页功能。前两道题目很简单，关键是第三道题目，用webservice实现两个整数求和,看到这个题目我连webservice的基本概念都不知道，回校问老师，老师也不清楚。没办法只能上网查资料，弄到半夜十二点半终于搞明白了。

      第二天机试顺利通过。之后公司来了几位应试的最后都被webService拒之门外，我问道怎么不上网查资料呢，他说，查了，网上的例子放到自己的机器出些不知道的错误，网上文章也都是些难懂的字眼看不懂。所以我把机试题的经验写到博客里，希望能对求职的朋友有一点帮助。

 概念：

    Web Service主要是为了使原来各孤立的站点之间的信息能够相互通信、共享而提出的一种接口。 Web Service所使用的是Internet上统一、开放的标准，如HTTP、XML、SOAP（简单对象访问协议）、WSDL等，所以Web Service可以在任何支持这些标准的环境（Windows,Linux）中使用。注：SOAP协议（Simple Object Access Protocal,简单对象访问协议）,它是一个用于分散和分布式环境下网络信息交换的基于XML的通讯协议。在此协议下，软件组件或应用程序能够通过标准的HTTP协议进行通讯。它的设计目标就是简单性和扩展性，这有助于大量异构程序和平台之间的互操作性，从而使存在的应用程序能够被广泛的用户访问

    说的通俗一点webservice它就是一个函数或着方法，它的特别之处在于这个方法布署到web容器之后，无论身处何地，只要能访问到这个web容器,谁都可以调用这个方法。实现webservie最快捷的就是用axis框架,将axis的几个jar包导入到项目里，把要实现webservice功能的类,复制一份放到WEBROOT目录下，将复制到WEBROOT目录下的类的后缀名改为.jws，然后布署到web容器，在地址栏中输入http://ip/项目名/类文件.jws，将会看到如图所示的界面:

 点击 Click to see the WSDL 会打开一个网页，网页包含一些xml的描述信息,如图

 如果看到上面的信息，表明的你的webservice已经发布成功了，在程序里可以调用这个"函数"了

简单的webservice服务调用代码:

package com.sunnylocus.test;

import javax.xml.namespace.QName;
import org.apache.axis.client.Call;
import org.apache.axis.client.Service;

public class TestCalculate {

	public static void main(String[] args) {
		try {
			/*我在公司的服务器测试的,公司的tomcat已把端口改成80 所以ip地址后面不用加端口号*/
			String endpoint = "http://192.168.0.16/axis/Calculate.jws";
			Service service = new Service();
			Call call = null;
			call = (Call) service.createCall();
			//设置操作名称(或着说被调用的方法名)
			call.setOperationName(new QName(endpoint, "getSum"));
			//设置目标终端地址
			call.setTargetEndpointAddress(new java.net.URL(endpoint));
			//设置传入参数
			Object[] params = {new Integer(5),new Integer(3)};
			//调用webservice
			Integer sum = (Integer) call.invoke(params);
			System.out.println("两数之和:"+sum);
		} catch (Exception ex) {
			ex.printStackTrace();
		}
	}
}

输出:

 代码及axis相关的jar包，我打包放在附件了，希望对找工作的朋友有点帮助。

• Windows7在微软WinHEC 2008上揭开神秘面纱
• 搜狐网站诚聘Java、PHP和C++工程师

       模板是指在薄片塑料板上面写字后挖空,再使用毛笔或色笔涂满挖空部分,就能看到纯手工而以不失工整的字样,看到模板上的挖空形状,马上就知道最后会变出什么样子的字,不过实际上所显现出来的字样还是要依所使用的画笔种类而定.拿黑色签字笔当画笔,结果当然就是签字笔的字样;当用铅笔来画,得到的也只会是灰黑色的铅笔字;如果用五颜六色的彩色笔,自然能创出让人眼花的多色字.但是,无论使用哪种文具,制作出来的字样都还是脱不了模板上已经固定的形状。

   下面我们用例子说明模板方法

  程序示例类之间的关系

  1.模板类，相当于我们上面提到的薄片塑料板

package com.pattern.templateMethod;

/**
 * 抽象类,充当模板角色
 * @author administrator
 *
 */
public abstract class AbstractDisplay {
	//由子类实现的抽象方法
	public abstract void open();   
	public abstract void print();
	public abstract void close();
	//抽象类实现的方法,final可以保证在子类不会被修改
	public final void display() {
		open();   //先open...
		for(int i=0; i < 5; i++) {  //反复输出5次
			print();  
		}
		close(); //输出完毕,close
	}
}

  2.字符类，输出单个字符

package com.pattern.templateMethod;

public class CharDisplay extends AbstractDisplay {
	private char ch;     //应输出的字符
	public CharDisplay(char ch) {  //把构造函数传递过来的字符ch,存储在字段内
		this.ch = ch;
	}
  
	public void open() {
		System.out.print("<<");   //输出"<<"作为开始字符串
	}
	public void close() {
		System.out.println(">>");  //输出 ">>"作为结束字符串
	}
	public void print() {
		System.out.print(ch);    //输出存储在字段的字符
	}

}

   3.字符串类，输出字符串

package com.pattern.templateMethod;

/**
 * 
 * @author administrator
 */
public class StringDisplay extends AbstractDisplay {
	private String string;  //应输出的字符串
	private int width;      //以byte为单位所求出的字符串的"长度"
	
	public StringDisplay(String string) {
		this.string =string;
		width = string.getBytes().length;
	}

	public void open() {  //打印头装饰字符串
		printLine();
	}
	public void print() { //打印内容
		System.out.println("|"+string+"|");
	}
	public void close() { //打印尾装饰字符串
		printLine();
	}

	public void printLine() {
		System.out.print("+");  //输出"+"号表示边框位置
		for(int i=0; i < width; ++i) {
			System.out.print("-");  //当作线段
		}
		System.out.println("+");  //输出"+"号表示边框位置
	}
}

  4.测试类

package com.pattern.templateMethod;

public class Main {
	public static void main(String[] args) {
		//建立1个有'A'的CharDisplay的对象
		AbstractDisplay d1 = new CharDisplay('A');
		//建立1个有"Hello world"的StringDisplay的对象
		AbstractDisplay d2 = new StringDisplay("Hello World");
		
		//d1,d2都是AbstractDisplay的子类对象,可以调用继承到的display()方法
		d1.display();
		d2.display();
	}
}

 输出:

 <<AAAAA>>
+-----------+
|Hello World|
|Hello World|
|Hello World|
|Hello World|
|Hello World|
+-----------+

设计思想：

  作为模板的方法定义在父类（父类为抽象类），而方法定义使用抽象方法，实现抽象方法的是子类，要在子类实现方法，才能决定具体的操作。如果在不同的子类执行不同实现就可以发展出不同的处理内容。不过，无论在哪个子类执行任何一种实现，处理的大致流程都还是要依照父类制定的方式。

• 搜狐网站诚聘Java、PHP和C++工程师
• Windows7在微软WinHEC 2008上揭开神秘面纱

  如果现在有一台使用12V直流电的笔记本电脑，要将插头接到220V的交流电电源，直接接到电源我想笔记本要报销了。你需要用到一个交流电适配器(AC Adapter)。交流电适配器能够将家用的220V交流电转换成我们需要的12V直流电。适配器的功能就是介入原有电源和需要的电源之间，作为沟通的桥梁。适配器的原文是adapter,代表"适合"的意思。

     在程序设计中我们也需要用到“适配器”,如果原有的内容无法直接利用时，通常要转换成必要的类型后再使用，实现转换功能的就是

Adapter Pattern

    Adapter Pattern分为两种情况:

•     类的Adapter Pattern(继承)
•     对象的Adapter Pattern(委托)

下面的程序使用类的Adapter Pattern输出字符串"$Hello$"和"*Hello*"

 程序示例1

  1.Print接口，可以看成我们需要的内容

package com.pattern.adapter;

public interface Print {
	public abstract void printWeak();
	public abstract void printStrong();
}

   2.原有的内容

package com.pattern.adapter;

public class Banner {
	private String string;
	public Banner(String string) {
		this.string = string;
	}
	
	public void showWithParen() {
		System.out.println("$"+string+"$");
	}
	
	public void showWithAster() {
		System.out.println("*"+string+"*");
	}
}

  3.适配器，将原有的内容转换成我们需要的

package com.pattern.adapter;

/**
 * 适配器类
 * @author administrator
 */
public class PrintBanner extends Banner implements Print {
	
	public PrintBanner(String string) {
		//调用父类的构造函数
		super(string);
	}
	//输出减弱的字符串
	public void printStrong() {
		showWithParen();
	}
	//输出加强的字符串
	public void printWeak() {
		showWithAster();
	}

}

  4.测试类

package com.pattern.adapter;

public class Main {
	public static void main(String[] args) {
		Print p =new PrintBanner("Hello");
		//输出减弱字符
		p.printWeak();
		//输出加强字符
		p.printStrong();
	}
}

  从Main类的源代码中完全看不出有Banner类,showWithParen()，showWtihAster()方法，好象只有人给笔记本电脑提供12V直流电，根据不知道它的原形(Adapter适配器的另一端)竟然是220V的交流电!

 下面的代码采用对象的委托实现程序示例1的功能

  程序救命2：

  1.注意这里的Print不再是接口，而是抽象类

package com.pattern.adapter;

public abstract Print {
	public abstract void printWeak();
	public abstract void printStrong();
}

  2.适配器，采用对象委托模式

package com.pattern.adapter;

/**
 * 适配器类
 * @author administrator
 */
public class PrintBanner extends Print {
	private Banner banner;
	public PrintBanner(String string) {
		this.banner = new Banner(string);
	}
	//输出减弱的字符串
	public void printStrong() {
		banner.showWithParen();
	}
	//输出加强的字符串
	public void printWeak() {
		banner.showWithAster();
	}
}

   测试类同上

  设计思想：

     把一个类的接口变换成客户端所期待的另一种接口，从而使原本因接口原因不匹配而无法一起工作的两个类能够一起工作。适配类可以根据参数返还一个合适的实例给客户端。

• Windows7在微软WinHEC 2008上揭开神秘面纱
• 搜狐网站诚聘Java、PHP和C++工程师

1.Aggregate接口所声明的方法只有iterator方法一个，这是为了建立一个对对应聚合的
iterator

package com.pattern.iterator;

public interface Aggregate {
	public abstract Iterator iterator();
}

2.iterator接口，执行元素递增，具有类似循环变量的功能。

package com.pattern.iterator;
public interface Iterator {
	public abstract boolean hasNext();
	public abstract Object next();
}

3. 书籍类

package com.pattern.iterator;
public class Book {
	private String name="";

	public Book(String name) {
		this.name = name;
	}
	
	/**
	 * 获得书籍名称
	 * @return String
	 */
	public String getName() {
		return name;
	}
}

4.书架类

package com.pattern.iterator;
/**
 * 书架类
 * @author administrator
 */
public class BookShelf implements Aggregate{
	private Book[] books;
	private int last = 0;
	
	public BookShelf(int maxSize) {
		this.books = new Book[maxSize];
	}
	
	public Book getBookAt(int index) {
		return books[index];
	}
	
	//添加书籍
	public void appendBook(Book book) {
		this.books[last] = book;
		last++;
	}
	//获得书架存书的数量
	public int getLength() {
		return books.length;
	}
                //获得书架迭代器对象
	public Iterator iterator() {
		return new BookShelfIterator(this);
	}
	
}

5.书架迭代器类

package com.pattern.iterator;
public class BookShelfIterator implements Iterator{
	private BookShelf bookShelf;
	private int index;
	
	public BookShelfIterator(BookShelf bookShelf) {
		this.bookShelf = bookShelf;
		this.index = 0;
	}
	
	//检查是否还有下一本书
	public boolean hasNext() {
		if(index < bookShelf.getLength()) {
			return true;
		}
		else {
			return false;
		}
	}
	//返回指定位置的书籍
	public Object next() {
		Book book = bookShelf.getBookAt(index);
		index ++;
		return book;
	}
}

6.测试类

package com.pattern.iterator;

public class Main {
	public static void main(String[] args) {
		//生成一个书架
		BookShelf bookShelf = new BookShelf(4);
		//向书架添加书籍
		bookShelf.appendBook(new Book("周恩来的晚年岁月"));
		bookShelf.appendBook(new Book("C++网络编程"));
		bookShelf.appendBook(new Book("J2EE网络编程精解"));
		bookShelf.appendBook(new Book("Java编程思想"));
		
		//获得书架迭代器
		Iterator it = bookShelf.iterator();
		while(it.hasNext()) {
			Book book = (Book)it.next();
			System.out.println(book.getName());
		}
	}
}

输出结果:

周恩来的晚年岁月
C++网络编程
J2EE网络编程精解
Java编程思想

迭代器设计恩想：
      迭代器可以顺序访问一个聚集中的元素而不必显露聚集的内部对象。多个对象聚在一起形成的总体称为聚集，聚集对象是能够包容一组对象的容器对象。迭代器模式将迭代逻辑封装到一个独立的对象中，从而与聚集本身隔开。迭代算法独立于聚集对象，修改迭代算法不会对聚集对象产生任何影响，实现程序的松耦合。

• 搜狐网站诚聘Java、PHP和C++工程师
• Windows7在微软WinHEC 2008上揭开神秘面纱

• 搜狐网站诚聘Java、PHP和C++工程师
• Windows7在微软WinHEC 2008上揭开神秘面纱

     前几天做了一个jsp文件下载的页面，刚开始是直接链接到要下载的文件上，在装有像迅雷，网际快车下载软件没有问题，但在没有装这些软件的机器上会把文件直接打开，如果是一个带后缀名为.rar压缩文件后会直接打开,页面全是乱码。最后重新做了一遍，download.jsp页面接收文件的id,根据这个id号找到对应的文件所有在的路径，把要下载的文件转换成流输出,下载的功能实现了，不过每次下载文件tomcat都要报

java.lang.IllegalStateException:getOutputStream() has already been called for this response

查了好多的资料，终于明白了报错的原因

        在tomcat5下jsp中出现此错误一般都是在jsp中使用了输出流,没有处理好的原因。
具体的原因就是：
        在tomcat中jsp编译成servlet之后在函数_jspService(HttpServletRequest request,HttpServletResponse response)的最后有一段这样的代码
finally {
       if (_jspxFactory != null) _jspxFactory.releasePageContext(_jspx_page_context);
     }
这里是在释放在jsp中使用的对象，会调用response.getWriter(),因为这个方法是和response.getOutputStream()相冲突的！所以会出现以上这个异常。

在使用完输出流以后加入下面两条语句
out.clear();
out = pageContext.pushBody();

示例：download.jsp

//新建文件输入输出流
OutputStream output = null;
FileInputStream fis = null;
try{
    //新建File对象
    File f = new File("文件路径");
    //新建文件输入输出流对象
   output = response.getOutputStream();
    fis = new FileInputStream(f);
    //设置每次写入缓存大小
    byte[] buffer = new byte[1024];
    //把输出流写入客户端
    int i = =1;
    while((i = fis.read(b)) != -1){
      output.write(buffer, 0, i);
    }
    output.flush();
}
catch(Exception e){
    e.printStackTrace();
}
finally{
    if(fis != null){
      fis.close();
      fis = null;
    }
    if(output != null){
      output.close();
      output = null;
    }
    if(out != null){
    //下面这两行解决getOutputStream() has already been called for this response异常
      out.clear();
      out = pageContext.pushBody();
    }
}

• 搜狐网站诚聘Java、PHP和C++工程师
• Windows7在微软WinHEC 2008上揭开神秘面纱

  在用SSH登陆Linux操作系统，发现返回中文提示信息全是乱码，我看了下公司服务器linux配置信息，要修改 /etc/sysconfig目录下的 i18n文件

修改内容如图:

修改后重新启动，中文乱码解决...

• 搜狐网站诚聘Java、PHP和C++工程师
• Windows7在微软WinHEC 2008上揭开神秘面纱

       在大部分Linux发行版本中，sendmail这个古老的邮件系统包是默认安装的，装完系统后，重启时，不少兄弟遇到在启动过程中，到了启动sendmail服务的时候就停止了，没有耐性和经验的朋友这时候可能会以为系统出故障或者系统没有装好，其实既不是系统出故障，一般也不是系统没有安装好，而是系统sendmail的时候在查询你设置的主机名的A记录或反向域名记录，由于全球9台DNS根系统都在美国，这个时候会去查询本机主机名对应的dns A记录，特别时你安装系统时设置的一些“奇怪”的主机名的时候，比如webserver等等之类的，这个时候sendmail会去做这个操作过程。

Apr 28 13:41:36 webserver sendmail[3494]: gethostby*.getanswer: asked for "webserver IN AAAA", got type "A"

Apr 28 13:42:36 webserversendmail[3499]: gethostby*.getanswer: asked for "webserver IN AAAA", got type "A"

Apr 28 13:43:37 webserver sendmail: sendmail startup succeeded

Apr 28 13:43:37 webserver sm-msp-queue[3509]: gethostby*.getanswer: asked for "webserver IN AAAA", got type "A"

     运气好，我的意思是你的“RP”好，呵呵，查询比较快，你感觉不到异样，“RP”不好，少则一到两分钟，多则四到五分钟，而且要命的是不报任何错误信息，这个时间大大超过了我们能忍受的“8s”时间了，心里承受力差的兄弟就要受煎熬了。

知道了问题的症结，就可以对症下药了，比如我们可以修改系统配置文件/etc/hosts

让sendmial绕过查询远程主机，这里给出一种最简单的方法，给主机设置一个别名

修改/etc/hosts ，未修改之前
127.0.0.1 localhost.localdomain localhost
修改成
127.0.0.1 localhost.localdomain localhost 主机名称

查看本机的主机名称的命令是:  hostname
再次重新启动sendmail看看

[root@webserver ~]# service sendmail restart
Shutting down sm-client: [ OK ]
Shutting down sendmail: [ OK ]
Starting sendmail: [ OK ]
Starting sm-client: [ OK ]

启动时间已经到秒级了。 

• 搜狐网站诚聘Java、PHP和C++工程师
• Windows7在微软WinHEC 2008上揭开神秘面纱

BACKUP DATABASE Northwind 
   TO DISK = 'c:\Northwind.bak'
GO

   CREATE DATABASE sunnyShop
   ON PRIMARY (FILENAME = 'F:\sunnyShop\DB\sunnyShop.mdf')
   FOR ATTACH
  GO
 

RESTORE DATABASE TestDB 
   FROM DISK = 'c:\Northwind.bak'
   WITH MOVE 'Northwind' TO 'E:\test.mdf',
   MOVE 'Northwind_log' TO 'E:test.ldf'
   GO

• Windows7在微软WinHEC 2008上揭开神秘面纱
• 搜狐网站诚聘Java、PHP和C++工程师

create database sunnyShop
on PRIMARY
(
	NAME = sunnyShop_date,
	FILENAME='F:\sunnyShop.mdf',
	SIZE = 10,
	MAXSIZE = UNLIMITED,
	FILEGROWTH = 5
)
LOG ON
(
	NAME='sunnyShop_dat',
	FILENAME='F:\sunnyShop.ldf',
	SIZE =5MB,
	MAXSIZE = 25MB,
	FILEGROWTH =5MB
)
GO
USE sunnyShop
GO

USE master
GO
CREATE DATABASE Archive 
ON
PRIMARY ( NAME = Arch1,
      FILENAME = 'c:\program files\microsoft sql    server\mssql\data\archdat1.mdf',
      SIZE = 100MB,
      MAXSIZE = 200,
      FILEGROWTH = 20),
( NAME = Arch2,
   FILENAME = 'c:\program files\microsoft sql server\mssql\data\archdat2.ndf',
   SIZE = 100MB,
   MAXSIZE = 200,
   FILEGROWTH = 20),
( NAME = Arch3,
   FILENAME = 'c:\program files\microsoft sql server\mssql\data\archdat3.ndf',
   SIZE = 100MB,
   MAXSIZE = 200,
   FILEGROWTH = 20)
LOG ON 
( NAME = Archlog1,
   FILENAME = 'c:\program files\microsoft sql server\mssql\data\archlog1.ldf',
   SIZE = 100MB,
   MAXSIZE = 200,
   FILEGROWTH = 20),
( NAME = Archlog2,
   FILENAME = 'c:\program files\microsoft sql server\mssql\data\archlog2.ldf',
   SIZE = 100MB,
   MAXSIZE = 200,
   FILEGROWTH = 20)
GO

USE master
GO
CREATE DATABASE Products
ON 
( NAME = prods_dat,
   FILENAME = 'c:\program files\microsoft sql server\mssql\data\prods.mdf',
   SIZE = 4,
   MAXSIZE = 10,
   FILEGROWTH = 1 )
GO

• Windows7在微软WinHEC 2008上揭开神秘面纱
• 搜狐网站诚聘Java、PHP和C++工程师