sleep 和wai t区别

       1、这两个方法来自不同的类分别是Thread和Object

　　2、最主要是sleep方法没有释放锁，而 wait 方法释放了锁，使得其他线程可以使用同步控制块或者方法。

　　3、wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在任何地方使用（使用范围）

　　synchronized(x){

　　     x.notify()

　　     //或者wait()

　　}

　　4、sleep必须捕获异常，而wait，notify和notifyAll不需要捕获异常

　　扩充阅读：

　　java 线程中的sleep和wait有一个共同作用，停止当前线程任务运行，但他们存在一定的不同，首先我们先看sleep中的构造函数

　　sleep(long millis)           Causes the currently executing thread to sleep (temporarily cease execution) for the specified number of milliseconds, subject to the precision and accuracy of system timers and schedulers.

　　sleep(long millis, int nanos)          Causes the currently executing thread to sleep (cease execution) for the specified number of milliseconds plus the specified number of nanoseconds, subject to the precision and accuracy of system timers and schedulers.

　　sleep方法属于Thread类中方法，表示让一个线程进入睡眠状态，等待一定的时间之后，自动醒来进入到可运行状态，不会马上进入运行状态，因为 线程调度机制恢复线程的运行也需要时间，一个线程对象调用了sleep方法之后，并不会释放他所持有的所有对象锁，所以也就不会影响其他进程对象的运行。 但在sleep的过程中过程中有可能被其他对象调用它的interrupt(),产生InterruptedException异常，如果你的程序不捕获 这个异常，线程就会异常终止，进入TERMINATED状态，如果你的程序捕获了这个异常，那么程序就会继续执行catch语句块（可能还有 finally语句块）以及以后的代码。

　　注意sleep()方法是一个静态方法，也就是说他只对当前对象有效，通过t.sleep()让t对象进入sleep，这样的做法是错误的，它只会是使当前线程被sleep 而不是t线程

　　wait方法

　　void wait(long timeout)

　　Causes the current thread to wait until either another thread invokes the notify() method or the notifyAll() method for this object, or a specified amount of time has elapsed.

　　void wait(long timeout, int nanos)

　　Causes the current thread to wait until another thread invokes the notify() method or the notifyAll() method for this object, or some other thread interrupts the current thread, or a certain amount of real time has elapsed.

　　wait属于Object的成员方法，一旦一个对象调用了wait方法，必须要采用notify()和notifyAll()方法唤醒该进程;如果线 程拥有某个或某些对象的同步锁，那么在调用了wait()后，这个线程就会释放它持有的所有同步资源，而不限于这个被调用了wait()方法的对象。 wait()方法也同样会在wait的过程中有可能被其他对象调用interrupt()方法而产生

　　InterruptedException，效果以及处理方式同sleep()方法

　　追加内容：

　　Collection是个java.util下的接口，它是各种集合结构的父接口。

　　Collections是个java.util下的类，它包含有各种有关集合操作的静态方法。

　　Collection 层次结构中的根接口。Collection 表示一组对象，这些对象也称为 collection的元素。一些 collection 允许有重复的元素，而另一些则不允许。一些 collection 是有序的，而另一些则是无序的。JDK 不提供此接口的任何直接 实现：它提供更具体的子接口（如 Set 和 List）实现。此接口通常用来传递 collection，并在需要最大普遍性的地方操作这些 collection。

　　collections 此类完全由在 collection 上进行操作或返回 collection 的静态方法组成。它包含在 collection 上操作的多态算法，即“包装器”，包装器返回由指定 collection 支持的新 collection，以及少数其他内容。 如果为此类的方法所提供的 collection 或类对象为 null，则这些方法都会抛出 NullPointerException。

 

java多线程：

 

