博客
关于我
强烈建议你试试无所不能的chatGPT，快点击我
并发编程（十五）——定时器 ScheduledThreadPoolExecutor 实现原理与源码深度解析...
阅读量：7099 次
发布时间：2019-06-28

本文共 18365 字，大约阅读时间需要 61 分钟。

在上一篇线程池的文章中从ThreadPoolExecutor源码分析了其运行机制。限于篇幅，留下了ScheduledThreadPoolExecutor未做分析，因此本文继续从源代码出发分析ScheduledThreadPoolExecutor的内部原理。

类声明

1 public class ScheduledThreadPoolExecutor2         extends ThreadPoolExecutor3         implements ScheduledExecutorService {

ScheduledThreadPoolExecutor继承了ThreadPoolExecutor，实现了ScheduledExecutorService。因此它具有ThreadPoolExecutor的所有能力。所不同的是它具有定时执行，以周期或间隔循环执行任务等功能。

这里我们先看下ScheduledExecutorService的源码：

ScheduledExecutorService

1 //可调度的执行者服务接口 2 public interface ScheduledExecutorService extends ExecutorService { 3  4     //指定时延后调度执行任务，只执行一次，没有返回值 5     public ScheduledFuture
      schedule(Runnable command, 6                                        long delay, TimeUnit unit); 7  8     //指定时延后调度执行任务，只执行一次，有返回值 9     public 
     
       ScheduledFuture
      
        schedule(Callable
       
         callable,10                                            long delay, TimeUnit unit);11 12     //指定时延后开始执行任务，以后每隔period的时长再次执行该任务13     public ScheduledFuture
         scheduleAtFixedRate(Runnable command,14                                                   long initialDelay,15                                                   long period,16                                                   TimeUnit unit);17 18     //指定时延后开始执行任务，以后任务执行完成后等待delay时长，再次执行任务19     public ScheduledFuture
         scheduleWithFixedDelay(Runnable command,20                                                      long initialDelay,21                                                      long delay,22                                                      TimeUnit unit);23 }

其中schedule方法用于单次调度执行任务。这里主要理解下后面两个方法。

  • scheduleAtFixedRate：该方法在initialDelay时长后第一次执行任务，以后每隔period时长，再次执行任务。注意，period是从任务开始执行算起的。开始执行任务后，定时器每隔period时长检查该任务是否完成，如果完成则再次启动任务，否则等该任务结束后才再次启动任务，看下图示例

  • scheduleWithFixDelay：该方法在initialDelay时长后第一次执行任务，以后每当任务执行完成后，等待delay时长，再次执行任务，看下图示例。

使用例子

1、schedule(Runnable command,long delay, TimeUnit unit)

