多线程有2种创建方式：
    <1>、通过实现Runnable接口定义一个由Thread驱动的任务，后通过把自己传给Thread的构造来启动一个线程。

1. public class ThreadImRunnable implements Runnable {
   
2. //实现接口中抽象方法
   
3. public void run() {
   
4.   System.out.println("[-ThreadImRunnable ]");
   
5. }
   
6. //Main方法
   
7. public static void main(String[] args) throws InterruptedException {
   
8.   //生成一个对象，并开启线程
   
9.   new Thread(new ThreadImRunnable()).start();
   
10. }
    
11. }

复制代码

    <2>、直接继承自Thread来创建线程。

1. public class ThreadExThread extends Thread {
   
2. //继承父类的接口
   
3. @Override
   
4. public void run() {
   
5.                     System.out.println("[-ThreadExThread ]");
   
6. }
   
7. //Main方法
   
8. public static void main(String[] args) throws InterruptedException {
   
9.   //生成一个对象，并开启线程
   
10.   new ThreadExThread().start();   
    
11. }
    
12. }

复制代码

利弊与区别：同一实例有不同的运行线程数量为例子

1. // 实现 Runnable 接口的线程
   
2. public class ThreadImRunnable implements Runnable {
   
3. private int x = 0;
   
4. 
   
5. // 实现接口中抽象方法
   
6. public void run() {
   
7. for (int i = 0; i < 10; i++) {
   
8. System.out.println("[#" + Thread.currentThread().getName() + "]"+ (++x));
   
9. }
   
10. }
    
11. 
    
12. // Main方法
    
13. public static void main(String[] args) throws InterruptedException {
    
14. // 生成一个对象
    
15. ThreadImRunnable thread = new ThreadImRunnable();
    
16. // 对这个对象开启两个线程
    
17. new Thread(thread).start();
    
18. new Thread(thread).start();
    
19. }
    
20. }

复制代码

运行结果：
[#Thread-0]1
[#Thread-0]3
[#Thread-0]4
[#Thread-1]2
[#Thread-1]5
[#Thread-1]6
[#Thread-1]7
[#Thread-1]8
[#Thread-1]9
[#Thread-1]10
[#Thread-1]11
[#Thread-1]12
[#Thread-1]13
[#Thread-0]14
[#Thread-0]15
[#Thread-0]16
[#Thread-0]17
[#Thread-0]18
[#Thread-0]19
[#Thread-0]20

1. // 继承 Thread 类的线程
   
2. public class ThreadExThread extends Thread {
   
3. private int x = 0;
   
4. 
   
5. // 实现接口中抽象方法
   
6. @Override
   
7. public void run() {
   
8. for (int i = 0; i < 10; i++) {
   
9. System.out.println("[#" + this.getName() + "]" + (++x));
   
10. }
    
11. }
    
12. 
    
13. // Main方法
    
14. public static void main(String[] args) throws InterruptedException {
    
15. // 生成一个对象，并开启线程
    
16. ThreadExThread thread = new ThreadExThread();
    
17. thread.start();
    
18. thread.start();
    
19. }
    
20. }

复制代码

运行结果：
[#Thread-0]1
[#Thread-0]2
[#Thread-0]3
[#Thread-0]4
[#Thread-0]5
[#Thread-0]6
[#Thread-0]7
[#Thread-0]8
[#Thread-0]9
[#Thread-0]10
Exception in thread "main" java.lang.IllegalThreadStateException at java.lang.Thread.start(Thread.java:595)  at main.ThreadExThread.main(ThreadExThread.java:17)

分析：同样是创建了两个线程，为什么结果不一样呢？
        使用实现Runnable接口方式创建线程可以共享同一个目标对象（ ThreadImRunnable thread = new ThreadImRunnable(); ），实现了多个相同线程处理同一份资源，我们把上面的2个线程称为同一实例(Runnable实例)的多个线程。一个Thread的实例一旦调用start()方法，就再也没有机会运行了，这意味着: [通过Thread实例的start()，一个Thread的实例只能产生一个线程]

采用继承Thread类方式：

   <1>优点：编写简单，如果需要访问当前线程，无需使用Thread.currentThread()方法，直接使用this，即可获得当前线程。
   <2> 缺点：因为线程类已经继承了Thread类，所以不能再继承其他的父类。

采用实现Runnable接口方式：

    <1> 优点：线程类只是实现了Runable接口，还可以继承其他的类。在这种方式下，可以多个线程共享同一个目标对象，所以非常适合多个相同线程来处理同一份资源的情况，从而可以将CPU代码和数据分开，形成清晰的模型，较好地体现了面向对象的思想。
    <2> 缺点：编程稍微复杂，如果需要访问当前线程，必须使用Thread.currentThread()方法。

Jdk1.5 新特性-线程池：[活动] （主推）2、Jdk1.5 新特性-线程池（下半部）

把帖子在修改下吧，代码块中不能更改字体样式，好了我再加分

曹睿翔 发表于 2013-5-7 19:25
把帖子在修改下吧，代码块中不能更改字体样式，好了我再加分

呵呵，不好意思啊，竟然之前没发现。

学习啦。。。。。。。