线程或者说多线程，是我们处理多任务的强大工具。线程和进程是不同的，每个进程都是一个独立运行的程序，拥有自己的变量，且不同进程间的变量不能共享；而 线程是运行在进程内部的，每个正在运行的进程至少有一个线程，而且不同的线程之间可以在进程范围内共享数据。也就是说进程有自己独立的存储空间，而线程是 和它所属的进程内的其他线程共享一个存储空间。线程的使用可以使我们能够并行地处理一些事情。线程通过并行的处理给用户带来更好的使用体验，比如你使用的 邮件系统（outlook、Thunderbird、foxmail等），你当然不希望它们在收取新邮件的时候，导致你连已经收下来的邮件都无法阅读，而 只能等待收取邮件操作执行完毕。这正是线程的意义所在。 

实现线程的方式 

实现线程的方式有两种： 

1. 继承java.lang.Thread，并重写它的run()方法，将线程的执行主体放入其中。
2. 实现java.lang.Runnable接口，实现它的run()方法，并将线程的执行主体放入其中。

这是继承Thread类实现线程的示例： 

public class ThreadTest extends Thread {
    public void run() {
        // 在这里编写线程执行的主体
        // do something
    }
}

这是实现Runnable接口实现多线程的示例： 

public class RunnableTest implements Runnable {
    public void run() {
        // 在这里编写线程执行的主体
        // do something
    }
}

这两种实现方 式的区别并不大。继承Thread类的方式实现起来较为简单，但是继承它的类就不能再继承别的类了，因此也就不能继承别的类的有用的方法了。而使用是想 Runnable接口的方式就不存在这个问题了，而且这种实现方式将线程主体和线程对象本身分离开来，逻辑上也较为清晰，所以推荐大家更多地采用这种方 式。 

如何启动线程 

我们通过以上 两种方式实现了一个线程之后，线程的实例并没有被创建，因此它们也并没有被运行。我们要启动一个线程，必须调用方法来启动它，这个方法就是Thread类 的start()方法，而不是run()方法（既不是我们继承Thread类重写的run()方法，也不是实现Runnable接口的run()方法）。 run()方法中包含的是线程的主体，也就是这个线程被启动后将要运行的代码，它跟线程的启动没有任何关系。上面两种实现线程的方式在启动时会有所不 同。 

继承Thread类的启动方式： 

public class ThreadStartTest {
    public static void main(String[] args) {
        // 创建一个线程实例
        ThreadTest tt = new ThreadTest();
        // 启动线程
        tt.start();
    }
}

实现Runnable接口的启动方式： 

public class RunnableStartTest {
    public static void main(String[] args) {
        // 创建一个线程实例
        Thread t = new Thread(new RunnableTest());
        // 启动线程
        t.start();
    }
}

实际上这两种启动线程的方式原理是一样的。首先都是调用本地方法启动一个线程，其次是在这个线程里执行目标对象的run()方法。那么这个目标对象是什么呢？为了弄明白这个问题，我们来看看Thread类的run()方法的实现： 

public void run() {
    if (target != null) {
        target.run();
    }
}

当我们采用实 现Runnable接口的方式来实现线程的情况下，在调用new Thread(Runnable target)构造器时，将实现Runnable接口的类的实例设置成了线程要执行的主体所属的目标对象target，当线程启动时，这个实例的 run()方法就被执行了。当我们采用继承Thread的方式实现线程时，线程的这个run()方法被重写了，所以当线程启动时，执行的是这个对象自身的 run()方法。总结起来就一句话，线程类有一个Runnable类型的target属性，它是线程启动后要执行的run()方法所属的主体，如果我们采 用的是继承Thread类的方式，那么这个target就是线程对象自身，如果我们采用的是实现Runnable接口的方式，那么这个target就是实 现了Runnable接口的类的实例。 

线程的状态 

在Java 1.4及以下的版本中，每个线程都具有新建、可运行、阻塞、死亡四种状态，但是在Java 5.0及以上版本中，线程的状态被扩充为新建、可运行、阻塞、等待、定时等待、死亡六种。线程的状态完全包含了一个线程从新建到运行，最后到结束的整个生 命周期。线程状态的具体信息如下： 

