Future接口和FutureTask类【FutureTask实现了Runnable和Future接口】

API：

 

public interface Future {

    /**
     * Attempts to cancel execution of this task.  This attempt will
     * fail if the task has already completed, has already been cancelled,
     * or could not be cancelled for some other reason. If successful,
     * and this task has not started when cancel is called,
     * this task should never run.  If the task has already started,
     * then the mayInterruptIfRunning parameter determines
     * whether the thread executing this task should be interrupted in
     * an attempt to stop the task.
     */
    boolean cancel(boolean mayInterruptIfRunning);

    /**
     * Returns true if this task was cancelled before it completed
     * normally.
     *
     * @return true if this task was cancelled before it completed
     */
    boolean isCancelled();

    /**
     * Returns true if this task completed.
     *
     * Completion may be due to normal termination, an exception, or
     * cancellation -- in all of these cases, this method will return
     * true.
     *
     * @return true if this task completed
     */
    boolean isDone();

    /**
     * Waits if necessary for the computation to complete, and then
     * retrieves its result.
     *
     * @return the computed result
     * @throws CancellationException if the computation was cancelled
     * @throws ExecutionException if the computation threw an
     * exception
     * @throws InterruptedException if the current thread was interrupted
     * while waiting
     */
    V get() throws InterruptedException, ExecutionException;

    /**
     * Waits if necessary for at most the given time for the computation
     * to complete, and then retrieves its result, if available.
     *
     * @param timeout the maximum time to wait
     * @param unit the time unit of the timeout argument
     * @return the computed result
     * @throws CancellationException if the computation was cancelled
     * @throws ExecutionException if the computation threw an
     * exception
     * @throws InterruptedException if the current thread was interrupted
     * while waiting
     * @throws TimeoutException if the wait timed out
     */
    V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}

 

public interface Executor {
    void execute(Runnable command);
}

public interface ExecutorService extends Executor {

     Future submit(Callable task);
     Future submit(Runnable task, T result);
    Future submit(Runnable task);
    ...
}

public class FutureTask  extends Object
            implements Future, Runnable {
      FutureTask(Callable callable)
             //创建一个 FutureTask，一旦运行就执行给定的 Callable。
      FutureTask(Runnable runnable, V result)
             //创建一个 FutureTask，一旦运行就执行给定的 Runnable，并安排成功完成时 get 返回给定的结果 。
}
/*参数：
runnable - 可运行的任务。
result - 成功完成时要返回的结果。
如果不需要特定的结果，则考虑使用下列形式的构造：Future f = new FutureTask(runnable, null)  */   
    
   
     
  单独使用Runnable时： 
          无法获得返回值 
    
  单独使用Callable时： 
          无法在新线程中(new Thread(Runnable r))使用，只能使用ExecutorService 
          Thread类只支持Runnable 
    
  FutureTask： 
           实现了Runnable和Future，所以兼顾两者优点 
           既可以使用ExecutorService，也可以使用Thread 
    
  Callable pAccount = new PrivateAccount();
    FutureTask futureTask = new FutureTask(pAccount);
    // 使用futureTask创建一个线程
    Thread thread = new Thread(futureTask);
    thread.start(); 
     
  ================================================================= 
  public interface Future Future 表示异步计算的结果。Future有个get方法而获取结果只有在计算完成时获取，否则会一直阻塞直到任务转入完成状态，然后会返回结果或者抛出异常。  
     
  Future 主要定义了5个方法： 1)boolean cancel(boolean mayInterruptIfRunning)：试图取消对此任务的执行。如果任务已完成、或已取消，或者由于某些其他原因而无法取消，则此尝试将失败。当调用 cancel 时，如果调用成功，而此任务尚未启动，则此任务将永不运行。如果任务已经启动，则 mayInterruptIfRunning 参数确定是否应该以试图停止任务的方式来中断执行此任务的线程。此方法返回后，对 isDone() 的后续调用将始终返回 true。如果此方法返回 true，则对 isCancelled() 的后续调用将始终返回 true。  
  2）boolean isCancelled()：如果在任务正常完成前将其取消，则返回 true。 3）boolean isDone()：如果任务已完成，则返回 true。 可能由于正常终止、异常或取消而完成，在所有这些情况中，此方法都将返回 true。 4）V get()throws InterruptedException,ExecutionException：如有必要，等待计算完成，然后获取其结果。 5）V get(long timeout,TimeUnit unit) throws InterruptedException,ExecutionException,TimeoutException：如有必要，最多等待为使计算完成所给定的时间之后，获取其结果（如果结果可用）。 
  6）finishCompletion()该方法在任务完成（包括异常完成、取消）后调用。删除所有正在get获取等待的节点且唤醒节点的线程。和调用done方法和置空callable. 
    
  CompletionService接口能拿到按完成顺序拿到一组线程池中所有线程，依靠的就是FutureTask中的finishCompletion()方法。 
  /**
    该方法在任务完成（包括异常完成、取消）后调用。删除所有正在get获取等待的节点且唤醒节点的线程。和调用done方法和置空callable.
    **/
    private void finishCompletion() {
        // assert state > COMPLETING;
        for (WaitNode q; (q = waiters) != null;) {
            if (UNSAFE.compareAndSwapObject(this, waitersOffset, q, null)) {
                for (;;) {
                    Thread t = q.thread;
                    if (t != null) {
                        q.thread = null;
                        LockSupport.unpark(t);
                    }
                    WaitNode next = q.next;
                    if (next == null)
                        break;
                    q.next = null; // unlink to help gc
                    q = next;
                }
                break;
            }
        }

        done();

        callable = null;        // to reduce footprint
    } 
    
    
   
   public class FutureTask  extends Object
    implements Future, Runnable 
   Future是一个接口， FutureTask类是Future 的一个实现类，并实现了Runnable，因此FutureTask可以传递到线程对象Thread中新建一个线程执行。所以可通过Excutor(线程池) 来执行,也可传递给Thread对象执行。 
   如果在主线程中需要执行比较耗时的操作时，但又不想阻塞主线程时，可以把这些作业交给Future对象在后台完成，当主线程将来需要时，就可以通过Future对象获得后台作业的计算结果或者执行状态。  
   
   
   FutureTask是为了弥补Thread的不足而设计的，它可以让程序员准确地知道线程什么时候执行完成并获得到线程执行完成后返回的结果（如果有需要）。 
     
   FutureTask是一种可以取消的异步的计算任务。它的计算是通过Callable实现的，它等价于可以携带结果的Runnable，并且有三个状态：等待、运行和完成。完成包括所有计算以任意的方式结束，包括正常结束、取消和异常。 
   
  Executor框架利用FutureTask来完成异步任务，并可以用来进行任何潜在的耗时的计算。一般FutureTask多用于耗时的计算，主线程可以在完成自己的任务后，再去获取结果。 
    FutureTask多用于耗时的计算，主线程可以在完成自己的任务后，再去获取结果。 
    
    
    
  JDK: 
  此类提供了对 Future 的基本实现。仅在计算完成时才能检索结果；如果计算尚未完成，则阻塞 get 方法。一旦计算完成，就不能再重新开始或取消计算。 
    
  可使用 FutureTask 包装 Callable 或 Runnable 对象。因为 FutureTask 实现了 Runnable，所以可将 FutureTask 提交给 Executor 执行。 
    
    
  //构造方法摘要
FutureTask(Callable callable)
          //创建一个 FutureTask，一旦运行就执行给定的 Callable。

FutureTask(Runnable runnable, V result)
          //创建一个 FutureTask，一旦运行就执行给定的 Runnable，并安排成功完成时 get 返回给定的结果 。
//参数：
runnable - 可运行的任务。
result - 成功完成时要返回的结果。
如果不需要特定的结果，则考虑使用下列形式的构造：Future f = new FutureTask(runnable, null)   
    
   
    
  Example1: 
  下面的例子模拟一个会计算账的过程，主线程已经获得其他帐户的总额了，为了不让主线程等待 PrivateAccount类的计算结果的返回而启用新的线程去处理， 并使用 FutureTask对象来监控，这样，主线程还可以继续做其他事情， 最后需要计算总额的时候再尝试去获得privateAccount 的信息。  
    
  package test;

import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

/**
 *
 * @author Administrator
 *
 */
