allcnewsBLOGNEWSBLOGASKBLOGBLOGZSK全部技术问答问答技术问答it问答代码软件新闻开发博客电脑/网络手机/数码笔记本电脑互联网操作系统软件硬件编程开发360产品资源分享电脑知识文档中心IT全部全部分类全部分类技术牛文全部分类教程最新网页制作cms教程平面设计媒体动画操作系统网站运营网络安全服务器教程数据库工具网络安全软件教学vbscript正则表达式javascript批处理更多»编程更新教程更新游戏更新allitnewsJava新闻网络医疗信息化安全创业站长电商科技访谈域名会议专栏创业动态融资创投创业学院 / 产品经理创业公司人物访谈营销开发数据库服务器系统虚拟化云计算嵌入式移动开发作业作业1常见软件all电脑网络手机数码生活游戏体育运动明星影音休闲爱好文化艺术社会民生教育科学医疗健康金融管理情感社交地区其他电脑互联网软件硬件编程开发360相关产品手机平板其他电子产品摄影器材360硬件通讯智能设备购物时尚生活常识美容塑身服装服饰出行旅游交通汽车购房置业家居装修美食烹饪单机电脑游戏网页游戏电视游戏桌游棋牌游戏手机游戏小游戏掌机游戏客户端游戏集体游戏其他游戏体育赛事篮球足球其他运动球类运动赛车健身运动运动用品影视娱乐人物音乐动漫摄影摄像收藏宠物幽默搞笑起名花鸟鱼虫茶艺彩票星座占卜书画美术舞蹈小说图书器乐声乐小品相声戏剧戏曲手工艺品历史话题时事政治就业职场军事国防节日风俗法律法规宗教礼仪礼节自然灾害360维权社会人物升学入学人文社科外语资格考试公务员留学出国家庭教育学习方法语文物理生物工程学农业数学化学健康知识心理健康孕育早教内科外科妇产科儿科皮肤科五官科男科整形中医药品传染科其他疾病医院两性肿瘤科创业投资企业管理财务税务银行股票金融理财基金债券保险贸易商务文书国民经济爱情婚姻家庭烦恼北京上海重庆天津黑龙江吉林辽宁河北内蒙古山西陕西宁夏甘肃青海新疆西藏四川贵州云南河南湖北湖南山东江苏浙江安徽江西福建广东广西海南香港澳门台湾海外地区

futuretask源码分析(推荐)

来源:脚本之家  责任编辑:小易  时间:2017/10/11 16:54:48


futuretask源码分析(推荐)

其实设计师的工资就差两个字,那就是高级和初级,几张简单的扁平化图片对比了初级设计师与高级设计师在工作方法和态度上的不同,向大家阐明了初级设计师与高级设计师之间的差距,值得设计师用来借鉴。时间观念初级设计师和高级设计师的区别!新手设计师迟到30分钟。资深设计师早到5分钟。如何处理图片初级设计师和高级设计师的区别!新手设计师用1-3天时间处理图片。资深设计师通常先花半天的时间思考,只花半个小时做设计。服装观念初级设计师和高级设计师的区别!新手设计师舒服就OK。资深设计师根据场合穿衣服,并注意细节。沟通技巧初级设计师和高级设计师的区别!新手设计师你说你的,她说她的。资深设计师懂得换位思考,能感受到他首先先来看一下古代女性的几种发型,作为一个编发爱好者,真心觉得这些发型个个美上天呀古代确实没有什么发卡皮筋,但是古代有簪(一足)钗(两足)梳(粗齿),篦(细齿)这几种基本类型,当然还有头绳~现代有一字夹,U夹,小皮筋等一堆物件。你会发现,其实古代的梳头工具还蛮全的,簪子可以盘发、支撑,钗可以固定、支撑(不就是U簪嘛~),梳子可以固定、压发、支撑,篦子可以固定、压发(超强刘海贴一般的存在),于是,只要用好这些工具,其实古代和现代盘发差不了多少(古代头发多,工具也大一些,很配嘛~)然后,我们来分析一下发型。古代有过腰的长头发和木头或真发做的假发包,复杂发型的发量绝对足够。想说大家也不要被影视剧里的