1. NEW（新建状态、初始化状态）：线程对象已经被创建，但是还没有被启动时的状态。这段时间就是在我们调用new命令之后，调用start()方法之前。
2. RUNNABLE（可运行状态、就绪状态）：在我们调用了线程的start()方法之后线程所处的状态。处于RUNNABLE状态的线程在JAVA虚拟机（JVM）上是运行着的，但是它可能还正在等待操作系统分配给它相应的运行资源以得以运行。
3. BLOCKED（阻塞状态、被中断运行）：线程正在等待其它的线程释放同步锁，以进入一个同步块或者同步方法继续运行；或者它已经进入了某个同步块或同步方法，在运行的过程中它调用了某个对象继承自java.lang.Object的wait()方法，正在等待重新返回这个同步块或同步方法。
4. WAITING（等待状态）：当 前线程调用了java.lang.Object.wait()、java.lang.Thread.join()或者 java.util.concurrent.locks.LockSupport.park()三个中的任意一个方法，正在等待另外一个线程执行某个操 作。比如一个线程调用了某个对象的wait()方法，正在等待其它线程调用这个对象的notify()或者notifyAll()（这两个方法同样是继承 自Object类）方法来唤醒它；或者一个线程调用了另一个线程的join()（这个方法属于Thread类）方法，正在等待这个方法运行结束。
5. TIMED_WAITING（定时等待状态）：当 前线程调用了java.lang.Object.wait(long timeout)、java.lang.Thread.join(long millis)、java.util.concurrent.locks.LockSupport.packNanos(long nanos)、java.util.concurrent.locks.LockSupport.packUntil(long deadline)四个方法中的任意一个，进入等待状态，但是与WAITING状态不同的是，它有一个最大等待时间，即使等待的条件仍然没有满足，只要到 了这个时间它就会自动醒来。
6. TERMINATED（死亡状态、终止状态）：线程完成执行后的状态。线程执行完run()方法中的全部代码，从该方法中退出，进入TERMINATED状态。还有一种情况是run()在运行过程中抛出了一个异常，而这个异常没有被程序捕获，导致这个线程异常终止进入TERMINATED状态。

在Java5.0及以上版本中，线程的全部六种状态都以枚举类型的形式定义在java.lang.Thread类中了，代码如下： 

public enum State {
    NEW,
    RUNNABLE,
    BLOCKED,
    WAITING,
    TIMED_WAITING,
    TERMINATED;
}

sleep()和wait()的区别 

sleep()方法和wait()方法都成产生让当前运行的线程停止运行的效果，这是它们的共同点。下面我们来详细说说它们的不同之处。 

sleep()方法是本地方法，属于Thread类，它有两种定义： 

public static native void sleep(long millis) throws InterruptedException;
public static void sleep(long millis, int nanos) throws InterruptedException {
    //other code
}

其中的参数 millis代表毫秒数（千分之一秒），nanos代表纳秒数（十亿分之一秒）。这两个方法都可以让调用它的线程沉睡（停止运行）指定的时间，到了这个时 间，线程就会自动醒来，变为可运行状态（RUNNABLE），但这并不表示它马上就会被运行，因为线程调度机制恢复线程的运行也需要时间。调用 sleep()方法并不会让线程释放它所持有的同步锁；而且在这期间它也不会阻碍其它线程的运行。上面的连个方法都声明抛出一个 InterruptedException类型的异常，这是因为线程在sleep()期间，有可能被持有它的引用的其它线程调用它的 interrupt()方法而中断。中断一个线程会导致一个InterruptedException异常的产生，如果你的程序不捕获这个异常，线程就会 异常终止，进入TERMINATED状态，如果你的程序捕获了这个异常，那么程序就会继续执行catch语句块（可能还有finally语句块）以及以后 的代码。 

为了更好地理解interrupt()效果，我们来看一下下面这个例子： 

