6. 任务执行
分类:www.bwin88.com

科学家揭秘身体如何高效准确执行运动任务

一大早,早餐还没赶趟吃,就这么站在和煦的岗位

职务平日是有个别虚无的且离散的做事单元。通过把应用程序的行事表明到八个任务中,能够简化程序的团伙结构,提供一种自然的事体边界来优化错误复苏进程,以及提供一种自然的互相职业组织来升高并发性。

中午,阳光明媚,还没来得及吃早饭,小编和K已经站在了岗位,瞧着那芬芳的面包和巧克力咖啡,小编怎么能完美术职业作,明日是初始职务的率后天,为了伪装,可恶的中校竟然让大家伪装成记着,那时候大家站在十字路口,这里不知爆发了怎么样,一个从大自然中掉下的莫名飞船,坠毁在了这里,小编和K难堪的站在那边,拿着八个话筒聊起“近年来,一架莫名的飞艇降落到了兴谷街的十字路口。”说了一大堆,连笔者要好都要晕倒了,终于结束了,笔者和K去买了点早饭,坐上了车,大校告诉了笔者们,明天不可能回集散地,所以笔者猜明天他卡Sandra不回去,小编能够安歇一天了。

独立性有辅助完成产出, 因为只要存在充足多的拍卖财富, 那么这一个独立的职分都得以互相试行.

本报讯(采访者黄辛 见习报事人卜叶)最近几年,美利哥《国家中国科学技术大学学院刊》在线刊登了中科院神经调研所所长、脑科学与智能技能顶级立异为主决策者蒲慕明研讨组的一项成果。该钻探系统描述了背外侧纹状体间接通路和直接通路的同一堆神经元在活动学习进程中的电活动变化,并发掘两条通路的神经细胞活动在运动表现中具备相对独立又彼此相当的剧中人物分工。

6.1 在线程中实行职务

  • 当围绕“职务施行”来统筹应用程序时,第一步是要寻找清晰的任务边界。
  • 在美好图景下,各类任务之间是相互独立的:职分不凭仗其余任务的境况,结果或边际效应。
  • 独立性有援救完毕产出。
  • 对于大大多服务器应用程序都以单独的客商须要作为边界。

作者和K一齐决定,去花园玩,假日都未有理想玩,放起音乐,在一级公路上一块狂奔,不是尖叫,那是的心气多么欢喜,随着时局发现在吹,这种感到能够算得特别激情,达到了花园本身倍感自个儿回去了童年不平时,我和K一路上谈笑自若,以前特性热点,喜欢教育外人,自以为王的K,明天给人了二个,不雷同的痛感,大概他也回到了童年有的时候吗。笔者和K一齐去了游乐场,玩了部分激发的游乐,也不知过了多短期,看了石英表,四点了,小编和K离开了俱乐部,在花园里走了一圈,赏了景象。就打道回府吃饭了,吃饭时,来了多少个意外的旁人,他们忽然拿入手枪,击穿玻璃,当自家打到他时,他成为明亮金棕,那时小编来看了Cassandra

无限制创建线程的不足:

背外侧纹状体脑区首要收受来自以为运动皮层四肢代表区的照耀,对运动技能的上学、运动的举行、运动习于旧贯的多变具备重大成效。该脑区布满的多棘投射神经元分别介导了基底神经节运动调节中的两条杰出通路,即直接通路和直接通路。不过,两条通路在活动学习进度的涉企机制尚不显著。

6.1.1 串行地实践职责
class SingleThreadWebServer{
    public stati void main(String[] args) throws IOException{
        ServerSocket socket = new ServerSocket(80);
        while (true){
            Socket connection = socket.accept();
            handleRequest(connection);
        }
    }
}

如上为串行的Web服务器达成,在理论上是没有错的,但在实质上选拔上它的试行品质是比很糟糕的,因为它每一次只可以处理二个伸手。

  • 适用场景:
    当任务数量相当少且实践时间不长时,恐怕当服务器只为单个顾客提供劳动,并且客商每一遍只发生贰个呼吁时。

