Cyh的博客
Email:kissyan4916@163.com
posts - 26, comments - 19, trackbacks - 0, articles - 220
导航
BlogJava
首页
新随笔
联系
聚合
管理
公告
一直努力努力努力,像奴隶奴隶奴隶!~~
<
2024年11月
>
日
一
二
三
四
五
六
27
28
29
30
31
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
1
2
3
4
5
6
7
常用链接
我的随笔
我的文章
我的评论
我的参与
最新评论
随笔档案
(25)
2011年5月 (1)
2010年4月 (12)
2010年1月 (1)
2009年12月 (2)
2009年6月 (1)
2009年4月 (4)
2009年2月 (4)
文章分类
(219)
Android(26)
DB(5)
J2EE(31)
J2SE(79)
JavaScript(15)
others(47)
SOA&Web Service(1)
中间件(1)
软件工程(12)
软件架构(2)
文章档案
(220)
2011年8月 (1)
2010年12月 (23)
2010年11月 (2)
2010年8月 (5)
2010年7月 (2)
2010年6月 (2)
2010年5月 (1)
2010年4月 (12)
2010年3月 (28)
2010年2月 (5)
2010年1月 (23)
2009年12月 (39)
2009年6月 (14)
2009年5月 (31)
2009年3月 (2)
2009年2月 (29)
2009年1月 (1)
新闻档案
(66)
2010年10月 (1)
2010年9月 (5)
2010年8月 (11)
2010年7月 (21)
2010年6月 (13)
2010年5月 (8)
2010年4月 (5)
2009年11月 (2)
相册
Ryan
收藏夹
(7)
JAVA(7)
最新随笔
1. 集成FCKeditor 3.5.3
2. android自适应屏幕方向和大小
3. Android游戏开发之旅(二十) 双按事件捕获
4. Android游戏开发之旅(十八) SoundPool类
5. Android游戏开发之旅(十九) 分辨率大全
6. Android游戏开发之旅(十七) 图像渐变特效
7. Android游戏开发之旅(十六) 异步音乐播放
8. Android游戏开发之旅(十四) 游戏开发实战一
9. Android游戏开发之旅(十五) 按键中断处理
10. Android游戏开发之旅(十二)Sensor重力感应(2)
搜索
最新评论
1. re: struts2 checkboxlist标签的使用
同居同意同意
--yuk
2. re: struts2 checkboxlist标签的使用
ss
--d
3. re: JavaMail(4)--使用POP3接收邮件
邮件信息可以打印出来,可是下载邮件会出错是什么原因?
--琳喵喵0721
4. re: JavaMail(4)--使用POP3接收邮件
评论内容较长,点击标题查看
--流风
5. re: 操作PDF文件
评论内容较长,点击标题查看
--ly.wolf
阅读排行榜
1. struts2 checkboxlist标签的使用(18223)
2. struts2异常拦截器(5857)
3. struts2迭代标签(3845)
4. 用freemind 秒杀Spring Security(1914)
5. 加载顺序会影响对spring bean 的调用。(1489)
线程--任务执行架构
Posted on 2009-12-22 20:53
啥都写点
阅读(555)
评论(0)
编辑
收藏
所属分类:
J2SE
Executor服务对象是用来执行Runnable任务的,常用的方法如下:
execute方法用于执行Ruannable类型的任务。
ExecutorService服务对象能执行和终止Callable任务,它继承了Executor,所以也能执行Runnable任务。常用的方法如下:
submit方法用来提交Callable 或Runnable任务,并返回代表此任务的Future对象。
invokeAll方法批处理任务集合,并返回一个代表这些任务的Future对象集合。
shutdown方法在完成已提交的任务后关闭服务,不再接受新任务。
shutdownNow方法停止所有正在执行的任务并关闭服务。
isTerminated测试是否所有任务都执行完毕了。
isShuttdown测试是否该ExecutorService已被关闭。
ScheduledExecutorService服务对象继承ExecutorService,提供了按时间安排执行任务的功能。常用的方法如下:
a>schedule(task,initDelay)方法安排所提交的Runnable任务按指定的间隔重复执行。
b>scheduleAtFixedRate方法安排所提交的Runnable任务按指定的间隔重复执行。
c>sheduleWithFixedDelay方法安排所提交的Runnable任务在每次执行完后,等待delay所指定的时间后重复执行。
Executors类用来创建各种服务对象,常用的方法如下:
a> callable(Runnable task)方法将Runnable的任务转化成Callable的任务。
b> newSingleThreadExecutor方法产生一个ExecutorService对象,这个对象只有一个线程可用来执行任务,若任务多于一个,则按先后顺序执行任务。
c>newCachedThreadPool方法产生一个ExecutorService对象,这个对象带有一个线程池,线程池的大小会根据需要调整,线程执行完任务后返回线程池,供执行下一次任务使用。
d>newFixedThreadPool(int poolSize)方法产生一个ExecutorService对象,这个对象带有一个大小为poolSize的线程池,若任务数量大于poolSize,任务会被放在一个队列里顺序执行
e> newSingleThreadScheduledExecutor方法产生一个ScheduledExecutorService对象,这个对象的线程池大小为1,若任务多余一个,任务将按先后顺序执行。
f>newScheduledThreadPool(int poolSize) 方法产生一个ScheduleExecutorService对象,这个对象的线程池大小为poolSize,若任务数量大于poolSize,任务会在一个队列里等待执行。
import
java.util.concurrent.Callable;
import
java.util.concurrent.ExecutionException;
import
java.util.concurrent.ExecutorService;
import
java.util.concurrent.Executors;
import
java.util.concurrent.Future;
import
java.util.concurrent.ScheduledExecutorService;
import
java.util.concurrent.TimeUnit;
/** */
/**
* 新的任务执行架构。
* 在Java 5.0之前启动一个任务是通过调用Thread类的start()方法来实现的,
* 任务的提于交和执行是同时进行的,如果你想对任务的执行进行调度,
* 或是控制同时执行的线程数量就需要额外编写代码来完成。
* 5.0里提供了一个新的任务执行架构使你可以轻松地调度和控制任务的执行,
* 并且可以建立一个类似数据库连接池的线程池来执行任务。
* 这个架构主要有三个接口和其相应的具体类组成。
* 这三个接口是Executor, ExecutorService和ScheduledExecutorService。
* (1)Executor接口:是用来执行Runnable任务的,它只定义一个方法:
* execute(Runnable command):执行Ruannable类型的任务
* (2)ExecutorService:继承了Executor的方法,并提供了执行Callable任务和中止任务执行的服务,
* 其定义的方法主要有:
* submit(task):可用来提交Callable或Runnable任务,并返回代表此任务的Future对象
* invokeAll(collection of tasks):批处理任务集合,并返回一个代表这些任务的Future对象集合
* shutdown():在完成已提交的任务后关闭服务,不再接受新任务
* shutdownNow():停止所有正在执行的任务并关闭服务。
* isTerminated():测试是否所有任务都执行完毕了。
* isShutdown():测试是否该ExecutorService已被关闭
* (3)ScheduledExecutorService:继承ExecutorService,提供了按时间安排执行任务的功能、
* schedule(task, initDelay): 安排所提交的Callable或Runnable任务在initDelay指定的时间后执行。
* scheduleAtFixedRate():安排所提交的Runnable任务按指定的间隔重复执行
* scheduleWithFixedDelay():安排所提交的Runnable任务在每次执行完后,等待delay所指定的时间后重复执行。
*
* 通过Executors类来获得各种服务对象。
* callable(Runnable task): 将Runnable的任务转化成Callable的任务
* newSingleThreadExecutor: 产生一个ExecutorService对象,这个对象只有一个线程可用来执行任务,若任务多于一个,任务将按先后顺序执行。
* newCachedThreadPool(): 产生一个ExecutorService对象,这个对象带有一个线程池,线程池的大小会根据需要调整,线程执行完任务后返回线程池,供执行下一次任务使用。
* newFixedThreadPool(int poolSize):产生一个ExecutorService对象,这个对象带有一个大小为poolSize的线程池,若任务数量大于poolSize,任务会被放在一个queue里顺序执行。
* newSingleThreadScheduledExecutor:产生一个ScheduledExecutorService对象,这个对象的线程池大小为1,若任务多于一个,任务将按先后顺序执行。
* newScheduledThreadPool(int poolSize): 产生一个ScheduledExecutorService对象,这个对象的线程池大小为poolSize,若任务数量大于poolSize,任务会在一个queue里等待执行
*/
public
class
ExecuteArch
{
/** */
/**
* 该线程输出一行字符串
*/
public
static
class
MyThread
implements
Runnable
{
public
void
run()
{
System.out.println(
"
Task repeating.
"
+
System.currentTimeMillis());
try
{
Thread.sleep(
1000
);
}
catch
(InterruptedException e)
{
System.out.println(
"
Task interrupted.
"
+
System.currentTimeMillis());
}
}
}
/** */
/**
* 该Callable结束另一个任务
*/
public
static
class
MyCallable
implements
Callable
{
private
Future future;
public
MyCallable(Future future)
{
this
.future
=
future;
}
public
String call()
{
System.out.println(
"
To cancell Task
"
+
+
System.currentTimeMillis());
this
.future.cancel(
true
);
return
"
Task cancelled!
"
;
}
}
/** */
/**
*
@param
args
*
@throws
ExecutionException
*
@throws
InterruptedException
*/
public
static
void
main(String[] args)
throws
InterruptedException,
ExecutionException
{
//
产生一个ExecutorService对象,这个对象带有一个线程池,线程池的大小会根据需要调整,
//
线程执行完任务后返回线程池,供执行下一次任务使用。
ExecutorService cachedService
=
Executors.newCachedThreadPool();
Future myThreadFuture
=
cachedService.submit(
new
MyThread());
Future myCallableFuture
=
cachedService.submit(
new
MyCallable(
myThreadFuture));
System.out.println(myCallableFuture.get());
System.out.println(
"
-----------------
"
);
//
将Runnable任务转换成Callable任务
Callable myThreadCallable
=
Executors.callable(
new
MyThread());
Future myThreadCallableFuture
=
cachedService.submit(myThreadCallable);
//
对于Runnable任务,转换成Callable任务后,也没有返回值
System.out.println(myThreadCallableFuture.get());
cachedService.shutdownNow();
System.out.println(
"
-----------------
"
);
//
产生一个ExecutorService对象,这个对象带有一个大小为poolSize的线程池,
//
若任务数量大于poolSize,任务会被放在一个queue里顺序执行
ExecutorService fixedService
=
Executors.newFixedThreadPool(
2
);
fixedService.submit(
new
MyThread());
fixedService.submit(
new
MyThread());
//
由于线程池大小为2,所以后面的任务必须等待前面的任务执行完后才能被执行。
myThreadFuture
=
fixedService.submit(
new
MyThread());
myCallableFuture
=
fixedService.submit(
new
MyCallable(myThreadFuture));
System.out.println(myCallableFuture.get());
fixedService.shutdownNow();
System.out.println(
"
-----------------
"
);
//
产生一个ScheduledExecutorService对象,这个对象的线程池大小为poolSize,
//
若任务数量大于poolSize,任务会在一个queue里等待执行
ScheduledExecutorService fixedScheduledService
=
Executors
.newScheduledThreadPool(
2
);
//
新建任务1
MyThread task1
=
new
MyThread();
//
使用任务执行服务立即执行任务1,而且此后每隔2秒执行一次任务1。
myThreadFuture
=
fixedScheduledService.scheduleAtFixedRate(task1,
0
,
2
,
TimeUnit.SECONDS);
//
新建任务2
MyCallable task2
=
new
MyCallable(myThreadFuture);
//
使用任务执行服务等待5秒后执行任务2,执行它后会将任务1关闭。
myCallableFuture
=
fixedScheduledService.schedule(task2,
5
,
TimeUnit.SECONDS);
System.out.println(myCallableFuture.get());
fixedScheduledService.shutdownNow();
}
}
--
学海无涯
Powered by:
BlogJava
Copyright © 啥都写点