一个类实现Runable接口与继承Thread这两种方式有什么区别？

最直观的就是对于共享数据资源操作class Ticket implements Runnable//extends Thread
{
        private int tick = 100;
        public void run()
        {
                while(true)
                {
                        if(tick>0)
                                System.out.println(Thread.currentThread().getName()+"sale:"+tick--);
                }
        }
}
class  TicketDemo
{
        public static void main(String[] args)
        {       

                Ticket t = new Ticket();//非创建线程。需要Thread或Thread子类对象。
               
                Thread t1 = new Thread(t);//创建方法1卖了400张票，建立了4个对象，每个对象的特有属性tick都等于100
                Thread t2 = new Thread(t);//而方法2中，只建立了一个对象，仅有100张票。
                Thread t3 = new Thread(t);
                Thread t4 = new Thread(t);

                t1.start();
                t2.start();
                t3.start();
                t4.start();
        }
}
此例中如果使用Thread子类创建线程的话，创建了4个对象。会发现在4个窗口售出了400张票，与实际要求不符合。
应用实现接口Runnable子类对象的优点在于，只创建了一个其子类对象，并作为参数传递Thread。多线程仅仅是对这一个对象操作。
不会出现多对象的问题。

当一个类继承了一个父类，这时你又想让这个做为一个线程启动时，他就不能再继承Thread了，因为一个类只能有一个父类，所以这时可以用实现Runnable的方式。
还有在多个线程共同处理同一资源的时候也需使用Runnable的方式才能做到。

当你的系统中有多个线程切换的时候 最好事先runable接口，这个和java的多态性可以很好的结合
当你只有一个线程的时候就集成thread即可，因为他没有交替的资源访问

当你的系统中有多个县城切换的时候 最好事先runable接口，这个和java的多态性可以很好的结合
当你只有一个线程的时候就集成thread即可，因为他没有交替的资源访问

一个类实现Runable接口与继承Thread这两种方式有什么区别？

实现方式避免了单继承的局限性,

实现方式将要同步运行的代码放在Runnable接口的子类的run()方法中

继承方式将要同步运行的代码放在Tread类的子类的run()方法中

哥们你可以去看看今天前面我给以哥们回答得多线程的问题的那两个例子，哎，我再给你贴一次吧
class MyThread extends Thread{        // 继承Thread类，作为线程的实现类
        private int ticket = 5 ;                // 表示一共有5张票
        public void run(){        // 覆写run()方法，作为线程 的操作主体
                for(int i=0;i<100;i++){
                        if(this.ticket>0){
                                System.out.println("卖票：ticket = " + ticket--) ;
                        }
                }
        }
};
public class ThreadDemo04{
        public static void main(String args[]){
                MyThread mt1 = new MyThread() ;         // 实例化对象
                MyThread mt2 = new MyThread() ;         // 实例化对象
                MyThread mt3 = new MyThread() ;         // 实例化对象
                mt1.run() ;        // 调用线程主体
                mt2.run() ;        // 调用线程主体
                mt3.run() ;        // 调用线程主体
        }
};

class MyThread implements Runnable{        // 继承Thread类，作为线程的实现类
        private int ticket = 5 ;                // 表示一共有5张票
        public void run(){        // 覆写run()方法，作为线程 的操作主体
                for(int i=0;i<100;i++){
                        if(this.ticket>0){
                                System.out.println("卖票：ticket = " + ticket--) ;
                        }
                }
        }
};
public class RunnableDemo02{
        public static void main(String args[]){
                MyThread mt = new MyThread() ;         // 实例化对象
                new Thread(mt).run() ;        // 调用线程主体
                new Thread(mt).run() ;        // 调用线程主体
                new Thread(mt).run() ;        // 调用线程主体
        }
};

哥们你去运行这两个程序，看看结果就可以理解了

通过Thread类和Runnable接口都可以实现多线程，从Thread类的定义可以清楚的发现，Thread类也是Runnable接口的子类，但在Thread类中并没有完全的实现Runnable接口中的run方法，在Thread类中run方法调用的是Runnable接口中的run方法，也就是说此方法是由Runnable子类完成的，所以如果要通过继承Thread类实现多线程，则必须覆写run方法
同时Thread类和Runnable接口之间在使用上还是有区别的，如果一个类继承Thread类，则不适合于多线程共享，而实现了Runnable接口，就可以方便的实现资源的共享。