1 /** 2  * @author: ChenHao 3  * @Date: Created in 14:54 2019/1/11 4  */ 5 public class Test1 { 6     public static void main(String[] args) throws ExecutionException, InterruptedException { 7         // 延迟1s后开始执行，只执行一次，没有返回值 8         ScheduledExecutorService executorService = new ScheduledThreadPoolExecutor(10); 9         ScheduledFuture
      result = executorService.schedule(new Runnable() {10             @Override11             public void run() {12                 System.out.println("gh");13                 try {14                     Thread.sleep(3000);15                 } catch (InterruptedException e) {16                     // TODO Auto-generated catch block17                     e.printStackTrace();18                 }19             }20         }, 1000, TimeUnit.MILLISECONDS);21         System.out.println(result.get());22     }23 }

运行结果：

 

2、schedule(Callable<V> callable, long delay, TimeUnit unit);

1 public class Test2 { 2     public static void main(String[] args) throws ExecutionException, InterruptedException { 3         // 延迟1s后开始执行，只执行一次，有返回值 4         ScheduledExecutorService executorService = new ScheduledThreadPoolExecutor(10); 5         ScheduledFuture
     
       result = executorService.schedule(new Callable
      
       () { 6             @Override 7             public String call() throws Exception { 8                 try { 9                     Thread.sleep(3000);10                 } catch (InterruptedException e) {11                     // TODO Auto-generated catch block12                     e.printStackTrace();13                 }14                 return "ghq";15             }16         }, 1000, TimeUnit.MILLISECONDS);17         // 阻塞，直到任务执行完成18         System.out.print(result.get());19     }20 }

运行结果：

 

3、scheduleAtFixedRate

1 /** 2  * @author: ChenHao 3  * @Date: Created in 14:54 2019/1/11 4  */ 5 public class Test3 { 6     public static void main(String[] args) throws ExecutionException, InterruptedException { 7         ScheduledExecutorService executorService = new ScheduledThreadPoolExecutor(10); 8         // 从加入任务开始算1s后开始执行任务，1+2s开始执行，1+2*2s执行，1+n*2s开始执行； 9         // 但是如果执行任务时间大于2s则不会并发执行后续任务,当前执行完后,接着执行下次任务。10         ScheduledFuture
      result = executorService.scheduleAtFixedRate(new Runnable() {11             @Override12             public void run() {13                 System.out.println(System.currentTimeMillis());14             }15         }, 1000, 2000, TimeUnit.MILLISECONDS);16     }17 }

运行结果：

 

4、scheduleWithFixedDelay

1 /** 2  * @author: ChenHao 3  * @Date: Created in 14:54 2019/1/11 4  */ 5 public class Test4 { 6     public static void main(String[] args) throws ExecutionException, InterruptedException { 7         //任务间以固定时间间隔执行，延迟1s后开始执行任务，任务执行完毕后间隔2s再次执行，任务执行完毕后间隔2s再次执行，依次往复 8         ScheduledExecutorService executorService = new ScheduledThreadPoolExecutor(10); 9         ScheduledFuture
      result = executorService.scheduleWithFixedDelay(new Runnable() {10             @Override11             public void run() {12                 System.out.println(System.currentTimeMillis());13             }14         }, 1000, 2000, TimeUnit.MILLISECONDS);15 16         // 由于是定时任务，一直不会返回17         result.get();18         System.out.println("over");19     }20 }

运行结果：

源码分析

构造器

1 public ScheduledThreadPoolExecutor(int corePoolSize) {2        super(corePoolSize, Integer.MAX_VALUE, 0, TimeUnit.NANOSECONDS,3              new DelayedWorkQueue());4 }

 

 内部其实都是调用了父类ThreadPoolExecutor的构造器，因此它具有ThreadPoolExecutor的所有能力。

 通过super方法的参数可知，核心线程的数量即传入的参数，而线程池的线程数为Integer.MAX_VALUE，几乎为无上限。

 这里采用了DelayedWorkQueue任务队列，也是定时任务的核心，是一种优先队列，时间小的排在前面，所以获取任务的时候就能先获取到时间最小的执行，可以看我上篇文章《》。

 由于这里队列没有定义大小，所以队列不会添加满，因此最大的线程数就是核心线程数，超过核心线程数的任务就放在队列里，并不重新开启临时线程。

我们先来看看几个入口方法的实现：

1 public ScheduledFuture
      schedule(Runnable command, 2                                    long delay, 3                                    TimeUnit unit) { 4     if (command == null || unit == null) 5         throw new NullPointerException(); 6     RunnableScheduledFuture
      t = decorateTask(command, 7         new ScheduledFutureTask
     
      (command, null, 8                                       triggerTime(delay, unit))); 9     delayedExecute(t);10     return t;11 }12 13 public 
      
        ScheduledFuture
       
         schedule(Callable
        
          callable,14                                        long delay,15                                        TimeUnit unit) {16     if (callable == null || unit == null)17         throw new NullPointerException();18     RunnableScheduledFuture
         
           t = decorateTask(callable,19         new ScheduledFutureTask
          
           (callable,20 triggerTime(delay, unit)));21 delayedExecute(t);22 return t;23 }24 25 public ScheduledFuture
            scheduleAtFixedRate(Runnable command,26 long initialDelay,27 long period,28 TimeUnit unit) {29 if (command == null || unit == null)30 throw new NullPointerException();31 if (period <= 0)32 throw new IllegalArgumentException();33 ScheduledFutureTask
           
             sft =34 new ScheduledFutureTask
            
             (command,35 null,36 triggerTime(initialDelay, unit),37 unit.toNanos(period));38 RunnableScheduledFuture
             
               t = decorateTask(command, sft);39 sft.outerTask = t;40 delayedExecute(t);41 return t;42 }43 44 public ScheduledFuture
               scheduleWithFixedDelay(Runnable command,45 long initialDelay,46 long delay,47 TimeUnit unit) {48 if (command == null || unit == null)49 throw new NullPointerException();50 if (delay <= 0)51 throw new IllegalArgumentException();52 ScheduledFutureTask
              
                sft =53 new ScheduledFutureTask
               
                (command,54 null,55 triggerTime(initialDelay, unit),56 unit.toNanos(-delay));57 RunnableScheduledFuture
                
                  t = decorateTask(command, sft);58 sft.outerTask = t;59 delayedExecute(t);60 return t;61 }

 

 这几个方法都是将任务封装成了ScheduledFutureTask，上面做的首先把runnable装饰为delay队列所需要的格式的元素，然后把元素加入到阻塞队列，然后线程池线程会从阻塞队列获取超时的元素任务进行处理，下面看下队列元素如何实现的。

ScheduledFutureTask

ScheduledFutureTask是一个延时定时任务，它可以返回任务剩余延时时间，可以被周期性地执行。

属性

1 private class ScheduledFutureTask
     
       2         extends FutureTask
      
        implements RunnableScheduledFuture
       
         { 3         /** 是一个序列，每次创建任务的时候，都会自增。 */ 4         private final long sequenceNumber; 5  6         /** 任务能够开始执行的时间 */ 7         private long time; 8  9         /**10          * 任务周期执行的时间11          * 0表示不是一个周期定时任务12          * 正数表示固定周期时间去执行任务13          * 负数表示任务完成之后，延时period时间再去执行任务14          */15         private final long period;16 17         /** 表示再次执行的任务，在reExecutePeriodic中调用 */18         RunnableScheduledFuture
        
          outerTask = this;19 20         /**21          * 表示在任务队列中的索引位置，用来支持快速从队列中删除任务。22          */23         int heapIndex;24 }

ScheduledFutureTask继承了 FutureTask 和 RunnableScheduledFuture

属性说明：

  1. sequenceNumber: 是一个序列，每次创建任务的时候，都会自增。
  2. time: 任务能够开始执行的时间。
  3. period: 任务周期执行的时间。0表示不是一个周期定时任务。
  4. outerTask: 表示再次执行的任务，在reExecutePeriodic中调用
  5. heapIndex: 表示在任务队列中的索引位置，用来支持快速从队列中删除任务。

构造器

  • 创建延时任务

1 /** 2  * 创建延时任务 3  */ 4 ScheduledFutureTask(Runnable r, V result, long ns) { 5     // 调用父类的方法 6     super(r, result); 7     // 任务开始的时间 8     this.time = ns; 9     // period是0，不是一个周期定时任务10     this.period = 0;11     // 每次创建任务的时候，sequenceNumber都会自增12     this.sequenceNumber = sequencer.getAndIncrement();13 }14 15  /**16  * 创建延时任务17  */18 ScheduledFutureTask(Callable
     
       callable, long ns) {19     // 调用父类的方法20     super(callable);21     // 任务开始的时间22     this.time = ns;23     // period是0，不是一个周期定时任务24     this.period = 0;25     // 每次创建任务的时候，sequenceNumber都会自增26     this.sequenceNumber = sequencer.getAndIncrement();27 }

 我们看看super()，其实就是FutureTask 里面的构造方法，关于FutureTask 可以看看我之前的文章《》

1 public FutureTask(Runnable runnable, V result) { 2     this.callable = Executors.callable(runnable, result); 3     this.state = NEW;       // ensure visibility of callable 4 } 5 public FutureTask(Callable
     
       callable) { 6     if (callable == null) 7         throw new NullPointerException(); 8     this.callable = callable; 9     this.state = NEW;       // ensure visibility of callable10 }
  • 创建延时定时任务
1 /** 2  * 创建延时定时任务 3  */ 4 ScheduledFutureTask(Runnable r, V result, long ns, long period) { 5     // 调用父类的方法 6     super(r, result); 7     // 任务开始的时间 8     this.time = ns; 9     // 周期定时时间10     this.period = period;11     // 每次创建任务的时候，sequenceNumber都会自增12     this.sequenceNumber = sequencer.getAndIncrement();13 }

延时定时任务不同的是设置了period，后面通过判断period是否为0来确定是否是定时任务。

run()

1 public void run() { 2     // 是否是周期任务 3     boolean periodic = isPeriodic(); 4     // 如果不能在当前状态下运行，那么就要取消任务 5     if (!canRunInCurrentRunState(periodic)) 6         cancel(false); 7     // 如果只是延时任务，那么就调用run方法，运行任务。 8     else if (!periodic) 9         ScheduledFutureTask.super.run();10     // 如果是周期定时任务，调用runAndReset方法，运行任务。11     // 这个方法不会改变任务的状态，所以可以反复执行。12     else if (ScheduledFutureTask.super.runAndReset()) {13         // 设置周期任务下一次执行的开始时间time14         setNextRunTime();15         // 重新执行任务outerTask16         reExecutePeriodic(outerTask);17     }18 }

这个方法会在ThreadPoolExecutor的runWorker方法中调用，而且这个方法调用，说明肯定已经到了任务的开始时间time了。这个方法我们待会会再继续来回看一下

  1. 先判断当前线程状态能不能运行任务，如果不能，就调用cancel()方法取消本任务。
  2. 如果任务只是一个延时任务，那么调用父类的run()运行任务，改变任务的状态，表示任务已经运行完成了。
  3. 如果任务只是一个周期定时任务，那么就任务必须能够反复执行，那么就不能调用run()方法，它会改变任务的状态。而是调用runAndReset()方法，只是简单地运行任务，而不会改变任务状态。
  4. 设置周期任务下一次执行的开始时间time，并重新执行任务。

schedule(Runnable command, long delay,TimeUnit unit)

1 public ScheduledFuture
      schedule(Runnable command, 2                                   long delay, 3                                   TimeUnit unit) { 4    if (command == null || unit == null) 5        throw new NullPointerException(); 6  7    //装饰任务，主要实现public long getDelay(TimeUnit unit)和int compareTo(Delayed other)方法 8    RunnableScheduledFuture
      t = decorateTask(command, 9        new ScheduledFutureTask
     
      (command, null,10                                      triggerTime(delay, unit)));11    //添加任务到延迟队列12    delayedExecute(t);13    return t;14 }

 获取延时执行时间

1 private long triggerTime(long delay, TimeUnit unit) { 2     return triggerTime(unit.toNanos((delay < 0) ? 0 : delay)); 3 } 4  5 /** 6  * Returns the trigger time of a delayed action. 7  */ 8 long triggerTime(long delay) { 9     //当前时间加上延时时间10     return now() +11         ((delay < (Long.MAX_VALUE >> 1)) ? delay : overflowFree(delay));12 }

上述的decorateTask方法把Runnable任务包装成ScheduledFutureTask，用户可以根据自己的需要覆写该方法：

1 protected 
     
       RunnableScheduledFuture
      
        decorateTask(Runnable runnable, RunnableScheduledFuture
       
         task) {2     return task;3 }

schedule的核心是其中的delayedExecute方法：

1 private void delayedExecute(RunnableScheduledFuture
      task) { 2     if (isShutdown())   // 线程池已关闭 3         reject(task);   // 任务拒绝策略 4     else { 5         //将任务添加到任务队列，会根据任务延时时间进行排序 6         super.getQueue().add(task); 7         // 如果线程池状态改变了，当前状态不能运行任务，那么就尝试移除任务， 8         // 移除成功，就取消任务。 9         if (isShutdown() && !canRunInCurrentRunState(task.isPeriodic()) && remove(task))10             task.cancel(false);  // 取消任务11         else12             // 预先启动工作线程，确保线程池中有工作线程。13             ensurePrestart();14     }15 }

这个方法的主要作用就是将任务添加到任务队列中，因为这里任务队列是优先级队列DelayedWorkQueue，它会根据任务的延时时间进行排序。

  • 如果线程池不是RUNNING状态，不能执行延时任务task，那么调用reject(task)方法，拒绝执行任务task。

  • 将任务添加到任务队列中，会根据任务的延时时间进行排序。

  • 因为是多线程并发环境，就必须判断在添加任务的过程中，线程池状态是否被别的线程更改了，那么就可能要取消任务了。

  • 将任务添加到任务队列后，还要确保线程池中有工作线程，不然任务也不为执行。所以ensurePrestart()方法预先启动工作线程，确保线程池中有工作线程。

1 void ensurePrestart() { 2     // 线程池中的线程数量 3     int wc = workerCountOf(ctl.get()); 4     // 如果小于核心池数量，就创建新的工作线程 5     if (wc < corePoolSize) 6         addWorker(null, true); 7     // 说明corePoolSize数量是0，必须创建一个工作线程来执行任务 8     else if (wc == 0) 9         addWorker(null, false);10 }

通过ensurePrestart可以看到，如果核心线程池未满，则新建的工作线程会被放到核心线程池中。如果核心线程池已经满了，ScheduledThreadPoolExecutor不会像ThreadPoolExecutor那样再去创建归属于非核心线程池的工作线程，加入到队列就完了，等待核心线程执行完任务再拉取队列里的任务。也就是说，在ScheduledThreadPoolExecutor中，一旦核心线程池满了，就不会再去创建工作线程。

这里思考一点，什么时候会执行else if (wc == 0)创建一个归属于非核心线程池的工作线程？

答案是，当通过setCorePoolSize方法设置核心线程池大小为0时，这里必须要保证任务能够被执行，所以会创建一个工作线程，放到非核心线程池中。

看到 addWorker(null, true); 并没有将任务设置进入，而是设置的null, 则说明线程池里线程第一次启动时， runWorker中取到的 firstTask为null,需要通过 getTask() 从队列中取任务，这里可以看看我之前写的关于线程池的文章《》。

getTask()中  Runnable r = timed ? workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :workQueue.take();如果是存在核心线程则调用take()，如果传入的核心线程为0，则存在一个临时线程，调用poll()，这两个方法都会先获取时间，看看有没有达到执行时间，没有达到执行时间则阻塞，可以看看我上一篇文章，达到执行时间，则取到任务，就会执行下面的run方法。

1 public void run() { 2     // 是否是周期任务 3     boolean periodic = isPeriodic(); 4     // 如果不能在当前状态下运行，那么就要取消任务 5     if (!canRunInCurrentRunState(periodic)) 6         cancel(false); 7     // 如果只是延时任务，那么就调用run方法，运行任务。 8     else if (!periodic) 9         ScheduledFutureTask.super.run();10     // 如果是周期定时任务，调用runAndReset方法，运行任务。11     // 这个方法不会改变任务的状态，所以可以反复执行。12     else if (ScheduledFutureTask.super.runAndReset()) {13         // 设置周期任务下一次执行的开始时间time14         setNextRunTime();15         // 重新执行任务outerTask16         reExecutePeriodic(outerTask);17     }18 }19 20 public boolean isPeriodic() {21     return period != 0;22 }

 schedule不是周期任务，那么调用父类的run()运行任务，改变任务的状态，表示任务已经运行完成了。

scheduleAtFixedRate(Runnable command,long initialDelay,long period,TimeUnit unit)

1 public ScheduledFuture
      scheduleAtFixedRate(Runnable command, 2                                              long initialDelay, 3                                              long period, 4                                              TimeUnit unit) { 5    if (command == null || unit == null) 6        throw new NullPointerException(); 7    if (period <= 0) 8        throw new IllegalArgumentException(); 9    //装饰任务类，注意period=period>0，不是负的10    ScheduledFutureTask
     
       sft =11        new ScheduledFutureTask
      
       (command,12                                      null,13                                      triggerTime(initialDelay, unit),14                                      unit.toNanos(period));15    RunnableScheduledFuture
       
         t = decorateTask(command, sft);16    sft.outerTask = t;17    //添加任务到队列18    delayedExecute(t);19    return t;20 }

如果是周期任务则执行上面run()方法中的第12行，调用父类中的runAndReset（），这个方法同run方法比较的区别是call方法执行后不设置结果，因为周期型任务会多次执行，所以为了让FutureTask支持这个特性除了发生异常不设置结果。

执行完任务后通过setNextRunTime方法计算下一次启动时间:

1 private void setNextRunTime() { 2    long p = period; 3   //period=delay; 4    if (p > 0) 5        time += p;//由于period>0所以执行这里，设置time=time+delay 6    else 7        time = triggerTime(-p); 8 } 9 10 long triggerTime(long delay) {11     return now() +12         ((delay < (Long.MAX_VALUE >> 1)) ? delay : overflowFree(delay));13 }

scheduleAtFixedRate会执行到情况一，下一次任务的启动时间最早为上一次任务的启动时间加period。

scheduleWithFixedDelay会执行到情况二，这里很巧妙的将period参数设置为负数到达这段代码块，在此又将负的period转为正数。情况二将下一次任务的启动时间设置为当前时间加period。

然后将任务再次添加到任务队列:

1 /** 2  * 重新执行任务task 3  */ 4 void reExecutePeriodic(RunnableScheduledFuture
        task) { 5     // 判断当前线程池状态能不能运行任务 6     if (canRunInCurrentRunState(true)) { 7         // 将任务添加到任务队列，会根据任务延时时间进行排序 8         super.getQueue().add(task); 9         // 如果线程池状态改变了，当前状态不能运行任务，那么就尝试移除任务，10         // 移除成功，就取消任务。11         if (!canRunInCurrentRunState(true) && remove(task))12             task.cancel(false);13         else14             // 预先启动工作线程，确保线程池中有工作线程。15             ensurePrestart();16     }17 }

这个方法与delayedExecute方法很像，都是将任务添加到任务队列中。

  1. 如果当前线程池状态能够运行任务，那么任务添加到任务队列。
  2. 如果在在添加任务的过程中，线程池状态是否被别的线程更改了，那么就要进行判断，是否需要取消任务。
  3. 调用ensurePrestart()方法，预先启动工作线程，确保线程池中有工作线程。

ScheduledFuture的get方法

既然ScheduledFuture的实现是ScheduledFutureTask，而ScheduledFutureTask继承自FutureTask，所以ScheduledFuture的get方法的实现就是FutureTask的get方法的实现，FutureTask的get方法的实现分析在ThreadPoolExecutor篇已经写过，这里不再叙述。要注意的是ScheduledFuture的get方法对于非周期任务才是有效的。

推荐博客

　　

ScheduledThreadPoolExecutor总结

  • ScheduledThreadPoolExecutor是实现自ThreadPoolExecutor的线程池，构造方法中传入参数n，则最多会有n个核心线程工作，空闲的核心线程不会被自动终止,而是一直阻塞在DelayedWorkQueue的take方法尝试获取任务。构造方法传入的参数为0，ScheduledThreadPoolExecutor将以非核心线程工作，并且最多只会创建一个非核心线程，参考上文中ensurePrestart方法的执行过程。而这个非核心线程以poll方法获取定时任务之所以不会因为超时就被回收，是因为任务队列并不为空，只有在任务队列为空时才会将空闲线程回收，详见ThreadPoolExecutor篇的runWorker方法,之前我以为空闲的非核心线程超时就会被回收是不正确的,还要具备任务队列为空这个条件。

  • ScheduledThreadPoolExecutor的定时执行任务依赖于DelayedWorkQueue，其内部用可扩容的数组实现以启动时间升序的二叉树。

  • 工作线程尝试获取DelayedWorkQueue的任务只有在任务到达指定时间才会成功，否则非核心线程会超时返回null，核心线程一直阻塞。

  • 对于非周期型任务只会执行一次并且可以通过ScheduledFuture的get方法阻塞得到结果，其内部实现依赖于FutureTask的get方法。

  • 周期型任务通过get方法无法获取有效结果，因为FutureTask对于周期型任务执行的是runAndReset方法，并不会设置结果。周期型任务执行完毕后会重新计算下一次启动时间并且再次添加到DelayedWorkQueue中。

转载于:https://www.cnblogs.com/java-chen-hao/p/10283413.html

你可能感兴趣的文章
localStorage
查看>>
循环中的异步&&循环中的闭包
查看>>
外墙清洗机器人现身多幢大楼，清洗前后泾渭分明！
查看>>
算法与数据结构之枚举算法
查看>>
为什么Python发展这么快，有哪些优势？
查看>>
sublime-text3 安装 emmet 插件
查看>>
Promise 的then 里发生了什么
查看>>
【跃迁之路】【719天】程序员高效学习方法论探索系列（实验阶段476-2019.2.9）...
查看>>
微信小程序--------语音识别（前端自己也能玩）
查看>>
JS每日一题：什么情况下适合使合vuex？Vuex使用中有几个步骤？
查看>>
Data Lake Analytics: 以SQL方式查询Redis数据
查看>>
Salesforce和SAP Netweaver里数据库表的元数据设计
查看>>
原生js + css3 + 定时器 无缝轮播图（部分）
查看>>
CNCF案例研究：VSCO
查看>>
表单密码自动填充hack
查看>>
217. Contains Duplicate
查看>>
聊聊flink JobManager的High Availability
查看>>
Tensorflow源码解析3 -- TensorFlow核心对象 - Graph
查看>>
Redis哨兵机制
查看>>
【手牵手】搭建前端组件库（二）
查看>>
喝酒易醉，品茶养心，人生如梦，品茶悟道，何以解忧？唯有杜康！-- 愿君每日到此一游！
当前时间: 2025-02-08 19:09:07   当前IP: 3.17.165.204   联系邮箱:javaeecc@qq.com     Copyright © 2020 - 2022 baihongyu.com 京ICP备2021015314号-2
强烈建议你试试无所不能的CHAT-GPT，快点击我
强烈建议你试试无所不能的CHAT-GPT，快点击我