Java多线程一：创建线程

Java中线程的创建一般有如下三种方法：
1. 继承Thread类，覆写run()方法
2. 实现Runnable接口，重写run()方法
3. 实现Callable接口，重写cal()方法

继承Thread类

public class MyThread1 extends Thread {

    @Override
    public void run() {
        System.out.println("通过继承Thread类创建一个线程");
    }
}

实现Runnable接口

public class MyThread2 implements Runnable {

    public void run() {
        System.out.println("通过实现Runnable接口创建一个线程");
    }
}

实现Callable接口

public class MyThread3 implements Callable<Integer> {

    public Integer call() throws Exception {
        System.out.println("通过实现Callable接口创建一个线程:返回一个1-100的随机整数");
        return new Random().nextInt(100);
    }

}

Thread类和Runnable接口的比较

两者最明显的比较是接口和继承的区别，继承Thread类就限制了该类不能去继承其他父类，而接口可以实现多个。
其次是对象创建的区别，我们已下面的例子来演示(注意输出结果):

package com.yin.myproject.demo.concurrent.base.create;

class MyThread4 extends Thread {

    private int ticket = 10;
    private String name;

    public MyThread4(String name) {
        this.name = name;
    }

    public void run() {
        for (int i = 0; i < 500; i++) {
            if (this.ticket > 0) {
                System.out.println(this.name + "卖票---->" + (this.ticket--));
            }
        }
    }
}

public class ThreadCreateDemo1 {
    public static void main(String[] args) {
        Thread mt1 = new MyThread4("一号窗口");
        Thread mt2 = new MyThread4("二号窗口");
        Thread mt3 = new MyThread4("三号窗口");
        mt1.start();
        mt2.start();
        mt3.start();
    }
}

class MyThread5 implements Runnable {

    private int ticket = 10;

    public MyThread5() {
    }

    public void run() {
        for (int i = 0; i < 500; i++) {
            if (this.ticket > 0) {
                System.out.println(Thread.currentThread().getName() + "卖票---->" + (this.ticket--));
            }
        }
    }
}

public class ThreadCreateDemo2 {
    public static void main(String[] args) {
        MyThread5 mt = new MyThread5();
        Thread mt1 = new Thread(mt, "一号窗口");
        Thread mt2 = new Thread(mt, "二号窗口");
        Thread mt3 = new Thread(mt, "三号窗口");
        mt1.start();
        mt2.start();
        mt3.start();
    }
}

(本例讨论两者差异，请忽略线程不安全的问题)输出结果请自行打印比较，现在分析其原因：
对于demo1,相当于我们创建了一个三个类，每个类之间是相互独立的，表现在程序上就是三个窗口各自卖各自的10张票。而demo2实现Runnable接口， 相当于是拿出一个卖票10张得任务给三个人去共同完成，new MyThread相当于创建一个任务，然后实例化三个Thread，创建三个线程即安排三个窗口去执行。
基于以上两点可以看出，一般在实现一个任务使用多线程时，实现Runnable()接口即可，特殊情况考虑使用Thread();

总结

个人认为线程的创建可以分为两部分，任务的创建和线程的创建，比如在继承Thread实现多线程时，实例化时相当于即创建了任务和线程。而实现Runnable接口时，实例化类相当于创建了任务，而在构造Thread类时才真正创建了线程。个人理解，如有错误欢迎指正

参考:
http://www.cnblogs.com/hpuCode/archive/2012/04/10/2441024.html