AI 助理
文档备案控制台
开发者社区 开发与运维 文章 正文

Java:定时启动线程

2017-11-15 1096
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介：
这里提供两种在指定时间后启动线程的方法。一是通过java.util.concurrent.DelayQueue实现；二是通过java.util.concurrent.ScheduledThreadPoolExecutor实现。
1. java.util.concurrent.DelayQueue
类DelayQueue是一个无界阻塞队列，只有在延迟期满时才能从中提取元素。它接受实现Delayed接口的实例作为元素。
<<interface>>Delayed.java
package java.util.concurrent;
import java.util.*;
public  interface Delayed  extends Comparable<Delayed> {
     long getDelay(TimeUnit unit);
}
getDelay()返回与此对象相关的剩余延迟时间，以给定的时间单位表示。此接口的实现必须定义一个 compareTo 方法，该方法提供与此接口的 getDelay 方法一致的排序。

DelayQueue队列的头部是延迟期满后保存时间最长的 Delayed 元素。当一个元素的getDelay(TimeUnit.NANOSECONDS) 方法返回一个小于等于 0 的值时，将发生到期。
2.设计带有时间延迟特性的队列
类DelayedTasker维护一个DelayQueue<DelayedTask> queue，其中DelayedTask实现了Delayed接口，并由一个内部类定义。外部类和内部类都实现Runnable接口，对于外部类来说，它的run方法是按定义的时间先后取出队列中的任务，而这些任务即内部类的实例，内部类的run方法定义每个线程具体逻辑。

这个设计的实质是定义了一个具有时间特性的线程任务列表，而且该列表可以是任意长度的。每次添加任务时指定启动时间即可。
DelayedTasker.java
package com.zj.timedtask;

import  static java.util.concurrent.TimeUnit.SECONDS;
import  static java.util.concurrent.TimeUnit.NANOSECONDS;

import java.util.Collection;
import java.util.Collections;
import java.util.Random;
import java.util.concurrent.DelayQueue;
import java.util.concurrent.Delayed;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public  class DelayedTasker  implements Runnable {
    DelayQueue<DelayedTask> queue =  new DelayQueue<DelayedTask>();

     public  void addTask(DelayedTask e) {
       queue.put(e);
    }

     public  void removeTask() {
       queue.poll();
    }

     public Collection<DelayedTask> getAllTasks() {
        return Collections.unmodifiableCollection(queue);
    }

     public  int getTaskQuantity() {
        return queue.size();
    }

     public  void run() {
        while (!queue.isEmpty())
            try {
              queue.take().run();
           }  catch (InterruptedException e) {
              System.out.println("Interrupted");
           }
       System.out.println("Finished DelayedTask");
    }

     public  static  class DelayedTask  implements Delayed, Runnable {
        private  static  int counter = 0;
        private  final  int id = counter++;
        private  final  int delta;
        private  final  long trigger;

        public DelayedTask( int delayInSeconds) {
           delta = delayInSeconds;
           trigger = System.nanoTime() + NANOSECONDS.convert(delta, SECONDS);
       }

        public  long getDelay(TimeUnit unit) {
            return unit.convert(trigger - System.nanoTime(), NANOSECONDS);
       }

        public  int compareTo(Delayed arg) {
           DelayedTask that = (DelayedTask) arg;
            if (trigger < that.trigger)
               return -1;
            if (trigger > that.trigger)
               return 1;
            return 0;
       }

        public  void run() {
            //run all that you want to do
           System.out.println( this);
       }

        public String toString() {
            return "[" + delta + "s]" + "Task" + id;
       }
    }

     public  static  void main(String[] args) {
       Random rand =  new Random();
       ExecutorService exec = Executors.newCachedThreadPool();
       DelayedTasker tasker =  new DelayedTasker();
        for ( int i = 0; i < 10; i++)
           tasker.addTask( new DelayedTask(rand.nextInt(5)));
       exec.execute(tasker);
       exec.shutdown();
    }
}
结果：
[0s]Task 1
[0s]Task 2
[0s]Task 3
[1s]Task 6
[2s]Task 5
[3s]Task 8
[4s]Task 0
[4s]Task 4
[4s]Task 7
[4s]Task 9
Finished DelayedTask
3. java.util.concurrent.ScheduledThreadPoolExecutor
该类可以另行安排在给定的延迟后运行任务（线程），或者定期（重复）执行任务。在构造子中需要知道线程池的大小。最主要的方法是：