1、线程生命周期的开支相当高.
线程的创导与销毁并非绝非代价的, 线程的创制进度都会须要时刻, 延迟管理的诉求. 而且要求JVM和操作系统提供一些帮助操作.
2、财富消耗:
活跃的线程会消耗系统能源, 尤其是内部存款和储蓄器. 要是可运营的线程数量多于可用处理器的数额, 那么有个别线程将闲置. 大批量悠然的线程会占用多数内存, 给垃圾回收器带来压力. 依据Java规范, 要是你曾经颇负丰裕多的线程使具备CPU保存辛劳景色, 那么再成立越来越多的线程反而会稳中有降质量;

探讨职员演习小鼠学习推杆移动职分,并经过特异性标识直接通路和直接通路的神经细胞,观望到伴随小鼠的读书进度,两条通路的神经细胞集群都日益爆发了特种、牢固、顺序性发放的电活动方式。直接通路神经元侧向于在实信号感知和推杆操作时活动,而直接通路神经元则越来越多地在推杆动作后反馈,况且在差别的移动职分场景中,同一批神经元的电活动情势会发出退换。进一步试验发掘,特异性禁止间接通路神经元会破坏推杆移动的前奏,而特异性制止直接通路神经元会挑起试验间隔里的荒唐推杆次数字展现然提升。任一通路的平抑均会骤降推杆动作本人的谙习程度。

6.1.2 显式地为职务创设线程
class ThreadPerTaskWebServer{
    public stati void main(String[] args) throws IOException{
        ServerSocket socket = new ServerSocket(80);
        while (true){
            final Socket connection = socket.accept();

            Runnable task = new Runnable(){
                public void run(){
                    handleRequest(connection);
                }
            };

            new Thread(task).start();
        }
    }
}

如上选取的是为各类央浼创立二个新的线程来提供服务,进而实现越来越高的响应性。
但要注意的是这里的天职管理代码handleRequest方法必需是线程安全的,因为当有八个职分时会并发地调用这段代码。

在线程池中实行职务线程, 这种办法有过多”没任务每线程”无法比拟的优势,

商量申明,直接通路和间接通路的神经细胞都参加了小鼠实行向右推杆职责的进度。在职责法规的进行上,前面二个首要承担目的运动的开头,前面一个主要担负与职责指标毫不相关运动的遏制;在实际动作的实行上,两个都插足了对排气动作正确度的调整。两条通路相互十分,共同确定保证小鼠高效、正确地实践活动职务。

6.1.3 无界定创制线程的阙如
  • 线程生命周期的费用非常高。线程的创设进程必要时间,延迟管理的伸手,并且须求JVM和操作系统提供一些协理扶助。纵然哀告的达到率相当高且诉求的管理进度是轻量级的,那么为各个需要创造三个新线程会消耗大量的预计能源。
  • 能源消耗。活跃的线程会损耗系统能源,非常是内部存款和储蓄器。假设有恢宏的空余线程,那么会攻下好多内存,给垃圾回收器带来压力。假若大气线程在竞争CPU能源,再创立线程反而会骤降品质。
  • 稳定性。可创设线程的数码存在三个范围。这么些限制值将随着平台的例外而不一致。假设破坏了这几个限制,那么很只怕抛出OutOfMemoryError非常。

1、重用存在的线程, 并非创设新的线程, 那能够在管理多央求时平衡线程创制, 灭亡爆发的开支.
2、另一项好处便是在央求到达时, 工小编线程平常已经存在, 用于创制线程的等候时间并不会推迟义务的实践, 由此提升了响应式.

连带杂谈音讯:DOI:10.1073/pnas.一九零二712116

6.2 Executor框架

