进程与多线程：
进程----是程序的一次动态执行过程，它经历了代码加载，执行，执行完毕的一个完整过程，这个过程也是进程本身从产生，发展到最终消亡的过程。
多线程----是实现并发机制的一种有效手段，进程和线程一样，都是实现并发的一个基本单位。
 
Java的多线程实现----继承Thread类和实现Runnable接口
class MyThread extends Thread {
  private String name;

  public MyThread(String name) {
    super();// 通过构造方法进行赋值的操作
    this.name = name;
  }

  @Override
  public void run() {
    // 继承Thread类 复写run（），作为线程的操作主体
    super.run();
    for (int i = 0; i < 10; i++) {
      System.out.println(name + "在执行" + i + "次");
    }
  }

}

public class ThreadDemo {

  /**
    * @param args
    */
  public static void main(String[] args) {
    // TODO Auto-generated method stub
    
      MyThread myThread = new MyThread("线程A");
      MyThread myThread1 = new MyThread("线程B");
      MyThread myThread2 = new MyThread("线程C");
      myThread .run();
      myThread1 .run();
      myThread2 .run();
    
  }

}
以上就已经完成了一个线程的操作类,直接使用此类就可以完成功能,由运行结果可以看出，线程是先执行A 再执行B后执行C并没有达到并发执行的效果，因为是通过对象调方法这种传统方式。所以要想启动一个线程必须调用Thread类中的start（）方法 这个方法才真正的叫做启动线程。
 
修改后代码如下：
class MyThread extends Thread {
  private String name;

  public MyThread(String name) {
    super();// 通过构造方法进行赋值的操作
    this.name = name;
  }

  @Override
  public void run() {
    // 继承Thread类 复写run（），作为线程的操作主体
    super.run();
    for (int i = 0; i < 5; i++) {
      System.out.println(name + "在执行" + i + "次");
    }
  }

}

public class ThreadDemo {

  /**
    * @param args
    */
  public static void main(String[] args) {
    // TODO Auto-generated method stub
    
      MyThread myThread = new MyThread("线程A");
      MyThread myThread1 = new MyThread("线程B");
      MyThread myThread2 = new MyThread("线程C");
      //不要通过对象调run(),要调Thread类中的start（），从而实现线程的并发执行
      myThread .start();
      myThread1 .start();
      myThread2 .start();
    
  }

}
在看看运行效果。
 
接下来我们再看看如何实现Runnable接口
class MyRunnable implements Runnable {
  private String name;

  public MyRunnable(String name) {
    super();
    this.name = name;
  }

  @Override
  public void run() {
    // TODO Auto-generated method stub
    for (int i = 0; i < 10; i++) {
      System.out.println(name + "执行线程" + i);
    }
  }

}
public class RunnableDemo {

  /**
    * @param args
    */
  public static void main(String[] args) {
    
    MyRunnable myThread = new MyRunnable("线程A");
    MyRunnable myThread1 = new MyRunnable("线程B");
    MyRunnable myThread2 = new MyRunnable("线程C");
    // 如果需要启动线程则肯定依靠Thread类，若继承Thread类，则可以直接调用start（），
    // 但在Runnable接口中没有start（）， 就要通过Thread类获得start（）
    Thread t1 = new Thread(myThread);// 实例化Thread类对象
    Thread t2 = new Thread(myThread1);
    Thread t3 = new Thread(myThread2);
    t1.start();
    t2.start();
    t3.start();

  }

}
使用Thread类无法实现资源共享的目的，而实现Runnable接口能够实现。
来看下面的合理化的“买票”的例子：
class MyRunnable implements Runnable {
  private int ticket = 15;

  @Override
  public void run() {
    // TODO Auto-generated method stub
    for (int i = 0; i < 111; i++) {
      if (this.ticket > 0) {
        System.out.println("买票=" + ticket--);
      } else {
        return;
      }
    }
  }

}
public class RunnableDemo {

  /**
    * @param args
    */
  public static void main(String[] args) {
    
    MyRunnable myThread = new MyRunnable();
    //启动3个买票线程
    new Thread(myThread).run();
    new Thread(myThread).run();
    new Thread(myThread).run();

  }

}
总结：
使用runnable接口比thread类有如下优点：
1.适合多个相同代码的线程去处理同一个资源
2.可以避免单继承带来的限制
3.增强了代码的健壮性，代码能够被多个线程共享，代码和数据还是独立的。
 
线程的5个基本状态：
1.创建：Thread t = new Thread ();
2.就绪：调用start（），等待CPU进行调度
3.运行：执行run（）方法
4.阻塞：暂时停止运行，交给其他线程使用
5.死亡：执行完毕