public class InterruptTest {
    public static void main(String[] args) {
        Thread t = new Thread() {
            public void run() {
                try {
                    System.out.println("我被执行了-在sleep()方法前");
                    // 停止运行10分钟
                    Thread.sleep(1000 * 60 * 60 * 10);
                    System.out.println("我被执行了-在sleep()方法后");
                } catch (InterruptedException e) {
                    System.out.println("我被执行了-在catch语句块中");
                }
                System.out.println("我被执行了-在try{}语句块后");
            }
        };
        // 启动线程
        t.start();
        // 在sleep()结束前中断它
        t.interrupt();
    }
}

运行结果： 

1. 我被执行了-在sleep()方法前
2. 我被执行了-在catch语句块中
3. 我被执行了-在try{}语句块后

wait()方法也是本地方法，属于Object类，有三个定义： 

public final void wait() throws InterruptedException {
    //do something
}
public final native void wait(long timeout) throws InterruptedException;
public final void wait(long timeout, int nanos) throws InterruptedException {
    //do something
}

wari() 和wait(long timeout,int nanos)方法都是基于wait(long timeout)方法实现的。同样地，timeout代表毫秒数，nanos代表纳秒数。当调用了某个对象的wait()方法时，当前运行的线程就会转入 等待状态（WAITING），等待别的线程再次调用这个对象的notify()或者notifyAll()方法（这两个方法也是本地方法）唤醒它，或者到 了指定的最大等待时间，线程自动醒来。如果线程拥有某个或某些对象的同步锁，那么在调用了wait()后，这个线程就会释放它持有的所有同步资源，而不限 于这个被调用了wait()方法的对象。wait()方法同样会被Thread类的interrupt()方法中断，并产生一个 InterruptedException异常，效果同sleep()方法被中断一样。 

实现同步的方式 

同步是多线程中的重要概念。同步的使用可以保证在多线程运行的环境中，程序不会产生设计之外的错误结果。同步的实现方式有两种，同步方法和同步块，这两种方式都要用到synchronized关键字。 

给一个方法增加synchronized修饰符之后就可以使它成为同步方法，这个方法可以是静态方法和非静态方法，但是不能是抽象类的抽象方法，也不能是接口中的接口方法。下面代码是一个同步方法的示例： 

public synchronized void aMethod() {
    // do something
}
public static synchronized void anotherMethod() {
    // do something
}

线程在执行同 步方法时是具有排它性的。当任意一个线程进入到一个对象的任意一个同步方法时，这个对象的所有同步方法都被锁定了，在此期间，其他任何线程都不能访问这个 对象的任意一个同步方法，直到这个线程执行完它所调用的同步方法并从中退出，从而导致它释放了该对象的同步锁之后。在一个对象被某个线程锁定之后，其他线 程是可以访问这个对象的所有非同步方法的。 

同步块的形式 虽然与同步方法不同，但是原理和效果是一致的。同步块是通过锁定一个指定的对象，来对同步块中包含的代码进行同步；而同步方法是对这个方法块里的代码进行 同步，而这种情况下锁定的对象就是同步方法所属的主体对象自身。如果这个方法是静态同步方法呢？那么线程锁定的就不是这个类的对象了，也不是这个类自身， 而是这个类对应的java.lang.Class类型的对象。同步方法和同步块之间的相互制约只限于同一个对象之间，所以静态同步方法只受它所属类的其它 静态同步方法的制约，而跟这个类的实例（对象）没有关系。 

下面这段代码演示了同步块的实现方式： 

public void test() {
    // 同步锁
    String lock = "LOCK";
    // 同步块
    synchronized (lock) {
        // do something
    }
    int i = 0;
    // ...
}

对于作为同步锁的对象并没有什么特别要求，任意一个对象都可以。如果一个对象既有同步方法，又有同步块，那么当其中任意一个同步方法或者同步块被某个线程执行时，这个对象就被锁定了，其他线程无法在此时访问这个对象的同步方法，也不能执行同步块。 

synchronized和Lock 

Lock是一 个接口，它位于Java 5.0新增的java.utils.concurrent包的子包locks中。concurrent包及其子包中的类都是用来处理多线程编程的。实现 Lock接口的类具有与synchronized关键字同样的功能，但是它更加强大一些。 java.utils.concurrent.locks.ReentrantLock是较常用的实现了Lock接口的类。下面是 ReentrantLock类的一个应用实例： 