@SuppressWarnings("all")
public class FutureTaskDemo {
    public static void main(String[] args) {
        // 初始化一个Callable对象和FutureTask对象
        Callable pAccount = new PrivateAccount();
        FutureTask futureTask = new FutureTask(pAccount);
        // 使用futureTask创建一个线程
        Thread pAccountThread = new Thread(futureTask);
        System.out.println("futureTask线程现在开始启动，启动时间为：" + System.nanoTime());
        pAccountThread.start();
        System.out.println("主线程开始执行其他任务");
        // 从其他账户获取总金额
        int totalMoney = new Random().nextInt(100000);
        System.out.println("现在你在其他账户中的总金额为" + totalMoney);
        System.out.println("等待私有账户总金额统计完毕...");
        // 测试后台的计算线程是否完成，如果未完成则等待
        while (!futureTask.isDone()) {
            try {
                Thread.sleep(500);
                System.out.println("私有账户计算未完成继续等待...");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("futureTask线程计算完毕，此时时间为" + System.nanoTime());
        Integer privateAccountMoney = null;
        try {
            privateAccountMoney = (Integer) futureTask.get();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        System.out.println("您现在的总金额为：" + totalMoney + privateAccountMoney.intValue());
    }
}

@SuppressWarnings("all")
class PrivateAccount implements Callable {
    Integer totalMoney;

    @Override
    public Object call() throws Exception {
        Thread.sleep(5000);
        totalMoney = new Integer(new Random().nextInt(10000));
        System.out.println("您当前有" + totalMoney + "在您的私有账户中");
        return totalMoney;
    }

} 
   运行结果    
    
   
    
     
     来源： 
     
   http://zheng12tian.iteye.com/blog/991484 
   
   
    
     
       
     
   
   
   Example2： 
   
   
   public class FutureTaskSample {

    static FutureTask future = new FutureTask(new Callable(){
        public String call(){
            return getPageContent();
        }
    });

    public static void main(String[] args) throws InterruptedException, ExecutionException{
        //Start a thread to let this thread to do the time exhausting thing
        new Thread(future).start();

        //Main thread can do own required thing first
        doOwnThing();

        //At the needed time, main thread can get the result
        System.out.println(future.get());
    }

    public static String doOwnThing(){
        return "Do Own Thing";
    }
    public static String getPageContent(){
        return "Callable method...";
    }
} 结果为：Callable method... 
    
   不科学啊，为毛？？！ 
   
  
    来源： http://tomyz0223.iteye.com/blog/1019924 
   
   
    改为这样，结果就正常： 
   
   
   public class FutureTaskSample {

    public static void main(String[] args) throws InterruptedException, ExecutionException{
        //Start a thread to let this thread to do the time exhausting thing
        Callable call = new MyCallable();
        FutureTask future = new FutureTask(call);
        new Thread(future).start();

        //Main thread can do own required thing first
        //doOwnThing();
        System.out.println("Do Own Thing");

        //At the needed time, main thread can get the result
        System.out.println(future.get());
    }

}


    class MyCallable implements Callable{

        @Override
        public String call() throws Exception {
             return getPageContent();
        }

        public String getPageContent(){
            return "Callable method...";
        }
    } 结果： 
   
   
   
     Do Own Thing 
    
   
     Callable method... 
    
     
   
  
      
   Example3： 
   import java.util.concurrent.Callable;

public class Changgong implements Callable{

    private int hours=12;
    private int amount;

    @Override
    public Integer call() throws Exception {
        while(hours>0){
            System.out.println("I'm working......");
            amount ++;
            hours--;
            Thread.sleep(1000);
        }
        return amount;
    }
} 
     
   public class Dizhu {

    public static void main(String args[]){
        Changgong worker = new Changgong();
        FutureTask jiangong = new FutureTask(worker);
        new Thread(jiangong).start();
        while(!jiangong.isDone()){
            try {
                System.out.println("看长工做完了没...");
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        int amount;
        try {
            amount = jiangong.get();
            System.out.println("工作做完了,上交了"+amount);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (ExecutionException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}  
    
   
   
   结果： 
   
   
   看工人做完了没... 
    
   I'm working...... 
    
   看工人做完了没... 
    
   I'm working...... 
    
   看工人做完了没... 
    
   I'm working...... 
    
   看工人做完了没... 
    
   I'm working...... 
    
   看工人做完了没... 
    
   I'm working...... 
    
   看工人做完了没... 
    
   I'm working...... 
    
   看工人做完了没... 
    
   I'm working...... 
    
   看工人做完了没... 
    
   I'm working...... 
    
   看工人做完了没... 
    
   I'm working...... 
    
   看工人做完了没... 
    
   I'm working...... 
    
   看工人做完了没... 
    
   I'm working...... 
    
   看工人做完了没... 
    
   I'm working...... 
    
   看工人做完了没... 
    
   工作做完了,上交了12 
   
  
      
   /**
 * Factory and utility methods for {@link Executor}, {@link
 * ExecutorService}, {@link ScheduledExecutorService}, {@link
 * ThreadFactory}, and {@link Callable} classes defined in this
 * package. This class supports the following kinds of methods:
 *
 *   
      *    Methods that create and return an {@link ExecutorService}  
      *        set up with commonly useful configuration settings.  
      *    Methods that create and return a {@link ScheduledExecutorService}  
      *        set up with commonly useful configuration settings.  
      *    Methods that create and return a "wrapped" ExecutorService, that  
      *        disables reconfiguration by making implementation-specific methods  
      *        inaccessible.  
      *    Methods that create and return a {@link ThreadFactory}  
      *        that sets newly created threads to a known state.  
      *    Methods that create and return a {@link Callable}  
      *        out of other closure-like forms, so they can be used  
      *        in execution methods requiring Callable.  
      *
 *
 * @since 1.5
 * @author Doug Lea
 */
public class Executors {

    /**
     * Creates a thread pool that reuses a fixed number of threads
     * operating off a shared unbounded queue.  At any point, at most
     * nThreads threads will be active processing tasks.
     * If additional tasks are submitted when all threads are active,
     * they will wait in the queue until a thread is available.
     * If any thread terminates due to a failure during execution
     * prior to shutdown, a new one will take its place if needed to
     * execute subsequent tasks.  The threads in the pool will exist
     * until it is explicitly {@link ExecutorService#shutdown shutdown}.
     *
     * @param nThreads the number of threads in the pool
     * @return the newly created thread pool
     * @throws IllegalArgumentException if nThreads <= 0
     */
    public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue());
    }

    /**
     * Creates a thread pool that reuses a fixed number of threads
     * operating off a shared unbounded queue, using the provided
     * ThreadFactory to create new threads when needed.  At any point,
     * at most nThreads threads will be active processing
     * tasks.  If additional tasks are submitted when all threads are
     * active, they will wait in the queue until a thread is
     * available.  If any thread terminates due to a failure during
     * execution prior to shutdown, a new one will take its place if
     * needed to execute subsequent tasks.  The threads in the pool will
     * exist until it is explicitly {@link ExecutorService#shutdown
     * shutdown}.
     *
     * @param nThreads the number of threads in the pool
     * @param threadFactory the factory to use when creating new threads
     * @return the newly created thread pool
     * @throws NullPointerException if threadFactory is null
     * @throws IllegalArgumentException if nThreads <= 0
     */
    public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue(),
                                      threadFactory);
    }

    /**
     * Creates an Executor that uses a single worker thread operating
     * off an unbounded queue. (Note however that if this single
     * thread terminates due to a failure during execution prior to
     * shutdown, a new one will take its place if needed to execute
     * subsequent tasks.)  Tasks are guaranteed to execute
     * sequentially, and no more than one task will be active at any
     * given time. Unlike the otherwise equivalent
     * newFixedThreadPool(1) the returned executor is
     * guaranteed not to be reconfigurable to use additional threads.
     *
     * @return the newly created single-threaded Executor
     */
    public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue()));
    }

    /**
     * Creates an Executor that uses a single worker thread operating
     * off an unbounded queue, and uses the provided ThreadFactory to
     * create a new thread when needed. Unlike the otherwise
     * equivalent newFixedThreadPool(1, threadFactory) the
     * returned executor is guaranteed not to be reconfigurable to use
     * additional threads.
     *
     * @param threadFactory the factory to use when creating new
     * threads
     *
     * @return the newly created single-threaded Executor
     * @throws NullPointerException if threadFactory is null
     */
    public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory) {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue(),
                                    threadFactory));
    }

    /**
     * Creates a thread pool that creates new threads as needed, but
     * will reuse previously constructed threads when they are
     * available.  These pools will typically improve the performance
     * of programs that execute many short-lived asynchronous tasks.
     * Calls to execute will reuse previously constructed
     * threads if available. If no existing thread is available, a new
     * thread will be created and added to the pool. Threads that have
     * not been used for sixty seconds are terminated and removed from
     * the cache. Thus, a pool that remains idle for long enough will
     * not consume any resources. Note that pools with similar
     * properties but different details (for example, timeout parameters)
     * may be created using {@link ThreadPoolExecutor} constructors.
     *
     * @return the newly created thread pool
     */
    public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue());
    }

    /**
     * Creates a thread pool that creates new threads as needed, but
     * will reuse previously constructed threads when they are
     * available, and uses the provided
     * ThreadFactory to create new threads when needed.
     * @param threadFactory the factory to use when creating new threads
     * @return the newly created thread pool
     * @throws NullPointerException if threadFactory is null
     */
    public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory) {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue(),
                                      threadFactory);
    }

    /**
     * Creates a single-threaded executor that can schedule commands
     * to run after a given delay, or to execute periodically.
     * (Note however that if this single
     * thread terminates due to a failure during execution prior to
     * shutdown, a new one will take its place if needed to execute
     * subsequent tasks.)  Tasks are guaranteed to execute
     * sequentially, and no more than one task will be active at any
     * given time. Unlike the otherwise equivalent
     * newScheduledThreadPool(1) the returned executor is
     * guaranteed not to be reconfigurable to use additional threads.
     * @return the newly created scheduled executor
     */
    public static ScheduledExecutorService newSingleThreadScheduledExecutor() {
        return new DelegatedScheduledExecutorService
            (new ScheduledThreadPoolExecutor(1));
    }

    /**
     * Creates a single-threaded executor that can schedule commands
     * to run after a given delay, or to execute periodically.  (Note
     * however that if this single thread terminates due to a failure
     * during execution prior to shutdown, a new one will take its
     * place if needed to execute subsequent tasks.)  Tasks are
     * guaranteed to execute sequentially, and no more than one task
     * will be active at any given time. Unlike the otherwise
     * equivalent newScheduledThreadPool(1, threadFactory)
     * the returned executor is guaranteed not to be reconfigurable to
     * use additional threads.
     * @param threadFactory the factory to use when creating new
     * threads
     * @return a newly created scheduled executor
     * @throws NullPointerException if threadFactory is null
     */
    public static ScheduledExecutorService newSingleThreadScheduledExecutor(ThreadFactory threadFactory) {
        return new DelegatedScheduledExecutorService
            (new ScheduledThreadPoolExecutor(1, threadFactory));
    }

    /**
     * Creates a thread pool that can schedule commands to run after a
     * given delay, or to execute periodically.
     * @param corePoolSize the number of threads to keep in the pool,
     * even if they are idle.
     * @return a newly created scheduled thread pool
     * @throws IllegalArgumentException if corePoolSize < 0
     */
    public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
        return new ScheduledThreadPoolExecutor(corePoolSize);
    }

    /**
     * Creates a thread pool that can schedule commands to run after a
     * given delay, or to execute periodically.
     * @param corePoolSize the number of threads to keep in the pool,
     * even if they are idle.
     * @param threadFactory the factory to use when the executor
     * creates a new thread.
     * @return a newly created scheduled thread pool
     * @throws IllegalArgumentException if corePoolSize < 0
     * @throws NullPointerException if threadFactory is null
     */
    public static ScheduledExecutorService newScheduledThreadPool(
            int corePoolSize, ThreadFactory threadFactory) {
        return new ScheduledThreadPoolExecutor(corePoolSize, threadFactory);
    }
    ........

    /** Cannot instantiate. */
    private Executors() {}
} ================================================================================ 
    
    
    FutureTask实现原理-源码 
     
     
     FutureTask源码 
     
        下面我们介绍一下FutureTask内部的一些实现机制。下文从以下几点叙述： 
    
   
   
   类继承结构 
   核心成员变量 
   内部状态转换 
   核心方法解析 
   
  1 类继承结构 
        首先我们看一下FutureTask的继承结构： 
  　　　  
        FutureTask实现了RunnableFuture接口，而RunnableFuture继承了Runnable和Future，也就是说FutureTask既是Runnable，也是Future。 
  2 核心成员变量 
      FutureTask内部定义了以下变量，以及它们的含义如下 
   
   volatile int state:表示对象状态，volatile关键字保证了内存可见性。futureTask中定义了7种状态，代表了7种不同的执行状态 
   
   
    
    private  static  final  int  NEW          =  0 ;  //任务新建和执行中
