Java四种线程池newCachedThreadPool,newFixedThreadPool,newScheduledThreadPool,newSingleThreadExecutor

1、new Thread的弊端

进行一个异步义务你还只是之类new Thread吗?

new Thread(new Runnable() {

    @Override
    public void run() {
        // TODO Auto-generated method stub
        }
    }
).start();

这你就out太多了,new Thread的害处如下:

a. 每便new Thread新建对象品质差。
b.
线程贫乏统一管理,大概无界定新建线程,互相之间竞争,及大概占用过多系统财富以致死机或oom。
c. 贫乏越来越多效益,如准时试行、依期实践、线程中断。

对待new Thread,Java提供的各样线程池的功利在于:

a. 重用存在的线程,减弱对象创制、灭绝的支出,质量佳。
b.
可实用调控最大并发线程数,进步系统能源的使用率,同不经常候幸免过多能源竞争,制止拥塞。
c. 提供准时实践、定时履行、单线程、并发数调整等成效。

介绍new
Thread的缺陷及
Java三种线程池的采用,对Android一样适用。本文是基本功篇,后边会享受下线程池一些尖端功用。

2、Java 线程池

Java通过Executors提供种种线程池,分别为:

  • newCachedThreadPool创制一个可缓存线程池,假设线程池长度超过处理需求,可灵活回笼空闲线程,若无可回收,则新建线程。
  • newFixedThreadPool
    创制三个定长线程池,可决定线程最大并发数,超出的线程会在队列中等候。
  • newScheduledThreadPool
    创立贰个定长线程池,扶持准时及周期性职分实行。
  • newSingleThreadExecutor
    创立二个单线程化的线程池,它只会用独一的职业线程来实践职分,保障具有任务依据钦定顺序(FIFO,
    LIFO, 优先级卡塔尔推行。

1、new Thread的弊端
试行三个异步职分你还只是之类new Thread吗?

(1)newCachedThreadPool:

始建一个可缓存线程池,假若线程池长度当先管理供给,可灵活回笼空闲线程,若无可回笼,则新建线程。示例代码如下:

ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
    for (int i = 0; i < 10; i++) {
        final int index = i;
    try {
        Thread.sleep(index * 1000);
    } 
        catch (InterruptedException e) {
            e.printStackTrace();
    }

cachedThreadPool.execute(new Runnable() {

@Override
public void run() {
    System.out.println(index);
}
});
}

线程池为无限大,当实行第二个职责时首先个任务现已完结,会复用推行第叁个职责的线程,而不用每便新建线程。

Java

(2)newFixedThreadPool:

始建三个定长线程池,可调控线程最大并发数,超过的线程会在队列中等候。示例代码如下:

ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
    for (int i = 0; i < 10; i++) {
    final int index = i;

    fixedThreadPool.execute(new Runnable() {

@Override
public void run() {
try {
    System.out.println(index);
    Thread.sleep(2000);
} catch (InterruptedException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
    }
}
});
}

因为线程池大小为3,每种职分输出index后sleep 2秒,所以每两秒打字与印刷3个数字。

定长线程池的大小最佳依据系统财富进行安装。如Runtime.getRuntime(卡塔尔国.availableProcessors(State of Qatar。可参照PreloadDataCache。

new Thread(new Runnable() { @Override public void run() { // TODO
Auto-generated method stub } }).start();

(3)newScheduledThreadPool:

创设一个定长线程池,扶持定期及周期性职责推行。延迟施行示例代码如下:

ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
 scheduledThreadPool.schedule(new Runnable() {

@Override
public void run() {
    System.out.println("delay 3 seconds");
}
}, 3, TimeUnit.SECONDS);

意味着延迟3秒施行。

期限实践示例代码如下:

scheduledThreadPool.scheduleAtFixedRate(new Runnable() {

@Override
public void run() {
    System.out.println("delay 1 seconds, and excute every 3 seconds");
}
}, 1, 3, TimeUnit.SECONDS);

代表延迟1秒后每3秒实行一回。

ScheduledExecutorService比Timer更安全,功效越来越强有力

1
2
3
4
5
6
7
new Thread(new Runnable() {
 
@Override
public void run() {
// TODO Auto-generated method stub
}
}).start();

(4)newSingleThreadExecutor:

成立三个单线程化的线程池,它只会用独一的办事线程来实践职务,有限支撑具备职责依照钦定顺序(FIFO,
LIFO, 优先级卡塔尔施行。示例代码如下:

ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
for (int i = 0; i < 10; i++) {
final int index = i;
singleThreadExecutor.execute(new Runnable() {

@Override
public void run() {
    try {
        System.out.println(index);
    Thread.sleep(2000);
} catch (InterruptedException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
        }
}
    });
}

结果依次输出,约等于各类试行顺序职责。

近期大好些个GUI程序都是单线程的。Android中单线程可用以数据库操作,文件操作,应用批量安装,应用批量剔除等不合乎并发但只怕IO拥塞性及影响UI线程响应的操作。

这你就out太多了,new Thread的坏处如下:

线程池的机能:

线程池功能正是节制系统中执行线程的多寡。
根据系统的条件情状,能够活动或手动设置线程数量,到达运转的一级效果与利益;少了浪费了系统财富,多了引致系统拥挤作用不高。用线程池调控线程数量,别的线程排
队等候。贰个职务奉行完结,再从队列的中取最前方的任务起初施行。若队列中一直不等待进程,线程池的这一财富处于等候。当七个新任务需求周转时,假如线程池
中有等待的做事线程,就足以初步运维了;不然步入等待队列。

a. 每一趟new Thread新建对象质量差。
b.
线程缺乏统一保管,或许无界定新建线程,相互之间竞争,及容许占用过多系统能源以致死机或oom。
c. 贫乏越多效果与利益,如准时施行、定时施行、线程中断。
对照new Thread,Java提供的多种线程池的功利在于:
澳门新葡亰娱乐官网,a. 重用存在的线程,减弱对象创制、死灭的支付,质量佳。
b.
可使得调整最大并发线程数,进步系统财富的使用率,同时制止过多财富角逐,制止堵塞。
c. 提供定期试行、准时实践、单线程、并发数调整等职能。

缘何要用线程池:

1.收缩了创制和销毁线程的次数,每一个专门的学业线程都得以被重新使用,可实施多个职责。

2.方可依附系统的担当技艺,调解线程池湖南中华工程公司作线线程的多寡,制止因为消耗过多的内部存款和储蓄器,而把服务器累趴下(每种线程要求大致1MB内部存储器,线程开的越多,消耗的内部存款和储蓄器也就越大,最终死机卡塔尔。

Java里面线程池的甲级接口是Executor,不过严苛意义上讲Executor并非三个线程池,而只是一个实施线程的工具。真正的线程池接口是ExecutorService。

正如关键的多少个类:

ExecutorService: 真正的线程池接口。

ScheduledExecutorService:
能和Timer/TimerTask相近,驱除那个急需职分再一次推行的难题。

ThreadPoolExecutor: ExecutorService的默许达成。

ScheduledThreadPoolExecutor:
世襲ThreadPoolExecutor的ScheduledExecutorService接口达成,周期性任务调治的类完成。

要结构二个线程池是比较复杂的,尤其是对于线程池的原理不是很领会的气象下,很有望安插的线程池不是较优的,因而在Executors类里面提供了部分静态工厂,生成一些常用的线程池。

 

1.newSingleThreadExecutor

成立贰个单线程的线程池。那几个线程池独有三个线程在办事,也正是相当于单线程串行实施全数职务。如若这一个独一的线程因为那些结束,那么会有二个新的线程来代替它。此线程池有限扶持具有任务的推行顺序依照职分的交给顺序实施。

2、Java 线程池
Java通过Executors提供多种线程池,分别为:
newCachedThreadPool创立一个可缓存线程池,如果线程池长度超越管理需求,可灵活回笼空闲线程,若无可回收,则新建线程。
newFixedThreadPool
创立二个定长线程池,可决定线程最大并发数,超过的线程会在队列中等候。
newScheduledThreadPool 制造二个定长线程池,扶助依期及周期性职分推行。
newSingleThreadExecutor
创造二个单线程化的线程池,它只会用独一的行事线程来实践职务,保障全部职责遵照钦命顺序(FIFO,
LIFO, 优先级卡塔尔(قطر‎实行。

2.newFixedThreadPool

创办固定大小的线程池。每一趟提交叁个职务就创办三个线程,直到线程达到线程池的最大尺寸。线程池的大小一旦达到最大值就会保持不改变,要是某些线程因为奉行相当而告终,那么线程池会补充一个新线程。

(1). newCachedThreadPool
始建四个可缓存线程池,假设线程池长度超越管理须要,可灵活回笼空闲线程,若无可回笼,则新建线程。示例代码如下:

3.newCachedThreadPool

创造叁个可缓存的线程池。假如线程池的高低超过了拍卖职分所急需的线程,

那就是说就能够回笼部分空暇(60秒不试行职责)的线程,当职分数大增时,此线程池又足以智能的增进新线程来处理职责。此线程池不会对线程池大小做约束,线程池大小完全依据于操作系统(可能说JVM)能够创制的最大线程大小。

Java

4.newScheduledThreadPool

开创一个尺寸Infiniti的线程池。此线程池支持依期以至周期性实施义务的须要。

ExecutorService cachedThreadPool = Executors.newCachedThreadPool(); for
(int i = 0; i < 10; i++) { final int index = i; try {
Thread.sleep(index * 1000); } catch (InterruptedException e) {
e.printStackTrace(); } cachedThreadPool.execute(new Runnable() {
@Override public void run() { System.out.println(index); } }); }

实例代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
for (int i = 0; i < 10; i++) {
final int index = i;
try {
Thread.sleep(index * 1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
 
cachedThreadPool.execute(new Runnable() {
 
@Override
public void run() {
System.out.println(index);
}
});
}

一、固定大小的线程池,newFixedThreadPool:

package app.executors;  

import java.util.concurrent.Executors;  
import java.util.concurrent.ExecutorService;  

/** 
 * Java线程:线程池 
 *  
 * @author xiho
 */  
public class Test {  
    public static void main(String[] args) {  
        // 创建一个可重用固定线程数的线程池  
        ExecutorService pool = Executors.newFixedThreadPool(2);  
        // 创建线程  
        Thread t1 = new MyThread();  
        Thread t2 = new MyThread();  
        Thread t3 = new MyThread();  
        Thread t4 = new MyThread();  
        Thread t5 = new MyThread();  
        // 将线程放入池中进行执行  
        pool.execute(t1);  
        pool.execute(t2);  
        pool.execute(t3);  
        pool.execute(t4);  
        pool.execute(t5);  
        // 关闭线程池  
        pool.shutdown();  
    }  
}  

class MyThread extends Thread {  
    @Override  
    public void run() {  
        System.out.println(Thread.currentThread().getName() + "正在执行。。。");  
    }  
}

输出结果:

pool-1-thread-1正在执行。。。  
pool-1-thread-3正在执行。。。  
pool-1-thread-4正在执行。。。  
pool-1-thread-2正在执行。。。  
pool-1-thread-5正在执行。。。

改动ExecutorService pool =
Executors.newFixedThreadPool(5卡塔尔国中的参数:ExecutorService pool =
Executors.newFixedThreadPool(2卡塔尔(قطر‎,输出结果是:

pool-1-thread-1正在执行。。。  
pool-1-thread-1正在执行。。。  
pool-1-thread-2正在执行。。。  
pool-1-thread-1正在执行。。。  
pool-1-thread-2正在执行。。。

从上述结果能够看来,newFixedThreadPool的参数钦赐了能够运转的线程的最大数据,超越那个数据的线程加进去现在,不会运营。其次,插手线程池的线程归于托管情形,线程的运维不受参预顺序的熏陶。

线程池为无限大,当实践第叁个职分时首先个任务已经形成,会复用实行第二个义务的线程,而不用每趟新建线程。

二、单职务线程池,newSingleThreadExecutor:

只有是把上述代码中的ExecutorService pool =
Executors.newFixedThreadPool(2卡塔尔改为ExecutorService pool =
Executors.newSingleThreadExecutor(State of Qatar;
出口结果:

pool-1-thread-1正在执行。。。  
pool-1-thread-1正在执行。。。  
pool-1-thread-1正在执行。。。  
pool-1-thread-1正在执行。。。  
pool-1-thread-1正在执行。。。

能够看见,每一回调用execute方法,其实最终都以调用了thread-1的run方法。

 

三、可变尺寸的线程池,newCachedThreadPool:

与地点的相近,只是退换下pool的创导格局:ExecutorService pool =
Executors.newCachedThreadPool(卡塔尔国;

出口结果:

pool-1-thread-1正在执行。。。  
pool-1-thread-2正在执行。。。  
pool-1-thread-4正在执行。。。  
pool-1-thread-3正在执行。。。  
pool-1-thread-5正在执行。。。

这种方式的特点是:可遵照须求成立新线程的线程池,不过在从前结构的线程可用时将重用它们。

(2). newFixedThreadPool
始建三个定长线程池,可决定线程最大并发数,超过的线程会在队列中等待。示例代码如下:

四、延迟连接池,newScheduledThreadPool:

public class TestScheduledThreadPoolExecutor {

    public static void main(String[] args) {

        ScheduledThreadPoolExecutor exec = new ScheduledThreadPoolExecutor(1);

        exec.scheduleAtFixedRate(new Runnable() {//每隔一段时间就触发异常

                      @Override

                      publicvoid run() {

                           //throw new RuntimeException();

                           System.out.println("================");

                      }

                  }, 1000, 5000, TimeUnit.MILLISECONDS);

        exec.scheduleAtFixedRate(new Runnable() {//每隔一段时间打印系统时间,证明两者是互不影响的

                      @Override

                      publicvoid run() {

                           System.out.println(System.nanoTime());

                      }

                  }, 1000, 2000, TimeUnit.MILLISECONDS);

    }

}

出口结果:

================

8384644549516

8386643829034

8388643830710

================

8390643851383

8392643879319

8400643939383

Java

ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3); for
(int i = 0; i < 10; i++) { final int index = i;
fixedThreadPool.execute(new Runnable() { @Override public void run() {
try { System.out.println(index); Thread.sleep(2000); } catch
(InterruptedException e) { // TODO Auto-generated catch block
e.printStackTrace(); } } }); }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
for (int i = 0; i < 10; i++) {
final int index = i;
fixedThreadPool.execute(new Runnable() {
 
@Override
public void run() {
try {
System.out.println(index);
Thread.sleep(2000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
});
}

因为线程池大小为3,各个职责输出index后sleep 2秒,所以每两秒打字与印刷3个数字。

定长线程池的尺寸最棒依据系统财富进行安装。如Runtime.getRuntime(卡塔尔(قطر‎.availableProcessors(State of Qatar。可参看PreloadDataCache。

 

(3) newScheduledThreadPool
制造四个定长线程池,扶植定时及周期性职务试行。延迟实行示例代码如下:

Java

ScheduledExecutorService scheduledThreadPool =
Executors.newScheduledThreadPool(5); scheduledThreadPool.schedule(new
Runnable() { @Override public void run() { System.out.println(“delay 3
seconds”); } }, 3, TimeUnit.SECONDS);

1
2
3
4
5
6
7
8
ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
scheduledThreadPool.schedule(new Runnable() {
 
@Override
public void run() {
System.out.println("delay 3 seconds");
}
}, 3, TimeUnit.SECONDS);

代表延迟3秒试行。

 

为期履行示例代码如下:

Java

scheduledThreadPool.scheduleAtFixedRate(new Runnable() { @Override
public void run() { System.out.println(“delay 1 seconds, and excute
every 3 seconds”); } }, 1, 3, TimeUnit.SECONDS);

1
2
3
4
5
6
7
scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
 
@Override
public void run() {
System.out.println("delay 1 seconds, and excute every 3 seconds");
}
}, 1, 3, TimeUnit.SECONDS);

表示延迟1秒后每3秒推行三回。

ScheduledExecutorService比Timer更安全,功效更有力,前面会有一篇单独开展自己检查自纠。

 

(4)、newSingleThreadExecutor
成立八个单线程化的线程池,它只会用独一的劳作线程来施行任务,保险全数职分依据钦点顺序(FIFO,
LIFO, 优先级卡塔尔国实践。示例代码如下:

Java

ExecutorService singleThreadExecutor =
Executors.newSingleThreadExecutor(); for (int i = 0; i < 10; i++) {
final int index = i; singleThreadExecutor.execute(new Runnable() {
@Override public void run() { try { System.out.println(index);
Thread.sleep(2000); } catch (InterruptedException e) { // TODO
Auto-generated catch block e.printStackTrace(); } } }); }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
for (int i = 0; i < 10; i++) {
final int index = i;
singleThreadExecutor.execute(new Runnable() {
 
@Override
public void run() {
try {
System.out.println(index);
Thread.sleep(2000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
});
}

结果依次输出,也正是种种施行各样任务。

这几天大多数GUI程序都以单线程的。Android中单线程可用以数据库操作,文件操作,应用批量装置,应用批量剔除等不适合併发但或者IO梗塞性及影响UI线程响应的操作。

 

 

 

 

 

线程池的效应:

线程池效能正是限量系统中实施线程的多少。
     依据系统的条件情况,能够自动或手动设置线程数量,达到运营的最棒效果与利益;少了浪费了系统能源,多了以致系统拥挤效用不高。用线程池调节线程数量,别的线程排
队等候。一个任务实行达成,再从队列的中取最前方的职分开头实施。若队列中尚无等待进程,线程池的这一能源处于等候。当三个新职分须求周转时,假使线程池
中有等待的做事线程,就足以开端运维了;否则进入等待队列。

为啥要用线程池:

1.减去了创制和销毁线程的次数,各类职业线程都得以被重复利用,可推行七个职务。

2.足以遵照系统的担当本事,调度线程池广西中华南戏剧学院程公司作线线程的数码,幸免因为消耗过多的内部存款和储蓄器,而把服务器累趴下(每种线程需求大概1MB内部存款和储蓄器,线程开的愈来愈多,消耗的内部存款和储蓄器也就越大,最终死机卡塔尔。

Java里面线程池的五星级接口是Executor,可是严酷意义上讲Executor并不是四个线程池,而只是二个试行线程的工具。真正的线程池接口是ExecutorService。

正如根本的多少个类:

ExecutorService

真正的线程池接口。

ScheduledExecutorService

能和Timer/TimerTask类似,解决那些需要任务重复执行的问题。

ThreadPoolExecutor

ExecutorService的默认实现。

ScheduledThreadPoolExecutor

继承ThreadPoolExecutor的ScheduledExecutorService接口实现,周期性任务调度的类实现。

要配置二个线程池是相比复杂的,尤其是对于线程池的规律不是很精通的境况下,很有望布置的线程池不是较优的,因而在Executors类里面提供了部分静态工厂,生成一些常用的线程池。

1. newSingleThreadExecutor

开创叁个单线程的线程池。那一个线程池唯有一个线程在办事,也正是一定于单线程串行试行全部职分。若是这么些独一的线程因为非常甘休,那么会有三个新的线程来代表它。此线程池有限协助全部义务的实行顺序依照职分的交给顺序试行。

2.newFixedThreadPool

始建固定大小的线程池。每一回提交三个职务就创建二个线程,直到线程达到线程池的最大尺寸。线程池的尺寸一旦达到规定的标准最大值就能够维持不改变,倘若某些线程因为推行卓殊而终止,那么线程池会补充叁个新线程。

3. newCachedThreadPool

开创二个可缓存的线程池。如若线程池的分寸超越了管理职分所急需的线程,

那么就能够回笼部分空闲(60秒不施行职责)的线程,当职务数扩展时,此线程池又有啥不可智能的丰盛新线程来管理职务。此线程池不会对线程池大小做约束,线程池大小完全重视于操作系统(或许说JVM)能够创制的最大线程大小。

4.newScheduledThreadPool

创设三个抑扬顿挫Infiniti的线程池。此线程池帮忙定时以至周期性实践职分的供给。

实例

1:newSingleThreadExecutor

MyThread.java

publicclassMyThread extends Thread {

    @Override

    publicvoid run() {

        System.out.println(Thread.currentThread().getName() + "正在执行。。。");

    }

}

TestSingleThreadExecutor.java

publicclassTestSingleThreadExecutor {

    publicstaticvoid main(String[] args) {

        //创建一个可重用固定线程数的线程池

        ExecutorService pool = Executors. newSingleThreadExecutor();

        //创建实现了Runnable接口对象,Thread对象当然也实现了Runnable接口

        Thread t1 = new MyThread();

        Thread t2 = new MyThread();

        Thread t3 = new MyThread();

        Thread t4 = new MyThread();

        Thread t5 = new MyThread();

        //将线程放入池中进行执行

        pool.execute(t1);

        pool.execute(t2);

        pool.execute(t3);

        pool.execute(t4);

        pool.execute(t5);

        //关闭线程池

        pool.shutdown();

    }

}

输出结果

pool-1-thread-1正在执行。。。

pool-1-thread-1正在执行。。。

pool-1-thread-1正在执行。。。

pool-1-thread-1正在执行。。。

pool-1-thread-1正在执行。。。

2newFixedThreadPool

TestFixedThreadPool.Java

publicclass TestFixedThreadPool {

    publicstaticvoid main(String[] args) {

        //创建一个可重用固定线程数的线程池

        ExecutorService pool = Executors.newFixedThreadPool(2);

        //创建实现了Runnable接口对象,Thread对象当然也实现了Runnable接口

        Thread t1 = new MyThread();

        Thread t2 = new MyThread();

        Thread t3 = new MyThread();

        Thread t4 = new MyThread();

        Thread t5 = new MyThread();

        //将线程放入池中进行执行

        pool.execute(t1);

        pool.execute(t2);

        pool.execute(t3);

        pool.execute(t4);

        pool.execute(t5);

        //关闭线程池

        pool.shutdown();

    }

}

输出结果

pool-1-thread-1正在执行。。。

pool-1-thread-2正在执行。。。

pool-1-thread-1正在执行。。。

pool-1-thread-2正在执行。。。

pool-1-thread-1正在执行。。。

3 newCachedThreadPool

TestCachedThreadPool.java

publicclass TestCachedThreadPool {

    publicstaticvoid main(String[] args) {

        //创建一个可重用固定线程数的线程池

        ExecutorService pool = Executors.newCachedThreadPool();

        //创建实现了Runnable接口对象,Thread对象当然也实现了Runnable接口

        Thread t1 = new MyThread();

        Thread t2 = new MyThread();

        Thread t3 = new MyThread();

        Thread t4 = new MyThread();

        Thread t5 = new MyThread();

        //将线程放入池中进行执行

        pool.execute(t1);

        pool.execute(t2);

        pool.execute(t3);

        pool.execute(t4);

        pool.execute(t5);

        //关闭线程池

        pool.shutdown();

    }

}

输出结果:

pool-1-thread-2正在执行。。。

pool-1-thread-4正在执行。。。

pool-1-thread-3正在执行。。。

pool-1-thread-1正在执行。。。

pool-1-thread-5正在执行。。。

4newScheduledThreadPool

TestScheduledThreadPoolExecutor.java

publicclass TestScheduledThreadPoolExecutor {

    publicstaticvoid main(String[] args) {

        ScheduledThreadPoolExecutor exec = new ScheduledThreadPoolExecutor(1);

        exec.scheduleAtFixedRate(new Runnable() {//每隔一段时间就触发异常

                      @Override

                      publicvoid run() {

                           //throw new RuntimeException();

                           System.out.println("================");

                      }

                  }, 1000, 5000, TimeUnit.MILLISECONDS);

        exec.scheduleAtFixedRate(new Runnable() {//每隔一段时间打印系统时间,证明两者是互不影响的

                      @Override

                      publicvoid run() {

                           System.out.println(System.nanoTime());

                      }

                  }, 1000, 2000, TimeUnit.MILLISECONDS);

    }

}

出口结果

================

8384644549516

8386643829034

8388643830710

================

8390643851383

8392643879319

8400643939383

 

 

You can leave a response, or trackback from your own site.

Leave a Reply

网站地图xml地图