1、多线程是指同时存在几个执行体,按几条不同的执行线索共同工作的情况
2、多线程使得编程人员可以很方便地开发出具有多线程功能，能同时处理多个任务的功能强大的应用程序
3、执行线程给人一种几个事件同时发生的感觉，但这只是一种错觉，因为我们的计算机在任何给定的时刻只能执行那些线程中的一个。Java能快速地把控制从一个线程切换到另一个线程，产生正在同步执行的感觉.
1、程序、进程、线程
程序是一段静态的代码,它是应用软件执行的蓝本.
进程是程序的一次动态执行过程,它对应了从代码加载,执行至执行完毕的一个完整过程,这个过程也是进程本身从产生,发展至消亡的过程.
如果把银行一天的工作比作一个进程,那么早上打铃上班是进程的开始,晚上打下班铃是进程的结束.
线程是比进程更小的执行单位.一个进程在其执行过程中,可以产生多个线程,形成多条执行线索,每条线索,即每个线程也有它自身的产生,存在和消亡的过程,也是一个动态的概念.
就像银行一天的工作开始后,可以有多个不同的”线程”为客户服务,如财会部门,出纳部门,保安部门等.我们知道,每个进程都有一段专用的内存区域,与此不同的是,线程间可以共享相同的内存单元 包括代码与数据 ,并利用这些共享单元来实现数据交换,实时通信与必要的同步操作.比如在银行一天的工作开始后,财会部门,出纳部门,保安部门这三个线程共享银行的电力资源,财会部门,出纳部门可能共享银行的帐目数据等.多线程的程序能更好地表达和解决现实世界的具体问题,是计算机应用开发和程序设计的一个必然发展趋势.
2、线程的状态与生命周期
每个Java 程序都有一个缺省的主线程.
对于应用程序,主线程是main()方法执行的线索。
对于Applet,主线程指挥浏览器加载并执行Java小程序.
要想实现多线程,必须在主线程中创建新的线程对象.Java 语言使用Thread 类及其子类的对象来表示线程,新建的线程在它的一个完整的生命周期中通常要经历5种状态：
新建：一个Thread类或其子类的对象被创建时，新生的线程处于新建状态，此时拥有了响应的内存空间和其他资源，被初始化了。
就绪：新建线程被启动后，进入就绪队列，等待CPU。被阻塞的线程解除阻塞后也会进入就绪队列。
运行：就绪状态的线程被调度而占有CPU，此时线程会自动去执行它的run()方法。
阻塞：一个正在执行的线程因为某些原因被挂起，让出CPU，进入阻塞状态。
死亡：线程不再具有继续运行的能力。分正常中止和提前中止。
Java中Runnable和Thread的区别
在java中可有两种方式实现多线程，一种是继承Thread类，一种是实现Runnable接口；Thread类是在java.lang包中定义的。一个类只要继承了Thread类同时覆写了本类中的run()方法就可以实现多线程操作了，但是一个类只能继承一个父类，这是此方法的局限。
在java中可有两种方式实现多线程，一种是继承Thread类，一种是实现Runnable接口；Thread类是在java.lang包中定义的。一个类只要继承了Thread类同时覆写了本类中的run()方法就可以实现多线程操作了，但是一个类只能继承一个父类，这是此方法的局限。
下面看例子：
1. package org.thread.demo;
2. class MyThread extends Thread{
3. private String name;
4. public MyThread(String name) {
5. super();
6. this.name = name;
7. }
8. public void run(){
9. for(int i=0;i<10;i++){
10. System.out.println("线程开始："+this.name+",i="+i);
11. }
12. }
13. }
14. package org.thread.demo;
15. public class ThreadDemo01 {
16. public static void main(String[] args) {
17. MyThread mt1=new MyThread("线程a");
18. MyThread mt2=new MyThread("线程b");
19. mt1.run();
20. mt2.run();
21. }
22. }
但是，此时结果很有规律，先第一个对象执行，然后第二个对象执行，并没有相互运行。在JDK的文档中可以发现，一旦调用start()方法，则会通过JVM找到run()方法。下面启动start()方法启动线程：
1. package org.thread.demo;
2. public class ThreadDemo01 {
3. public static void main(String[] args) {
4. MyThread mt1=new MyThread("线程a");
5. MyThread mt2=new MyThread("线程b");
6. mt1.start();
7. mt2.start();
8. }
9. };
这样程序可以正常完成交互式运行。那么为啥非要使用start();方法启动多线程呢？
在JDK的安装路径下，src.zip是全部的java源程序，通过此代码找到Thread中的start()方法的定义，可以发现此方法中使用了private native voidstart0();其中native关键字表示可以调用操作系统的底层函数，那么这样的技术成为JNI技术（java Native Interface）
Runnable接口
在实际开发中一个多线程的操作很少使用Thread类，而是通过Runnable接口完成。
1. public interface Runnable{
2. public void run();
3. }
例子：
1. package org.runnable.demo;
2. class MyThread implements Runnable{
3. private String name;
4. public MyThread(String name) {
5. this.name = name;
6. }
7. public void run(){
8. for(int i=0;i<100;i++){
9. System.out.println("线程开始："+this.name+",i="+i);
10. }
11. }
12. };
但是在使用Runnable定义的子类中没有start()方法，只有Thread类中才有。此时观察Thread类，有一个构造方法：public Thread(Runnable targer)此构造方法接受Runnable的子类实例，也就是说可以通过Thread类来启动Runnable实现的多线程。（start()可以协调系统的资源）：
1. package org.runnable.demo;
2. import org.runnable.demo.MyThread;
3. public class ThreadDemo01 {
4. public static void main(String[] args) {
5. MyThread mt1=new MyThread("线程a");
6. MyThread mt2=new MyThread("线程b");
7. new Thread(mt1).start();
8. new Thread(mt2).start();
9. }
10. }
两种实现方式的区别和联系：
在程序开发中只要是多线程肯定永远以实现Runnable接口为主，因为实现Runnable接口相比继承Thread类有如下好处：
· 避免点继承的局限，一个类可以继承多个接口。
· 适合于资源的共享
以卖票程序为例，通过Thread类完成：
1. package org.demo.dff;
2. class MyThread extends Thread{
3. private int ticket=10;
4. public void run(){
5. for(int i=0;i<20;i++){
6. if(this.ticket>0){
7. System.out.println("卖票：ticket"+this.ticket--);
8. }
9. }
10. }
11. };
下面通过三个线程对象，同时卖票：
1. package org.demo.dff;
2. public class ThreadTicket {
3. public static void main(String[] args) {
4. MyThread mt1=new MyThread();
5. MyThread mt2=new MyThread();
6. MyThread mt3=new MyThread();
7. mt1.start();//每个线程都各卖了10张，共卖了30张票
8. mt2.start();//但实际只有10张票，每个线程都卖自己的票
9. mt3.start();//没有达到资源共享
10. }
11. }
如果用Runnable就可以实现资源共享，下面看例子：
1. package org.demo.runnable;
2. class MyThread implements Runnable{
3. private int ticket=10;
4. public void run(){
5. for(int i=0;i<20;i++){
6. if(this.ticket>0){
7. System.out.println("卖票：ticket"+this.ticket--);
8. }
9. }
10. }
11. }
12. package org.demo.runnable;
13. public class RunnableTicket {
14. public static void main(String[] args) {
15. MyThread mt=new MyThread();
16. new Thread(mt).start();//同一个mt，但是在Thread中就不可以，如果用同一
17. new Thread(mt).start();//个实例化对象mt，就会出现异常
18. new Thread(mt).start();
19. }
20. };
虽然现在程序中有三个线程，但是一共卖了10张票，也就是说使用Runnable实现多线程可以达到资源共享目的。
三：怎么实现多线程
java中多线程的实现方式有两种，一种是继承java.lang.Thread类，另一种是实现java.lang.Runnable接口。
下面是两种方式的简单代码。继承Thread类方式：importjava.lang.Thread; //用集成
Thread类方式实现多线程。
public class Test{
public static voidmain(String arg[]){
T t1=new T(); T t2=new T();//更改新线程名称
t1.setName("t1");t2.setName("t2"); //启动线程
t1.start(); t2.start(); } }
class T extends Thread{ //重写run()方法
public void run(){System.out.println(this.getName()); } }输出结果为：t1t2
实现Runnable接口方式：在使用Runnable接口时需要建立一个Thread实例。
因此，无论是通过Thread类还是Runnable接口建立线程，都必须建立Thread类或它的子类的实例。
import java.lang.*; //用实现Runnable接口的方式实现多线程。
public class Test{
public static voidmain(String arg[]){
T t1=new T();
T t2=new T(); //一定要实例化Thread对象，将实现Runnable接口的对象作为参数传入。 Thread th1=newThread(t1,"t1");
Thread th2=newThread(t2,"t2"); //启动线程 th1.start(); th2.start(); } }
class T implements Runnable{//重写run()方法
public void run(){System.out.println(Thread.currentThread().getName()); } }输出结果为：t1t2public void run()方法是JAVA中线程的执行体方法，所有线程的操作都是从run方法开始，有点类似于main()方法，即主线程。