private Lock lock = new ReentrantLock();
public void testLock() {
    // 锁定对象
    lock.lock();
    try {
        // do something
    } finally {
        // 释放对对象的锁定
        lock.unlock();
    }
}

lock() 方法用于锁定对象，unlock()方法用于释放对对象的锁定，他们都是在Lock接口中定义的方法。位于这两个方法之间的代码在被执行时，效果等同于被 放在synchronized同步块中。一般用法是将需要在lock()和unlock()方法之间执行的代码放在try{}块中，并且在 finally{}块中调用unlock()方法，这样就可以保证即使在执行代码抛出异常的情况下，对象的锁也总是会被释放，否则的话就会为死锁的产生增 加可能。 

使用 synchronized关键字实现的同步，会把一个对象的所有同步方法和同步块看做一个整体，只要有一个被某个线程调用了，其他的就无法被别的线程执 行，即使这些方法或同步块与被调用的代码之间没有任何逻辑关系，这显然降低了程序的运行效率。而使用Lock就能够很好地解决这个问题。我们可以把一个对 象中按照逻辑关系把需要同步的方法或代码进行分组，为每个组创建一个Lock类型的对象，对实现同步。那么，当一个同步块被执行时，这个线程只会锁定与当 前运行代码相关的其他代码最小集合，而并不影响其他线程对其余同步代码的调用执行。 

关于死锁 

死锁就是一个 进程中的每个线程都在等待这个进程中的其他线程释放所占用的资源，从而导致所有线程都无法继续执行的情况。死锁是多线程编程中一个隐藏的陷阱，它经常发生 在多个线程共用资源的时候。在实际开发中，死锁一般隐藏的较深，不容易被发现，一旦死锁现象发生，就必然会导致程序的瘫痪。因此必须避免它的发生。 

程序中必须同时满足以下四个条件才会引发死锁： 

1. 互斥（Mutual exclusion）：线程所使用的资源中至少有一个是不能共享的，它在同一时刻只能由一个线程使用。
2. 持有与等待（Hold and wait）：至少有一个线程已经持有了资源，并且正在等待获取其他的线程所持有的资源。
3. 非抢占式（No pre-emption）：如果一个线程已经持有了某个资源，那么在这个线程释放这个资源之前，别的线程不能把它抢夺过去使用。
4. 循环等待（Circular wait）：假设有N个线程在运行，第一个线程持有了一个资源，并且正在等待获取第二个线程持有的资源，而第二个线程正在等待获取第三个线程持有的资源，依此类推……第N个线程正在等待获取第一个线程持有的资源，由此形成一个循环等待。

线程池 

线程池就像数 据库连接池一样，是一个对象池。所有的对象池都有一个共同的目的，那就是为了提高对象的使用率，从而达到提高程序效率的目的。比如对于Servlet，它 被设计为多线程的（如果它是单线程的，你就可以想象，当1000个人同时请求一个网页时，在第一个人获得请求结果之前，其它999个人都在郁闷地等待）， 如果为每个用户的每一次请求都创建一个新的线程对象来运行的话，系统就会在创建线程和销毁线程上耗费很大的开销，大大降低系统的效率。因 此，Servlet多线程机制背后有一个线程池在支持，线程池在初始化初期就创建了一定数量的线程对象，通过提高对这些对象的利用率，避免高频率地创建对 象，从而达到提高程序的效率的目的。 

下面实现一个最简单的线程池，从中理解它的实现原理。为此我们定义了四个类，它们的用途及具体实现如下： 