串行实践的标题在于其不好的响应性和吞吐量,而“为各类任务分配一个线程”的主题素材在于资源管理的繁杂。因此,为了提供了一种灵活的线程池来达成作为Executor框架的一有个别,来简化线程的处理职业。

  • Executor基于生产者-开支者情势,提交职责的操作相当于劳动者,执行职责的线程则一定于花费者。

正如为依照线程池的Web服务器:

class ThreadPerTaskWebServer{
    //定义线程池大小
    private static final int NTHREAD = 100;
    //定义Executor
    private static final Executor exec = 
        Executors.newFixedThreadPool(NTHREAD);

    public static void main(String[] args) throws IOException{
        ServerSocket socket = new ServerSocket(80);
        while (true){
            final Socket connection = socket.accept();

            Runnable task = new Runnable(){
                public void run(){
                    handleRequest(connection);
                }
            };
            //将任务添加到线程池中
            exec.execute(task);
        }
    }
}

Executor的落到实处常常会创制线程来施行任务, 然而JVM独有在具有的线程全体休憩后才会脱离, 因而就算不可能正确的关闭Executor, 那么JVM将不大概收场;

《中夏族民共和国科学报》 (2019-05-14 第1版 要闻)

6.2.2 实践政策

在概念实践政策时,供给考虑使命的“What,Where,When,How”等方面。

  • 在怎样(What)线程中实行职责?
  • 义务遵照(What)顺序推行(FIFO, LIFO,优先级)?
  • 在队列中有多少个(How Many)职务在等候实行?
  • 倘诺系统由于过载而急需拒绝叁个任务,那么应该选拔哪三个(Which)任务?其它怎么着(How)布告应用程序有职分被拒绝?
  • 在执行多少个使命在此之前或现在,应该实行哪些(What)动作?

1、Executor的生命周期:
贰个Executor实践的天职的生命周期有4个阶段:

6.2.3 线程池

线程池指的是管理一组同构专门的工作线程的财富池。线程池往往与做事行列有关。在干活行列中保存了独具等待试行的任务。工笔者线程从办事行列中获得一个职务,实践职务,然后重临线程池并伺机下二个职责。

  • 线程池的亮点:通过录取现存的线程实际不是创办新线程,能够免止线程创立和销毁的支付。而且当呼吁到达时,专门的学问线程平常已经存在,减弱了守候线程创设的年月,从而提升响应性。

  • 两种常见创制线程池的静态工厂方法:
    a. newFixedThreadPool:创制二个定点长度的线程池,每提交五个职责就创办一个线程,直到到达线程的最大数据,则规模不再变化。
    b. newCachedThreadPool:创制三个可缓存的线程池,要是线程池的脚下规模超过了管理须要,那么会回收空闲的线程,而当必要扩张时,则足以增加新的线程,且线程池的规模未有限制。
    c. newSingleThreadPool:创造单个线程来施行职责,确认保证依据任务在劳作行列中的顺序来串行实行。
    d. newScheduledThreadPool:创设四个永久长度的线程池,且以延缓或定时的议程来进行义务。

1、创建;
2、提交;
3、开始;
4、完成;
6.2.4 Executor的生命周期

Executor的贯彻日常会创建线程来推行职分,但JVM独有在全数(非守护线程)线程全体结束后才会退出。由此,借使无法正确地关闭Executor,那么JVM将不能收场。

  • 为了消除实践服务的生命周期难题,Executor扩大了ExecutorService接口:
public interface ExecutorService extends Executor{
    void shutdown();
    List<Runnable> shutdownNow();
    boolean isShutdown();
    boolean isTerminated();
    boolean awaitTerminated(long timeout, TimeUtil unit)
        throws InterruptedException;
}
  • ExecutorService的生命周期有3中状态:运维,关闭和已偃旗息鼓。
    a. ExecutorService在初始创设时处于运维状态。
    b. shutdown方法将实行平缓的关闭进度:不再接受新的天职,同偶尔候等待已经付出的职务实施到位-蕴含那一个还未起头施行的职分。
    c. shutdownNow方法将试行狂暴的倒闭进程:它将尝试裁撤全体运营中的任务,并且不再运营队列中平素不开端施行的天职。
    d. 等全部职责都做到后,ExecutorService将转入终止情形,能够调用awaitTermination来等待ExecutorService达到终止情况,可能经过调用isTerminated来轮询Executor瑟维斯是不是曾经告一段落。