FutureTask只实现RunnableFuture接口:

当然是做球迷难。球迷也分档次,一般球迷都有自己热衷的球队和球员。只要有他们的比赛,不分白天黑夜,一定要看直播。如果没有直播,心里就会七上八下。赢了欢呼,输了沮丧。吃不好睡不好。如果是忠实的球迷,连队员。防恶意抓取,请查看原文,,真格学网提供内容。

该接口继承了java.lang.Runnable和Future接口,也就是继承了这两个接口的特性。

论UI,Flyme不会比MIUI差。小米有MIX,魅族有什么?小米有小米6,魅族有PRO7?或许,PRO7的设计会令人耳目一新,但到底会有多少人愿意为这样的设计买单?再者,从热度和销量来讲,PRO7和。防恶意抓取,请查看原文,,真格学网提供内容。

1.可以不必直接继承Thread来生成子类,只要实现run方法,且把实例传入到Thread构造函数,Thread就可以执行该实例的run方法了( Thread(Runnable) )。

您好,感谢邀请,飘窗铺了大理石之后还是可以做防护栏的。不知道你现在是装好了大理石台面了没有,具体可以有两种操作方法:1、如果你们家的飘窗原本就有防护栏,但你想要铺大理石,你可以先找人将栏杆先折除,等石。防恶意抓取,请查看原文,,真格学网提供内容。

2.可以让任务独立执行,get获取任务执行结果时,可以阻塞直至执行结果完成。也可以中断执行,判断执行状态等。

这个问题,我想可能需要分不同的情况,比如,小孩多大了,爷爷奶奶是否可以做比较好的养育人,母亲不去外地上班对家庭会造成多大的经济压力。当然,最后我的答案还是:不会!从妈妈自己的体验角度来说,为了上班挣钱。防恶意抓取,请查看原文,,真格学网提供内容。

FutureTask是一个支持取消行为的异步任务执行器。该类实现了Future接口的方法。

文明养狗从我做起,遛狗的时候最好带上牵引绳,遇到大狗早点把自己的宝贝抱起来,尽量杜绝自己宝贝受伤害,遇到伤害小狗的恶犬要把110,把这些恶犬及早处理掉,还有就是自己的狗狗,既然养了它,就要让他生活的合。防恶意抓取,请查看原文,,真格学网提供内容。

如: 1. 取消任务执行

不是说老外婚礼之前就不拍照片了。婚礼之前拍的照片都是不穿婚纱的,很多时候就是两人穿着日常着装,去大街树林海边、或者平时两人常常去逛的地方玩着逛着,然后摄影师记录这次两人出去玩的过程。当然摄影师会在拍摄。防恶意抓取,请查看原文,,真格学网提供内容。

2. 查询任务是否执行完成

“彼钗、玉、花、麝者,皆张其罗而穴其隧,所以迷眩缠陷天下者也。”语出自《红楼梦》第二十一回贤袭人娇嗔箴宝玉俏平儿软语救贾琏。大概情节是宝玉在黛玉那里和湘云三人一起呆到二更天,袭人来催了几次后才肯回去,。防恶意抓取,请查看原文,,真格学网提供内容。

3. 获取任务执行结果(”get“任务必须得执行完成才能获取结果,否则会阻塞直至任务完成)。

这种鉴宝节目,如果存在砸宝环节,一定会提前让藏友签一份“生死文书”,以防出现纠纷。“生死文书”的本质是合同,签字后具有法律效力,各方均应遵守。“生死文书”大致包括如下内容:藏宝人提供藏品;由节目组选定。防恶意抓取,请查看原文,,真格学网提供内容。

注意:一旦任务执行完成,则不能执行取消任务或者重新启动任务。(除非一开始就使用runAndReset模式运行任务)

