黑马程序员——JAVA——多线程

----------android培训、java培训、java学习型技术博客、期待与您交流！------------ 

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()方法，即主线程。