Thread和Runnable的区别

线程Thread的5状态：
创建——>就绪——>运行——>阻塞——>停止
创建：new
就绪：创建对象后，执行start方法，即加入线程队列等待获取CPU资源。这个时候为就绪状态。
运行：抢夺到CPU时间片，该thread开始运行run中的代码。
阻塞：如果在run方法中执行了sleep或者调用了thread的wait/join方法，意味着放弃CPU资源而进入阻塞状态，但是运行还没有完毕，等待重新获得CPU资源后，重新进入就绪状态
停止：一般停止线程有两种方式：1执行完毕run方法，2调用stop方法，后者不推荐使用。可以在run方法中循环检查某个public变量，当想要停止该线程时候，通过thread.para为false即可以将run提前运行完毕，即进入了停止状态

---

1. 关于线程创建问题

多线程可以通过两种方式来创建。
一、通过继承Thread类
二、通过实现Runnable接口
java：单继承多实现

2. 多线程有哪些优点呢？

一、多线程共享同一块内存空间和一组系统资源
二、线程本身的数据通常都是只有微处理器的寄存器数据，以及供程序执行的堆栈。所以系统在产生一个线程或者线程的切换要比进程系统的负担小很多。

3. 关于共享数据的问题比较

Thread：多个线程分别完成自己的任务
Runnable：多个线程共同完成一个任务。

Thread：

1. 自定义一个类ThreadTest 继承Thread
2. new ThreadTest.start(); /可以创建多个ThreadTest实例并且启动，/

public  class ThreadDemo   
{   
      public static void main(String []args)   
      {   
          MyThread thread1 = new MyThread ();   
          MyThread thread2 = new MyThread ()  
          MyThread thread3 = new MyThread ();   
          MyThread thread4 = new MyThread ();  
          thread1.start()； 
          thread2.start()； 
          thread3.start()； 
          thread4.start()； 
      }   
}   
class MyThread extends Thread
{ 
          int things = 5; 

          public void run() { 
              while(things > 0)
              { 
              System.out.println(currentThread().getName() + " things:" + things); things--; 
              } 
          }
}

结果如下：

Thread-0 things:5
Thread-0 things:4
Thread-2 things:5
Thread-1 things:5
Thread-1 things:4
Thread-1 things:3
Thread-1 things:2
Thread-1 things:1
Thread-2 things:4
Thread-2 things:3
Thread-2 things:2
Thread-2 things:1
Thread-0 things:3
Thread-0 things:2
Thread-0 things:1

-->运行后会发现，多个线程对象各自占有各自的资源，并且去争夺CPU时间片去完成各自的线程，并不是同时完成统一的任务，所以得出结论：Thread类实际无法达到资源共享的目的

Runnable：

1. 自定义一个类ThreadTest实现Runnable接口
2. new Thread(test).start();
   此处是new 一个线程毕竟传入实现了Runnable的类实例作为参数

public  class ThreadDemo   
{   
      public static void main(String []args)   
      {   
          MyRunnable run = new MyRunnable("run");  
          Thread th1 = new Thread(run, "Thread 1");
          Thread th2 = new Thread(run, "Thread 2");  
          Thread th3 = new Thread(run, "Thread 3");

          th1.start();
          th2.start();
          th3.start();
    }   
}   
class MyRunnable implements Runnable   
{   
          String name;   
          public MyRunnable(String name) 
          { 
              this.name = name; 
          }

          int things = 5;
          public void run()   
          {   
            while(things >0)   
          {   
            System.out.println(name + " things:" + things);  
        }   
    }   
}  

run things:3
run things:2
run things:1
run things:0
run things:3

-->运行后会发现，运行之后我们发现，这三个线程使用同一资源同时(即合作)完成了我们需要完成的任务。，所以得出结论：Runnable是可以共享数据的，多个Thread可以同时加载一个Runnable，当各自Thread获得CPU时间片的时候开始运行runnable，runnable里面的资源是被共享的

通过以上比较我们即可得出Thread与Runnable的区别：
1、Runnable适合于多个相同程序代码线程去处理统一资源的情况，把虚拟的cpu（线程）同程序的代码，数据有效分离，较好体现面向对象的编程的思想.
2、Runnable可以避免由于Java的单继承机制带来的局限。可以再继承其他类的同时，还能实现多线程的功能。
3、Runnable能增加程序的健壮性。代码能够被多个线程共享。