java中Thread和Runnable的不同

Runnable方式可以避免Thread方式由于Java单继承特性带来的缺陷。
Runnable的代码可以被多个线程（Thread实例）共享，适合与多个线程处理同一资源的情况。

class MyRunnable implements Runnable {

    private int ticketsCont = 5;

    @Override
    public void run() {
        while (ticketsCont > 0) {
            ticketsCont--;
            System.out.println(Thread.currentThread().getName() + "卖了1张票，剩余的票数为：" + ticketsCont);
        }
    }
}

public class TicketsRunnable {
    public static void main(String[] args) {

        MyRunnable myRunnable = new MyRunnable();
        Thread thread1 = new Thread(myRunnable, "窗口1");
        Thread thread2 = new Thread(myRunnable, "窗口2");
        Thread thread3 = new Thread(myRunnable, "窗口3");

        thread1.start();
        thread2.start();
        thread3.start();
    }
}

//运行结果：
//窗口1卖了1张票，剩余的票数为：4
//窗口1卖了1张票，剩余的票数为：3
//窗口1卖了1张票，剩余的票数为：2
//窗口1卖了1张票，剩余的票数为：1
//窗口1卖了1张票，剩余的票数为：0

class MyThread extends Thread {
    //火车票的总数
    private int ticketsCont = 5;
    //线程的名字
    private String name;


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

    @Override
    public void run() {
        while (ticketsCont > 0) {
            ticketsCont--;
            System.out.println(name + "卖了一张票，剩余的票数为：" + ticketsCont);
        }
    }
}

public class TicketsThread {
    public static void main(String[] args) {
        MyThread t1 = new MyThread("窗口1");
        MyThread t2 = new MyThread("窗口2");
        MyThread t3 = new MyThread("窗口3");
        t1.start();
        t2.start();
        t3.start();
    }
}
//运行结果：
//窗口1卖了一张票，剩余的票数为：4
//窗口1卖了一张票，剩余的票数为：3
//窗口1卖了一张票，剩余的票数为：2
//窗口1卖了一张票，剩余的票数为：1
//窗口1卖了一张票，剩余的票数为：0
//窗口3卖了一张票，剩余的票数为：4
//窗口3卖了一张票，剩余的票数为：3
//窗口3卖了一张票，剩余的票数为：2
//窗口3卖了一张票，剩余的票数为：1
//窗口3卖了一张票，剩余的票数为：0
//窗口2卖了一张票，剩余的票数为：4
//窗口2卖了一张票，剩余的票数为：3
//窗口2卖了一张票，剩余的票数为：2
//窗口2卖了一张票，剩余的票数为：1
//窗口2卖了一张票，剩余的票数为：0

运行得出结果，你就会发现两种方式的不同：

• 继承Thread类的方式会启动三个线程，每个线程都会卖5张票。
• 实现Runnable接口的会启动三个线程，三个线程共享一个资源。也就是三个线程卖5张票。

出现这种情况的原因是两种不同的线程实现方式本身就决定了其是否能进行资源共享:

Thread:

一个线程只能启动一次，通过Thread实现线程时，线程和线程所要执行的任务是捆绑在一起的。
也就使得一个任务只能启动一个线程，不同的线程执行的任务是不相同的，所以两个线程之间是不能共享资源的，也没必要。
当然如果一定要Thread的实现资源共享，那么可以在共享变量加上static关键字。

Runnable:

一个任务可以启动多个线程，通过Runnable方式实现的线程，实际是开辟一个线程，将任务传
递进去，由此线程执行。可以实例化多个 Thread对象，将同一任务传递进去，也就是一个任务可以
启动多个线程来执行它。这些线程执行的是同一个任务，所以他们的资源是共享。