[1] schedule
public ScheduledFuture<?> schedule(Runnable command,  long delay,TimeUnit unit)
创建并执行在给定延迟后启用的一次性操作。
指定者：
-接口 ScheduledExecutorService 中的 schedule;
参数：
-command - 要执行的任务 ;
-delay - 从现在开始延迟执行的时间 ;
-unit - 延迟参数的时间单位 ;
返回：
-表示挂起任务完成的 ScheduledFuture，并且其 get() 方法在完成后将返回 null。
 
[2] scheduleAtFixedRate
public ScheduledFuture<?> scheduleAtFixedRate(
Runnable command, long initialDelay, long period,TimeUnit unit)
创建并执行一个在给定初始延迟后首次启用的定期操作，后续操作具有给定的周期；也就是将在 initialDelay 后开始执行，然后在 initialDelay+period 后执行，接着在 initialDelay + 2 * period 后执行，依此类推。如果任务的任何一个执行遇到异常，则后续执行都会被取消。否则，只能通过执行程序的取消或终止方法来终止该任务。如果此任务的任何一个执行要花费比其周期更长的时间，则将推迟后续执行，但不会同时执行。
指定者：
-接口 ScheduledExecutorService 中的 scheduleAtFixedRate;
参数：
-command - 要执行的任务 ;
-initialDelay - 首次执行的延迟时间 ;
-period - 连续执行之间的周期 ;
-unit - initialDelay 和 period 参数的时间单位 ;
返回：
-表示挂起任务完成的 ScheduledFuture，并且其 get() 方法在取消后将抛出异常。
4.设计带有时间延迟特性的线程执行者
类ScheduleTasked关联一个ScheduledThreadPoolExcutor，可以指定线程池的大小。通过schedule方法知道线程及延迟的时间，通过shutdown方法关闭线程池。对于具体任务（线程）的逻辑具有一定的灵活性（相比前一中设计，前一种设计必须事先定义线程的逻辑，但可以通过继承或装饰修改线程具体逻辑设计）。
ScheduleTasker.java
package com.zj.timedtask;

import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public  class ScheduleTasker {
     private  int corePoolSize = 10;
    ScheduledThreadPoolExecutor scheduler;

     public ScheduleTasker() {
       scheduler =  new ScheduledThreadPoolExecutor(corePoolSize);
    }

     public ScheduleTasker( int quantity) {
       corePoolSize = quantity;
       scheduler =  new ScheduledThreadPoolExecutor(corePoolSize);
    }

     public  void schedule(Runnable event,  long delay) {
       scheduler.schedule(event, delay, TimeUnit.SECONDS);
    }

     public  void shutdown() {
       scheduler.shutdown();
    }

     public  static  void main(String[] args) {
       ScheduleTasker tasker =  new ScheduleTasker();
       tasker.schedule( new Runnable() {
            public  void run() {
              System.out.println("[1s]Task 1");
           }
       }, 1);
       tasker.schedule( new Runnable() {
            public  void run() {
              System.out.println("[2s]Task 2");
           }
       }, 2);
       tasker.schedule( new Runnable() {
            public  void run() {
              System.out.println("[4s]Task 3");
           }
       }, 4);
       tasker.schedule( new Runnable() {
            public  void run() {
              System.out.println("[10s]Task 4");
           }
       }, 10);

       tasker.shutdown();
    }
}
结果：
[1s]Task 1
[2s]Task 2
[4s]Task 3

[10s]Task 4



本文转自zhangjunhd51CTO博客，原文链接：http://blog.51cto.com/zhangjunhd/74646，如需转载请自行联系原作者

