Java并发编程:Callable、Future和FutureTask 实现龟兔赛跑

1、不清楚的看博客http://www.cnblogs.com/dolphin0520/p/3949310.html

我们使用上面的代码来实现一个龟兔赛跑

package com.weiyuan.test;

import java.util.concurrent.Callable;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class Main {

    public static void main(String[] args) throws Exception {
        // TODO Auto-generated method stub
        int countTime = 4000;//跑步的总时间
        ExecutorService service = Executors.newFixedThreadPool(2);
        Task tuzi = new Task("兔子", 500);
        Task wugui = new Task("乌龟", 1000);
        Future<Integer> rst1 = service.submit(tuzi);
        Future<Integer> rst2 = service.submit(wugui);

        /**
         * 跑步总的时间长度是4秒
         * */
        Thread.sleep(countTime);

        /*
         * 跑步时间到了,记得退出线程
         * */
        tuzi.setFlag(false);
        wugui.setFlag(false);

        Integer num1 = rst1.get();
        Integer num2 = rst2.get();
        System.out.println("兔子"+"跑了"+num1+"步");
        System.out.println("乌龟"+"跑了"+num2+"步");

        /**
         * 关闭线程池
         * */
        service.shutdown();
    }

    public static class Task implements Callable<Integer>{

        /**
         * 兔子还是乌龟
         * time 兔子和乌龟跑步的时间
         * 跑步时间大了停止线程的退出
         * 跑步的步数
         * */
        private String name;
        private long time;
        private boolean flag = true;
        private int step = 0;

        public Task(String name, long time) {
            this.name = name;
            this.time = time;
        }

        @Override
        public Integer call() throws Exception {
            // TODO Auto-generated method stub
            while(flag){
                Thread.sleep(time);
                step ++ ;
            }

            return step;
        }

        public String getName() {
            return name;
        }

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

        public long getTime() {
            return time;
        }

        public void setTime(long time) {
            this.time = time;
        }

        public boolean isFlag() {
            return flag;
        }

        public void setFlag(boolean flag) {
            this.flag = flag;
        }

    }

}

程序的运行结果是:

兔子跑了9步
乌龟跑了5步

时间: 2024-10-21 15:34:00

Java并发编程:Callable、Future和FutureTask 实现龟兔赛跑的相关文章

Java 并发编程——Callable+Future+FutureTask

项目中经常有些任务需要异步(提交到线程池中)去执行,而主线程往往需要知道异步执行产生的结果,这时我们要怎么做呢?用runnable是无法实现的,我们需要用callable实现. import java.util.concurrent.Callable; import java.util.concurrent.ExecutionException; import java.util.concurrent.ExecutorService; import java.util.concurrent.Ex

java 并发runable,callable,future,futureTask

转载自:http://www.cnblogs.com/dolphin0520/p/3949310.html package future_call; import java.util.concurrent.Callable; /** * Created by luozhitao on 2017/8/10. */ public class Task implements Callable<Integer> { // @Override public Integer call() throws E

【原创】JAVA并发编程——Callable和Future源码初探

JAVA多线程实现方式主要有三种:继承Thread类.实现Runnable接口.使用ExecutorService.Callable.Future实现有返回结果的多线程.其中前两种方式线程执行完后都没有返回值,只有最后一种是带返回值的. thread和runnable不讨论了. 太多地方可以找到他们的探究了 重点看callable和future, 先上一段代码: package com.future.chenjun.test; import java.util.concurrent.Callab

java:并发编程-Callable与Future模式

自己对线程池的理解: coresize 3 maxsize 5 blockLinkedQuenue 3 当提交的任务在<=3时,创建三个线程干活 大于3时,把任务先加入阻塞式队列,当有空闲的核心线程便去执行他们,队列中的任务执行是实际运行的线程在复用执行 如果后面有提交了很多任务,队列都放不下了,就赶紧创建新的线程去执行他们,如果任务已经大于了>队列+最大线程数,没有能力干活了,只能崩塌了,抛出拒绝异常 一.合理配置线程池 CPU密集 CPU密集的意思是该任务需要大量的运算,而没有阻塞,CPU

Java并发编程:Callable、Future和FutureTask(转)

Java并发编程:Callable.Future和FutureTask 在前面的文章中我们讲述了创建线程的2种方式,一种是直接继承Thread,另外一种就是实现Runnable接口. 这2种方式都有一个缺陷就是:在执行完任务之后无法获取执行结果. 如果需要获取执行结果,就必须通过共享变量或者使用线程通信的方式来达到效果,这样使用起来就比较麻烦. 而自从Java 1.5开始,就提供了Callable和Future,通过它们可以在任务执行完毕之后得到任务执行结果. 今天我们就来讨论一下Callabl

15、Java并发编程:Callable、Future和FutureTask

Java并发编程:Callable.Future和FutureTask 在前面的文章中我们讲述了创建线程的2种方式,一种是直接继承Thread,另外一种就是实现Runnable接口. 这2种方式都有一个缺陷就是:在执行完任务之后无法获取执行结果. 如果需要获取执行结果,就必须通过共享变量或者使用线程通信的方式来达到效果,这样使用起来就比较麻烦. 而自从Java 1.5开始,就提供了Callable和Future,通过它们可以在任务执行完毕之后得到任务执行结果. 今天我们就来讨论一下Callabl

Java并发编程 - Executor,Executors,ExecutorService, CompletionServie,Future,Callable

一.Exectuor框架简介 Java从1.5版本开始,为简化多线程并发编程,引入全新的并发编程包:java.util.concurrent及其并发编程框架(Executor框架). Executor框架是指java 5中引入的一系列并发库中与executor相关的一些功能类,其中包括线程池,Executor,Executors,ExecutorService,CompletionService,Future,Callable等.他们的关系为 在Executor框架中,使用执行器(Exectuo

java并发编程--Runnable Callable及Future

1.Runnable Runnable是个接口,使用很简单: 1. 实现该接口并重写run方法 2. 利用该类的对象创建线程 3. 线程启动时就会自动调用该对象的run方法 通常在开发中结合ExecutorService使用,将任务的提交与任务的执行解耦开,同时也能更好地利用Executor提供的各种特性 ExecutorService executor = Executors.newCachedThreadPool(); executor.submit(new Runnable() { pub

Java并发:Callable、Future和FutureTask

Java并发编程:Callable.Future和FutureTask 在前面的文章中我们讲述了创建线程的2种方式,一种是直接继承Thread,另外一种就是实现Runnable接口. 这2种方式都有一个缺陷就是:在执行完任务之后无法获取执行结果. 如果需要获取执行结果,就必须通过共享变量或者使用线程通信的方式来达到效果,这样使用起来就比较麻烦. 而自从Java 1.5开始,就提供了Callable和Future,通过它们可以在任务执行完毕之后得到任务执行结果. 今天我们就来讨论一下Callabl

Java并发编程之线程创建和启动(Thread、Runnable、Callable和Future)

这一系列的文章暂不涉及Java多线程开发中的底层原理以及JMM.JVM部分的解析(将另文总结),主要关注实际编码中Java并发编程的核心知识点和应知应会部分. 说在前面,Java并发编程的实质,是线程对象调用start方法启动多线程,而线程对象则必须是Thread类或其子类实现.Runnable和Callable的作用类似于Comparable.Serializable,是用于被并发的类实现的接口,从而使得Thread类可以在初始化时传入这个被并发的类.此是大前提.本文从多线程实现和启动出发,对