Java中Runnable和Thread的区别

  本文标签：Java　

  在java中可有两种 模式实现多线程，一种是继承Thread类，一种是实现Runnable接口；Thread类是在java.lang包中定义的 。一个类惟独继承了Thread类同时覆写了本类中的run() 步骤就 可以实现多线程操作了，然而一个类不得不继承一个父类，这是此步骤的局限 。
  下面看例子：
1 package org.thread.demo;
2 class MyThread extends Thread{
3 private String name;
4 public MyThread(String name) {
5 super();
6 this.name = name;
7 }
8 public void run(){
9 for(int i=0;i<10;i++){
10 System.out.println("线程开端："+this.name+",i="+i);
11 }
12 }
thread技术13 }
14 package org.thread.demo;
15 public class ThreadDemo01 {
16 public static void main(String[] args) {
17 MyThread mt1=new MyThread("线程a");
18 MyThread mt2=new MyThread("线程b");
19 mt1.run();
20 mt2.run();
21 }
22 }
  然而，此时后果很有法则，先第一个对象执行，而后第二个对象执行，并没有彼此运行 。在JDK的文档中 可以发现，一旦调用start() 步骤，则会通过JVM到run() 步骤 。下面启动start() 步骤启动线程：
23 package org.thread.demo;
24 public class ThreadDemo01 {
25 public static void main(String[] args) {
26 MyThread mt1=new MyThread("线程a");
27 MyThread mt2=new MyThread("线程b");
28 mt1.start();
29 mt2.start();
30 }
31 };
  这样程序 可以畸形实现交互式运行 。那么为啥非要 使用start(); 步骤启动多线程呢？
  在JDK的安装路径下，src.zip是所有的java源程序，通过此代码到Thread中的start() 步骤的定义， 可以发现此步骤中 使用了private native void start0();其中native 要害字示意 可以调用操作系统的底层函数，那么这样的技术成为JNI技术(java Native Interface)
  Runnable接口
  在实际开辟中一个多线程的操作很少 使用Thread类，而是通过Runnable接口实现 。
32 public interface Runnable{
33 public void run();
34 }
  例子：
35 package org.runnable.demo;
36 class MyThread implements Runnable{
37 private String name;
38 public MyThread(String name) {
39 this.name = name;
40 }
41 public void run(){
42 for(int i=0;i<100;i++){
43 System.out.println("线程开端："+this.name+",i="+i);
44 }
45 }
46 };
  然而在 使用Runnable定义的子类中没有start() 步骤，惟独Thread类中才有 。此时视察Thread类，有一个 构造 步骤：public Thread(Runnable targer)此 构造步骤承受Runnable的子类实例，也便是说 可以通过Thread类来启动Runnable实现的多线程 。(start() 可以协调系统的资源)：
47 package org.runnable.demo;
48 import org.runnable.demo.MyThread;
49 public class ThreadDemo01 {
50 public static void main(String[] args) {
51 MyThread mt1=new MyThread("线程a");
52 MyThread mt2=new MyThread("线程b");
53 new Thread(mt1).start();
54 new Thread(mt2).start();
55 }
56 }
  两种实现 模式的区别和联络：
  在程序开辟中惟独是多线程确定永远以实现Runnable接口为主，由于实现Runnable接口相比继承Thread类有如下 好处：
∙ 幸免点继承的局限，一个类 可以继承多个接口 。
∙ 合适于资源的共享
  以卖票程序为例，通过Thread类实现：
57 package org.demo.dff;
58 class MyThread extends Thread{
59 private int ticket=10;
60 public void run(){
61 for(int i=0;i<20;i++){
62 if(this.ticket>0){
63 System.out.println("卖票：ticket"+this.ticket--);
64 }
65 }
66 }
67 };
  下面通过三个线程对象，同时卖票：
68 package org.demo.dff;
69 public class ThreadTicket {
70 public static void main(String[] args) {
71 MyThread mt1=new MyThread();
72 MyThread mt2=new MyThread();
73 MyThread mt3=new MyThread();
74 mt1.start();//每个线程都各卖了10张，共卖了30张票 
75 mt2.start();//但实际惟独10张票，每个线程都卖自己的票 
76 mt3.start();//没有达到资源共享 
77 }
78 }
  假如用Runnable就 可以实现资源共享，下面看例子：
79 package org.demo.runnable;
80 class MyThread implements Runnable{
81 private int ticket=10;
82 public void run(){
83 for(int i=0;i<20;i++){
84 if(this.ticket>0){
85 System.out.println("卖票：ticket"+this.ticket--);
86 }
87 }
88 }
89 }
90 package org.demo.runnable;
91 public class RunnableTicket {
92 public static void main(String[] args) {
93 MyThread mt=new MyThread();
94 new Thread(mt).start();//同一个mt，然而在Thread中就不 可以，假如用同一 
95 new Thread(mt).start();//个实例化对象mt，就会浮现 异样 
96 new Thread(mt).start();
97 }
98 };
  固然现在程序中有三个线程，然而一共卖了10张票，也便是说 使用Runnable实现多线程 可以达到资源共享目标 。
  Runnable接口和Thread中间的联络：
  public class Thread extends Object implements Runnable
  发现Thread类也是Runnable接口的子类 。
  原文链接：blog.csdn/wwww1988600/article/details/7309070

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。