哪里慢了,你是用联通吗?我还真找朋友一起做过对比:我的手机是小米,联通卡,不管是在3g还是4g网络下,都比移动电信的快,朋友的手机有苹果的,华为,小米,oppo。也不管是在农村还是市区,都是我的快,信。防恶意抓取,请查看原文,,真格学网提供内容。

FutureTask支持执行两种任务, Callable 或者 Runnable的实现类。且可把FutureTask实例交由Executor执行。

作为一个一遇到电视剧就泪点奇低的人(咳咳),其实我是很容易受到剧中的情节感染而深受感动的,诸如其他答案提到的《花千骨》、《步步惊心》、《仙剑奇侠传》这些,只要演员和配音不让我跳戏,只要这配乐够煽情够虐。防恶意抓取,请查看原文,,真格学网提供内容。

源码部分(很简单):

我玩过的手游挺多,有保卫萝卜,植物大战僵尸,剑侠情缘手游等等,真正让我着迷的只有皇室战争,这是2016年现象级的全球最佳手游,2017年第二季度依然是最具吸引力手游之一,位列全球手游收入榜第二,3分钟。防恶意抓取,请查看原文,,真格学网提供内容。

public class FutureTask<V> implements RunnableFuture<V> {
  /*
   * Revision notes: This differs from previous versions of this
   * class that relied on AbstractQueuedSynchronizer, mainly to
   * avoid surprising users about retaining interrupt status during
   * cancellation races. Sync control in the current design relies
   * on a "state" field updated via CAS to track completion, along
   * with a simple Treiber stack to hold waiting threads.
   *
   * Style note: As usual, we bypass overhead of using
   * AtomicXFieldUpdaters and instead directly use Unsafe intrinsics.
   */
  /**
   * The run state of this task, initially NEW. The run state
   * transitions to a terminal state only in methods set,
   * setException, and cancel. During completion, state may take on
   * transient values of COMPLETING (while outcome is being set) or
   * INTERRUPTING (only while interrupting the runner to satisfy a
   * cancel(true)). Transitions from these intermediate to final
   * states use cheaper ordered/lazy writes because values are unique
   * and cannot be further modified.
   *
   * Possible state transitions:
   * NEW -> COMPLETING -> NORMAL
   * NEW -> COMPLETING -> EXCEPTIONAL
   * NEW -> CANCELLED
   * NEW -> INTERRUPTING -> INTERRUPTED
   */
  private volatile int state;
  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;
  /** The underlying callable; nulled out after running */
  private Callable<V> callable;
  /** 用来存储任务执行结果或者异常对象,根据任务state在get时候选择返回执行结果还是抛出异常 */
  private Object outcome; // non-volatile, protected by state reads/writes
  /** 当前运行Run方法的线程 */
  private volatile Thread runner;
  /** Treiber stack of waiting threads */
  private volatile WaitNode waiters;
  /**
   * Returns result or throws exception for completed task.
   *
   * @param s completed state value
   */
  @SuppressWarnings("unchecked")
  private V report(int s) throws ExecutionException {
    Object x = outcome;
    if (s == NORMAL)
      return (V)x;
    if (s >= CANCELLED)
      throw new CancellationException();
    throw new ExecutionException((Throwable)x);
  }
  /**
   * Creates a {@code FutureTask} that will, upon running, execute the
   * given {@code Callable}.
   *
   * @param callable the callable task
   * @throws NullPointerException if the callable is null
   */
  public FutureTask(Callable<V> callable) {
    if (callable == null)
      throw new NullPointerException();
    this.callable = callable;
    this.state = NEW;    // ensure visibility of callable
  }
  /**
   * Creates a {@code FutureTask} that will, upon running, execute the
   * given {@code Runnable}, and arrange that {@code get} will return the
   * given result on successful completion.
   *
   * @param runnable the runnable task
   * @param result the result to return on successful completion. If
   * you don't need a particular result, consider using
   * constructions of the form:
   * {@code Future<?> f = new FutureTask<Void>(runnable, null)}
   * @throws NullPointerException if the runnable is null
   */
  public FutureTask(Runnable runnable, V result) {
    this.callable = Executors.callable(runnable, result);
    this.state = NEW;    // ensure visibility of callable
  }
  //判断任务是否已取消(异常中断、取消等)
  public boolean isCancelled() {
    return state >= CANCELLED;
  }
  /**
  判断任务是否已结束(取消、异常、完成、NORMAL都等于结束)
  **
  public boolean isDone() {
    return state != NEW;
  }
  /**
  mayInterruptIfRunning用来决定任务的状态。
          true : 任务状态= INTERRUPTING = 5。如果任务已经运行,则强行中断。如果任务未运行,那么则不会再运行
          false:CANCELLED  = 4。如果任务已经运行,则允许运行完成(但不能通过get获取结果)。如果任务未运行,那么则不会再运行
  **/
  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;
  }
  /**
   * @throws CancellationException {@inheritDoc}
   */
  public V get() throws InterruptedException, ExecutionException {
    int s = state;
    //如果任务未彻底完成,那么则阻塞直至任务完成后唤醒该线程
    if (s <= COMPLETING)
      s = awaitDone(false, 0L);
    return report(s);
  }
  /**
   * @throws CancellationException {@inheritDoc}
   */
  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);
  }
  /**
   * Protected method invoked when this task transitions to state
   * {@code isDone} (whether normally or via cancellation). The
   * default implementation does nothing. Subclasses may override
   * this method to invoke completion callbacks or perform
   * bookkeeping. Note that you can query status inside the
   * implementation of this method to determine whether this task
   * has been cancelled.
   */
  protected void done() { }
  /**
  该方法在FutureTask里只有run方法在任务完成后调用。
  主要保存任务执行结果到成员变量outcome 中,和切换任务执行状态。
  由该方法可以得知:
  COMPLETING : 任务已执行完成(也可能是异常完成),但还未设置结果到成员变量outcome中,也意味着还不能get
  NORMAL  : 任务彻底执行完成
  **/
  protected void set(V v) {
    if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
      outcome = v;
      UNSAFE.putOrderedInt(this, stateOffset, NORMAL); // final state
      finishCompletion();
    }
  }
  /**
   * Causes this future to report an {@link ExecutionException}
   * with the given throwable as its cause, unless this future has
   * already been set or has been cancelled.
   *
   * <p>This method is invoked internally by the {@link #run} method
   * upon failure of the computation.
   *
   * @param t the cause of failure
   */
  protected void setException(Throwable t) {
    if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
      outcome = t;
      UNSAFE.putOrderedInt(this, stateOffset, EXCEPTIONAL); // final state
      finishCompletion();
    }
  }
  /**
  由于实现了Runnable接口的缘故,该方法可由执行线程所调用。
  **/
  public void run() {
    //只有当任务状态=new时才被运行继续执行
    if (state != NEW ||
      !UNSAFE.compareAndSwapObject(this, runnerOffset,
                     null, Thread.currentThread()))
      return;
    try {
      Callable<V> c = callable;
      if (c != null && state == NEW) {
        V result;
        boolean ran;
        try {
          //调用Callable的Call方法
          result = c.call();
          ran = true;
        } catch (Throwable ex) {
          result = null;
          ran = false;
          setException(ex);
        }
        if (ran)
          set(result);
      }
    } finally {
      // runner must be non-null until state is settled to
      // prevent concurrent calls to run()
      runner = null;
      // state must be re-read after nulling runner to prevent
      // leaked interrupts
      int s = state;
      if (s >= INTERRUPTING)
        handlePossibleCancellationInterrupt(s);
    }
  }
  /**
  如果该任务在执行过程中不被取消或者异常结束,那么该方法不记录任务的执行结果,且不修改任务执行状态。
  所以该方法可以重复执行N次。不过不能直接调用,因为是protected权限。
  **/
  protected boolean runAndReset() {
    if (state != NEW ||
      !UNSAFE.compareAndSwapObject(this, runnerOffset,
                     null, Thread.currentThread()))
      return false;
    boolean ran = false;
    int s = state;
    try {
      Callable<V> c = callable;
      if (c != null && s == NEW) {
        try {
          c.call(); // don't set result
          ran = true;
        } catch (Throwable ex) {
          setException(ex);
        }
      }
    } finally {
      // runner must be non-null until state is settled to
      // prevent concurrent calls to run()
      runner = null;
      // state must be re-read after nulling runner to prevent
      // leaked interrupts
      s = state;
      if (s >= INTERRUPTING)
        handlePossibleCancellationInterrupt(s);
    }
    return ran && s == NEW;
  }
  /**
   * Ensures that any interrupt from a possible cancel(true) is only
   * delivered to a task while in run or runAndReset.
   */
  private void handlePossibleCancellationInterrupt(int s) {
    // It is possible for our interrupter to stall before getting a
    // chance to interrupt us. Let's spin-wait patiently.
    if (s == INTERRUPTING)
      while (state == INTERRUPTING)
        Thread.yield(); // wait out pending interrupt
    // assert state == INTERRUPTED;
    // We want to clear any interrupt we may have received from
    // cancel(true). However, it is permissible to use interrupts
    // as an independent mechanism for a task to communicate with
    // its caller, and there is no way to clear only the
    // cancellation interrupt.
    //
    // Thread.interrupted();
  }
  /**
   * Simple linked list nodes to record waiting threads in a Treiber
   * stack. See other classes such as Phaser and SynchronousQueue
   * for more detailed explanation.
   */
  static final class WaitNode {
    volatile Thread thread;
    volatile WaitNode next;
    WaitNode() { thread = Thread.currentThread(); }
  }
  /**
  该方法在任务完成(包括异常完成、取消)后调用。删除所有正在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
  }
  /**
  阻塞等待任务执行完成(中断、正常完成、超时)
  **/
  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 else的顺序也是有讲究的。
      1.先判断线程是否中断,中断则从队列中移除(也可能该线程不存在于队列中)
      2.判断当前任务是否执行完成,执行完成则不再阻塞,直接返回。
      3.如果任务状态=COMPLETING,证明该任务处于已执行完成,正在切换任务执行状态,CPU让出片刻即可
      4.q==null,则证明还未创建节点,则创建节点
      5.q节点入队
      6和7.阻塞
      **/
      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) // cannot time out yet
        Thread.yield();
      else if (q == null)
        q = new WaitNode();
      else if (!queued)
        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
        LockSupport.park(this);
    }
  }
  /**
   * Tries to unlink a timed-out or interrupted wait node to avoid
   * accumulating garbage. Internal nodes are simply unspliced
   * without CAS since it is harmless if they are traversed anyway
   * by releasers. To avoid effects of unsplicing from already
   * removed nodes, the list is retraversed in case of an apparent
   * race. This is slow when there are a lot of nodes, but we don't
   * expect lists to be long enough to outweigh higher-overhead
   * schemes.
   */
  private void removeWaiter(WaitNode node) {
    if (node != null) {
      node.thread = null;
      retry:
      for (;;) {     // restart on removeWaiter race
        for (WaitNode pred = null, q = waiters, s; q != null; q = s) {
          s = q.next;
          if (q.thread != null)
            pred = q;
          else if (pred != null) {
            pred.next = s;
            if (pred.thread == null) // check for race
              continue retry;
          }
          else if (!UNSAFE.compareAndSwapObject(this, waitersOffset,
                             q, s))
            continue retry;
        }
        break;
      }
    }
  }
  // Unsafe mechanics
  private static final sun.misc.Unsafe UNSAFE;
  private static final long stateOffset;
  private static final long runnerOffset;
  private static final long waitersOffset;
  static {
    try {
      UNSAFE = sun.misc.Unsafe.getUnsafe();
      Class<?> k = FutureTask.class;
      stateOffset = UNSAFE.objectFieldOffset
        (k.getDeclaredField("state"));
      runnerOffset = UNSAFE.objectFieldOffset
        (k.getDeclaredField("runner"));
      waitersOffset = UNSAFE.objectFieldOffset
        (k.getDeclaredField("waiters"));
    } catch (Exception e) {
      throw new Error(e);
    }
  }
}

