1创建线程的办法
直接继承Thread
实现Runnable接口
这2种方式都有一个缺陷就是:在执行完任务之后无法获取执行结果。如果需要获取执行结果,就必须通过共享变量或者使用线程通信的方式来达到效果,这样使用起来就比较麻烦。
而自从Java 1.5开始,就提供了Callable和Future,通过它们可以在任务执行完毕之后得到任务执行结果。Callable
2.Thread和Runnable区别
- Thread是类,需要继承,而只能继承一个父类,有局限性。
- Thread可直接用start()方法启动线程,而Runnable没有start()方法,需要使用newThread(object).start();
- Runnable就可以实现资源共享,而通过Thread类实现,各自线程的资源是独立的,不方便共享。
public static void main(String[] args) {
// TODO Auto-generated method stub
new MyThread().start();
new MyThread().start();
}
class MyThread extends Thread{
private int ticket = 5;
public void run(){
while(true){
System.out.println("Thread ticket = " + ticket--);
if(ticket < 0){
break;
}
}
}
}
//输出结果
Thread ticket = 5
Thread ticket = 5
Thread ticket = 4
Thread ticket = 4
Thread ticket = 3
Thread ticket = 2
Thread ticket = 3
Thread ticket = 1
Thread ticket = 2
Thread ticket = 0
Thread ticket = 1
Thread ticket = 0
public static void main(String[] args) {
// TODO Auto-generated method stub
MyThread2 m= new MyThread();
new Thread(m).start();
new Thread(m).start();
}
class MyThread2 implements Runnable{
private int ticket = 5;
public void run(){
while(true){
System.out.println("Runnable ticket = " + ticket--);
if(ticket < 0){
break;
}
}
}
}
//输出结果:资源的共享
Runnable ticket = 5
Runnable ticket = 4
Runnable ticket = 3
Runnable ticket = 2
Runnable ticket = 1
Runnable ticket = 0
3.Callable和Runnable
1.接口的定义
public interface Callable<V>
{
V call() throws Exception;
}
public interface Runnable {
public abstract void run();
}
2.Callable和Runnable的异同
Callable的call()方法类似于Runnable接口中run()方法,都定义任务要完成的工作,实现这两个接口时要分别重写这两个方法,主要的不同之处是call()方法是有返回值的(其实还有一些区别,例如call方法可以抛出异常,run方法不可以),运行Callable任务可以拿到一个Future对象,表示异步计算的结果。它提供了检查计算是否完成的方法,以等待计算的完成,并检索计算的结果。通过Future对象可以了解任务执行情况,可取消任务的执行,还可获取执行结果。
3.Callable类型的任务可以有两种执行方式
我们先定义一个Callable任务MyCallableTask:
class MyCallableTask implements Callable<Integer>{
@Override
public Integer call() throws Exception {
System.out.println("线程在进行计算");
Thread.sleep(3000);
int sum = 0;
for(int i=0;i<100;i++)
sum += i;
return sum;
}
}
①借助FutureTask执行
FutureTask类同时实现了两个接口,Future和Runnable接口,所以它既可以作为Runnable被线程执行,又可以作为Future得到Callable的返回值。
借助FutureTask执行的大体流程是:
Callable<Integer> mycallabletask = new MyCallableTask();
FutureTask<Integer> futuretask= new FutureTask<Integer>(mycallabletask);
new Thread(futuretask).start();
通过futuretask可以得到MyCallableTask的call()的运行结果:
futuretask.get()
②借助线程池来运行
线程池中执行Callable任务的原型例如:
public interface ExecutorService extends Executor {
//提交一个Callable任务,返回值为一个Future类型
<T> Future<T> submit(Callable<T> task);
//other methods...
}
借助线程池来运行Callable任务的一般流程为:
ExecutorService exec = Executors.newCachedThreadPool();
Future<Integer> future = exec.submit(new MyCallableTask());
通过future可以得到MyCallableTask的call()的运行结果:
future.get();
4.相关例子
a.Callable任务借助FutureTask运行:
public class CallableAndFutureTask {
public static void main(String[] args) {
Callable<Integer> callable = new Callable<Integer>() {
public Integer call() throws Exception {
return new Random().nextInt(100);
}
};
FutureTask<Integer> future = new FutureTask<Integer>(callable);
new Thread(future).start();
try {
Thread.sleep(5000);
System.out.println(**future.get()**);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
b.Callable任务和线程池一起使用,然后返回值是Future:
public class CallableAndFuture {
public static void main(String[] args) {
ExecutorService threadPool = Executors.newSingleThreadExecutor();
Future<Integer> future = threadPool.submit(new Callable<Integer>() {
public Integer call() throws Exception {
return new Random().nextInt(100);
}
});
try {
Thread.sleep(5000);// 可能做一些事情
System.out.println(future.get());
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
c.当执行多个Callable任务,有多个返回值时,我们可以创建一个Future的集合
class MyCallableTask implements Callable<String> {
private int id;
public OneTask(int id){
this.id = id;
}
@Override
public String call() throws Exception {
for(int i = 0;i<5;i++){
System.out.println("Thread"+ id);
Thread.sleep(1000);
}
return "Result of callable: "+id;
}
}
public class Test {
public static void main(String[] args) {
//Callable<String> mycallabletask = new MyCallableTask(1);
ExecutorService exec = Executors.newCachedThreadPool();
ArrayList<Future<String>> results = new ArrayList<Future<String>>();
for (int i = 0; i < 5; i++) {
results.add(exec.submit(new MyCallableTask(i)));
}
for (Future<String> fs : results) {
if (fs.isDone()) {
try {
System.out.println(fs.get());
} catch (Exception e) {
e.printStackTrace();
}
} else {
System.out.println("MyCallableTask任务未完成!");
}
}
exec.shutdown();
}
}