日常来说为永葆关闭操作的Web服务器

class LifecycleWebServer{
    private final ExecutorService exec = ...;

    public static void main(String[] args) throws IOException{
        ServerSocket socket = new ServerSocket(80);
        while (! exec.isShutdown()){
            try{
                final Socket connection = socket.accept();
                exec.execute(new Runnable(){
                    public void run() { handleRequest(connection); }
                })
            } catch (RejectedExecutionException e){
                if (!exec.isShutdown())
                    log("task submission rejected",e);
            }
        }
    }

    public void stop() { exec.shutdown(); }

    void handleRequest(Socket connection){
        Request req = readRequest(connection);
        //判断是否为请求关闭的指令
        if (isShutdownRequest(req))
            stop();
        else 
            dispatchRequest(req);
    }
}

假设大家需求关闭服务器,那么能够在前后相继中调用stop方法,或然以客商端央求情势向Web服务器发送二个一定格式的HTTP央浼。

Future描述了职分的生命周期,并提供了相关的法门来收获任务的结果、裁撤职责以及查看职分是或不是以及达成也许被打消;

6.3 寻找可选择的并行性

大家来兑现一个浏览器的页面渲染功能,它的法力是将HTML页面绘制到图像缓存中,为了轻松起见,我们假诺HTML页面中只满含标签文本和图表。

  • 方案一:串行地渲染页面元素
public class SingleThreadRenderer{
    void renderPage(CharSequence source){
        //加载文本
        renderText(source);
        List<ImageData> ImageData = new ArrayList<ImageData>();
        //下载图片
        for (ImageData imageInfo : scanForImageInfo(source))
            ImageData.add(imageInfo.downloadImage());
        //加载图片
        for (ImageData data : ImageData)
            renderImage(data);
    }
}

讲评:该中方法在图片下载进度中比很多年美利坚合众国的首都是在等待I/O操作实行到位,在那之间CPU差不离不做任何职业,使得客户在阅览最终页面此前要等待很短的年月。

  • 方案二:使用Future等待图片下载

Future表示一个职分的生命周期,并提供了对应的主意判别是还是不是已经实现或撤废,以及获得职务的结果和打消职分等。

public interface Future<V> {
    boolean cancel(boolean mayInterruptIfRunning);
    boolean isCancelled();
    boolean isDone();
    V get() throws InterruptedException,ExecutionException,
            CancellationException;
    //限时获取
    V get(long timeout, TimeUtil unit) throws InterruptedException,
        ExecutionException, CancellationException, TimeoutException;
}

使用Future实现页面渲染器:

public class FutureRenderer {
    private final ExecutorService exec = ....;

    void renderPage(CharSequence source){
        //获取图片信息
        final List<ImageInfo> imageInfos = scanForImageInfo(source);
        //定义图片下载任务
        Callable<List<ImageData>> task = 
            new Callable<List<ImageData>>() {
                //通过call方法返回结果
                public List<ImageData> call(){
                    public List<ImageData> result 
                        = new ArrayList<ImageData>();
                    for (ImageInfo imageInfo : imageInfos)
                        result.add(imageInfo.downloadImage());
                    return result;
                }

            };
        //将任务添加到线程池中
        Future<List<ImageData>> future = exec.submit(task);
        //加载文本信息
        renderText(source);

        try{
            //获取图片结果,并加载图片
            List<ImageData> imageData = future.get();
            for (ImageData data : imageData)
                renderImage(data);
        } catch (InterruptedException e){
            //重新设置线程的中断状态
            Thread.currentThread().interrupt();
            //取消任务
            future.cancel(true);
        } catch (ExecutionException e){
            throw launderThrowable(e.getCause());
        }
    }
}