总结

以上就是本文关于futuretask源码分析(推荐)的全部内容,希望对大家有所帮助。感兴趣的朋友可以参阅:Java利用future及时获取多线程运行结果浅谈Java多线程处理中Future的妙用(附源码)futuretask用法及使用场景介绍等,有什么问题可以随时留言,欢迎大家一起交流讨论。

中国和中东地区在气候环境、汽车法规、用车条件等方面有着本质的差异性,这也使得中东版普拉多2700在国内并不适用。NO.1【排放不达标】中东版排放不能达到国V标准,一线大城市无法上牌NO.2【机油散热慢】中东版:设置在前水箱下部,小型风冷散热器国产版:透过前格栅,设置传动器油散热器NO.3【电瓶容量低】中东版:小容量电瓶,电瓶型号:55D23L国产版:大容量电瓶,电瓶型号:80D26LNO.4【起动。防恶意抓取,请查看原文,,真格学网提供内容。

很多人对沉香的概念理解有误区,认为沉香就是简单的一种木材,基实不然,沉香的形成过程极其复杂,它是大自然造化的结晶。我已想不起最早听到“沉香”是在什么时候了,但可以肯定的是,在那之后的很长一段时间里,我都认为它只是一种木材。现在,我相信仍有很多人与我当初一样,并不完全了解沉香,有些了解沉香的人也会将其称为一种木材,因为这样说出来容易被人理解,能省去不少口舌,而如果要解释何为沉香,可并不是几句话就能说得清楚的,这样久而久之,把沉香认为是一种木头的人就越来越多了。而我由于从事这个行业,经常会被人问到到底什么是沉香,每当这时我就会说上长篇复杂的一段,以至于讲到人家听得烦,因为他们本以为我会给出个简单的当然是做球迷难。球迷也分档次,一般球迷都有自己热衷的球队和球员。只要有他们的比赛,不分白天黑夜,一定要看直播。如果没有直播,心里就会七上八下。赢了欢呼,输了沮丧。吃不好睡不好。如果是忠实的球迷,连队员的训练,生活都有关心。比赛一定要到场观看,加油。穿上“队服”,喊破喉咙。要是买不上票简直比失恋还痛苦。到异地比赛就更不用说了。虽说又难又苦,但乐此不疲,乐在其中。只有付出并无回报。股民就不一样。少则一部手机,多则几台电脑,足不出户即可完成交易。结果也很简单,赚钱和赔钱。只要善于学习,不断提高,赚钱的机会总会有的。只要心理素质好,不作为职业股民,和打麻将,下棋一样。输赢很正常。正因为做股民简单,所以


  • 本文相关:
  • futuretask用法及使用场景介绍
  • java中的runnable,callable,future,futuretask的比较
  • java多线程返回值使用示例(callable与futuretask)
  • java 使用异常的好处总结
  • java 防盗链详解及解决办法
  • 30分钟入门java8之lambda表达式学习
  • java实现软件运行时启动信息窗口的方法
  • springboot集成mqtt的实践开发
  • java中equals()方法重写实现代码
  • spring boot实战之使用jsp的示例
  • 浅谈java8中map的新方法--replace
  • 详解java利用实现对称加密(des、3des、aes)
  • 获取java的mybatis框架项目中的sqlsession的方法
  • 免责声明 - 关于我们 - 联系我们 - 广告联系 - 友情链接 - 帮助中心 - 频道导航
    Copyright © 2017 www.zgxue.com All Rights Reserved