java创建两个线程的方法和它们的区别
◆需要从Java.lang.Thread类派生一个新的线程类，重载它的run()方法；
◆实现Runnalbe接口，重载Runnalbe接口中的run()方法。
为什么Java要提供两种方法来创建线程呢？它们都有哪些区别？相比而言，哪一种方法更好呢？
在Java中，类仅支持单继承，也就是说，当定义一个新的类的时候，它只能扩展一个外部类.这样，如果创建自定义线程类的时候是通过扩展 Thread类的方法来实现的，那么这个自定义类就不能再去扩展其他的类，也就无法实现更加复杂的功能。因此，如果自定义类必须扩展其他的类，那么就可以使用实现Runnable接口的方法来定义该类为线程类，这样就可以避免Java单继承所带来的局限性。
还有一点最重要的就是使用实现Runnable接口的方式创建的线程可以处理同一资源，从而实现资源的共享.
（1）通过扩展Thread类来创建多线程
假设一个影院有三个售票口，分别用于向儿童、成人和老人售票。影院为每个窗口放有100张电影票，分别是儿童票、成人票和老人票。三个窗口需要同时卖票，而现在只有一个售票员，这个售票员就相当于一个CPU，三个窗口就相当于三个线程。通过程序来看一看是如何创建这三个线程的。
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
<SPAN style="FONT-SIZE: 16px">publicclass MutliThreadDemo {
publicstatic void main(String [] args){
MutliThread m1=newMutliThread("Window 1");
MutliThread m2=newMutliThread("Window 2");
MutliThread m3=newMutliThread("Window 3");
m1.start();
m2.start();
m3.start();
}
}
class MutliThread extends Thread{
privateint ticket=100;//每个线程都拥有100张票
MutliThread(String name){
super(name);//调用父类带参数的构造方法
}
publicvoid run(){
while(ticket>0){
System.out.println(ticket--+" is saled by "+Thread.currentThread().getName());
}
}
}
</SPAN>
程序中定义一个线程类，它扩展了Thread类。利用扩展的线程类在MutliThreadDemo类的主方法中创建了三个线程对象，并通过start()方法分别将它们启动。
从结果可以看到，每个线程分别对应100张电影票，之间并无任何关系，这就说明每个线程之间是平等的，没有优先级关系，因此都有机会得到CPU的处理。但是结果显示这三个线程并不是依次交替执行，而是在三个线程同时被执行的情况下，有的线程被分配时间片的机会多，票被提前卖完，而有的线程被分配时间片的机会比较少，票迟一些卖完。
可见，利用扩展Thread类创建的多个线程，虽然执行的是相同的代码，但彼此相互独立，且各自拥有自己的资源，互不干扰。
（2）通过实现Runnable接口来创建多线程
?
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
<SPAN style="FONT-SIZE: 16px">publicclass MutliThreadDemo2 {
publicstatic void main(String [] args){
MutliThread m1=newMutliThread("Window 1");
MutliThread m2=newMutliThread("Window 2");
MutliThread m3=newMutliThread("Window 3");
Thread t1=newThread(m1);
Thread t2=newThread(m2);
Thread t3=newThread(m3);
t1.start();
t2.start();
t3.start();
}
}
class MutliThread implements Runnable{
privateint ticket=100;//每个线程都拥有100张票
privateString name;
MutliThread(String name){
this.name=name;
}
publicvoid run(){
while(ticket>0){
System.out.println(ticket--+" is saled by "+name);
}
}
}
</SPAN>
由于这三个线程也是彼此独立，各自拥有自己的资源，即100张电影票，因此程序输出的结果和（1）结果大同小异。均是各自线程对自己的100张票进行单独的处理，互不影响。
可见，只要现实的情况要求保证新建线程彼此相互独立，各自拥有资源，且互不干扰，采用哪个方式来创建多线程都是可以的。因为这两种方式创建的多线程程序能够实现相同的功能。
由于这三个线程也是彼此独立，各自拥有自己的资源，即100张电影票，因此程序输出的结果和例4.2.1的结果大同小异。均是各自线程对自己的100张票进行单独的处理，互不影响。
可见，只要现实的情况要求保证新建线程彼此相互独立，各自拥有资源，且互不干扰，采用哪个方式来创建多线程都是可以的。因为这两种方式创建的多线程程序能够实现相同的功能。
（3）通过实现Runnable接口来实现线程间的资源共享
现实中也存在这样的情况，比如模拟一个火车站的售票系统，假如当日从A地发往B地的火车票只有100张，且允许所有窗口卖这100张票，那么每一个窗口也相当于一个线程，但是这时和前面的例子不同之处就在于所有线程处理的资源是同一个资源，即100张车票。如果还用前面的方式来创建线程显然是无法实现的，这种情况该怎样处理呢？看下面这个程序，程序代码如下所示：
View Code?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
<SPAN style="FONT-SIZE: 16px">publicclass MutliThreadDemo3 {
publicstatic void main(String [] args){
MutliThread m=newMutliThread();
Thread t1=newThread(m,"Window 1");
Thread t2=newThread(m,"Window 2");
Thread t3=newThread(m,"Window 3");
t1.start();
t2.start();
t3.start();
}
}
class MutliThread implements Runnable{
privateint ticket=100;//每个线程都拥有100张票
publicvoid run(){
while(ticket>0){
System.out.println(ticket--+" is saled by "+Thread.currentThread().getName());
}
}
}
</SPAN>
结果正如前面分析的那样，程序在内存中仅创建了一个资源，而新建的三个线程都是基于访问这同一资源的，并且由于每个线程上所运行的是相同的代码，因此它们执行的功能也是相同的。
可见，如果现实问题中要求必须创建多个线程来执行同一任务，而且这多个线程之间还将共享同一个资源，那么就可以使用实现Runnable接口的方式来创建多线程程序。而这一功能通过扩展Thread类是无法实现的，读者想想看，为什么？
实现Runnable接口相对于扩展Thread类来说，具有无可比拟的优势。这种方式不仅有利于程序的健壮性，使代码能够被多个线程共享，而且代码和数据资源相对独立，从而特别适合多个具有相同代码的线程去处理同一资源的情况。这样一来，线程、代码和数据资源三者有效分离，很好地体现了面向对象程序设计的思想。因此，几乎所有的多线程程序都是通过实现Runnable接口的方式来完成的。
方法 1、通过扩展Thread类来创建多线程
假设一个影院有三个售票口，分别用于向儿童、成人和老人售票。影院为每个窗口放有100张电影票，分别是儿童票、成人票和老人票。三个窗口需要同时卖票，而现在只有一个售票员，这个售票员就相当于一个CPU，三个窗口就相当于三个线程。通过程序来看一看是如何创建这三个线程的。
1 public class MutliThreadDemo {
2 public static void main(String[] args) {
3 MutliThread m1=new MutliThread("Window 1");
4 MutliThread m2=new MutliThread("Window 2");
5 MutliThread m3=new MutliThread("Window 3");
6 m1.start();
7 m2.start();
8 m3.start();
9 }
10 }
1 public class MutliThread extends Thread {
2 private int ticket=100;//每个线程都拥有100张票
3
4 public MutliThread (){}
5 public MutliThread (String name){
6 super(name);
7 }
8
9 @Override
10 public void run() {
11 while(ticket>0){
12 System.out.println(ticket--+" is saled by "+Thread.currentThread().getName());
13 }
14 }
15 }
程序中定义一个线程类，它扩展了Thread类。利用扩展的线程类在MutliThreadDemo类的主方法中创建了三个线程对象，并通过start()方法分别将它们启动。
从结果可以看到，每个线程分别对应100张电影票，之间并无任何关系，这就说明每个线程之间是平等的，没有优先级关系，因此都有机会得到CPU的处理。但是结果
显示这三个线程并不是依次交替执行，而是在三个线程同时被执行的情况下，有的线程被分配时间片的机会多，票被提前卖完，而有的线程被分配时间片的机会比较
少，票迟一些卖完。
可见，利用扩展Thread类创建的多个线程，虽然执行的是相同的代码，但彼此相互独立，且各自拥有自己的资源，互不干扰。
2、通过实现Runnable接口来创建多线程
1 public class MutliThreadDemo {
2 public static void main(String[] args) {
3 MutliThread m1=new MutliThread("Window 1");
4 MutliThread m2=new MutliThread("Window 2");
5 MutliThread m3=new MutliThread("Window 3");
6 Thread t1=new Thread(m1);
7 Thread t2=new Thread(m2);
8 Thread t3=new Thread(m3);
9 t1.start();
10 t2.start();
11 t3.start();
12 }
13 }
1 public class MutliThread implements Runnable{
2 private int ticket=100;//每个线程都拥有100张票
3 private String name;
4 MutliThread(String name){
5 this.name=name;
6 }
7 public void run(){
8 while(ticket>0){
9 System.out.println(ticket--+" is saled by "+name);
10 }
11 }
12 }
由于这三个线程也是彼此独立，各自拥有自己的资源，即100张电影票，因此程序输出的结果和 1 结果大同小异。均是各自线程对自己的100张票进行单独的处理，互不影响。
可见，只要现实的情况要求保证新建线程彼此相互独立，各自拥有资源，且互不干扰，采用哪个方式来创建多线程都是可以的。因为这两种方式创建的多线程程序能够实现相同的功能。
3、通过实现Runnable接口来实现线程间的资源共享
现实中也存在这样的情况，比如模拟一个火车站的售票系统，假如当日从A地发往B地的火车票只有100张，且允许所有窗口卖这100张票，那么每一个窗口也相当于一个线程，但是这时和前面的例子不同之处就在于所有线程处理的资源是同一个资源，即100张车票。如果还用前面的方式来创建线程显然是无法实现的，这种情况该怎样处理呢？看下面这个程序，程序代码如下所示：
1 public class MutliThreadDemo {
2 public static void main(String[] args) {
3 MutliThread m=new MutliThread();
4 Thread t1=new Thread(m);
5 Thread t2=new Thread(m);
6 Thread t3=new Thread(m);
7 t1.start();
8 t2.start();
9 t3.start();
10 }
11 }
1 public class MutliThread implements Runnable{
2 private int ticket=100;//每个线程都拥有100张票
3 public void run(){
4 while(ticket>0){
5 System.out.println(ticket--+" is saled by "+Thread.currentThread());
6 }
7 }
8 }
结果正如前面分析的那样，程序在内存中仅创建了一个资源，而新建的三个线程都是基于访问这同一资源的，并且由于每个线程上所运行的是相同的代码，因此它们执行的功能也是相同的。
可见，如果现实问题中要求必须创建多个线程来执行同一任务，而且这多个线程之间还将共享同一个资源，那么就可以使用实现Runnable接口的方式来创建多线程程序。而这一功能通过扩展Thread类是无法实现的，读者想想看，为什么？
实现Runnable接口相对于扩展Thread类来说，具有无可比拟的优势。这种方式不仅有利于程序的健壮性，使代码能够被多个线程共享，而且代码和数据资源相对独立，从而特别适合多个具有相同代码的线程去处理同一资源的情况。这样一来，线程、代码和数据资源三者有效分离，很好地体现了面向对象程序设计的思想。因此，几乎所有的多线程程序都是通过实现Runnable接口的方式来完成的。
区别
第1只线程创建的办法有1个弊端:
线程和线程可以运行的任务概念有了1起，重用性有限制。
更多时候可以把线程和线程可以运行的任务分解开
求教高手:第1只办法如何解释是线程和任务概念有了1起，如何解释了重用性有限制
第2只办法如何查看出的无概念有1起 ，重用性没有限制?
办理解不了，着急上火，感谢感谢感谢感谢帮帮忙。
public class Th读取Demo {
public st安奈特c void main(String[] args) {
Th读取 p1 = new Person1();
Th读取 p2 = new Person2();
p1.start();
p2.start();
}
}
//左右是第1只创建线程的办法
class Person1 extends Th读取{
public void run(){
for(int i=0;i<1000;i++){
System.out.println("我是线程1");
}
}
}
class Person2 extends Th读取{
public void run(){
for(int i=0;i<1000;i++){
System.out.println("我是线程2");
}
}
}
---------------------------------------------------------------------------------------------------------------------------------
public class Th读取Demo2 {
public st安奈特c void main(String[] args) {
Runnable runnable1 = new Person3();
Runnable runnable2 = new Person4();
Th读取 t1 = new Th读取(runnable1);
Th读取 t2 = new Th读取(runnable2);
t1.start();
t2.start();
}
}
//左右是第2只创建线程的办法
class Person3 implements Runnable{
public void run() {
for(int i=0;i<1000;i++){
System.out.println("我是线程3?");
}
}
}
class Person4implements Runnable{
public void run() {
for(int i =0;i<1000;i++){
System.out.println("我是线程4");
}
}
}
