java多线程—Runnable、Thread、Callable区别

时间:2022-03-25 17:34:51

多线程编程优点

  1. 进程之间不能共享内存,但线程之间共享内存非常容易。

  2. 系统创建线程所分配的资源相对创建进程而言,代价非常小。

Java中实现多线程有3种方法:

  • 继承Thread类

  • 实现Runnable接口

  • 实现Callable接口(参考<Java编程思想(第4版)>  21.2.4章节,原来一直以为是2种,后来发现是3种)

第一种实现方法—继承Thread类

继承Thread类,需要覆盖方法 run()方法,在创建Thread类的子类时需要重写 run(),加入线程所要执行的代即可。

下边是一个卖票程序小例子:

 1 package ThreadOne;
 2 
 3 public class ThreadByExtends {
 4 
 5     public static void main(String[] args) {
 6         // TODO Auto-generated method stub
 7         new MyThread().start();
 8         new MyThread().start();
 9         new MyThread().start();
10     }
11 
12 }
13 
14 class MyThread extends Thread {
15     private int ticket = 5;
16 
17     public void run() {
18 
19         for (int i = 0; i < 10; i++) {
20             if (ticket > 0) {
21                 System.out.println("车票第" + ticket-- + "张");
22             }
23         }
24     }
25 
26 }

输出结果为:

java多线程—Runnable、Thread、Callable区别

这样代码的写法简单,符合大家的习惯,但是直接继承Thread类有一个很大的缺点,因为“java类的继承是单一的,extends后面只能指定一个父类”,所有如果当前类继承Thread类之后就不可以继承其他类。如果我们的类已经从一个类继承(如Swing继承自 Panle 类、JFram类等),则无法再继承 Thread 类,这时如果我们又不想建立一个新的类,应该怎么办呢?

第二种实现方法—实现Runnable接口

如果要实现多继承就得要用implements,Java 提供了接口 java.lang.Runnable 来解决上边的问题。

Runnable是可以共享数据的,多个Thread可以同时加载一个Runnable,当各自Thread获得CPU时间片的时候开始运行RunnableRunnable里面的资源是被共享的,所以使用Runnable更加的灵活。

下边还是卖票例子:

 1 package ThreadOne;
 2 
 3 public class ThreadRunnable {
 4 
 5     public static void main(String[] args) {
 6         MyThread1 myThread = new MyThread1();
 7         new Thread(myThread).start();
 8         new Thread(myThread).start();
 9     }
10 }
11 
12 class MyThread1 implements Runnable {
13 
14     private int ticket = 5;
15 
16     public void run() {
17         for (int i = 0; i < 10; i++) {
18             if (ticket > 0) {
19                 System.out.println("ticket = " + ticket--);
20             }
21         }
22     }
23 
24 }

 

输出结果:

java多线程—Runnable、Thread、Callable区别

  1. 在第二种方法(Runnable)中,ticket输出的顺序并不是54321,这是因为线程执行的时机难以预测,ticket--并不是原子操作(关于原子操作后边会有详解)。
  2. 在第一种方法中,我们new了3个Thread对象,即三个线程分别执行三个对象中的代码,因此便是三个线程去独立地完成卖票的任务;而在第二种方法中,我们同样也new了3个Thread对象,但只有一个Runnable对象,3个Thread对象共享这个Runnable对象中的代码,因此,便会出现3个线程共同完成卖票任务的结果。如果我们new出3个Runnable对象,作为参数分别传入3个Thread对象中,那么3个线程便会独立执行各自Runnable对象中的代码,即3个线程各自卖5张票。
  3. 在第二种方法中,由于3个Thread对象共同执行一个Runnable对象中的代码,因此可能会造成线程的不安全,比如可能ticket会输出-1(如果我们System.out....语句前加上线程休眠操作,该情况将很有可能出现),这种情况的出现是由于,一个线程在判断ticket为1>0后,还没有来得及减1,另一个线程已经将ticket减1,变为了0,那么接下来之前的线程再将ticket减1,便得到了-1。这就需要加入同步操作(即互斥锁),确保同一时刻只有一个线程在执行每次for循环中的操作。而在第一种方法中,并不需要加入同步操作,因为每个线程执行自己Thread对象中的代码,不存在多个线程共同执行同一个方法的情况。

第三种—实现Callable接口

Runnable是执行工作的独立任务,但是它不返回任何值。如果你希望任务在完成的能返回一个值,那么可以实现Callable接口而不是Runnable接口。在Java SE5中引入的Callable是一种具有类型参数的泛型,它的参数类型表示的是从方法call()(不是run())中返回的值。

例子如下:

 1 package ThreadOne;
 2 
 3 import java.awt.Panel;
 4 import java.util.concurrent.Callable;
 5 import java.util.concurrent.Future;
 6 import java.util.concurrent.FutureTask;
 7 
 8 public class ThreadCallable extends Panel {
 9 
10     public static void main(String[] args) {
11 
12         MyThread2 myThread2 = new MyThread2();
13 
14         FutureTask<Integer> futureTask = new FutureTask<>(myThread2);
15         new Thread(futureTask, "线程名:有返回值的线程2").start();
16 
17         try {
18             System.out.println("子线程的返回值:" + futureTask.get());
19         } catch (Exception e) {
20             e.printStackTrace();
21         }
22     }
23 }
24 
25 class MyThread2 implements Callable<Integer> {
26 
27     public Integer call() throws Exception {
28         System.out.println("当前线程名——" + Thread.currentThread().getName());
29         int i = 0;
30         for (; i < 5; i++) {
31             System.out.println("循环变量i的值:" + i);
32         }
33 
34         return i;
35     }
36 
37 }

 

运行结果如下:

java多线程—Runnable、Thread、Callable区别

总结

实现Runnable接口相比继承Thread类有如下优势:

  1. 可以避免由于Java的单继承特性而带来的局限;
  2. 增强程序的健壮性,代码能够被多个线程共享,代码与数据是独立的;
  3. 适合多个相同程序代码的线程区处理同一资源的情况。

 

实现Runnable接口和实现Callable接口的区别:

  1. Runnable是自从java1.1就有了,而Callable是1.5之后才加上去的
  2. Callable规定的方法是call(),Runnable规定的方法是run()
  3. Callable的任务执行后可返回值,而Runnable的任务是不能返回值(是void)
  4. call方法可以抛出异常,run方法不可以
  5. 运行Callable任务可以拿到一个Future对象,表示异步计算的结果。它提供了检查计算是否完成的方法,以等待计算的完成,并检索计算的结果。通过Future对象可以了解任务执行情况,可取消任务的执行,还可获取执行结果。
  6. 加入线程池运行,Runnable使用ExecutorService的execute方法,Callable使用submit方法。

参考

http://blog.csdn.net/ns_code/article/details/17161237

http://tonl.iteye.com/blog/1874187