1. Task（任务）：这是个代表任务的抽象类，其中定义了一个deal()方法，继承Task抽象类的子类需要 实现这个方法，并把这个任务需要完成的具体工作在deal()方法编码实现。线程池中的线程之所以被创建，就是为了执行各种各样数量繁多的任务的，为了方 便线程对任务的处理，我们需要用Task抽象类来保证任务的具体工作统一放在deal()方法里来完成，这样也使代码更加规范。 
   Task的定义如下： 
   

   public abstract class Task {
       public enum State {
           /* 新建 */NEW, /* 执行中 */RUNNING, /* 已完成 */FINISHED
       }
       // 任务状态
       private State state = State.NEW;
       public void setState(State state) {
           this.state = state;
       }
       public State getState() {
           return state;
       }
       public abstract void deal();
   }

2. TaskQueue（任务队列）：在同一时刻，可能有很多任务需要执行，而程序在同一时刻只能执行 一定数量的任务，当需要执行的任务数超过了程序所能承受的任务数时怎么办呢？这就有了先执行哪些任务，后执行哪些任务的规则。TaskQueue类就定义 了这些规则中的一种，它采用的是FIFO（先进先出，英文名是First In First Out）的方式，也就是按照任务到达的先后顺序执行。 
   TaskQueue类的定义如下： 
   

   import java.util.Iterator;
   import java.util.LinkedList;
   import java.util.List;
   public class TaskQueue {
       private List<Task> queue = new LinkedList<Task>();
       // 添加一项任务
       public synchronized void addTask(Task task) {
           if (task != null) {
               queue.add(task);
           }
       }
       // 完成任务后将它从任务队列中删除
       public synchronized void finishTask(Task task) {
           if (task != null) {
               task.setState(Task.State.FINISHED);
               queue.remove(task);
           }
       }
       // 取得一项待执行任务
       public synchronized Task getTask() {
           Iterator<Task> it = queue.iterator();
           Task task;
           while (it.hasNext()) {
               task = it.next();
               // 寻找一个新建的任务
               if (Task.State.NEW.equals(task.getState())) {
                   // 把任务状态置为运行中
                   task.setState(Task.State.RUNNING);
                   return task;
               }
           }
           return null;
       }
   }

   
   addTask(Task task)方法用于当一个新的任务到达时，将它添加到任务队列中。这里使用了LinkedList类来保存任务到达的先后顺序。 finishTask(Task task)方法用于任务被执行完毕时，将它从任务队列中清除出去。getTask()方法用于取得当前要执行的任务。
3. TaskThread（执行任务的线程）：它继承自Thread类，专门用于执行任务队列中的待执行任务。

   public class TaskThread extends Thread {
       // 该线程所属的线程池
       private ThreadPoolService service;
       public TaskThread(ThreadPoolService tps) {
           service = tps;
       }
       public void run() {
           // 在线程池运行的状态下执行任务队列中的任务
           while (service.isRunning()) {
               TaskQueue queue = service.getTaskQueue();
               Task task = queue.getTask();
               if (task != null) {
                   task.deal();
               }
               queue.finishTask(task);
           }
       }
   }

4. ThreadPoolService（线程池服务类）：这是线程池最核心的一个类。它在被创建了时 候就创建了几个线程对象，但是这些线程并没有启动运行，但调用了start()方法启动线程池服务时，它们才真正运行。stop()方法可以停止线程池服 务，同时停止池中所有线程的运行。而runTask(Task task)方法是将一个新的待执行任务交与线程池来运行。 
   ThreadPoolService类的定义如下： 
   

   import java.util.ArrayList;
   import java.util.List;
   public class ThreadPoolService {
       // 线程数
       public static final int THREAD_COUNT = 5;
       // 线程池状态
       private Status status = Status.NEW;
       private TaskQueue queue = new TaskQueue();
       public enum Status {
           /* 新建 */NEW, /* 提供服务中 */RUNNING, /* 停止服务 */TERMINATED,
       }
       private List<Thread> threads = new ArrayList<Thread>();
       public ThreadPoolService() {
           for (int i = 0; i < THREAD_COUNT; i++) {
               Thread t = new TaskThread(this);
               threads.add(t);
           }
       }
       // 启动服务
       public void start() {
           this.status = Status.RUNNING;
           for (int i = 0; i < THREAD_COUNT; i++) {
               threads.get(i).start();
           }
       }
       // 停止服务
       public void stop() {
           this.status = Status.TERMINATED;
       }
       // 是否正在运行
       public boolean isRunning() {
           return status == Status.RUNNING;
       }
       // 执行任务
       public void runTask(Task task) {
           queue.addTask(task);
       }
       protected TaskQueue getTaskQueue() {
           return queue;
       }
   }

