java多线程实现uable(java多线程用法)

导语：java多线程—Runnable、Thread、Callable区别

多线程编程优点：

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

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

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 }

输出结果为：

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

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

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

Runnable是可以共享数据的，多个Thread可以同时加载一个Runnable，当各自Thread获得CPU时间片的时候开始运行Runnable，Runnable里面的资源是被共享的，所以使用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 }

输出结果：

在第二种方法（Runnable）中，ticket输出的顺序并不是54321，这是因为线程执行的时机难以预测，ticket--并不是原子操作(关于原子操作后边会有详解)。在第一种方法中，我们new了3个Thread对象，即三个线程分别执行三个对象中的代码，因此便是三个线程去独立地完成卖票的任务；而在第二种方法中，我们同样也new了3个Thread对象，但只有一个Runnable对象，3个Thread对象共享这个Runnable对象中的代码，因此，便会出现3个线程共同完成卖票任务的结果。如果我们new出3个Runnable对象，作为参数分别传入3个Thread对象中，那么3个线程便会独立执行各自Runnable对象中的代码，即3个线程各自卖5张票。在第二种方法中，由于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 }

运行结果如下：

总结

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

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

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

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

本文内容由小德整理编辑！