private  static  final  int  COMPLETING   =  1 ;  //任务将要执行完毕
private  static  final  int  NORMAL       =  2 ;  //任务正常执行结束
private  static  final  int  EXCEPTIONAL  =  3 ;  //任务异常
private  static  final  int  CANCELLED    =  4 ;  //任务取消
private  static  final  int  INTERRUPTING =  5 ;  //任务线程即将被中断
private  static  final  int  INTERRUPTED  =  6 ;  //任务线程已中断 
    
   
   
   Callable callable:被提交的任务 
   Object outcome:任务执行结果或者任务异常 
   volatile Thread runner:执行任务的线程 
   volatile WaitNode waiters：等待节点，关联等待线程 
   long stateOffset:state字段的内存偏移量 
   long runnerOffset：runner字段的内存偏移量 
   long waitersOffset：waiters字段的内存偏移量 
   
      后三个字段是配合Unsafe类做CAS操作使用的。 
  3 内部状态转换 
      FutureTask中使用state表示任务状态，state值变更的由CAS操作保证原子性。 
      FutureTask对象初始化时，在构造器中把state置为为NEW，之后状态的变更依据具体执行情况来定。 
  　  例如任务执行正常结束前，state会被设置成COMPLETING，代表任务即将完成，接下来很快就会被设置为NARMAL或者EXCEPTIONAL，这取决于调用Runnable中的call()方法是否抛出了异常。有异常则后者，反之前者。 
  　　任务提交后、任务结束前取消任务，那么有可能变为CANCELLED或者INTERRUPTED。在调用cancel方法时，如果传入false表示不中断线程，state会被置为CANCELLED，反之state先被变为INTERRUPTING，后变为INTERRUPTED。 
       总结下，FutureTask的状态流转过程，可以出现以下四种情况： 
          1. 任务正常执行并返回。 NEW -> COMPLETING -> NORMAL 
  　　  2. 执行中出现异常。NEW -> COMPLETING -> EXCEPTIONAL 
          3. 任务执行过程中被取消，并且不响应中断。NEW -> CANCELLED 
  　　  4. 任务执行过程中被取消，并且响应中断。 NEW -> INTERRUPTING -> INTERRUPTED　　 
  4 核心方法解析 
  　　接下来我们一起扒一扒FutureTask的源码。我们先看一下任务线程是怎么执行的。当任务被提交到线程池后，会执行futureTask的run()方法。 
  1 public void run() 
   
    
    public  void  run() {         // 校验任务状态
        if  (state != NEW || !UNSAFE.compareAndSwapObject( this , runnerOffset,  null , Thread.currentThread()))
            return ;
        try  {
            Callable c = callable;　　　　　　　 // double check
            if  (c !=  null  && state == NEW) {
                V result;
                boolean  ran;
                try  {　　　　　　　　　　　　 //执行业务代码
                    result = c.call();
                    ran =  true ;
                }  catch  (Throwable ex) {
                    result =  null ;
                    ran =  false ;
                    setException(ex);
                }
                if  (ran)
                    set(result);
            }
        }  finally  {　　　　　　   // 重置runner
            runner =  null ;
            int  s = state;
            if  (s >= INTERRUPTING)
                handlePossibleCancellationInterrupt(s);
        }
    } 
    
   
  　　翻译一下，这个方法经历了以下几步 
   
   校验当前任务状态是否为NEW以及runner是否已赋值。这一步是防止任务被取消。 
   double-check任务状态state 
   执行业务逻辑，也就是c.call()方法被执行 
   如果业务逻辑异常，则调用setException方法将异常对象赋给outcome，并且更新state值 
   如果业务正常，则调用set方法将执行结果赋给outcome，并且更新state值 
   
   我们继续往下看，setException(Throwable t)和set(V v) 具体是怎么做的 
   
    
    protected  void  set(V v) {
        // state状态 NEW->COMPLETING
        if  (UNSAFE.compareAndSwapInt( this , stateOffset, NEW, COMPLETING)) {
            outcome = v;
            // COMPLETING -> NORMAL 到达稳定状态
            UNSAFE.putOrderedInt( this , stateOffset, NORMAL);
            // 一些结束工作
            finishCompletion();
        }
    } 
    
   
   
    
    protected  void  setException(Throwable t) {
    // state状态 NEW->COMPLETING
    if  (UNSAFE.compareAndSwapInt( this , stateOffset, NEW, COMPLETING)) {
        outcome = t;
        // COMPLETING -> EXCEPTIONAL 到达稳定状态
        UNSAFE.putOrderedInt( this , stateOffset, EXCEPTIONAL);
        // 一些结束工作
        finishCompletion();
    }
} 
    
   
      code中的注释已经写的很清楚，故不翻译了。状态变更的原子性由unsafe对象提供的CAS操作保证。FutureTask的outcome变量存储执行结果或者异常对象，会由主线程返回。 
  2  get()和get(long timeout, TimeUnit unit) 
      任务由线程池提供的线程执行，那么这时候主线程则会阻塞，直到任务线程唤醒它们。我们通过get(long timeout, TimeUnit unit)方法看看是怎么做的　　 
   
    
    public  V get( long  timeout, TimeUnit unit)
        throws  InterruptedException, ExecutionException, TimeoutException {
        if  (unit ==  null )
            throw  new  NullPointerException();
        int  s = state;
        if  (s <= COMPLETING &&
            (s = awaitDone( true , unit.toNanos(timeout))) <= COMPLETING)
            throw  new  TimeoutException();
        return  report(s);
    } 
    
   
  　  get的源码很简洁，首先校验参数，然后根据state状态判断是否超时，如果超时则异常，不超时则调用report(s)去获取最终结果。 
      当 s<= COMPLETING时，表明任务仍然在执行且没有被取消。如果它为true，那么走到awaitDone方法。 
      awaitDone是futureTask实现阻塞的关键方法，我们重点关注一下它的实现原理。 
   
    
    /**
 * 等待任务执行完毕,如果任务取消或者超时则停止
 * @param timed 为true表示设置超时时间
 * @param nanos 超时时间
 * @return 任务完成时的状态
 * @throws InterruptedException
 */