文章标签：
Java
关键词：
Java线程
Java定时
定时线程
Java启动
Java定时线程
科技小先锋
目录
相关文章
凉凉心.
|
6月前
|
JSON 网络协议 安全
【Java】（10）进程与线程的关系、Tread类；讲解基本线程安全、网络编程内容；JSON序列化与反序列化
几乎所有的操作系统都支持进程的概念，进程是处于运行过程中的程序，并且具有一定的独立功能，进程是系统进行资源分配和调度的一个独立单位一般而言，进程包含如下三个特征。独立性动态性并发性。
凉凉心.
327 1
凉凉心.
|
6月前
|
JSON 网络协议 安全
【Java基础】（1）进程与线程的关系、Tread类；讲解基本线程安全、网络编程内容；JSON序列化与反序列化
几乎所有的操作系统都支持进程的概念，进程是处于运行过程中的程序，并且具有一定的独立功能，进程是系统进行资源分配和调度的一个独立单位一般而言，进程包含如下三个特征。独立性动态性并发性。
凉凉心.
327 1
小白学大数据
|
7月前
|
数据采集 存储 弹性计算
高并发Java爬虫的瓶颈分析与动态线程优化方案
高并发Java爬虫的瓶颈分析与动态线程优化方案
小白学大数据
428 1
Java 数据库 Spring
310 0
蓝易云
|
7月前
|
算法 Java
Java多线程编程：实现线程间数据共享机制
以上就是Java中几种主要处理多线程序列化资源以及协调各自独立运行但需相互配合以完成任务threads 的技术手段与策略。正确应用上述技术将大大增强你程序稳定性与效率同时也降低bug出现率因此深刻理解每项技术背后理论至关重要.
蓝易云
491 16
艾伦~耶格尔
|
8月前
|
缓存 并行计算 安全
关于Java多线程详解
本文深入讲解Java多线程编程，涵盖基础概念、线程创建与管理、同步机制、并发工具类、线程池、线程安全集合、实战案例及常见问题解决方案，助你掌握高性能并发编程技巧，应对多线程开发中的挑战。
艾伦~耶格尔
632 0
小白学大数据
|
8月前
|
数据采集 存储 前端开发
Java爬虫性能优化：多线程抓取JSP动态数据实践
Java爬虫性能优化：多线程抓取JSP动态数据实践
小白学大数据
527 0
欲揽西江月
|
9月前
|
Java API 调度
从阻塞到畅通：Java虚拟线程开启并发新纪元
从阻塞到畅通：Java虚拟线程开启并发新纪元
欲揽西江月
466 83
AI小云
|
9月前
|
安全 算法 Java
Java 多线程：线程安全与同步控制的深度解析
本文介绍了 Java 多线程开发的关键技术，涵盖线程的创建与启动、线程安全问题及其解决方案，包括 synchronized 关键字、原子类和线程间通信机制。通过示例代码讲解了多线程编程中的常见问题与优化方法，帮助开发者提升程序性能与稳定性。
AI小云
389 0
欲揽西江月
|
9月前
|
存储 Java 调度
Java虚拟线程：轻量级并发的革命性突破
Java虚拟线程：轻量级并发的革命性突破
欲揽西江月
493 83

热门文章

最新文章

  • 1
    如何降低90%Java垃圾回收时间？以阿里HBase的GC优化实践为例
  • 2
    【Java每日一题】——第三十四题：设计一个学生类Student和它的一个子类Undergraduate
  • 3
    阿里云自然语言处理--中心词提取（中文）Java SDK 调用示例
  • 4
    MessagePack Java Jackson Dataformat 在 Map 中不使用 String 为 Key 的序列化
  • 5
    java面试题：写代码使得分别出现StackOverflowError和OutOfMemoryError
  • 6
    Java开发中PO、VO、DAO、BO、DTO、POJO 含义
  • 7
    Java小游戏程序打包成exe文件
  • 8
    Java入门系列-05-数据类型和类型转换
  • 9
    Java与.NET的WebServices相互调用
  • 10
    JniHelper调用java静态和非静态方法总结(即cocos2dx中调用android平台下显示第三方广告)
  • 1
    深入理解Java并发编程：线程安全与性能优化移动应用开发的未来：跨平台框架与原生操作系统的融合
    477
  • 2
    从C语言到C++_40(多线程相关)C++线程接口+线程安全问题加锁(shared_ptr+STL+单例)（下）
    259
  • 3
    从C语言到C++_40(多线程相关)C++线程接口+线程安全问题加锁(shared_ptr+STL+单例)（中）
    504
  • 4
    从C语言到C++_40(多线程相关)C++线程接口+线程安全问题加锁(shared_ptr+STL+单例)（上）
    304
  • 5
    Java多线程基础-6：线程安全问题及解决措施，synchronized关键字与volatile关键字（一）
    354
  • 6
    Java多线程基础-18：线程安全的集合类与ConcurrentHashMap
    920
  • 7
    Java 多线程系列Ⅶ（线程安全集合类）
    388
  • 8
    Java 多线程系列Ⅳ（单例模式+阻塞式队列+定时器+线程池）
    322
  • 9
    Java 多线程系列Ⅰ（创建线程+查看线程+Thread方法+线程状态）
    242
  • 10
    进程与线程（概念、并行、并发）
    410

    • 相关课程

    更多
  • Java面试疑难点解析 - 面试技巧及语言基础
  • Java面试疑难点解析 - Java Web开发
  • Java面试疑难点解析 - 系统架构及项目设计
  • Java编程入门
  • Java面向对象编程
  • Java高级编程

    • 相关电子书

    更多
  • Spring Cloud Alibaba - 重新定义 Java Cloud-Native
  • The Reactive Cloud Native Arch
  • JAVA开发手册1.5.0
    • 下一篇
    阿里云重磅新品：Agent安全中心，全新安全框架下AI Agent一体化防御平台