完成了上面四个类，我们就实现了一个简单的线程池。现在我们就可以使用它了，下面的代码做了一个简单的示例：

public class SimpleTaskTest extends Task {
    @Override
    public void deal() {
        // do something
    }
    public static void main(String[] args) throws InterruptedException {
        ThreadPoolService service = new ThreadPoolService();
        service.start();
        // 执行十次任务
        for (int i = 0; i < 10; i++) {
            service.runTask(new SimpleTaskTest());
        }
        // 睡眠1秒钟，等待所有任务执行完毕
        Thread.sleep(1000);
        service.stop();
    }
}

当然，我们实现的是最简单的，这里只是为了演示线程池的实现原理。在实际应用中，根据情况的不同，可以做很多优化。比如： 

• 调整任务队列的规则，给任务设置优先级，级别高的任务优先执行。
• 动态维护线程池，当待执行任务数量较多时，增加线程的数量，加快任务的执行速度；当任务较少时，回收一部分长期闲置的线程，减少对系统资源的消耗。

事实上Java5.0及以上版本已经为我们提供了线程池功能，无需再重新实现。这些类位于java.util.concurrent包中。 

Executors类提供了一组创建线程池对象的方法，常用的有一下几个： 

public static ExecutorService newCachedThreadPool() {
    // other code
}
public static ExecutorService newFixedThreadPool(int nThreads) {
    // other code
}
public static ExecutorService newSingleThreadExecutor() {
    // other code
}

newCachedThreadPool() 方法创建一个动态的线程池，其中线程的数量会根据实际需要来创建和回收，适合于执行大量短期任务的情况；newFixedThreadPool(int nThreads)方法创建一个包含固定数量线程对象的线程池，nThreads代表要创建的线程数，如果某个线程在运行的过程中因为异常而终止了，那么 一个新的线程会被创建和启动来代替它；而newSingleThreadExecutor()方法则只在线程池中创建一个线程，来执行所有的任务。 

这三个方法都 返回了一个ExecutorService类型的对象。实际上，ExecutorService是一个接口，它的submit()方法负责接收任务并交与 线程池中的线程去运行。submit()方法能够接受Callable和Runnable两种类型的对象。它们的用法和区别如下： 

1. Runnable接口：继承Runnable接口的类要实现它的run()方法，并将执行任务的代码放入其中，run()方法没有返回值。适合于只做某种操作，不关心运行结果的情况。
2. Callable接口：继承Callable接口的类要实现它的call()方法，并将执行任务的代码放入其中，call()将任务的执行结果作为返回值。适合于执行某种操作后，需要知道执行结果的情况。

无论是接收 Runnable型参数，还是接收Callable型参数的submit()方法，都会返回一个Future（也是一个接口）类型的对象。该对象中包含了 任务的执行情况以及结果。调用Future的boolean isDone()方法可以获知任务是否执行完毕；调用Object get()方法可以获得任务执行后的返回结果，如果此时任务还没有执行完，get()方法会保持等待，直到相应的任务执行完毕后，才会将结果返回。 

我们用下面的一个例子来演示Java5.0中线程池的使用： 

