麻痹的线程，老子一定搞懂你

【通过继承Thread】

　　一个Thread对象只能创建一个线程，即使它调用多次的.start()也会只运行一个的线程。

　　【看下面的代码 & 输出结果】


1 package Test;
2
3 class CTest extends Thread {
4 private int tickte = 20;
5
6 public void run() {
7 while (true) {
8 if (tickte > 0) {
9 System.out.println(Thread.currentThread().getName() + " 出售票 "
10 + tickte--);
11 } else {
12 System.exit(0);
13 }
14 }
15 }
16
17 }
18
19 public class Demo3 {
20 public static void main(String[] args) {
21 // new CTest().start();
22 // new CTest().start();
23 Thread t1 = new CTest();//创建一个线程
24 t1.start();
25 t1.start();
26 }
27 }
28
29 //
30 Thread-0 出售票 20
31 Thread-0 出售票 19
32 Thread-0 出售票 18
33 Thread-0 出售票 17
34 Thread-0 出售票 16
35 Thread-0 出售票 15
36 Thread-0 出售票 14
37 Thread-0 出售票 13
38 Thread-0 出售票 12
39 Thread-0 出售票 11
40 Thread-0 出售票 10
41 Thread-0 出售票 9
42 Thread-0 出售票 8
43 Thread-0 出售票 7
44 Thread-0 出售票 6
45 Thread-0 出售票 5
46 Thread-0 出售票 4
47 Thread-0 出售票 3
48 Thread-0 出售票 2
49 Thread-0 出售票 1
通过调用当前线程对象的名字Thread.currentThread.getName()，根据结果可以看出，只运行了一个线程。

这就说明了一个问题，每创建一个Thread对象，只能创建一个线程。

下面是创建多个Thread对象。




package Test;

class CTest extends Thread {
private int tickte = 20;

public void run() {
while (true) {
if (tickte > 0) {
System.out.println(Thread.currentThread().getName() + " 出售票 "
+ tickte--);
} else {
System.exit(0);
}
}
}

}

public class Demo3 {
public static void main(String[] args) {
new CTest().start();
new CTest().start();
}
} 上面启动了两个线程对象，他们各自执行自己的互不影响。

结果：


Thread-0 出售票 20
Thread-1 出售票 20
Thread-1 出售票 19
Thread-0 出售票 19
Thread-0 出售票 18
Thread-0 出售票 17
Thread-0 出售票 16
Thread-0 出售票 15
Thread-0 出售票 14
Thread-0 出售票 13
Thread-0 出售票 12
Thread-0 出售票 11
Thread-0 出售票 10
Thread-0 出售票 9
Thread-0 出售票 8
Thread-0 出售票 7
Thread-0 出售票 6
Thread-0 出售票 5
Thread-0 出售票 4
Thread-0 出售票 3
Thread-0 出售票 2
Thread-0 出售票 1
Thread-1 出售票 18
Thread-1 出售票 17
Thread-1 出售票 16
Thread-1 出售票 15
Thread-1 出售票 14
Thread-1 出售票 13
Thread-1 出售票 12
Thread-1 出售票 11
Thread-1 出售票 10
Thread-1 出售票 9
Thread-1 出售票 8
Thread-1 出售票 7
Thread-1 出售票 6
Thread-1 出售票 5
Thread-1 出售票 4
Thread-1 出售票 3
Thread-1 出售票 2
Thread-1 出售票 1可以看出是创建了两个线程。他们各自执行自己的线程，互不影响。

【多个线程操作一个对象】

　　


01 public class ThreadDemo9_4
02 {
03 public static void main(String [] args)
04 {
05 TestThread t = new TestThread() ;
06 // 启动了四个线程，并实现了资源共享的目的
07 new Thread(t).start();
08 new Thread(t).start();
09 new Thread(t).start();
10 new Thread(t).start();
11 }
12 }
13 class TestThread implements Runnable
14 {
15 private int tickets=20;
16 public void run()
17 {
18 while(true)
19 {
20 if(tickets>0)
21 System.out.println(Thread.currentThread().getName()+"出售票"+tickets--);
22 }
23 }
24 }上面通过实现Runnable的方式启动四个进程，但是他们共同操纵同一对象，实现了资源的互斥共享。

结果：


Thread-1 出售票 10
Thread-1 出售票 8
Thread-1 出售票 7
Thread-1 出售票 6
Thread-1 出售票 5
Thread-2 出售票 9
Thread-1 出售票 4
Thread-1 出售票 2
Thread-1 出售票 1
Thread-2 出售票 3　　可以看出，虽然是两个线程，但是操作的却只有一个资源。但是从程序的输出结果来看，尽管启动了两个线程对象，但是结果都是操纵了同一个资源，实现了资源共享的目的。

　　可见，实现Runnable接口相对于继承Thread类来说，有如下显著的优势：
（1）、 适合多个相同程序代码的线程去处理同一资源的情况，把虚拟CPU（线程）同程序的代码、数据有效分离，较好地体现了面向对象的设计思想。
（2）、 可以避免由于Java的单继承特性带来的局限。开发中经常碰到这样一种情况，即：当要将已经继承了某一个类的子类放入多线程中，由于一个类不能同时有两个父类，所以不能用继承Thread类的方式，那么就只能采用实现Runnable接口的方式了。
（3）、 增强了程序的健壮性，代码能够被多个线程共享，代码与数据是独立的。当多个线程的执行代码来自同一个类的实例时，即称它们共享相同的代码。多个线程可以操作相同的数据，与它们的代码无关。当共享访问相同的对象时，即共享相同的数据。当线程被构造时，需要的代码和数据通过一个对象作为构造函数实参传递进去，这个对象就是一个实现了Runnable接口的类的实例。

　　可以将一个Runnable接口的实例化对象作为参数去实例化Thread类对象。在实际的开发中，希望读者尽可能去使用Runnable接口去实现多线程机制。