day_34Java多线程

博客分类： 

一、进程和线程

 

采用Java的多线程机制可以使计算机资源得到更充分的使用，多线程可以使程序在同一时间内完成很多操作。

 

       本章讲解 进程与线程的共同点和区别、实现多线程的方法、线程的状态、对线程操作的方法、多线程的同步、线程间的通信，

以及线程生命周期的控制等内容。

        本章要点:

              了解进程和线程

               掌握实现多线程的方法

               熟悉线程的状态

               熟悉线程操作的方法

               熟悉线程同步的方法

               熟悉线程间通信的方法

伦理片 http://www.dotdy.com/ 

      Java是少数的几种支持“多线程”的语言之一。

     大多数的程序语言只能循序运行单独的一个程序块，但无法同时运行不同的多个程序块。

     

          Java的“多线程”恰可弥补这个遗憾，它可以让不同的程序块一起运行，

   如此一来就可让程序运行的更为顺畅，同时也可达到多任务处理的目的。

 

   进程的特征是:

 

           1.一个进程就是一个执行中的程序，而每一个进程都有自己独立的一块内存空间，一组系统资源。

     在进行概念中，每一个进程的内部数据和状态都是完全独立的。

           2.创建并执行一个进程的系统开销比较大。

           3.进程是程序的一次执行过程，是系统运行程序的基本单位。

     

   线程的特征是:

   

         1.在java中，程序通过流控制来执行程序流。程序中单个顺序的流控制称为线程。

         2.多线程指的是在单个进行中可以同时运行多个不同的线程，执行不同的任务。

多线程意味着一个程序的多行语句可以看上去几乎同时运行。

 

    二者都是一段完成某个特定功能的代码，是程序中单个顺序的流控制。

 

         不同的是同类的多个线程是共享一块内存空间和一组系统资源，

而线程本身的数据通常只有微处理器的寄存器数据，以及一个供程序执行时使用的堆栈。

所以系统在产生一个线程，或者在各个线程之间切换时，负担要比进程小得多，正因为如此，线程也被

称为轻负荷进程。一个进程中可以包含多个线程。

 

      多线程是实现并发机制的一种有效手段。

进程和线程一样，都是实现并发的一个基本单位。

线程和进程的只要差别体现在以下两个方面。

  1.同样作为基本的执行单元，线程是划分得比进程更小的执行单位。

  2.每个进程都有一段专用的内存区域。与此相反，线程却共享内存单元(包括代码和数据)，

 

通过共享的内存单元来实现数据交换、实时通信与必要的同步操作。

 

         多线程的应用范围很广。在一般情况下，程序的某些部分同待定的事件或资源联系在一起，同时又不想为它而

暂停程序其他部分的执行，在这种情况下，就可以考虑创建一个线程，令它与那个事件或资源关联到一起，并让它

独立于主程序运行。

通过使用线程，可以避免用户在运行程序和得到结果之间的停顿，还可以让一些任务(如打印任务)在后台运行，

而用户则在前台继续完成一些其他的工作。

      总之，利用多线程技术，可以使编程人员方便的开发出能同时处理多个任务的功能强大的应用程序。

 

 

二、认识线程

     

    2.1.所谓线程(Thread)是指程序的运行流程，“多线程”的机制则是指可以同时运行多个程序块，使程序运行的效率变得更高，

也可克服传统程序语言所无法解决的问题。

   例如，有些包含循环的线程可能要使用比较长的一段时间来运行，此时便可让另一个线程来做其他的处理。

 

   2.2本节用一个程序来说明单一线程与多线程的不同。

      Demo1是单一线程的范例。

 

Java代码  

1.      
2.        2.2.2代码案例1  
3.   
4. package day34;  
5.   
6. public class ThreadDemo1 {  
7.     //单一线程，只有等Thread运行完才可以运行main()  
8.     public static void main(String[] args) {  
9.         Thread td = new Thread();  
10.         td.run();  
11.         System.out.print("\n");  
12.         for(int i=0;i<5;i++) {  
13.             System.out.print("main()..."+i+"\t");  
14.         }  
15.     }  
16. }  
17.   
18. class Thread {  
19.     public void run() {  
20.         for(int i = 0;i<5;i++) {  
21.             System.out.print("Thread ..."+i+"\t");  
22.         }  
23.     }  
24. }  

 运行结果:

    在java里，是否可以同时运行，交替输出。其方法是--在java里激活多线程。

    

    如何激活线程:

   如果在类里要激活线程，必须先做好下面的两个准备

       1.线程必须扩展自Thread类，使自己成为它的子类。

       2.线程的处理必须编写在run()方法内。

 

 

