精华内容
下载资源
问答
  • 问:在一个线程中 sleep(1000) 方法,将使得该线程在多少时间后获得对 CPU 的控制(假设睡眠过程不会有其他时间唤醒该线程)?(C) A. 正好1000毫秒 B. 1000毫秒不到 C. >=1000毫秒 D. 不一定 解析:因为在...

    问:在一个线程中 sleep(1000) 方法,将使得该线程在多少时间后获得对 CPU 的控制(假设睡眠过程中不会有其他时间唤醒该线程)?(C)

    A. 正好1000毫秒
    B. 1000毫秒不到
    C. >=1000毫秒
    D. 不一定

    解析:因为在程序sleep之后线程进入就绪态,在这种状态下,需要检查现在是否有资源允许现在的线程继续运行,如果条件不满足,则需要等待。如果是现在有资源则立即执行。


    线程的五大状态
    (1)新建状态:即单纯地创建一个线程,创建线程有三种方式,在我的博客:线程的创建,可以自行查看!

    (2)就绪状态:在创建了线程之后,调用Thread类的start()方法来启动一个线程,即表示线程进入就绪状态!

    (3)运行状态:当线程获得CPU时间,线程才从就绪状态进入到运行状态!

    (4)阻塞状态:线程进入运行状态后,可能由于多种原因让线程进入阻塞状态,如:调用sleep()方法让线程睡眠,调用wait()方法让线程等待,调用join()方法、suspend()方法(它现已被弃用!)以及阻塞式IO方法。

    (5)死亡状态:run()方法的正常退出就让线程进入到死亡状态,还有当一个异常未被捕获而终止了run()方法的执行也将进入到死亡状态!

    在这里插入图片描述

    展开全文
  • 线程中sleep和wait的区别

    千次阅读 2016-04-28 16:18:38
    2、最主要是sleep方法没有释放锁,而wait方法释放了锁,使得其他线程可以使用同步控制块或者方法。 3、wait,notify和notifyAll只能在同步控制方法或者同步控制块里面使用,而sleep可以在  任何地方使用...

    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类实现线程的示例: 
    [java]  view plain copy
    1. public class ThreadTest extends Thread {  
    2.     public void run() {  
    3.         // 在这里编写线程执行的主体  
    4.         // do something  
    5.     }  
    6. }  

    这是实现Runnable接口实现多线程的示例: 
    [java]  view plain copy
    1. public class RunnableTest implements Runnable {  
    2.     public void run() {  
    3.         // 在这里编写线程执行的主体  
    4.         // do something  
    5.     }  
    6. }  

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

    如何启动线程  

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

    继承Thread类的启动方式: 
    [java]  view plain copy
    1. public class ThreadStartTest {  
    2.     public static void main(String[] args) {  
    3.         // 创建一个线程实例  
    4.         ThreadTest tt = new ThreadTest();  
    5.         // 启动线程  
    6.         tt.start();  
    7.     }  
    8. }  

    实现Runnable接口的启动方式: 
    [java]  view plain copy
    1. public class RunnableStartTest {  
    2.     public static void main(String[] args) {  
    3.         // 创建一个线程实例  
    4.         Thread t = new Thread(new RunnableTest());  
    5.         // 启动线程  
    6.         t.start();  
    7.     }  
    8. }  

    实际上这两种启动线程的方式原理是一样的。首先都是调用本地方法启动一个线程,其次是在这个线程里执行目标对象的run()方法。那么这个目标对象是什么呢?为了弄明白这个问题,我们来看看Thread类的run()方法的实现: 
    [java]  view plain copy
    1. public void run() {  
    2.     if (target != null) {  
    3.         target.run();  
    4.     }  
    5. }  

    当我们采用实现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类中了,代码如下: 
    [java]  view plain copy
    1. public enum State {  
    2.     NEW,  
    3.     RUNNABLE,  
    4.     BLOCKED,  
    5.     WAITING,  
    6.     TIMED_WAITING,  
    7.     TERMINATED;  
    8. }  

    sleep()和wait()的区别  

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

    sleep()方法是本地方法,属于Thread类,它有两种定义: 
    [java]  view plain copy
    1. public static native void sleep(long millis) throws InterruptedException;  
    2. public static void sleep(long millis, int nanos) throws InterruptedException {  
    3.     //other code  
    4. }  

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

    为了更好地理解interrupt()效果,我们来看一下下面这个例子: 
    [java]  view plain copy
    1. public class InterruptTest {  
    2.     public static void main(String[] args) {  
    3.         Thread t = new Thread() {  
    4.             public void run() {  
    5.                 try {  
    6.                     System.out.println("我被执行了-在sleep()方法前");  
    7.                     // 停止运行10分钟  
    8.                     Thread.sleep(1000 * 60 * 60 * 10);  
    9.                     System.out.println("我被执行了-在sleep()方法后");  
    10.                 } catch (InterruptedException e) {  
    11.                     System.out.println("我被执行了-在catch语句块中");  
    12.                 }  
    13.                 System.out.println("我被执行了-在try{}语句块后");  
    14.             }  
    15.         };  
    16.         // 启动线程  
    17.         t.start();  
    18.         // 在sleep()结束前中断它  
    19.         t.interrupt();  
    20.     }  
    21. }  

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

    wait()方法也是本地方法,属于Object类,有三个定义: 
    [java]  view plain copy
    1. public final void wait() throws InterruptedException {  
    2.     //do something  
    3. }  
    4. public final native void wait(long timeout) throws InterruptedException;  
    5. public final void wait(long timeout, int nanos) throws InterruptedException {  
    6.     //do something  
    7. }  

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

    实现同步的方式  

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

    给一个方法增加synchronized修饰符之后就可以使它成为同步方法,这个方法可以是静态方法和非静态方法,但是不能是抽象类的抽象方法,也不能是接口中的接口方法。下面代码是一个同步方法的示例: 
    [java]  view plain copy
    1. public synchronized void aMethod() {  
    2.     // do something  
    3. }  
    4. public static synchronized void anotherMethod() {  
    5.     // do something  
    6. }  

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

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

    下面这段代码演示了同步块的实现方式: 
    [java]  view plain copy
    1. public void test() {  
    2.     // 同步锁  
    3.     String lock = "LOCK";  
    4.     // 同步块  
    5.     synchronized (lock) {  
    6.         // do something  
    7.     }  
    8.     int i = 0;  
    9.     // ...  
    10. }  

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

    synchronized和Lock  

    Lock是一个接口,它位于Java 5.0新增的java.utils.concurrent包的子包locks中。concurrent包及其子包中的类都是用来处理多线程编程的。实现Lock接口的类具有与synchronized关键字同样的功能,但是它更加强大一些。java.utils.concurrent.locks.ReentrantLock是较常用的实现了Lock接口的类。下面是ReentrantLock类的一个应用实例: 
    [java]  view plain copy
    1. private Lock lock = new ReentrantLock();  
    2. public void testLock() {  
    3.     // 锁定对象  
    4.     lock.lock();  
    5.     try {  
    6.         // do something  
    7.     } finally {  
    8.         // 释放对对象的锁定  
    9.         lock.unlock();  
    10.     }  
    11. }  

    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的定义如下: 
      [java]  view plain copy
      1. public abstract class Task {  
      2.     public enum State {  
      3.         /* 新建 */NEW, /* 执行中 */RUNNING, /* 已完成 */FINISHED  
      4.     }  
      5.     // 任务状态  
      6.     private State state = State.NEW;  
      7.     public void setState(State state) {  
      8.         this.state = state;  
      9.     }  
      10.     public State getState() {  
      11.         return state;  
      12.     }  
      13.     public abstract void deal();  
      14. }  
    2. TaskQueue(任务队列):在同一时刻,可能有很多任务需要执行,而程序在同一时刻只能执行一定数量的任务,当需要执行的任务数超过了程序所能承受的任务数时怎么办呢?这就有了先执行哪些任务,后执行哪些任务的规则。TaskQueue类就定义了这些规则中的一种,它采用的是FIFO(先进先出,英文名是First In First Out)的方式,也就是按照任务到达的先后顺序执行。 
      TaskQueue类的定义如下: 
      [java]  view plain copy
      1. import java.util.Iterator;  
      2. import java.util.LinkedList;  
      3. import java.util.List;  
      4. public class TaskQueue {  
      5.     private List<Task> queue = new LinkedList<Task>();  
      6.     // 添加一项任务  
      7.     public synchronized void addTask(Task task) {  
      8.         if (task != null) {  
      9.             queue.add(task);  
      10.         }  
      11.     }  
      12.     // 完成任务后将它从任务队列中删除  
      13.     public synchronized void finishTask(Task task) {  
      14.         if (task != null) {  
      15.             task.setState(Task.State.FINISHED);  
      16.             queue.remove(task);  
      17.         }  
      18.     }  
      19.     // 取得一项待执行任务  
      20.     public synchronized Task getTask() {  
      21.         Iterator<Task> it = queue.iterator();  
      22.         Task task;  
      23.         while (it.hasNext()) {  
      24.             task = it.next();  
      25.             // 寻找一个新建的任务  
      26.             if (Task.State.NEW.equals(task.getState())) {  
      27.                 // 把任务状态置为运行中  
      28.                 task.setState(Task.State.RUNNING);  
      29.                 return task;  
      30.             }  
      31.         }  
      32.         return null;  
      33.     }  
      34. }  

      addTask(Task task)方法用于当一个新的任务到达时,将它添加到任务队列中。这里使用了LinkedList类来保存任务到达的先后顺序。finishTask(Task task)方法用于任务被执行完毕时,将它从任务队列中清除出去。getTask()方法用于取得当前要执行的任务。
    3. TaskThread(执行任务的线程):它继承自Thread类,专门用于执行任务队列中的待执行任务。
      [java]  view plain copy
      1. public class TaskThread extends Thread {  
      2.     // 该线程所属的线程池  
      3.     private ThreadPoolService service;  
      4.     public TaskThread(ThreadPoolService tps) {  
      5.         service = tps;  
      6.     }  
      7.     public void run() {  
      8.         // 在线程池运行的状态下执行任务队列中的任务  
      9.         while (service.isRunning()) {  
      10.             TaskQueue queue = service.getTaskQueue();  
      11.             Task task = queue.getTask();  
      12.             if (task != null) {  
      13.                 task.deal();  
      14.             }  
      15.             queue.finishTask(task);  
      16.         }  
      17.     }  
      18. }  
    4. ThreadPoolService(线程池服务类):这是线程池最核心的一个类。它在被创建了时候就创建了几个线程对象,但是这些线程并没有启动运行,但调用了start()方法启动线程池服务时,它们才真正运行。stop()方法可以停止线程池服务,同时停止池中所有线程的运行。而runTask(Task task)方法是将一个新的待执行任务交与线程池来运行。 
      ThreadPoolService类的定义如下: 
      [java]  view plain copy
      1. import java.util.ArrayList;  
      2. import java.util.List;  
      3. public class ThreadPoolService {  
      4.     // 线程数  
      5.     public static final int THREAD_COUNT = 5;  
      6.     // 线程池状态  
      7.     private Status status = Status.NEW;  
      8.     private TaskQueue queue = new TaskQueue();  
      9.     public enum Status {  
      10.         /* 新建 */NEW, /* 提供服务中 */RUNNING, /* 停止服务 */TERMINATED,  
      11.     }  
      12.     private List<Thread> threads = new ArrayList<Thread>();  
      13.     public ThreadPoolService() {  
      14.         for (int i = 0; i < THREAD_COUNT; i++) {  
      15.             Thread t = new TaskThread(this);  
      16.             threads.add(t);  
      17.         }  
      18.     }  
      19.     // 启动服务  
      20.     public void start() {  
      21.         this.status = Status.RUNNING;  
      22.         for (int i = 0; i < THREAD_COUNT; i++) {  
      23.             threads.get(i).start();  
      24.         }  
      25.     }  
      26.     // 停止服务  
      27.     public void stop() {  
      28.         this.status = Status.TERMINATED;  
      29.     }  
      30.     // 是否正在运行  
      31.     public boolean isRunning() {  
      32.         return status == Status.RUNNING;  
      33.     }  
      34.     // 执行任务  
      35.     public void runTask(Task task) {  
      36.         queue.addTask(task);  
      37.     }  
      38.     protected TaskQueue getTaskQueue() {  
      39.         return queue;  
      40.     }  
      41. }  

    完成了上面四个类,我们就实现了一个简单的线程池。现在我们就可以使用它了,下面的代码做了一个简单的示例:
    [java]  view plain copy
    1. public class SimpleTaskTest extends Task {  
    2.     @Override  
    3.     public void deal() {  
    4.         // do something  
    5.     }  
    6.     public static void main(String[] args) throws InterruptedException {  
    7.         ThreadPoolService service = new ThreadPoolService();  
    8.         service.start();  
    9.         // 执行十次任务  
    10.         for (int i = 0; i < 10; i++) {  
    11.             service.runTask(new SimpleTaskTest());  
    12.         }  
    13.         // 睡眠1秒钟,等待所有任务执行完毕  
    14.         Thread.sleep(1000);  
    15.         service.stop();  
    16.     }  
    17. }  

    当然,我们实现的是最简单的,这里只是为了演示线程池的实现原理。在实际应用中,根据情况的不同,可以做很多优化。比如: 
    • 调整任务队列的规则,给任务设置优先级,级别高的任务优先执行。
    • 动态维护线程池,当待执行任务数量较多时,增加线程的数量,加快任务的执行速度;当任务较少时,回收一部分长期闲置的线程,减少对系统资源的消耗。

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

    Executors类提供了一组创建线程池对象的方法,常用的有一下几个: 
    [java]  view plain copy
    1. public static ExecutorService newCachedThreadPool() {  
    2.     // other code  
    3. }  
    4. public static ExecutorService newFixedThreadPool(int nThreads) {  
    5.     // other code  
    6. }  
    7. public static ExecutorService newSingleThreadExecutor() {  
    8.     // other code  
    9. }  

    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中线程池的使用: 
    [java]  view plain copy
    1. import java.util.concurrent.*;  
    2. public class ExecutorTest {  
    3.     public static void main(String[] args) throws InterruptedException,  
    4.             ExecutionException {  
    5.         ExecutorService es = Executors.newSingleThreadExecutor();  
    6.         Future fr = es.submit(new RunnableTest());// 提交任务  
    7.         Future fc = es.submit(new CallableTest());// 提交任务  
    8.         // 取得返回值并输出  
    9.         System.out.println((String) fc.get());  
    10.         // 检查任务是否执行完毕  
    11.         if (fr.isDone()) {  
    12.             System.out.println("执行完毕-RunnableTest.run()");  
    13.         } else {  
    14.             System.out.println("未执行完-RunnableTest.run()");  
    15.         }  
    16.         // 检查任务是否执行完毕  
    17.         if (fc.isDone()) {  
    18.             System.out.println("执行完毕-CallableTest.run()");  
    19.         } else {  
    20.             System.out.println("未执行完-CallableTest.run()");  
    21.         }  
    22.         // 停止线程池服务  
    23.         es.shutdown();  
    24.     }  
    25. }  
    26. class RunnableTest implements Runnable {  
    27.     public void run() {  
    28.         System.out.println("已经执行-RunnableTest.run()");  
    29.     }  
    30. }  
    31. class CallableTest implements Callable {  
    32.     public Object call() {  
    33.         System.out.println("已经执行-CallableTest.call()");  
    34.         return "返回值-CallableTest.call()";  
    35.     }  
    36. }  

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

    使用完线程池之后,需要调用它的shutdown()方法停止服务,否则其中的所有线程都会保持运行,程序不会退出。
    展开全文
  • 线程中Sleep()、Wait()区别

    千次阅读 2017-01-15 14:49:26
    Sleep()、Wait():调用某个对象的wait()方法,相当于让当前线程交出此对象的锁monitor,然后进入等待状态,等待后续再次获得此对象的锁(Thread类sleep方法使当前线程暂停执行一段时间,从而让其他线程有机会继续...
    线程:
    Sleep()、Wait():调用某个对象的wait()方法,相当于让当前线程交出此对象的锁monitor,然后进入等待状态,等待后续再次获得此对象的锁(Thread类中的sleep方法使当前线程暂停执行一段时间,从而让其他线程有机会继续执行,但它并不释放对象锁);

    Condition是在java 1.5中才出现的,它用来替代传统的Object的wait()、notify()实现线程间的协作,相比使用Object的wait()、notify(),使用Condition1的await()、signal()、signalAll()这种方式实现线程间协作更加安全和高效。因此通常来说比较推荐使用Condition,在阻塞队列那一篇博文中就讲述到了,阻塞队列实际上是使用了Condition来模拟线程间协作。
    展开全文
  • 线程中sleep导致崩溃是一种错觉

    千次阅读 2018-11-04 19:49:17
    今天下午调试代码的时候,发现运行一段时间后肯定崩溃。使用输出发现死在sleep之前。嗯?是这个线程有问题?于是把线程功能逐步...验证办法很简单,去掉sleep会崩溃,去掉这个线程还是会崩溃。  碰到这种情况,...

       今天下午调试代码的时候,发现运行一段时间后肯定崩溃。使用输出发现死在sleep之前。嗯?是这个线程有问题?于是把线程功能逐步去掉,照样崩溃;不启动这个线程,还是崩溃。这是为什么?

      其实,sleep导致崩溃,是一种错觉。因为sleep的时间一般较长,如果此时别的地方崩溃,那么看起来就象是sleep导致的。验证办法很简单,去掉sleep会崩溃,去掉这个线程还是会崩溃。

      碰到这种情况,简单测试验证一下,目光放在别的地方。

    展开全文
  • 线程中Sleep的作用

    千次阅读 2013-11-08 14:20:09
     使用Sleep, 线程可以告诉系统,在一段时间内自己不需要调度。 Sleep函数的原型:  void Sleep(DWORD dwMilliseconds); 使用这个函数需要注意几点:  1、使用Sleep函数,将使线程自愿放弃属于它的时间片中...
  • 线程中sleep和wait有什么区别

    千次阅读 2017-02-10 09:14:49
    备注 : 上篇有点乱,重新转载一篇 不重复造轮子 sleep和wait区别
  • 线程中sleep()和wait()的区别

    千次阅读 2019-04-15 10:00:43
    sleep()方法是Thread的静态方法,提供了两种sleep的方式可让我们更灵活的控制,目的是为了使线程睡眠一段时间,自然醒后继续执行,不存在继续竞争,因为期间并没有释放同步锁. public static native void sleep(long ...
  • 线程中Sleep(0)的作用

    千次阅读 2012-09-20 08:04:59
    Sleep(n)的作用是让当前线程睡眠n毫秒,以便执行其他线程,如果没有其他线程,那睡眠n毫秒后,继续执行。 而如果n=0,Sleep(0)是指CPU交出当前线程的执行权,让CPU去执行其他线程。也就是放弃当前线程的时间片,...
  • Java多线程中Sleep与Wait的区别?

    千次阅读 2016-08-08 11:07:47
     首先我想说的是:在多线程编程,经常会使用sleep与wait操作,我们理解sleep与wait的最大区别是sleep等待是不会释放当前锁,而wait则反之。我今天想到一个现实例子来比较这两者的区别。   我以去
  • sleep不延迟时线程不会交出所有权,而WaitForSingleObject会,因此WaitForSingleObject比较彻底,效率更高。 哪位大虾有相关资料,发来研究研究。 大虾们多多讨论 什么东西最好就是自己试一试,不要凭想像,我...
  • 线程中sleep()方法和yield()方法

    千次阅读 2016-03-29 16:33:43
    cpu会从众多的可执行态里选择,也就是说,当前也就是刚刚的那个线程还是有可能会被再次执行到的,并不是说一定会执行其他线程而该线程在下一次不会执行到了。 Java线程中有一个Thread.yield( )方法,很多人...
  • 线程中sleep()方法和yeild()方法的区别

    千次阅读 2016-12-09 13:24:49
    1.sleep()方法会给其他线程运行的机会,而不管其他线程的优先级,因此会给较低优先级的线程运行的机会;yeild()方法只会给优先  级相同的或者比自己高的线程运行的机会. 2.sleep()方法声明抛出InterruptionException...
  • Java多线程中Sleep与Wait的区别

    千次阅读 2012-11-06 11:26:19
    Java的多线程是一种抢占式的机制,而不是分时机制。抢占式的机制是有多个线程处于可运行状态,但是只有一个线程在运行。 共同点: 1. 他们都是在多线程的环境下,都可以在程序的调用处阻塞指定的毫秒数,并返回...
  • Java多线程中sleep()和wait()有什么区别

    千次阅读 2013-10-02 14:16:50
    sleep线程类(Thread)的方法,导致此线程暂停执行指定时间,给执行机会给其他线程,但是监控状态依然保持,到时后会自动恢复。调用sleep 不会释放对象锁。 wait 是Object 类的方法,对此对象调用wait 方法导致...
  • sleep()是让某个线程暂停运行一段时间,其控制范围是由当前线程决定,也就是说,在线程里面决定.好比如说,我要做的事情是 "点火->烧水->煮面",而当我点完火之后我不立即烧水,我要休息一段时间再烧.对于运行的主动权是...
  • 一、sleep()sleep()方法源码: /** * Causes the currently executing thread to sleep (temporarily cease * execution) for the specified number of milliseconds, subject to * the precision and acc...
  • sleep和wait有一个共同作用,停止当前线程任务运行,但他们存在一定的不同: 1、sleep方法没有释放锁,而wait方法释放了锁,使得其他线程可以使用同步控制块或者方法 2、wait,notify和notifyAll只能在同步控制...
  • - A sleep线程类(Thread)的方法,wait是Object类的方法; - B sleep不释放对象锁,wait放弃对象锁 - C sleep暂停线程、但监控状态仍然保持,结束后会自动恢复 - D wait后进入等待锁定池,只有针对此对象发出...
  • Java线程中sleep()、wait()和notify()和notifyAll()、suspend和resume()、yield()、join()、interrupt()的用法和区别  从操作系统的角度讲,os会维护一个ready queue(就绪的线程队列)。并且在某一时刻cpu只为...
  • 线程之我见,有错误,请指正,谢谢 线程的执行需要cpu资源,而cpu的利用时各个线程进行“轮询”即轮时间...而sleep()的作用是让当前执行cpu的线程挂起,交出cpu,让其他等待cpu的线程执行, 测试程序: 1 #includ
  • 本文转载:http://blog.csdn.net/u0fly/article/details/6386591... 1、这两个方法来自不同的类分别是Thread和Object  2、最主要是sleep方法没有释放锁,而wait方法释放了锁,使得其他线程可以使用同步控制块或者方法
  • 并且在某一时刻cpu只为ready queue位于队列头部的线程服务。 但是当前正在被服务的线程可能觉得cpu的服务质量不够好,于是提前退出,这就是yield。 或者当前正在被服务的线程需要睡一会,醒来后继续被服务,这就是...
  • java中线程睡眠sleep()方法介绍

    万次阅读 多人点赞 2018-05-27 22:26:28
    1、方法介绍 sleep(long millis) 线程睡眠 millis 毫秒 sleep(long millis, int nanos) 线程睡眠 millis 毫秒 + nanos 纳秒2、如何调用sleep 因为sleep()是静态方法,所以最好的调用方法就是 Thread.sleep()。...
  • Java线程让步会让线程让出优先级,而休眠则会让线程进入阻塞状态等待被唤醒,这里我们对比线程等待的wait()方法,来详解Java线程让步yield()与线程休眠sleep()方法
  • Java的线程睡眠sleep

    千次阅读 2019-05-26 11:32:22
    当当前线程调用sleep()方法进入阻塞状态后,在其睡眠时间段内,该线程不会获得执行的机会,即使系统没有其他可执行的线程,处于sleep()线程也不会执行,因此sleep()方法常用来暂停程序的执行。 二代码 ...
  • java的睡眠--线程Sleep中断

    千次阅读 2015-12-25 18:45:26
    而在java,虚拟机的执行是分为多个线程的,所以直接Sleep、函数.Sleep、System.Sleep都是不存在的,这种理解是不对的 java分为多个线程,当线程被构建时,便有了内存资源和CPU的使用权, 一旦开始运行,那么单个...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 519,559
精华内容 207,823
关键字:

线程中的sleep