如上,大家将渲染进度分解为文本渲染和图纸渲染,使得双方并发实行。

大方相互独立且同类的职务进行并发管理, 会将顺序的职务分配到差异的天职中, 那样本领真正获得属性的晋升;

6.3.4 在异构职分并行化中存在的局限
  • 在上头的FutureRender中利用了四个任务,二个是背负渲染文本,叁个是承担渲染图片。借使渲染文本的快慢远远出乎渲染图片的快慢,那么程序的终极质量与串行实施的习性差距并非常的小,而代码却变复杂了。
  • 故此,唯有当大气相互独立且同构的职分能够并发进行处理时,才具反映出将顺序的劳作负荷分配到多少个职分中拉动的真的品质。

  • 将兼具的图片下载职务分解为多少个单身的下载任务并发举办

public class FutureRenderer {
    private final ExecutorService exec = ....;

    void renderPage(CharSequence source){
        //获取图片信息
        final List<ImageInfo> imageInfos = scanForImageInfo(source);
        //定义任务结果
        final List<Future<ImageData>> futures = new ArrayList<Future<ImageData>>();

        for (ImageInfo imageInfo : imageInfos){
            //定义任务
            Callable<ImageData> task = new Callable<ImageData>(){
                public ImageData call(){
                    return imageInfo.downloadImage();
                }
            }
            //添加到线程池中
            futures.add(exec.submit(task));
        }

        //遍历任务结果
        for (Future future : futures){
            try {
                //获取图片信息,并加载
                ImageData imageData = future.get();
                renderImage(imageData);
            }catch (InterruptedException e){
                //重新设置线程的中断状态
                Thread.currentThread().interrupt();
                //取消任务
                future.cancel(true);
            } catch (ExecutionException e){
                throw launderThrowable(e.getCause());
            }
        }
    }
}

如上,大家为每张图片都创建二个任务推行。但此处存在二个缺点,咱们在结尾遍历futures时,调用get方法取得图片,我们直到那一个的get方法若任务已经成功,那么会一向拿走到图片,若职务还未到位,那么会堵塞,直到职务成功。那么存在这么个难点:若首先张图未下载实现,而第二张下载实现,那时候第二张会因为第一张未下载完毕而导致被堵塞获取到。

  • 为了化解那么些主题材料,大家提供了CompletionService来更加好地促成。

CompletionService的落到实处是体贴多少个保存Future对象的BlockingQueue。只有当那一个Future对象情况是得了的时候,才会加盟到这几个Queue中,take()方法其实正是Producer-Consumer中的Consumer。它会从Queue中收取Future对象,假使Queue是空的,就能够阻塞在那边,直到有成功的Future对象参加到Queue中。

  • CompletionService接纳的是BlockingQueue<Future<V>>无界队列来管理Future。若有三个线程实践达成把重返结果放到BlockingQueue<Future<V>>里面,就可以透过completionServcie.take().get()抽取结果。
public class Renderer {
    private final ExecutorService exec;

    Renderer(ExecutorService exec) { this.exec = exec; }

    void renderPage(CharSequence source){
        //获取图片信息
        final List<ImageInfo> imageInfos = scanForImageInfo(source);
        //定义CompletionService
        CompletionService<ImageData> completionService = 
            new ExecutorCompletionService<ImageData>(exec);
        //将每张图片封装为任务
        for (final ImageInfo imageInfo : imageInfos){
            completionService.submit(new Callable<ImageData>(){
                public ImageData call(){
                    return imageInfo.downloadImage();
                }
            })
        }

        renderText(source);
        //获取图片信息
        for (int t = 0; t < imageInfos.size(); i   ){
            try {
                Future<ImageData> f = completionService.take();
                ImageData imageData = f.get();
                renderImage(imageData);
            }catch (InterruptedException e){
                //重新设置线程的中断状态
                Thread.currentThread().interrupt();
            } catch (ExecutionException e){
                throw launderThrowable(e.getCause());
            }

        }

    }
}