2.3通过继承Thread类实现多线程

   Thread存放在java.lang类库中。run()方法是定义在Thread类里的一个方法，因此把线程的程序代码编写在run()方法内，

事实上所做的就是覆写的操作。

   因此要使一个类可激活线程，必须按照下面的格式:

     class 类名称 extends Thread{ //从Thread类扩展出子类

       属性...

       方法...

       修饰符 run() {             //覆写Thread类里的run()方法

         以线程处理的程序;

       }

     }

 

2.3.1代码案例

 

Java代码  

1. package day34;  
2. import java.lang.Thread;  
3.   
4. public class ThreadDemo2 {  
5.     public static void main(String[] args) {  
6.         /*使用线程最大的问题就是不可确定性。 
7.          * 线程运行是，谁先拿到锁，谁先运行，没先后之分的。*/  
8.         Thread2 td2 = new Thread2();  
9.         td2.start();  
10.           
11.         for(int i=0;i<3;i++) {  
12.             System.out.print("main..."+i+"\t");  
13.             try {  
14.                 Thread.sleep(100);  
15.             } catch (InterruptedException e) {  
16.                 // TODO Auto-generated catch block  
17.                 e.printStackTrace();  
18.             }  
19.         }  
20.     }  
21. }  
22. /*如果在类里要激活线程，必须先做好下面的两个准备 
23.  *1.线程必须扩展自Thread类，使自己成为它的子类。 
24.  *2.线程的处理必须编写在run()方法内。*/  
25. class Thread2 extends Thread{  
26.     //java.lang.Thread  
27.     @Override  
28.     public void run() {  
29.         for(int i =0;i<3;i++){  
30.             System.out.print("Thread2..."+i+"\t");  
31.             try {  
32.                 Thread.sleep(100);  
33.             } catch (InterruptedException e) {  
34.                 // TODO Auto-generated catch block  
35.                 e.printStackTrace();  
36.             }  
37.         }  
38.     }  
39.       
40. }  
41.   
42.   
43. 运行结果:  
44. main...0    Thread2...0 Thread2...1 main...1    Thread2...2 main...2      

 注意:

 

    1.就不应该是交替显示，cpu分配给各个线程的执行时间是不确定的，另外每个线程也有优先级别

    2.使用线程最大的问题就是不可确定性。线程运行是，谁先拿到锁，谁先运行，没先后之分的。

 

 

2.4 通过实现Runnable接口实现多线程

    在java中如果一个类继承了某一个累 ，同时又想采用多线程技术的时候，就不能用Thread类产生线程，

因为java不允许多继承，这时要用Runnable接口来实现创建线程。

    格式:

     class 类名称 implements Runnable { //实现Runnable接口

        以线程处理的程序;  

        }

     }

 

 

2.4.1用Runnable接口实现多线程使用实例

代码案例:

Threadrunnable 代码  

1. package day34;  
2.   
3. public class ThreadRunnable {  
4.     public static void main(String[] args){  
5.         Thread3 td3 = new Thread3();  
6.         @SuppressWarnings("unused")  
7.         /*Thread(Runnable target) 分配新的 Thread 对象。  
8.          * 因为Runnable接口没start()方法，所以要通过Thread来启动多线程  
9.          */  
10.         Thread td4 = new Thread(td3);  
11.         td4.start();  
12.           
13.         for(int i =0;i<3;i++) {  
14.             System.out.print("main..."+i+"\t");  
15.             try {  
16.                 Thread.sleep(100);  
17.             } catch (InterruptedException e) {  
18.                 // TODO Auto-generated catch block  
19.                 e.printStackTrace();  
20.             }  
21.         }  
22.     }  
23. }  
24.   
25.   
26. //  
27. class Thread3 implements Runnable {  
28.   
29.     @Override  
30.     public void run() {  
31.         // TODO Auto-generated method stub  
32.         for (int i =0 ;i<3;i++) {  
33.             System.out.print("Thread3..."+i+"\t");     }  
34.     }  
35.       
36. }  

影音先锋电影 http://www.iskdy.com/

注意:

    1.将一个Runnable接口的实例化对象作为参数去实例化Thread类对象。

    2.在实际的开发中，尽可能地使用Runnable接口去实现多线程机制。

 

三、两种多线程实现机制的比较

 

1.java.lang.Thread 所已实现的接口： Runnable

2.区别：

  通过编写一个应用程序来比较分析。

模拟铁路售票系统的范例，实现4个售票发售某日某次列车的车票20张，一个售票点用一个线程来表示。