private  int  awaitDone( boolean  timed,  long  nanos)
        throws  InterruptedException {
    // 任务截止时间
    final  long  deadline = timed ? System.nanoTime() + nanos : 0L;
    WaitNode q =  null ;
    boolean  queued =  false ;
    // 自旋
    for  (;;) {
        if  (Thread.interrupted()) {
            //线程中断则移除等待线程,并抛出异常
            removeWaiter(q);
            throw  new  InterruptedException();
        }
        int  s = state;
        if  (s > COMPLETING) {
            // 任务可能已经完成或者被取消了
            if  (q !=  null )
                q.thread =  null ;
            return  s;
        }
        else  if  (s == COMPLETING)
            // 可能任务线程被阻塞了,主线程让出CPU
            Thread.yield();
        else  if  (q ==  null )
            // 等待线程节点为空,则初始化新节点并关联当前线程
            q =  new  WaitNode();
        else  if  (!queued)
            // 等待线程入队列,成功则queued=true
            queued = UNSAFE.compareAndSwapObject( this , waitersOffset,
                    q.next = waiters, q);
        else  if  (timed) {
            nanos = deadline - System.nanoTime();
            if  (nanos <= 0L) {
                //已经超时的话,移除等待节点
                removeWaiter(q);
                return  state;
            }
            // 未超时,将当前线程挂起指定时间
            LockSupport.parkNanos( this , nanos);
        }
        else
            // timed=false时会走到这里,挂起当前线程
            LockSupport.park( this );
    }
} 
    
   
  注释里也很清楚的写明了每一步的作用，我们以设置超时时间为例，总结一下过程 
   
   计算deadline，也就是到某个时间点后如果还没有返回结果，那么就超时了。 
   进入自旋，也就是死循环。 
   首先判断是否响应线程中断。对于线程中断的响应往往会放在线程进入阻塞之前，这里也印证了这一点。 
   判断state值，如果>COMPLETING表明任务已经取消或者已经执行完毕，就可以直接返回了。 
   如果任务还在执行，则为当前线程初始化一个等待节点WaitNode，入等待队列。这里和AQS的等待队列类似，只不过Node只关联线程，而没有状态。AQS里面的等待节点是有状态的。 
   计算nanos，判断是否已经超时。如果已经超时，则移除所有等待节点，直接返回state。超时的话，state的值仍然还是COMPLETING。 
   如果还未超时，就通过LockSupprot类提供的方法在指定时间内挂起当前线程，等待任务线程唤醒或者超时唤醒。 
   
  当线程被挂起之后，如果任务线程执行完毕，就会唤醒等待线程哦。这一步就是在finishCompletion里面做的，前面已经提到这个方法。我们再看看这个方法具体做了哪些事吧~ 
   
    
    /**
 * 移除并唤醒所有等待线程,执行done,置空callable
 * nulls out callable.
 */
private  void  finishCompletion() {
    //遍历等待节点
    for  (WaitNode q; (q = waiters) !=  null ;) {
        if  (UNSAFE.compareAndSwapObject( this , waitersOffset, q,  null )) {
            for  (;;) {
                Thread t = q.thread;
                if  (t !=  null ) {
                    q.thread =  null ;
                    //唤醒等待线程
                    LockSupport.unpark(t);
                }
                WaitNode next = q.next;
                if  (next ==  null )
                    break ;
                // unlink to help gc
                q.next =  null ;
                q = next;
            }
            break ;
        }
    }
    //模板方法,可以被覆盖
    done();
    //清空callable
    callable =  null ;
} 
    
   
  由代码和注释可以看出来，这个方法的作用主要在于唤醒等待线程。由前文可知，当任务正常结束或者异常时，都会调用finishCompletion去唤醒等待线程。这个时候，等待线程就可以醒来，开开心心的获得结果啦。　　 
  最后我们看一下任务取消　　 
  3 public boolean cancel(boolean mayInterruptIfRunning) 
    注意，取消操作不一定会起作用，这里我们先贴个demo 
   
    
     
    
    1 public class FutureDemo {
 2     public static void main(String[] args) {
 3         ThreadPoolExecutor executorService = (ThreadPoolExecutor) Executors.newFixedThreadPool(1);
 4         // 预创建线程
 5         executorService.prestartCoreThread();
 6 
 7         Future future = executorService.submit(new Callable() {
 8             @Override
 9             public Object call() {
10                 System.out.println("start to run callable");
11                 Long start = System.currentTimeMillis();
12                 while (true) {
13                     Long current = System.currentTimeMillis();
14                     if ((current - start) > 1000) {
15                         System.out.println("当前任务执行已经超过1s");
16                         return 1;
17                     }
18                 }
19             }
20         });
21 
22         System.out.println(future.cancel(false));
23 
24         try {
25             Thread.currentThread().sleep(3000);
26             executorService.shutdown();
27         } catch (Exception e) {
28             //NO OP
29         }
30     }
31 } 
    
     
    
   
  我们多次测试后发现，出现了2种打印结果，如图 
   
  　　　　　　　　　　　　　　　　结果1 
   
  　　　　　　　　　　　　　　　　结果2　　　　 
  第一种是任务压根没取消，第二种则是任务压根没提交成功。　 
      方法签名注释告诉我们，取消操作是可能会失败的，如果当前任务已经结束或者已经取消，则当前取消操作会失败。如果任务尚未开始，那么任务不会被执行。这就解释了出现上图结果2的情况。我们还是从源码去分析cancel()究竟做了哪些事。 
   
    
    public  boolean  cancel( boolean  mayInterruptIfRunning) {
        if  (state != NEW)
            return  false ;
        if  (mayInterruptIfRunning) {
            if  (!UNSAFE.compareAndSwapInt( this , stateOffset, NEW, INTERRUPTING))
                return  false ;
            Thread t = runner;
            if  (t !=  null )
                t.interrupt();
            UNSAFE.putOrderedInt( this , stateOffset, INTERRUPTED);  // final state
        }
        else  if  (!UNSAFE.compareAndSwapInt( this , stateOffset, NEW, CANCELLED))
            return  false ;
        finishCompletion();
        return  true ;
    } 
    
   
  　　执行逻辑如下 
   
   state不为NEW时，任务即将进入终态，直接返回false表明取消操作失败。 
   state状态为NEW，任务可能已经开始执行，也可能还未开始。 
   mayInterruptIfRunning表明是否中断线程。若是，则尝试将state设置为INTERRUPTING，并且中断线程，之后将state设置为终态INTERRUPTED。 
   如果mayInterruptIfRunning=false，则不中断线程，把state设置为CANCELLED 
   移除等待线程并唤醒。 
   返回true 
   
      可见，cancel()方法改变了futureTask的状态位，如果传入的是false并且业务逻辑已经开始执行，当前任务是不会被终止的，而是会继续执行，直到异常或者执行完毕。如果传入的是true，会调用当前线程的interrupt()方法，把中断标志位设为true。 
      事实上，除非线程自己停止自己的任务，或者退出JVM，是没有其他方法完全终止一个线程的任务的。mayInterruptIfRunning=true，通过希望当前线程可以响应中断的方式来结束任务。当任务被取消后，会被封装为CancellationException抛出。 
  总结 
  　　总结一下，futureTask中的任务状态由变量state表示，任务状态都基于state判断。而futureTask的阻塞则是通过自旋+挂起线程实现。理解FutureTask的内部实现机制，我们使用Future时才能更加得心应手。文中掺杂着笔者的个人理解，如果有不正之处，还望读者多多指正 
  

                            
                        
                    
                    
                    
                    
                    
                    
                
                
                    
                        
                        
                             
                        
                        
                        
                            
                        
                        
                        
                            
                        
                    
                
            
        
    
    
        你可能感兴趣的:(java,多线程)
        
            
                
                    设计六边形架构实战：基于Java的探索
                        苏鹃咪Healthy

                        设计六边形架构实战：基于Java的探索Designing-Hexagonal-Architecture-with-JavaDesigningHexagonalArchitecturewithJava,publishedbyPackt项目地址:https://gitcode.com/gh_mirrors/de/Designing-Hexagonal-Architecture-with-Java项目介
                    
                    GET、POST请求工具类
                        Mr.xie1024
