Java的多线程 简单入门
首先能够先搞清楚什么是程序、进程、线程，以及它们之间的关系：
定义：
一 程序仅仅是一组指令的有序集合。它是静态的
二 进程是具有一定独立功能的程序关于某个数据集合上的一次执行活动，是系统进行资源分配和调度的一个独立单位。
三 线程是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立执行的基本单位.线程自己基本上不拥有系统资源,仅仅拥有一点在执行中不可缺少的资源(如程序计数器,一组寄存器和栈),一个线程能够创建和撤销还有一个线程；
进程与线程差别与联系
(1) 划分尺度:线程更小，所以多线程程序并发性更高；
(2) 资源分配：进程是资源分配的基本单位，同一进程内多个线程共享其资源。
(3) 地址空间：进程拥有独立的地址空间，同一进程内多个线程共享其资源；
(4) 处理器调度：线程是处理器调度的基本单位。
(5) 运行：每一个线程都有一个程序运行的入口。顺序运行序列和程序的出口，但线程不能单独运行，必须组成进程。一个进程至少有一个主线程。简而言之,一个程序至少有一个进程,一个进程至少有一个线程.
进程和程序差别和联系
（1)程序仅仅是一组指令的有序集合，它本身没有不论什么执行的含义，它仅仅是一个静态的实体。而进程则不同，它是程序在某个数据集上的执行。进程是一个动态的实体。它有自己的生命周期。
反映了一个程序在一定的数据集上执行的所有动态过程。
（2)进程和程序并非一一相应的。一个程序运行在不同的数据集上就成为不同的进程，能够用进程控制块来唯一地标识每一个进程。而这一点正是程序无法做到的，由于程序没有和数据产生直接的联系，既使是运行不同的数据的程序，他们的指令的集合依旧是一样的，所以无法唯一地标识出这些运行于不同数据集上的程序。一般来说，一个进程肯定有一个与之相应的程序。并且仅仅有一个。而一个程序有可能没有与之相应的进程(由于它没有运行),也有可能有多个进程与之相应(运行在几个不同的数据集上)。
（3)进程还具有并发性和交往性。这也与程序的封闭性不同。
-------------------------------------------------------------------------------------------
先来转载一个非常easy的样例，简单又明了：
先看代码吧：
建一个主函数类：
public static void main(String[] args) {
thread1 t1 = new thread1();
//用Thread类的子类创建线程 t1即自己定义的线程类
Thread t2 = new Thread(new thread2());
//用Runnable接口类的对象创建线程，即Java提供的定义方式
t1.start(); //strat()方法启动线程
t2.start();
}
建第一个线程类:
public class thread1 extends Thread {
@Override
public void run() {
try {
Thread.sleep(7000); //主线程挂起7秒,之所以加这种方法是为了更好的理解线程．后面我会说的
System.out.println("one is start......");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
建第二个线程类:
public class thread2 implements Runnable {
public void run() {
System.out.println("two is start ...");
}
}
这些是原代码，当你执行。结果是two is start ... 然后过7秒one is start.... 不知道大家发现没有
主函数应该第一执行thread1.start() 这个类，输出结果是one is start.... 可是却没有．而是two is start ...
thread1.start();//strat()方法启动线程
thread2.start();
能够看出。启动线程的run()方法是通过调用线程的start()方法来实现的(见上例中主类)，调用start()方法启动线程的run()方法不同于一般的调用方法。调用一般方法时。必须等到一般方法执行完成才干够返回start()方法，而启动线程的run()方法后，start()告诉系统该线程准备就绪能够启动run()方法后，就返回start()方法执行调用start()方法语句以下的语句，这时run()方法可能还在执行，这样，线程的启动和执行并行进行，实现了多任务操作。
所以大家明确了吧，用了线程了。他们之间是互不影响的．thread1.start() 还没有结束。对thread2.start()没有影响 如今也明确我在thread1类中加Thread.sleep(7000)的意义了吧
就是为了更好的理解线程。
本篇文章来源于 :刘志猛博客 原文链接：http://www.liuzm.com/article/java/9128b.htm
----------------------以下来略微复杂一点点的：
编写具有多线程能力的程序常常会用到的方法有：
run(), start(), wait(), notify(), notifyAll(), sleep(), yield(), join()
另一个重要的keyword：synchronized
本文将对以上内容进行解说。
一：run() 和start()
演示样例1：
public class ThreadTest extends Thread {
public void run() {
for (int i = 0; i < 10; i++) {
System.out.print(" " + i);
}
}
public static void main(String[] args) {
new ThreadTest().start();
new ThreadTest().start();
}
}
这是个简单的多线程程序。run() 和start() 是大家都非常熟悉的两个方法。把希望并行处理的代码都放在run() 中；stat() 用于自己主动调用run()，
这是JAVA的内在机制规定的。而且run() 的訪问控制符必须是public，返回值必须是void（这样的说法不准确。run() 没有返回值）。run()
不带參数。
这些规定想必大家都早已知道了，但你是否清楚为什么run方法必须声明成这种形式？这涉及到JAVA的方法覆盖和重载的规定。这些内容非常重要，
请读者參考相关资料。
二：keywordsynchronized
有了synchronizedkeyword，多线程程序的执行结果将变得能够控制。
synchronizedkeyword用于保护共享数据。
请大家注意 "共享数据"，
你一定要分清哪些数据是共享数据，JAVA是面向对象的程序设计语言，所以刚開始学习的人在编写多线程程序时。easy分不清哪些数据是共享数据。请看以下的样例：
演示样例2：
public class ThreadTest implements Runnable {
public synchronized void run() {
for (int i = 0; i < 10; i++) {
System.out.print(" " + i);
}
}
public static void main(String[] args) {
Runnable r1 = new ThreadTest();
Runnable r2 = new ThreadTest();
Thread t1 = new Thread(r1);
Thread t2 = new Thread(r2);
t1.start();
t2.start();
}
}
在这个程序中，run() 被加上了synchronizedkeyword。
在main方法中创建了两个线程。你可能会觉得此程序的执行结果一定为：0123456789
0123456789。
但你错了！
这个程序中synchronizedkeyword保护的不是共享数据（
事实上在这个程序中synchronizedkeyword没有起到不论什么作用，此程序的执行结果是不可预先确定的）。这个程序中的t1, t2是两个对象（r1,
r2）的线程。
JAVA是面向对象的程序设计语言，不同的对象的数据是不同的，r1,
r2有各自的run() 方法，而synchronized使同一个对象的多个线程，
在某个时刻仅仅有当中的一个线程能够訪问这个对象的synchronized数据。
每一个对象都有一个 "锁标志"，
当这个对象的一个线程訪问这个对象的某个synchronized数据时。这个对象的全部被synchronized修饰的数据将被上锁（由于 "锁标志"
被当前线程拿走了），仅仅有当前线程訪问完它要訪问的synchronized数据时，当前线程才会释放 "锁标志"。
这样同一个对象的其他线程才有机会訪问synchronized数据。
演示样例3：
public class ThreadTest implements Runnable {
public synchronized void run() {
for (int i = 0; i < 10; i++) {
System.out.print(" " + i);
}
}
public static void main(String[] args) {
Runnable r = new ThreadTest();
Thread t1 = new Thread(r);
Thread t2 = new Thread(r);
t1.start();
t2.start();
}
}
假设你执行1000次这个程序。它的输出结果也一定每次都是：01234567890123456789。由于这里的synchronized保护的是共享数据。
t1,
t2是同一个对象（r）的两个线程，当当中的一个线程（比如：t1）開始运行run() 方法时。因为run() 受synchronized保护，所以同一个对象的其它线程（
t2）无法訪问synchronized方法（run方法）。仅仅有当t1运行完后t2才有机会运行。
演示样例4：
public class ThreadTest implements Runnable {
public void run() {
synchronized (this) {
for (int i = 0; i < 10; i++) {
System.out.print(" " + i);
}
}
}
public static void main(String[] args) {
Runnable r = new ThreadTest();
Thread t1 = new Thread(r);
Thread t2 = new Thread(r);
t1.start();
t2.start();
}
}
这个程序与演示样例3的执行结果一样。
在可能的情况下，应该把保护范围缩到最小，能够用演示样例4的形式，this代表 "这个对象"。没有必要把整个run() 保护起来。
run() 中的代码仅仅有一个for循环，所以仅仅要保护for循环就能够了。
演示样例5：
public class ThreadTest implements Runnable {
public void run() {
for (int k = 0; k < 5; k++) {
System.out.println(Thread.currentThread().getName()
+ " : for loop : " + k);
}
synchronized (this) {
for (int k = 0; k < 5; k++) {
System.out.println(Thread.currentThread().getName()
+ " : synchronized for loop : " + k);
}
}
}
public static void main(String[] args) {
Runnable r = new ThreadTest();
Thread t1 = new Thread(r, "t1_name");
Thread t2 = new Thread(r, "t2_name");
t1.start();
t2.start();
}
}
执行结果：t1_name : for loop : 0
t1_name : for loop : 1
t1_name : for loop : 2
t2_name : for loop : 0
t1_name : for loop : 3
t2_name : for loop : 1
t1_name : for loop : 4
t2_name : for loop : 2
t1_name : synchronized for loop : 0
t2_name : for loop : 3
t1_name : synchronized for loop : 1
t2_name : for loop : 4
t1_name : synchronized for loop : 2
t1_name : synchronized for loop : 3
t1_name : synchronized for loop : 4
t2_name : synchronized for loop : 0
t2_name : synchronized for loop : 1
t2_name : synchronized for loop : 2
t2_name : synchronized for loop : 3
t2_name : synchronized for loop : 4
第一个for循环没有受synchronized保护。对于第一个for循环。t1,
t2能够同一时候訪问。运行结果表明t1运行到了k = 2时，t2開始运行了。t1首先运行完了第一个for循环。此时还没有运行完第一个for循环（
t2刚运行到k = 2）。
t1開始运行第二个for循环，当t1的第二个for循环运行到k = 1时，t2的第一个for循环运行完了。
t2想開始运行第二个for循环。但因为t1首先运行了第二个for循环。这个对象的锁标志自然在t1手中（
synchronized方法的运行权也就落到了t1手中）。在t1没运行完第二个for循环的时候。它是不会释放锁标志的。
所以t2必须等到t1运行完第二个for循环后，它才干够运行第二个for循环
三：sleep()
演示样例6：
public class ThreadTest implements Runnable {
public void run() {
for (int k = 0; k < 5; k++) {
if (k == 2) {
try {
Thread.currentThread().sleep(5000);
}
catch (Exception e) {}
}
System.out.print(" " + k);
}
}
public static void main(String[] args) {
Runnable r = new ThreadTest();
Thread t = new Thread(r);
t.start();
}
}
sleep方法会使当前的线程暂停执行一定时间（给其他线程执行机会）。读者能够执行演示样例6，看看结果就明确了。sleep方法会抛出异常，必须提供捕获代码。
演示样例7：
public class ThreadTest implements Runnable {
public void run() {
for (int k = 0; k < 5; k++) {
if (k == 2) {
try {
Thread.currentThread().sleep(5000);
}
catch (Exception e) {}
}
System.out.println(Thread.currentThread().getName()
+ " : " + k);
}
}
public static void main(String[] args) {
Runnable r = new ThreadTest();
Thread t1 = new Thread(r, "t1_name");
Thread t2 = new Thread(r, "t2_name");
t1.setPriority(Thread.MAX_PRIORITY);
t2.setPriority(Thread.MIN_PRIORITY);
t1.start();
t2.start();
}
}
t1被设置了最高的优先级，t2被设置了最低的优先级。
t1不运行完，t2就没有机会运行。但因为t1在运行的中途歇息了5秒中，这使得t2就有机会运行了。
读者能够执行这个程序试试看。
演示样例8：
public class ThreadTest implements Runnable {
public synchronized void run() {
for (int k = 0; k < 5; k++) {
if (k == 2) {
try {
Thread.currentThread().sleep(5000);
}
catch (Exception e) {}
}
System.out.println(Thread.currentThread().getName()
+ " : " + k);
}
}
public static void main(String[] args) {
Runnable r = new ThreadTest();
Thread t1 = new Thread(r, "t1_name");
Thread t2 = new Thread(r, "t2_name");
t1.start();
t2.start();
}
}
请读者首先执行演示样例8程序，从执行结果上看：一个线程在sleep的时候，并不会释放这个对象的锁标志。
四：join()
演示样例9：
public class ThreadTest implements Runnable {
public static int a = 0;
public void run() {
for (int k = 0; k < 5; k++) {
a = a + 1;
}
}
public static void main(String[] args) {
Runnable r = new ThreadTest();
Thread t = new Thread(r);
t.start();
System.out.println(a);
}
}
请问程序的输出结果是5吗？答案是：有可能。
事实上你非常难遇到输出5的时候。通常情况下都不是5。
这里不解说为什么输出结果不是5。我要讲的是：
如何才干让输出结果为5。事实上非常easy，join() 方法提供了这样的功能。join() 方法，它可以使调用该方法的线程在此之前运行完成。
把演示样例9的main() 方法该成例如以下这样：
public static void main(String[] args) throws Exception {
Runnable r = new ThreadTest();
Thread t = new Thread(r);
t.start();
t.join();
System.out.println(a);
}
这时，输出结果肯定是5。join() 方法会抛出异常，应该提供捕获代码。
或留给JDK捕获。
演示样例10：
public class ThreadTest implements Runnable {
public void run() {
for (int k = 0; k < 10; k++) {
System.out.print(" " + k);
}
}
public static void main(String[] args) throws Exception {
Runnable r = new ThreadTest();
Thread t1 = new Thread(r);
Thread t2 = new Thread(r);
t1.start();
t1.join();
t2.start();
}
}
执行这个程序，看看结果是否与演示样例3一样
五：yield()
yield() 方法与sleep() 方法相似，仅仅是它不能由用户指定线程暂停多长时间。依照SUN的说法：
sleep方法能够使低优先级的线程得到运行的机会，当然也能够让同优先级和高优先级的线程有运行的机会。而yield()
方法仅仅能使同优先级的线程有运行的机会。
演示样例11：
public class ThreadTest implements Runnable {
public void run() {
8
for (int k = 0; k < 10; k++) {
if (k == 5 && Thread.currentThread().getName().equals("t1")) {
Thread.yield();
}
System.out.println(Thread.currentThread().getName()
+ " : " + k);
}
}
public static void main(String[] args) {
Runnable r = new ThreadTest();
Thread t1 = new Thread(r, "t1");
Thread t2 = new Thread(r, "t2");
t1.setPriority(Thread.MAX_PRIORITY);
t2.setPriority(Thread.MIN_PRIORITY);
t1.start();
t2.start();
}
}
输出结果：
t1 : 0
t1 : 1
t1 : 2
t1 : 3
t1 : 4
t1 : 5
t1 : 6
t1 : 7
t1 : 8
t1 : 9
t2 : 0
t2 : 1
t2 : 2
t2 : 3
t2 : 4
t2 : 5
t2 : 6
t2 : 7
t2 : 8
t2 : 9
多次执行这个程序。输出也是一样。这说明：yield() 方法不会使不同优先级的线程有执行的机会。
六：wait(), notify(), notifyAll()
首先说明：wait(), notify(),
notifyAll() 这些方法由java.lang.Object类提供，而上面讲到的方法都是由java.lang.Thread类提供（
Thread类实现了Runnable接口）。
wait(), notify(),
notifyAll() 这三个方法用于协调多个线程对共享数据的存取，所以必须在synchronized语句块内使用这三个方法。先看以下了样例：
演示样例12：
public class ThreadTest implements Runnable {
public static int shareVar = 0;
public synchronized void run() {
if (shareVar == 0) {
for (int i = 0; i < 10; i++) {
shareVar++;
if (shareVar == 5) {
try {
this.wait();
}
catch (Exception e) {}
}
}
}
if (shareVar != 0) {
System.out.print(Thread.currentThread().getName());
System.out.println(" shareVar = " + shareVar);
this.notify();
}
}
public static void main(String[] args) {
Runnable r = new ThreadTest();
Thread t1 = new Thread(r, "t1");
10
Thread t2 = new Thread(r, "t2");
t1.start();
t2.start();
}
}
执行结果：
t2 shareVar = 5
t1 shareVar = 10
t1线程最先运行。因为初始状态下shareVar为0。t1将使shareVar连续加1。当shareVar的值为5时，t1调用wait() 方法，
t1将处于歇息状态。同一时候释放锁标志。这时t2得到了锁标志開始运行，shareVar的值已经变为5。所以t2直接输出shareVar的值。
然后再调用notify() 方法唤醒t1。t1接着上次歇息前的进度继续运行，把shareVar的值一直加到10。因为此刻shareVar的值不为0，
所以t1将输出此刻shareVar的值。然后再调用notify() 方法，因为此刻已经没有等待锁标志的线程，所以此调用语句不起不论什么作用。
这个程序简单的示范了wait(), notify() 的使用方法，读者还须要在实践中继续摸索。
七：关于线程的补充
编写一个具有多线程能力的程序能够继承Thread类，也能够实现Runnable接口。在这两个方法中怎样选择呢？从面向对象的角度考虑，
作者建议你实现Runnable接口。有时你也必须实现Runnable接口。比如当你编写具有多线程能力的小应用程序的时候。
线程的调度：NewRunningRunnableOtherwise BlockedDeadBlocked in object`sit()
poolBlocked in object`slock poolnotify() Schedulercompletesrun() start()
sleep() or join() sleep() timeout or thread join() s or interupt()
Lockavailablesynchronized() Thread states
terupt() 一个Thread对象在它的生命周期中会处于各种不同的状态，上图形象地说明了这点。wa in
调用start() 方法使线程处于可执行状态，这意味着它能够由JVM调度并执行。
这并不意味着线程就会马上执行。
实际上，程序中的多个线程并非同一时候运行的。
除非线程正在真正的多CPU计算机系统上运行，否则线程使用单CPU必须轮流运行。可是。因为这发生的非常快，
我们经常觉得这些线程是同一时候运行的。
JAVA执行时系统的计划调度程序是抢占性的。假设计划调度程序正在执行一个线程而且来了还有一个优先级更高的线程，
那么当前正在运行的线程就被临时终止而让更高优先级的线程运行。
JAVA计划调度程序不会为与当前线程具有相同优先级的还有一个线程去抢占当前的线程。可是，虽然计划调度程序本身没有时间片（
即它没有给同样优先级的线程以运行用的时间片），但以Thread类为基础的线程的系统实现可能会支持时间片分配。这依赖详细的操作系统，
Windows与UNIX在这个问题上的支持不会全然一样。
因为你不能肯定小应用程序将执行在什么操作系统上。因此你不应该编写出依赖时间片分配的程序。就是说，
应该使用yield方法以同意同样优先级的线程有机会运行而不是希望每个线程都自己主动得到一段CPU时间片。
Thread类提供给你与系统无关的处理线程的机制。可是，线程的实际实现取决于JAVA执行所在的操作系统。
因此，
线程化的程序确实是利用了支持线程的操作系统。
当创建线程时。能够赋予它优先级。它的优先级越高，它就越能影响执行系统。
JAVA执行系统使用一个负责在全部执行JAVA程序内执行全部存在的计划调度程序。
该计划调度程序实际上使用一个固定优先级的算法来保证每一个程序中的最高优先级的线程得到CPU--同意最高优先级的线程在其他线程之前运行。
对于在一个程序中有几个同样优先级的线程等待运行的情况，该计划调度程序循环地选择它们。当进行下一次选择时选择前面没有运行的线程。
具有同样优先级的全部的线程都受到平等的对待。
较低优先级的线程在较高优先级的线程已经死亡或者进入不可运行状态之后才干运行。
继续讨论wait(), notify(), notifyAll()：
当线程运行了对一个特定对象的wait() 调用时，那个线程被放到与那个对象相关的等待池中。此外，调用wait() 的线程自己主动释放对象的锁标志。
能够调用不同的wait()：wait() 或wait(long timeout)
对一个特定对象运行notify() 调用时，将从对象的等待池中移走一个随意的线程，并放到锁标志等待池中，那里的线程一直在等待，
直到能够获得对象的锁标志。
notifyAll() 方法将从对象等待池中移走全部等待那个对象的线程并放到锁标志等待池中。
仅仅有锁标志等待池中的线程能获取对象的锁标志，锁标志同意线程从上次因调用wait() 而中断的地方開始继续执行。
在很多实现了wait() / notify() 机制的系统中，醒来的线程必然是那个等待时间最长的线程。然而。在Java技术中。并不保证这点。
注意。无论是否有线程在等待，都能够调用notify()。
假设对一个对象调用notify() 方法。而在这个对象的锁标志等待池中并没有线程，
那么notify() 调用将不起不论什么作用。
在JAVA中，多线程是一个奇妙的主题。
之所以说它 "奇妙"，是由于多线程程序的执行结果不可预測。但我们又能够通过某些方法控制多线程程序的执行。
要想灵活使用多线程，读者还须要大量实践。
// 另外。从JDK 1.2開始。SUN就不建议使用resume(), stop(), suspend() 了
-----------------------------------------------------------------
最后贴一段简单的代码自己看着玩：
import java.io.*;
//多线程编程
public class MultiThread
{
public static void main(String args[])
{
System.out.println("我是主线程!");
//以下创建线程实例thread1
ThreadUseExtends thread1=new ThreadUseExtends();
//创建thread2时以实现了Runnable接口的THhreadUseRunnable类实例为參数
Thread thread2=new Thread(new ThreadUseRunnable(),"SecondThread");
thread1.start();//启动线程thread1使之处于就绪状态
//thread1.setPriority(6);//设置thread1的优先级为6
//优先级将决定cpu空出时，处于就绪状态的线程谁先占据cpu開始执行
//优先级范围1到10,MIN_PRIORITY,MAX_PRIORITY,NORM_PAIORITY
//新线程继承创建她的父线程优先级,父线程通常有普通优先级即5NORM_PRIORITY
System.out.println("主线程将挂起7秒!");
try
{
Thread.sleep(7000);//主线程挂起7秒
}
catch (InterruptedException e)
{
return;
}
System.out.println("又回到了主线程!");
if(thread1.isAlive())
{
thread1.stop();//假设thread1还存在则杀掉他
System.out.println("thread1休眠过长,主线程杀掉了thread1!");
}
else
System.out.println("主线程没发现thread1,thread1已醒顺序运行结束了!");
thread2.start();//启动thread2
System.out.println("主线程又将挂起7秒!");
try
{
Thread.sleep(7000);//主线程挂起7秒
}
catch (InterruptedException e)
{
return;
}
System.out.println("又回到了主线程!");
if(thread2.isAlive())
{
thread2.stop();//假设thread2还存在则杀掉他
System.out.println("thread2休眠过长，主线程杀掉了thread2!");
}
else
System.out.println("主线程没发现thread2,thread2已醒顺序运行结束了!");
System.out.println("程序结束按随意键继续!");
try
{
System.in.read();
}
catch (IOException e)
{
System.out.println(e.toString());
}
}//main
}//MultiThread
class ThreadUseExtends extends Thread
//通过继承Thread类,并实现它的抽象方法run()
//适当时候创建这一Thread子类的实例来实现多线程机制
//一个线程启动后（也即进入就绪状态）一旦获得CPU将自己主动调用它的run()方法
{
ThreadUseExtends(){}//构造函数
public void run()
{
System.out.println("我是Thread子类的线程实例!");
System.out.println("我将挂起10秒!");
System.out.println("回到主线程,请稍等,刚才主线程挂起可能还没醒过来！
");
try
{
sleep(10000);//挂起5秒
}
catch (InterruptedException e)
{
return;
}
//假设该run()方法顺序运行完了,线程将自己主动结束,而不会被主线程杀掉
//但假设休眠时间过长,则线程还存活,可能被stop()杀掉
}
}
class ThreadUseRunnable implements Runnable
//通过实现Runnable接口中的run()方法,再以这个实现了run()方法的类
//为參数创建Thread的线程实例
{
//Thread thread2=new Thread(this);
//以这个实现了Runnable接口中run()方法的类为參数创建Thread类的线程实例
ThreadUseRunnable(){}//构造函数
public void run()
{
System.out.println("我是Thread类的线程实例并以实现了Runnable接口的类为參数!");
System.out.println("我将挂起1秒!");
System.out.println("回到主线程,请稍等 jn0-120 e20-040 ,刚才主线程挂起可能还没醒过来！");
try
{
Thread.sleep(1000);//挂起5秒
}
catch (InterruptedException e)
{
return;
}
//假设该run()方法顺序运行完了,线程将自己主动结束,而不会被主线程杀掉
//但假设休眠时间过长,则线程还存活,可能被stop()杀掉
}
}
//该程序可做的改动如改休眠时间或优先级setPriority()
--------------------------------------
最后，还在百度文库上看了一篇，写得也通俗易懂，大家能够借鉴一下：
http://wenku.baidu.com/view/51923164783e0912a2162abe.html
或者大家使用google搜索一下，非常多案例的。