关于进程核线程的区别，这里不佳赘述，大家只要知道，进程里包含很多线程，进程是资源分配的最小单位，线程是执行的最小单位。且程序被执行才可以有线程和进程的概念，程序是静态的，进程和线程是动态的。

Java 中线程一般有两种实现方式，分别是继承Thread类和实现Runnable 接口，这里先对继承和接口的实现的作简要的实例分析。注意：用的比较多的是使用接口实现的方法。

1继承Thread类 实例代码：

/*
  * 继承Thread类
  * 常用方法有：
  *   1 start():启动线程 并执行相应的run方法
  *   2 run():在继承Thread类后需要重写，将子线程需要执行的的方法放入
  *   3 直接Thread.currentThread():其为静态方法，
  *   4 getName():获得线程名字
  *   5 setName():设置线程名字
  *   6 yield():执行后，会让当前线程放弃CPU执行权，让其它线程执行，但是释放马上又会去抢
  *   7 join():执行后，会让当前线程放弃CPU执行权，让其它线程执行,并且是执行完
  *   8 isAlive():看当前线程是否存活(布尔型)
  *   9 sleep(long l):显式让程序睡眠l 毫秒 会有异常 只能try catch
  *   10 线程通信： wait() notify() notifyAll()
  *   11 设置线程优先级：get/setPriority()
  */
 public class TestThread {
     public static void main(String[] args) {
         //创建一个线程对象
         SubThread sub=new SubThread();
         SubThread sub1=new SubThread();//在创建一个线程
         sub.setPriority(Thread.MAX_PRIORITY);//最大优先级
         sub.setName("test1");//设置线程名
         sub.start();//1 使线程执行 2 调用run方法
         //sub.run();//直接使用run方法没有start不算多线程 那样相当于有主函数直接调用了run
         System.out.println("9999");
         for(int i=0;i<100;i++){
             System.out.println(Thread.currentThread().getName()+"====="+i);
             if(i%20==0) {
                 try {
                     sub.join();
                 } catch (InterruptedException e) {
                     // TODO Auto-generated catch block
                     e.printStackTrace();
                 }
             }
             System.out.println(sub.isAlive());
         }
     }
     
 }class SubThread extends Thread{
     //重写了run()方法
     public void run() {
         for(int i=0;i<100;i++) {
             try {
                 Thread.currentThread().sleep(1000);
             } catch (InterruptedException e) {
                 // TODO Auto-generated catch block
                 e.printStackTrace();
             }
             System.out.println(Thread.currentThread().getName()+"--"+i);
         }
     }
 }

2 下面写了一个小例子，模仿车站窗口售票的例子，大家可以看下具体应用：

//模拟车站三个窗口售票
 public class Test4 {
     public static void main(String[] args) {
         WinThread w1=new WinThread();
         WinThread w2=new WinThread();
         WinThread w3=new WinThread();
         w1.setName("Win 1");
         w2.setName("Win 2");
         w3.setName("Win 3");
         w1.start();
         w2.start();
         w3.start();
     }
 }
 class WinThread extends Thread{
     private static int tickets= 100;
     public void run() {
         while(tickets>0) {
             System.out.println(Thread.currentThread().getName()+" 售票 "+tickets--);
         }
         
     }
 }

3 结合上例 用实现Runnable接口来实现

public static void main(String[] args) {
         
         WinThread1 w1=new WinThread1();//接口中没有start方法
         Thread t1=new Thread(w1);//将接口实现和线程Thread发生关系
         Thread t2=new Thread(w1);//将接口实现和线程Thread发生关系
         t1.start();
         t2.start();
         
     }class WinThread1 implements Runnable {
    int tickets= 100;//z注意这里 tickets 不是静态的
     public void run() {
         while(tickets>0) {
             System.out.println(Thread.currentThread().getName()+" 售票 "+tickets--);
         }
         
     }
     
 }

通过对比，可以发现：继承和接口实现两者：接口实现更好：
        1 避免了Java单继承的缺陷

        2只需创建一个实例 方便线程共享数据的操作

希望对大家有帮助！有问题欢迎一起指证探讨