import java.util.concurrent.*;
public class ExecutorTest {
    public static void main(String[] args) throws InterruptedException,
            ExecutionException {
        ExecutorService es = Executors.newSingleThreadExecutor();
        Future fr = es.submit(new RunnableTest());// 提交任务
        Future fc = es.submit(new CallableTest());// 提交任务
        // 取得返回值并输出
        System.out.println((String) fc.get());
        // 检查任务是否执行完毕
        if (fr.isDone()) {
            System.out.println("执行完毕-RunnableTest.run()");
        } else {
            System.out.println("未执行完-RunnableTest.run()");
        }
        // 检查任务是否执行完毕
        if (fc.isDone()) {
            System.out.println("执行完毕-CallableTest.run()");
        } else {
            System.out.println("未执行完-CallableTest.run()");
        }
        // 停止线程池服务
        es.shutdown();
    }
}
class RunnableTest implements Runnable {
    public void run() {
        System.out.println("已经执行-RunnableTest.run()");
    }
}
class CallableTest implements Callable {
    public Object call() {
        System.out.println("已经执行-CallableTest.call()");
        return "返回值-CallableTest.call()";
    }
}

运行结果： 

1. 已经执行-RunnableTest.run()
2. 已经执行-CallableTest.call()
3. 返回值-CallableTest.call()
4. 执行完毕-RunnableTest.run()
5. 执行完毕-CallableTest.run()

 

使用完线程池之后，需要调用它的shutdown()方法停止服务，否则其中的所有线程都会保持运行，程序不会退出。

 

第一种解释：

  功能差不多,都用来进行线程控制,他们最大本质的区别是:sleep()不释放同步锁,wait()释放同步锁.  
    
  唤醒方法不同:sleep(milliseconds)可以用时间指定来使他自动醒过来,如果时间不到你只能调用interreput()来强行打断;wait()可以用notify()直接唤起.

第二种解释：

       sleep是Thread类的静态方法。sleep的作用是让线程休眠制定的时间，在时间到达时恢复，也就是说sleep将在接到时间到达事件时恢复线程执行，例如：

try{
     System.out.println("I'm going to bed");
     Thread.sleep(1000);
     System.out.println("I wake up");
}catch(IntrruptedException e) {

}

      wait是Object的方法，也就是说可以对任意一个对象调用wait方法，调用wait方法将会将调用者的线程挂起，直到其他线程调用同一个对象的notify方法才会重新激活调用者，例如：

//Thread 1

try{
     obj.wait();     //suspend thread until obj.notify() is called
}
catch(InterrputedException e) {
}

第三种解释：

这两者的施加者是有本质区别的. 
sleep()是让某个线程暂停运行一段时间,其控制范围是由当前线程决定,也就是说,在线程里面决定.好比如说,我要做的事情是 "点火->烧水->煮面",而当我点完火之后我不立即烧水,我要休息一段时间再烧.对于运行的主动权是由我的流程来控制.

而wait(),首先,这是由某个确定的对象来调用的, 将这个对象理解成一个传话的人,当这个人在某个线程里面说"暂停!",也是 thisOBJ.wait(),这里的暂停是阻塞,还是"点火->烧水->煮饭",thisOBJ就好比一个监督我的人站在我旁边,本来该线 程应该执行1后执行2,再执行3,而在2处被那个对象喊暂停,那么我就会一直等在这里而不执行3,但这个流程并没有结束,我一直想去煮饭,但还没被允许, 直到那个对象在某个地方说"通知暂停的线程启动!",也就是thisOBJ.notify()的时候,那么我就可以煮饭了,这个被暂停的线程就会从暂停处 继续执行.

其实两者都可以让线程暂停一段时间,但是本质的区别是一个线程的运行状态控制,一个是线程之间的通讯的问题

     在java.lang.Thread类中，提供了sleep()，而java.lang.Object类中提供了wait()，notify()和 notifyAll()方法来操作线程，sleep()可以将一个线程睡眠，参数可以指定一个时间。而wait()可以将一个线程挂起，直到超时或者该线 程被唤醒。
    wait有两种形式wait()和wait(milliseconds).
sleep和wait的区别有：
  1，这两个方法来自不同的类分别是Thread和Object
  2，最主要是sleep方法没有释放锁，而wait方法释放了锁，使得其他线程可以使用同步控制块或者方法。
  3，wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在
    任何地方使用
   synchronized(x){
      x.notify()
     //或者wait()
   }
   4,sleep必须捕获异常，而wait，notify和notifyAll不需要捕获异常