使用java.util.concurrent包编写一个延时执行的任务

package com.letv.lazybox.task;
/**
     若干参赛者参加竞走比赛,每组比赛有规定不同的全程米数,总赛时长;运动员若在规定赛时未跑完全程则出局

*/
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Iterator;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class TaskContraller {

    public static void main(String[] args) {
        //初始化
        ConcurrentHashMap<String, WalkingTask> walktaskmap = new ConcurrentHashMap<String, WalkingTask>();
        Player tom = new Player("Tom", 1000, 2000, 20);
        Player kitty = new Player("kitty", 800, 3000, 10);
        walktaskmap.put("Tom", new WalkingTask(tom));
        walktaskmap.put("kitty", new WalkingTask(kitty));

        System.out.println(new SimpleDateFormat("HH:mm:ss").format(new Date(
                System.currentTimeMillis())));
         //定义一个容量为50个线程的线程池
          final ScheduledExecutorService pool = Executors
                .newScheduledThreadPool(50);

        Iterator<String> ite = walktaskmap.keySet().iterator();
        while (ite.hasNext()) {
            String name = ite.next();
            WalkingTask walkingTask = walktaskmap.get(name);
            System.out.println(name + " is ready to walking...!");
            //立即执行任务,开始比赛
            pool.execute(walkingTask);
            //延时执行任务,停止比赛
            StopTask stopTask = new StopTask(walktaskmap, name);
            pool.schedule(stopTask, walkingTask.getPlayer().getTotalSeconds(),
                    TimeUnit.SECONDS);
        }

        System.out.println("main thread....");
    }
}
/**
   竞走任务类
*/
class WalkingTask implements Runnable {
    private boolean isStop = false;  //比赛是否停止
    private Player player;//参赛运动员信息

    public boolean isStop() {
        return this.isStop;
    }

    public void setStop(boolean isStop) {
        this.isStop = isStop;
    }

    public Player getPlayer() {
        return this.player;
    }

    public void setPlayer(Player player) {
        this.player = player;
    }

    public WalkingTask(Player player) {
        // TODO Auto-generated constructor stub
        this.player = player;
    }