如上,为每一张图下载都创设多个单身职责,并在线程池中实行它们,从而将串行的下载进度转变为相互的进度,这将收缩下载全数图片的总时间。

Runnable是一种有相当的大局限的空洞, 它无法重回二个值或许抛出三个受检查的那多少个;

6.3.7 为天职设置时间限制

只要有个别任务不或然在指按期间内做到,那么将不再必要它的结果,此时得以放弃那几个职分。但要注意,当这几个职务超时后应当及时停下,进而幸免浪费总括不必要的能源。

咱俩设置二个获取广告的体制,若在规定时期内得到到广告,则加载广告,不然设置私下认可广告。

Page renderPageWithAd() thorws InterruptedException{
    //设定结束时间
    long endNanos = System.nanoTime()   TIME_BUGGET;
    //提交任务
    Future<Ad> f = exec.submit(new FetchAdTask());
    //加载主界面
    Page page = renderPageBody();
    Ad ad;
    try {
        //在限定时间内获取广告,若线程异常或超时则设置为默认的广告
        long timeleft = endNanos - System.nanoTime();
        ad = f.get(timeleft, NANOSECONDS);
    } catch (ExecutionException e) {
        ad = DEFAULT_AD;
    } catch (TimeoutException e){
        ad = DEFAULT_AD;
        //超时后,取消任务
        f.cancel(true);
    }
    page.setAd(ad);
    return page;
}
  • ExecutorService的invokeAll艺术也能批量施行职分,并批量重回结果,但有个很沉重的劣点,必需等待全部的任务实施到位后统一再次来到,一方面内部存款和储蓄器持有的时间长;另一方面响应性也许有早晚的熏陶,毕竟大家都垂怜得舍不得放手看看刷刷的实践结果输出,并不是苦苦的等候;
public class InvokeAllTest {
    public static void main(String[] args) throws InterruptedException {
        ExecutorService exec = Executors.newFixedThreadPool(10);
        List<Callable<Integer>> tasks = new ArrayList<>();
        Callable<Integer> task = null;
        for (int i = 0; i < 10; i   ){
            task = new Callable<Integer>() {
                @Override
                public Integer call() throws Exception {
                    int random = new Random().nextInt(1000);
                    Thread.sleep(random);
                    System.out.println(Thread.currentThread().getName()   "休眠了 "   random);
                    return random;
                }
            };
            tasks.add(task);
        }
        long s = System.currentTimeMillis();
        List<Future<Integer>> results = exec.invokeAll(tasks);
        System.out.println("执行任务消耗了:"   (System.currentTimeMillis() - s)   "ms");
        for (int i = 0; i < results.size(); i   ){
            try {
                System.out.println(results.get(i).get());
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        }
    }
}

输出结果:
pool-1-thread-5休眠了 276
pool-1-thread-1休眠了 426
pool-1-thread-8休眠了 479
pool-1-thread-10休眠了 561
pool-1-thread-4休眠了 641
pool-1-thread-6休眠了 760
pool-1-thread-9休眠了 780
pool-1-thread-3休眠了 854
pool-1-thread-2休眠了 949
pool-1-thread-7休眠了 949
执行任务消耗了:974ms
426
949
854
641
276
760
949
479
780
561

如上,大家可以观看最后职责结果的出口是安份守己顺序输出的。

在Executor框架中, 已提交但从没初叶的天职能够收回, 但对于这个早已最初执行的职务, 唯有当它们能响应中断时, 本领收回; 撤除一个业已成功的职责不会有别的影响;

关于CompletionService的一个demo:

public class Test07 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Test07 t = new Test07();
        t.count();
    }

    public void count() throws InterruptedException, ExecutionException {
        ExecutorService exec = Executors.newCachedThreadPool();
        CompletionService<Integer> execcomp = new ExecutorCompletionService<>(exec);
        for (int i = 0; i < 10; i  ) {
            execcomp.submit(new Task(i, 1000 * (i   1)));
        }
        int sum = 0;
        for (int i = 0; i < 10; i  ) {
            System.out.println("1-i:"   i);
            Future<Integer> future = execcomp.take();
            System.out.println("2-i:"   i);
            sum  = future.get();
            System.out.println("3-i:"   i);
        }
        System.out.println("总数为:"   sum);
        exec.shutdown();
    }

    public static class Task implements Callable<Integer> {
        public Random mRandom;
        public int mIndex;
        public int mTime;

        public Task(int i, int time) {
            mRandom = new Random();
            mIndex = i;
            mTime = time;
        }

        @Override
        public Integer call() throws Exception {
            int i = mRandom.nextInt(10);
            int j = mRandom.nextInt(10);
            int sum = i * j;
            Thread.sleep(mTime);
            System.out.println("index:"   mIndex   ",sum:"   sum   "t");
            return sum;
        }
    }
}

