Java创建线程的三种方式

Java有三种创建线程的方式，分别是继承Thread类、实现Runable接口和使用线程池
1、继承Thread类
使用该方式创建及使用线程需按以下三个步骤：
（1）定义Thread类的子类，并重写父类的run()方法，方法里的内容就是线程所要执行的任务；
（2）创建子类的实例，即生成线程的实例对象；
（3）调用现成的start()方法来启动线程。

public class SubThread extends Thread {
    private int ticket = 100;
    private String name;
    public ImplThread(String name) {
        this.name = name;
    }
    public void run() {
        while (k > 0){
            System.out.println(ticket-- + "is saled by" + name);
        }
        try{
            sleep((int)Math.random() * 10);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
    public static void main (String []args){
        SubThread t1 = new SubThread("A");
        SubThread t2 = new SubThread("B");
        t1.start();
        t2.start();
    }
}

2、实现Runnable接口
（1）定义实现Runnable接口的实现类，并重写run()方法；
（2）创建Runnable接口实现类的实例，并将该实例作为参数传到Thread类的构造方法中来创建Thread对象，该Thread对象才是真正的线程对象；
（3）调用现成的start()方法来启动线程。

public class ImplThread implements Runnable {
    private int ticket = 100;
    private String name;
    public ImplThread(String name) {
        this.name = name;
    }
    public void run() {
        while (k > 0){
            System.out.println(ticket-- + "is saled by" + name);
        }
        try{
            sleep((int)Math.random() * 10);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
    public static void main (String []args){
        ImplThread i1 = new ImplThread("A");
        ImplThread i2 = new ImplThread("B");
        Thread t1 = new Thread(i1);
        Thread t2 = new Thread(i2);
        t1.start();
        t2.start();
    }
}

上面这段代码跟继承Thread类的线程代码呈现的效果是一样的，虽然执行的是相同的代码，但彼此相互独立，且各自拥有自己的资源，互不干扰。
但是，在某些场景，我们希望各线程能共享资源，这时候就只能扩展Runnable接口了。

public class ImplThread implements Runnable {
    private int ticket = 100;
    public void run() {
        while (k > 0){
            System.out.println(ticket-- + "is saled by" + Thread.currentThread());
        }
        try{
            sleep((int)Math.random() * 10);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
    public static void main (String []args){
        ImplThread i = new ImplThread();
        Thread t1 = new Thread(i);
        Thread t2 = new Thread(i);
        t1.start();
        t2.start();
    }
}

这时候，线程t1和t2共享这100张票。
3、使用线程池
使用线程池并不是创建线程，而是对线程进行管理。Excetor为线程池超级接口，该接口中定义了一个execute(Runnable command)方法，用来执行传递过来的线程，ExecutorService就是我们所说的线程池，它继承了Excetor接口。如何创建线程池呢？Java提供了Executors类，该类有四个静态方法分别可以创建不同类型的线程池（ExecutorService）。
Executors.newCachedThreadPool() 创建可变大小的线程池
Executors.newFixedThreadPool(int number) 创建固定大小的线程池
Executors.newSingleThreadPool() 创建单任务线程池
Executors.newScheduledThreadPool(int number) 创建延迟线程池

import java.util.concurrent.Executors;  
import java.util.concurrent.ExecutorService;  
public class Test {  
　　public static void main(String[] args) {  
　　//创建一个可重用固定线程数的线程池  
　　ExecutorService pool = Executors.newFixedThreadPool(2);  
　　//创建实现了Runnable接口对象，Thread对象当然也实现了Runnable接口  
　　Thread t1 = new MyThread();  
　　Thread t2 = new MyThread();  
　　Thread t3 = new MyThread();  
　　Thread t4 = new MyThread();  
　　Thread t5 = new MyThread();  
　　//将线程放入池中进行执行  
　　pool.execute(t1);  
　　pool.execute(t2);  
　　pool.execute(t3);  
　　pool.execute(t4);  
　　pool.execute(t5);  
　　//关闭线程池  
　　pool.shutdown();  
　　}  
}  
class MyThread extends Thread{  
　　@Override  
　　public void run() {  
　　System.out.println(Thread.currentThread().getName()+"正在执行。。。");  
　　}  
}   

输出：
pool-1-thread-1正在执行。。。
　　pool-1-thread-1正在执行。。。
　　pool-1-thread-1正在执行。。。
　　pool-1-thread-1正在执行。。。
　　pool-1-thread-2正在执行。。。
　　Process finished with exit code 0
可见，线程得到了重用，线程池里只有两个线程在执行。