    @Override
    public void run() {
        for (int i = 0; i <= this.player.getMeters(); i++) {
            if (this.isStop) {
                break;
            }
            System.out.println(this.player.getName() + " run:" + i + " m!");
            try {
                Thread.sleep(this.player.getMillsecond());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

/**
 中止比赛任务类
*/
class StopTask implements Runnable {
    private final String key; //被中止的运动员姓名
    private final ConcurrentHashMap<String, WalkingTask> mytasks;

    public StopTask(ConcurrentHashMap<String, WalkingTask> mytasks, String name) {
        this.mytasks = mytasks;
        this.key = name;
    }

    @Override
    public void run() {
        this.mytasks.get(this.key).setStop(true);
        String endTime = new SimpleDateFormat("HH:mm:ss").format(new Date(
                System.currentTimeMillis()));
        System.out.println("[ " + this.key + "] GAME OVER ! EndTime ="
                + endTime);
    }
}

/**
运动员信息类
*/
class Player {
    private String name;//姓名
    private int meters;//参赛里程
    private int millsecond;//该运动员平均每跑一米用时
    private int totalSeconds;//总赛时

    public Player(String name, int meters, int millsecond, int totalSeconds) {
        this.name = name;
        this.meters = meters;
        this.millsecond = millsecond;
        this.totalSeconds = totalSeconds;

    }

    public String getName() {
        return this.name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getMeters() {
        return this.meters;
    }

    public void setMeters(int meters) {
        this.meters = meters;
    }

    public int getMillsecond() {
        return this.millsecond;
    }

    public void setMillsecond(int millsecond) {
        this.millsecond = millsecond;
    }

    public int getTotalSeconds() {
        return this.totalSeconds;
    }

    public void setTotalSeconds(int totalSeconds) {
        this.totalSeconds = totalSeconds;
    }

}

时间: 2024-10-12 22:55:07

使用java.util.concurrent包编写一个延时执行的任务的相关文章

《java.util.concurrent 包源码阅读》14 线程池系列之ScheduledThreadPoolExecutor 第一部分

ScheduledThreadPoolExecutor是ThreadPoolExecutor的子类,同时实现了ScheduledExecutorService接口. public class ScheduledThreadPoolExecutor extends ThreadPoolExecutor implements ScheduledExecutorService ScheduledThreadPoolExecutor的功能主要有两点:在固定的时间点执行(也可以认为是延迟执行),重复执行.

《java.util.concurrent 包源码阅读》13 线程池系列之ThreadPoolExecutor 第三部分

这一部分来说说线程池如何进行状态控制,即线程池的开启和关闭. 先来说说线程池的开启,这部分来看ThreadPoolExecutor构造方法: public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory, RejectedExecut

《java.util.concurrent 包源码阅读》06 ArrayBlockingQueue

对于BlockingQueue的具体实现,主要关注的有两点:线程安全的实现和阻塞操作的实现.所以分析ArrayBlockingQueue也是基于这两点. 对于线程安全来说,所有的添加元素的方法和拿走元素的方法都会涉及到,我们通过分析offer方法和poll()方法就能看出线程安全是如何实现的. 首先来看offer方法 public boolean offer(E e) { checkNotNull(e); final ReentrantLock lock = this.lock; lock.lo

《java.util.concurrent 包源码阅读》 结束语

<java.util.concurrent 包源码阅读>系列文章已经全部写完了.开始的几篇文章是根据自己的读书笔记整理出来的(当时只阅读了部分的源代码),后面的大部分都是一边读源代码代码,一边写文章. 由于水平有限,在阅读源代码的时候,分析得也比较浅显,也有很多地方自己也没有研究明白,文章有的地方显得语焉不详,只能请各位多多见谅了. 后面会继续写一些关于Java并发编程的文章,希望各位多多指教. 这里整理了一个简单的目录,包含了本系列所有文章的链接: <java.util.concurr

《java.util.concurrent 包源码阅读》05 BlockingQueue

想必大家都很熟悉生产者-消费者队列,生产者负责添加元素到队列,如果队列已满则会进入阻塞状态直到有消费者拿走元素.相反,消费者负责从队列中拿走元素,如果队列为空则会进入阻塞状态直到有生产者添加元素到队列.BlockingQueue就是这么一个生产者-消费者队列. BlockingQueue是Queue的子接口 public interface BlockingQueue<E> extends Queue<E> BlockingQueue拿走元素时,如果队列为空,阻塞等待会有两种情况:

java.util.concurrent包

在JavaSE5中,JUC(java.util.concurrent)包出现了 在java.util.concurrent包及其子包中,有了很多好玩的新东西: 1.执行器的概念和线程池的实现.Executor.ExecutorService框架 从Executor接口开始,到ExecutorService,再到很多基于ThreadPoolExecutor实现的具体执行器.执行器实际上是采用了一种叫做命令模式的设计,将任务Runnable和具体执行线程相分离,并给出了生命周期等管理方法,一般只要e

《java.util.concurrent 包源码阅读》10 线程池系列之AbstractExecutorService

AbstractExecutorService对ExecutorService的执行任务类型的方法提供了一个默认实现.这些方法包括submit,invokeAny和InvokeAll. 注意的是来自Executor接口的execute方法是未被实现,execute方法是整个体系的核心,所有的任务都是在这个方法里被真正执行的,因此该方法的不同实现会带来不同的执行策略.这个在后面分析ThreadPoolExecutor和ScheduledThreadPoolExecutor就能看出来. 首先来看su

《java.util.concurrent 包源码阅读》03 锁

Condition接口 应用场景:一个线程因为某个condition不满足被挂起,直到该Condition被满足了. 类似与Object的wait/notify,因此Condition对象应该是被多线程共享的,需要使用锁保护其状态的一致性 示例代码: class BoundedBuffer { final Lock lock = new ReentrantLock(); final Condition notFull = lock.newCondition(); final Condition

《java.util.concurrent 包源码阅读》02 关于java.util.concurrent.atomic包

Aomic数据类型有四种类型:AomicBoolean, AomicInteger, AomicLong, 和AomicReferrence(针对Object的)以及它们的数组类型, 还有一个特殊的AomicStampedReferrence,它不是AomicReferrence的子类,而是利用AomicReferrence实现的一个储存引用和Integer组的扩展类 首先,所有原子操作都是依赖于sun.misc.Unsafe这个类,这个类底层是由C++实现的,利用指针来实现数据操作 关于CAS