服务器javahttp
                        HttpRequestUtil工具类importio.micrometer.core.instrument.util.StringUtils;importorg.slf4j.Logger;importorg.slf4j.LoggerFactory;importjava.io.*;importjava.net.HttpURLConnection;importjava.net.URL;importja
                    
                    Java创建型模式（一）——单例设计模式（饿汉式、懒汉式、枚举式，以及序列化反序列化破环单例模式和反射破环单例模式及破环单例模式的解决办法 | 完成详解，附有代码+案例）
                        蔚一
Java知识java设计模式开发语言intellij-idea单例模式
                        文章目录单例设计模式4.1.1单例模式的结构4.1.2单例模式的实现4.1.2.1饿汉式-静态变量方式4.1.2.2饿汉式-静态代码块方式4.1.2.3懒汉式-线程不安全4.1.2.4懒汉式-线程安全4.1.2.5懒汉式-双重检查锁4.1.2.6饿汉式—枚举类4.3单例模式存在的问题4.3.1序列化反序列化破环单例模式4.3.2反射破环单例模式4.4解决单例模式存在的问题4.4.1序列化、反序列方
                    
                    各类运维工具下载地址维护
                        容器云服务
运维
                        tomcat：Indexof/dist/tomcat/tomcat-8Indexof/dist/tomcat/tomcat-9Indexof/dist/tomcat/tomcat-10jdk：JavaDownloads|Oracle
                    
                    Dockerfile另一种使用普通用户启动的方式
                        容器云服务
容器云linuxdockerfiledocker
                        基础镜像的Dockerfile#使用Debian11.9的最小化版本作为基础镜像FROMdebian:11.11#维护者信息LABELmaintainer="caibingsen"#复制自定义的sources.list文件（如果有的话）COPYsources.list/etc/apt/sources.list#创建一个目录来存放JDKRUNmkdir-p/usr/java/jdk1.8.0_191
                    
                    JavaScript 进阶之路：探索高级特性和最佳实践
                        不在··
原型模式
                        面向对象的三大特征封装继承多态构造函数什么是构造函数通过new关键字调用一个函数的时候，这个函数就是构造函数。构造函数和普通函数的区别调用方式不同普通函数只用函数名调用构造函数通过new关键字调用返回值不同普通函数的返回值是函数体内return的结果构造函数的返回值是new关键字生成的对象JSPrototype原型对象所有的函数都有一个原型对象Prototype，并且只有函数才拥有原型对象Prot
                    
                    JAVA JDK7时间相关类
                        ＆白帝＆