Executor处理超时问题:

public class Test08 {
    private static volatile int time;
    private static volatile boolean isCancalled;

    public static void main(String[] args) {
        ExecutorService executor = Executors.newSingleThreadExecutor();
        Task t = new Task();
        Future<?> future = executor.submit(t);
        try {
            System.out.println("1");
            Object o = future.get(5000, TimeUnit.MILLISECONDS);
            System.out.println("o:"   o);
        } catch (InterruptedException e) {
            System.out.println("InterruptedException");
        } catch (ExecutionException e) {
            System.out.println("ExecutionException");
        } catch (TimeoutException e) {
            isCancalled = true;
            System.out.println("TimeoutException");
        } finally {
            future.cancel(true);
            executor.shutdownNow();
            System.out.println("executor.isShutdown:"   executor.isShutdown()   ",executor.isTerminated:"   executor.isTerminated());
        }
    }

    public static class Task implements Runnable {

        @Override
        public void run() {
            while (true) {
                try {
                    if (isCancalled) {
                        break;
                    }
                    Thread.sleep(100);
                    System.out.println("time:"   (  time));
                } catch (InterruptedException e) {
                    System.out.println("InterruptedException");
                }
            }
        }
    }
}

本文由必赢棋牌官网发布于www.bwin88.com,转载请注明出处:6. 任务执行

上一篇:全国科技(science and technology)活动周运营 下一篇:没有了
猜你喜欢
热门排行
精彩图文
  • www.bwin88.com中国科学家揭示衰老基因机制
    www.bwin88.com中国科学家揭示衰老基因机制
    中国科学家研究揭示哺乳动物高温保护机制 复旦大学脑科学研究院马兰研究组发现,一种记忆形成后,通过回忆可激活脑内的β抑制因子神经通路,使记忆
  • 残酷的世界,你没穷过你根本不懂
    残酷的世界,你没穷过你根本不懂
    曹则贤:世界上80%的物理学家根本不懂物理 20世纪初,原子论学说被确立了,科学家们赢得了争论,原子论学说不再是异端,科学家们成为了新的正统,
  • 这部科幻剧烂番茄95%,顶级物理期刊都打call
    这部科幻剧烂番茄95%,顶级物理期刊都打call
    “黑名单”能否堵死“烂期刊” 专家认为,执念于期刊,不如关注成果本身 原来不只是父母的教育害了你,还有读者,知音这些垃圾期刊害了你,让你不
  • 天津大学校长来校访问
    天津大学校长来校访问
    金东寒任天津大学校长 在日前召开的天津大学全体教师干部大会上,中共中央组织部相关部门负责同志宣布了中共中央、国务院的任免决定:李家俊由天津
  • 萨德来了,我们坚决抵制
    萨德来了,我们坚决抵制
    科学基金项目评审进入关键期 基金委:坚决抵制“撒网”式“打招呼”等现象 《唐人街探案2》因为影片中一个侏儒穿着阿根廷十号球衣引发了网友们十分