javajavapython开发语言
                        一Date类java.util.Date`类表示特定的瞬间，精确到毫秒。1Date类的构造方法Date类有多种构造方法，可以通过不同的方式创建Date对象。1.Date()构造方法该构造方法不带任何参数，用于创建一个表示当前时间的Date对象。它会返回一个表示当前日期和时间的Date实例。Datenow=newDate();System.out.println(now);//输出当前日期和时间Tu
                    
                    httppost请求工具类
                        玉离骚
java工具类
                        需要引入httpcore-4.3.1.jar、httpclient-4.3.6.jar。下面列举了是三个http请求方式参考packageyulisao;importjava.io.IOException;publicclassHttpUtil{/***httppost请求**@paramurl请求地址*@paramjson主报文（json字符串格式）*@paramuserId报文头参数*@ret
                    
                    Axios 教程：Promise 基础的 HTTP 客户端
                        吉皎妃Frasier

                        Axios教程：Promise基础的HTTP客户端axiosaxios/axios:Axios是一个基于Promise的HTTP客户端库，适用于浏览器和Node.js环境，用于在JavaScript应用中执行异步HTTP请求。相较于原生的XMLHttpRequest或FetchAPI，Axios提供了更简洁的API和更强大的功能。项目地址:https://gitcode.com/gh_mirror
                    
                    【Nginx系列】Nginx配置超时时间
                        m0_74824552
面试学习路线阿里巴巴nginx运维
                        ???欢迎来到我的博客，很高兴能够在这里和您见面！希望您在这里可以感受到一份轻松愉快的氛围，不仅可以获得有趣的内容和知识，也可以畅所欲言、分享您的想法和见解。推荐:kwan的首页,持续学习,不断总结,共同进步,活到老学到老导航檀越剑指大厂系列:全面总结java核心技术,jvm,并发编程redis,kafka,Spring,微服务等常用开发工具系列:常用的开发工具,IDEA,Mac,Alfred,G
                    
                    MySQL与Oracle对比及区别
                        m0_74823434
面试学习路线阿里巴巴java
                        一、比较1、MySQL的特点性能卓越，服务稳定，很少出现异常宕机；开放源代码无版本制约，自主性及使用成本低；历史悠久，社区和用户非常活跃，遇到问题及时寻求帮助；软件体积小，安装使用简单且易于维护，维护成本低；品牌口碑效应；支持多种OS，提供多种API接口，支持多种开发语言，对流行的PHP，Java很好的支持2、Oracle的特点兼容性：Oracle产品采用标准SQL，并经过美国u构架标准技术所（N
                    
                    [JS]学习笔记2 -- JAVAScript数据类型
                        Jizhi_Zhang
JavaScript学习笔记javascript学习笔记
                        一、常量概念：使用const声明的变量称为“常量”。使用场景：当某个变量永远不会改变的时候，就可以使用const来声明，而不是let。命名规范：和变量一致注：常量不允许重新赋值，在声明的时候必须要赋值（初始化）二、数据类型1、基本数据类型1.1数字型number学习中的数字，整数、小数、正数、负数可以有很多操作：算数+：求和-：求差*：求积/：求商%：取模（取余数）--开发中经常作为某个数字是否被
                    
                    基于 Node.js 的天气查询系统实现(附源码）
                        Kasper0121
node.js
                        项目概述这是一个基于Node.js的全栈应用，前端使用原生JavaScript和CSS，后端使用Express框架，通过调用第三方天气API实现天气数据的获取和展示。主要功能默认显示多个主要城市的天气信息支持城市天气搜索响应式布局设计深色主题界面优雅的加载动画技术栈后端：Node.js+Express前端：HTML5+CSS3+JavaScriptHTTP客户端：AxiosAPI：天气API(v1
                    
                    Three.js学习笔记
                        癫狂de痴梦
前端javascript学习前端
                        1.three.js的引入进入官网Three.js–JavaScript3DLibrary，下载文件解压文件，复制three.js-master\build\three.min.js文件在项目中，引入该文件。2.一个简单threeJs程序（1）创建场景constscene=newTHREE.Scene();（2）创建物体constgeomtry=newTHREE.BoxGeometry(1,1,1
                    
                    jwt相关问题及应用
                        2501_90243308
hivehadoop数据仓库
                        接收方生成签名的时候必须使用跟JWT发送方相同的密钥六，JWT在spa项目中的使用================项目中JwtFilter类packagecom.zking.vue.util;importjava.io.IOException;importjava.util.regex.Matcher;importjava.util.regex.Pattern;importjavax.servle
                    
                    Linux系统：第十章：服务器环境搭建
                        2501_90243308
服务器linux运维
                        JAVA_HOME=/opt/jdk1.8.0_152PATH=JAVAHOME/bin:JAVA_HOME/bin:JAVAHOME/bin:PATHexportJAVA_HOMEPATH然后保存退出：按Esc+：wq执行当前连接刚刚配置的脚本文件使配置文件生效：source/etc/profile或者reboot重启查看jdk版本：java-versionjavaversion“1.8.0_1
                    
                    Java 不可变集合全面解析
                        吉安.
开发语言java
                        在Java编程中，不可变集合是一种特殊类型的集合，一旦创建，其内容就不能被修改。这种特性使得不可变集合在某些场景下具有独特的优势。创建不可变集合的应用场景数据不可修改的场景：当某个数据不应该被修改时，将其防御性地拷贝到不可变集合中是一种很好的实践。例如，一些配置信息、常量数据等，将它们放在不可变集合中，可以确保在程序运行过程中其内容不会被意外修改。安全调用不可信库：当集合对象需要被不可信的库调用时
                    
                    Java配置文件从XML到Annotation完美转变
                        xiaoyustudiowww
java
                        首先Java配置XML文件光定义文件DTD（DocumentTypeDefinition）或者XSD（XMLSchemaDefinition）就很麻烦，解析XML虽然很规则但是解析XML的代码复杂，而Annotation很方便。其次XML不是程序代码，而Java中Annotation是程序代码继而非常灵活简洁。
                    
                    Flink (十二) ：Table API & SQL (一) 概览
                        Leven199527
Flinkflinksql大数据
                        ApacheFlink有两种关系型API来做流批统一处理：TableAPI和SQL。TableAPI是用于Scala和Java语言的查询API，它可以用一种非常直观的方式来组合使用选取、过滤、join等关系型算子。FlinkSQL是基于ApacheCalcite来实现的标准SQL。无论输入是连续的（流式）还是有界的（批处理），在两个接口中指定的查询都具有相同的语义，并指定相同的结果。TableAP
                    
                    Java力扣题解：169 多数元素——投票法
                        早起之王
leetcodeleetcode
                        题目给定一个大小为n的数组，找到其中的多数元素。多数元素是指在数组中出现次数大于⌊n/2⌋的元素。你可以假设数组是非空的，并且给定的数组总是存在多数元素。来源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/majority-element著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。分析这里的投票法，是以第一个元素为基准数，票
                    
                    [Qt]常用控件介绍-显示类控件-QLabel、QLCDNumber、QProgressBar、QCalendarWidget控件
                        北顾南栀倾寒
QtC++c++qt开发语言
                        目录1.Label控件属性介绍三种文本格式的设置应用编辑图片与自动拉伸应用QLable伙伴设置2.LCDNumber控件属性Demo：倒计时程序多线程实现倒计时程序3.ProgressBar控件属性Demo：定时器--进度条随机增长Qt头文件的前置声明4.CalendarWidget控件属性重要的信号1.Label控件可以用来显示文本和图片内容，内部含有许多功能，但是在运行后只能用于显示文本和实现
                    
                    Solon Cloud Gateway 开发：Helloword
                        组合缺一
SolonJavaFrameworkgatewayjavasolon
                        SolonCloudGateway，是一个可Java编程的分布式接口网关（或，代理网关）。有没有注册与发布服务。都可以用。不管是php或者node.js或得java，只要是http服务。也都可互通。下面，演示给一个服务（比如：https://www.baidu.com）配置代理网关呢？1、新建个空的solon-lib项目，添加maven依赖：生成空的solon-lib项目https://solon
                    
                    Python知识点：基于Python工具和技术，如何使用Truffle进行智能合约开发与部署
                        杰哥在此
Python系列python智能合约开发语言编程面试
                        开篇，先说一个好消息，截止到2025年1月1日前，翻到文末找到我，赠送定制版的开题报告和任务书，先到先得！过期不候！如何使用Truffle与Python进行智能合约开发与部署Truffle是一个强大的开发框架，它为以太坊智能合约的开发、测试和部署提供了一整套工具。虽然Truffle主要使用JavaScript和Solidity，但是它也可以与Python工具和技术配合使用，以实现更灵活的开发流程。
                    
                    LeetCode 21. 合并两个有序链表 链表合并 Java实现
                        Lentr0py
LeetCode算法题leetcode链表java算法数据结构
                        21.合并两个有序链表21.合并两个有序链表题目来源题目分析题目难度题目标签题目限制解题思路思路：核心算法步骤迭代法代码实现代码解读性能分析复杂度结果测试用例扩展讨论优化写法其他实现总结21.合并两个有序链表题目来源21.合并两个有序链表题目分析将两个升序链表合并为一个新的升序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。题目难度难度：简单题目标签标签：链表题目限制两个链表的节点数目
                    
                    力扣：69. x 的平方根 题解（Java）
                        HOOHV
力扣题解
                        题目地址：x的平方根题目描述：实现intsqrt(intx)函数。计算并返回x的平方根，其中x是非负整数。由于返回类型是整数，结果只保留整数的部分，小数部分将被舍去。示例1:输入:4输出:2示例2:输入:8输出:2说明:8的平方根是2.82842..., 由于返回类型是整数，小数部分将被舍去。解题思路：没什么好说的，调用函数，然后强制转换成int返回就行了。……其实是要手动开平方，用到公式(x+a
                    
                    java.sql.date 字符串,字符串到java.sql.Date
                        高度不可替代性
java.sql.date字符串
                        Irealizethishasbeenaskedalot.Ididactuallylook.I'vespenthourslookingaroundandtryingtofigurethisout.I'msupposedtobemakingaprogramthatstoreswhatamountstoalistofappointmentsinadatabase,withadescription,da
                    
                    使用Kotlin编写一个Http服务器
                        
后端kotlinhttp
                        首发于Enaium的个人博客引言在本文中，我们将使用Kotlin编写一个简单的HTTP服务器。我们将使用Java的ServerSocket类来实现这个服务器。我们将创建一个简单的服务器，它将监听端口8000，并在接收到请求时返回一个简单的响应。Http的格式HTTP请求和响应都是文本格式的。HTTP请求由请求行、请求头和请求体组成。HTTP响应由状态行、响应头和响应体组成。具体可以到MDN查看。代
                    
                    JavaScript常用的一些代码段
                        东锋1.3
javascriptjavascript开发语言ecmascript
                        带有重复项使用递归。对于给定字符串中的每个字母，为字母创建字谜。使用map（）将字母与每部分字谜组合，然后使用reduce（）将所有字谜组合到一个数组中，最基本情况是字符串长度等于2或1。constanagrams=str=>{if(str.lengthacc.concat(anagrams(str.slice(0,i)+str.slice(i+1)).map(val=>letter+val)),
                    
                    ZXing库 -- 生成二维码
                        蓝田～
python开发语言
                        引言二维码（QRCode）因其高密度的数据存储能力和易于扫描的特性，在现代社会中得到了广泛应用。ZXing是一个开源的二维码生成与读取库，它支持多种编程语言，包括Java。本指南将详细介绍如何在Java项目中使用ZXing库来生成带有透明背景的二维码。准备ZXing库com.google.zxingcore3.4.1com.google.zxingjavase3.4.1生成二维码编写代码packa
                    
                    日常小tip_Bat命令运行Java程序
                        蓝田～
小tipsjava开发语言
                        批处理命令介绍文章目录介绍常用语法bat命令运行一个简单的Java程序介绍批处理命令一般是一个文本文件，文件的每一行命令都会在DOS中执行。一般用来处理需要重复性执行的命令。常用语法echo:表示显示此命令后的字符echooff:表示不显示此命令后的命令行本身的字符@:与echooff类似，但是这条命令加在命令行之前，表示不显示这一行的命令行字符call:调用另外一个批处理文件pause:暂停当前
                    
                                开发者关心的那些事
                                    圣子足道
ios游戏编程apple支付
                                    我要在app里添加IAP，必须要注册自己的产品标识符（product identifiers）。产品标识符是什么？ 
产品标识符（Product Identifiers）是一串字符串，它用来识别你在应用内贩卖的每件商品。App Store用产品标识符来检索产品信息，标识符只能包含大小写字母（A-Z）、数字（0-9）、下划线（-）、以及圆点(.)。你可以任意排列这些元素，但我们建议你创建标识符时使用
                                
                                负载均衡器技术Nginx和F5的优缺点对比
                                    bijian1013
nginxF5
                                            对于数据流量过大的网络中，往往单一设备无法承担，需要多台设备进行数据分流，而负载均衡器就是用来将数据分流到多台设备的一个转发器。 
        目前有许多不同的负载均衡技术用以满足不同的应用需求，如软/硬件负载均衡、本地/全局负载均衡、更高
                                
                                LeetCode[Math] - #9 Palindrome Number
                                    Cwind
javaAlgorithm题解LeetCodeMath
                                    原题链接：#9 Palindrome Number 
  
要求： 
判断一个整数是否是回文数，不要使用额外的存储空间 
  
难度：简单 
  
分析： 
题目限制不允许使用额外的存储空间应指不允许使用O(n)的内存空间，O(1)的内存用于存储中间结果是可以接受的。于是考虑将该整型数反转，然后与原数字进行比较。 
注：没有看到有关负数是否可以是回文数的明确结论，例如
                                
                                画图板的基本实现
                                    15700786134
画图板
                                     要实现画图板的基本功能，除了在qq登陆界面中用到的组件和方法外，还需要添加鼠标监听器，和接口实现。 
首先，需要显示一个JFrame界面： 
public class DrameFrame extends JFrame {              //显示
                                
                                linux的ps命令
                                    被触发
linux
                                    Linux中的ps命令是Process Status的缩写。ps命令用来列出系统中当前运行的那些进程。ps命令列出的是当前那些进程的快照，就是执行ps命令的那个时刻的那些进程，如果想要动态的显示进程信息，就可以使用top命令。 
要对进程进行监测和控制，首先必须要了解当前进程的情况，也就是需要查看当前进程，而 ps 命令就是最基本同时也是非常强大的进程查看命令。使用该命令可以确定有哪些进程正在运行
                                
                                Android 音乐播放器 下一曲 连续跳几首歌
                                    肆无忌惮_
android
                                    最近在写安卓音乐播放器的时候遇到个问题。在MediaPlayer播放结束时会回调 
player.setOnCompletionListener(new OnCompletionListener() {

			@Override
			public void onCompletion(MediaPlayer mp) {
				mp.reset();
				Log.i("H
                                
                                java导出txt文件的例子
                                    知了ing
javaservlet
                                    代码很简单就一个servlet,如下： 
 
package com.eastcom.servlet;

import java.io.BufferedOutputStream;
import java.io.IOException;
import java.net.URLEncoder;
import java.sql.Connection;
import java.sql.Resu
                                
                                Scala stack试玩, 提高第三方依赖下载速度
                                    矮蛋蛋
scalasbt
                                    原文地址： 
http://segmentfault.com/a/1190000002894524 
sbt下载速度实在是惨不忍睹, 需要做些配置优化 
 
下载typesafe离线包, 保存为ivy本地库 
 
wget http://downloads.typesafe.com/typesafe-activator/1.3.4/typesafe-activator-1.3.4.zip 
解压r
                                
                                phantomjs安装(linux，附带环境变量设置) ，以及casperjs安装。
                                    alleni123
linuxspider
                                    1. 首先从官网 
http://phantomjs.org/下载phantomjs压缩包，解压缩到/root/phantomjs文件夹。 
 
2. 安装依赖 
 
sudo yum install fontconfig freetype libfreetype.so.6 libfontconfig.so.1 libstdc++.so.6 
 
3. 配置环境变量 
vi /etc/profil
                                
                                JAVA IO FileInputStream和FileOutputStream，字节流的打包输出
                                    百合不是茶
java核心思想JAVA IO操作字节流
                                    在程序设计语言中，数据的保存是基本，如果某程序语言不能保存数据那么该语言是不可能存在的，JAVA是当今最流行的面向对象设计语言之一，在保存数据中也有自己独特的一面，字节流和字符流 
1，字节流是由字节构成的，字符流是由字符构成的 字节流和字符流都是继承的InputStream和OutPutStream ,java中两种最基本的就是字节流和字符流 
  
类 FileInputStream
                                
                                Spring基础实例（依赖注入和控制反转）
                                    bijian1013
spring
                                    前提条件：在http://www.springsource.org/download网站上下载Spring框架，并将spring.jar、log4j-1.2.15.jar、commons-logging.jar加载至工程1.武器接口 
package com.bijian.spring.base3;

public interface Weapon {

   
    void kil
                                
                                HR看重的十大技能
                                    bijian1013
提升能力HR成长
                                        一个人掌握何种技能取决于他的兴趣、能力和聪明程度，也取决于他所能支配的资源以及制定的事业目标，拥有过硬技能的人有更多的工作机会。但是，由于经济发展前景不确定，掌握对你的事业有所帮助的技能显得尤为重要。以下是最受雇主欢迎的十种技能。 　　一、解决问题的能力 　　每天，我们都要在生活和工作中解决一些综合性的问题。那些能够发现问题、解决问题并迅速作出有效决
                                
                                【Thrift一】Thrift编译安装
                                    bit1129
thrift
                                    什么是Thrift 
The Apache Thrift software framework, for scalable cross-language services development, combines a software stack with a code generation engine to build services that work efficiently and s
                                
                                【Avro三】Hadoop MapReduce读写Avro文件
                                    bit1129
mapreduce
                                    Avro是Doug Cutting(此人绝对是神一般的存在）牵头开发的。 开发之初就是围绕着完善Hadoop生态系统的数据处理而开展的（使用Avro作为Hadoop MapReduce需要处理数据序列化和反序列化的场景）,因此Hadoop MapReduce集成Avro也就是自然而然的事情。 
这个例子是一个简单的Hadoop MapReduce读取Avro格式的源文件进行计数统计，然后将计算结果
                                
                                nginx定制500，502，503，504页面
                                    ronin47
nginx　错误显示
                                    server {
     listen 80;
     error_page  500/500.html;
     error_page  502/502.html;
     error_page  503/503.html;
     error_page  504/504.html;

     location /test {return502;}} 
配置很简单，和配
                                
                                java-1.二叉查找树转为双向链表
                                    bylijinnan
二叉查找树
                                    
import java.util.ArrayList;
import java.util.List;


public class BSTreeToLinkedList {
	
	/*
把二元查找树转变成排序的双向链表
题目：
输入一棵二元查找树，将该二元查找树转换成一个排序的双向链表。
要求不能创建任何新的结点，只调整指针的指向。
10
/ \
6 14
/ \ 
                                
                                Netty源码学习-HTTP-tunnel
                                    bylijinnan
javanetty
                                    Netty关于HTTP tunnel的说明： 
 
http://docs.jboss.org/netty/3.2/api/org/jboss/netty/channel/socket/http/package-summary.html#package_description 
 
这个说明有点太简略了 
 
一个完整的例子在这里： 
 
https://github.com/bylijinnan
                                
                                JSONUtil.serialize(map)和JSON.toJSONString(map)的区别
                                    coder_xpf
jqueryjsonmapval()
                                     JSONUtil.serialize(map)和JSON.toJSONString(map)的区别 
  
数据库查询出来的map有一个字段为空 
  
通过System.out.println()输出  JSONUtil.serialize(map)： {"one":"1","two":"nul
                                
                                Hibernate缓存总结
                                    cuishikuan
开源sshjavawebhibernate缓存三大框架
                                    一、为什么要用Hibernate缓存？ 
Hibernate是一个持久层框架，经常访问物理数据库。 
为了降低应用程序对物理数据源访问的频次，从而提高应用程序的运行性能。 
缓存内的数据是对物理数据源中的数据的复制，应用程序在运行时从缓存读写数据，在特定的时刻或事件会同步缓存和物理数据源的数据。 
  
二、Hibernate缓存原理是怎样的？ 
Hibernate缓存包括两大类：Hib
                                
                                CentOs6
                                    dalan_123
centos
                                    首先su - 切换到root下面1、首先要先安装GCC GCC-C++ Openssl等以来模块：yum -y install make gcc gcc-c++ kernel-devel m4 ncurses-devel openssl-devel2、再安装ncurses模块yum -y install ncurses-develyum install ncurses-devel3、下载Erang
                                
                                10款用 jquery 实现滚动条至页面底端自动加载数据效果
                                    dcj3sjt126com
JavaScript
                                      
无限滚动自动翻页可以说是web2.0时代的一项堪称伟大的技术，它让我们在浏览页面的时候只需要把滚动条拉到网页底部就能自动显示下一页的结果，改变了一直以来只能通过点击下一页来翻页这种常规做法。 
无限滚动自动翻页技术的鼻祖是微博的先驱：推特(twitter)，后来必应图片搜索、谷歌图片搜索、google reader、箱包批发网等纷纷抄袭了这一项技术，于是靠滚动浏览器滚动条
                                
                                ImageButton去边框&Button或者ImageButton的背景透明
                                    dcj3sjt126com
imagebutton
                                    在ImageButton中载入图片后，很多人会觉得有图片周围的白边会影响到美观，其实解决这个问题有两种方法 
一种方法是将ImageButton的背景改为所需要的图片。如：android:background="@drawable/XXX" 
第二种方法就是将ImageButton背景改为透明，这个方法更常用 
在XML里； 
   <ImageBut
                                
                                JSP之c:foreach
                                    eksliang
jspforearch
                                    原文出自：http://www.cnblogs.com/draem0507/archive/2012/09/24/2699745.html 
<c:forEach>标签用于通用数据循环，它有以下属性    属 性 描 述 是否必须 缺省值   items 进行循环的项目 否 无   begin 开始条件 否 0   end 结束条件 否 集合中的最后一个项目   step 步长 否 1
                                
                                Android实现主动连接蓝牙耳机
                                    gqdy365
android
                                    在Android程序中可以实现自动扫描蓝牙、配对蓝牙、建立数据通道。蓝牙分不同类型，这篇文字只讨论如何与蓝牙耳机连接。 
大致可以分三步： 
 
一、扫描蓝牙设备： 
1、注册并监听广播： 
 

BluetoothAdapter.ACTION_DISCOVERY_STARTED
BluetoothDevice.ACTION_FOUND
BluetoothAdapter.ACTION_DIS
                                
                                android学习轨迹之四：org.json.JSONException: No value for
                                    hyz301
json
                                    org.json.JSONException: No value for items  
在JSON解析中会遇到一种错误，很常见的错误 
  
06-21 12:19:08.714    2098-2127/com.jikexueyuan.secret I/System.out﹕ Result:{"status":1,"page":1,&
                                
                                干货分享：从零开始学编程 系列汇总
                                    justjavac
编程
                                    程序员总爱重新发明轮子，于是做了要给轮子汇总。 
 
  从零开始写个编译器吧系列 (知乎专栏)  
  从零开始写一个简单的操作系统 (伯乐在线)  
  从零开始写JavaScript框架 (图灵社区)  
  从零开始写jQuery框架 (蓝色理想 )  
  从零开始nodejs系列文章 (粉丝日志)  
  从零开始编写网络游戏 
                                
                                jquery-autocomplete 使用手册
                                    macroli
jqueryAjax脚本
                                    jquery-autocomplete学习 
一、用前必备 
官方网站：http://bassistance.de/jquery-plugins/jquery-plugin-autocomplete/  
当前版本：1.1 
需要JQuery版本：1.2.6 
二、使用 
<script src="./jquery-1.3.2.js" type="text/ja
                                
                                PLSQL-Developer或者Navicat等工具连接远程oracle数据库的详细配置以及数据库编码的修改
                                    超声波
oracleplsql
                                    　　在服务器上将Oracle安装好之后接下来要做的就是通过本地机器来远程连接服务器端的oracle数据库，常用的客户端连接工具就是PLSQL-Developer或者Navicat这些工具了。刚开始也是各种报错，什么TNS:no listener;TNS:lost connection;TNS:target hosts...花了一天的时间终于让PLSQL-Developer和Navicat等这些客户
                                
                                数据仓库数据模型之：极限存储--历史拉链表
                                    superlxw1234
极限存储数据仓库数据模型拉链历史表
                                    在数据仓库的数据模型设计过程中，经常会遇到这样的需求： 
 1. 数据量比较大; 2. 表中的部分字段会被update,如用户的地址，产品的描述信息，订单的状态等等; 3. 需要查看某一个时间点或者时间段的历史快照信息，比如，查看某一个订单在历史某一个时间点的状态，    比如，查看某一个用户在过去某一段时间内，更新过几次等等; 4. 变化的比例和频率不是很大，比如，总共有10
                                
                                10点睛Spring MVC4.1-全局异常处理
                                    wiselyman
spring mvc
                                    10.1 全局异常处理 
 
 使用@ControllerAdvice注解来实现全局异常处理; 
 使用@ControllerAdvice的属性缩小处理范围 
  
10.2 演示 
 
 演示控制器 
  
package com.wisely.web;

import org.springframework.stereotype.Controller;
import org.spring
                                
                
            
        
    


    
        
            按字母分类：
            ABCDEFGHIJKLMNOPQRSTUVWXYZ其他
        
    


    
        
            首页 -
            关于我们 -
            站内搜索 -
            Sitemap -
            侵权投诉
        
        版权所有 IT知识库 CopyRight © 2000-2050 E-COM-NET.COM , All Rights Reserved.
类继承结构
核心成员变量
内部状态转换
核心方法解析
校验当前任务状态是否为NEW以及runner是否已赋值。这一步是防止任务被取消。
double-check任务状态state
执行业务逻辑，也就是c.call()方法被执行
如果业务逻辑异常，则调用setException方法将异常对象赋给outcome，并且更新state值
如果业务正常，则调用set方法将执行结果赋给outcome，并且更新state值
计算deadline，也就是到某个时间点后如果还没有返回结果，那么就超时了。
进入自旋，也就是死循环。
首先判断是否响应线程中断。对于线程中断的响应往往会放在线程进入阻塞之前，这里也印证了这一点。
判断state值，如果>COMPLETING表明任务已经取消或者已经执行完毕，就可以直接返回了。
如果任务还在执行，则为当前线程初始化一个等待节点WaitNode，入等待队列。这里和AQS的等待队列类似，只不过Node只关联线程，而没有状态。AQS里面的等待节点是有状态的。
计算nanos，判断是否已经超时。如果已经超时，则移除所有等待节点，直接返回state。超时的话，state的值仍然还是COMPLETING。
如果还未超时，就通过LockSupprot类提供的方法在指定时间内挂起当前线程，等待任务线程唤醒或者超时唤醒。
state不为NEW时，任务即将进入终态，直接返回false表明取消操作失败。
state状态为NEW，任务可能已经开始执行，也可能还未开始。
mayInterruptIfRunning表明是否中断线程。若是，则尝试将state设置为INTERRUPTING，并且中断线程，之后将state设置为终态INTERRUPTED。
如果mayInterruptIfRunning=false，则不中断线程，把state设置为CANCELLED
移除等待线程并唤醒。
返回true