注册 登录  
 加关注
   显示下一条  |  关闭
温馨提示!由于新浪微博认证机制调整,您的新浪微博帐号绑定已过期,请重新绑定!立即重新绑定新浪微博》  |  关闭

淡泊明智

 
 
 

日志

 
 

Java中的多线程简单介绍(带代码)  

2012-11-29 17:17:34|  分类: Java多线程 |  标签: |举报 |字号 订阅

  下载LOFTER 我的照片书  |
一、提要
java中的多线程算是java中的一个 很大的难点 ,虽然 看了 很多书 ,相信对于 很多 接触 java不够 深的人来说 ,多线程永远都是心中的痛!
今天我们 就 通过大量的 例子 来 彻底把它征服 .


二、Runable接口
实现 Runable接口 是 实现多线程 的 一种方法。看例子 
  1. <SPAN style="FONT-SIZE: 14px">package thread;  
  2. public class LiftOff implements Runnable {  
  3. protected int countDown = 10// Default   
  4. private static int taskCount = 0;  
  5. private final int id = taskCount++;  
  6. public LiftOff() {}  
  7. public LiftOff(int countDown) {  
  8. this.countDown = countDown;  
  9. }  
  10. public String status() {  
  11. return "#" + id + "(" +  
  12. (countDown > 0 ? countDown : "Liftoff!") + "), ";  
  13. }  
  14. public void run() {  
  15. while(countDown-- > 0) {  
  16. System.out.print(status());  
  17. Thread.yield();  
  18. }  
  19. }  
  20. } </SPAN>  


这个类的实现了 一个线程 :implements了Runable接口 ,实现了 run方法。
通常情况下,run方法中都会有意个循环 ,直到任务结束的时候才会跳出来。
线程的主要任务是循环十次,每次打印出 终端 状态。Thread.yield()的作用是如果线程队列中有线程等待,则阻塞自己,
将资源 交给 下一个等待的线程。


在main函数中 调用如下:
  1. <SPAN style="FONT-SIZE: 14px">package thread;  
  2. public class Main {  
  3. public static void main(String[] arges)  
  4. {  
  5. LiftOff tmp=new LiftOff();  
  6. tmp.run();  
  7. System.out.println("Waiting for LiftOff");  
  8. }  
  9. }  
  10. </SPAN>  

 

将类型初始化实例时候 ,直接 调用run方法,线程就会开始运行。
运行结果:
#0(9), #0(8), #0(7), #0(6), #0(5), #0(4), #0(3), #0(2), #0(1), #0(Liftoff!), Waiting for LiftOff
这里实际上并没有线程的概念,只是用到了一些简单的函数调用。
真正的线程需要将Runable装到一个Thread中去。


三、Thread实例
传统的使用Runable对象的方法就是把它作为一个参数传给Thread的构造函数作为参数,然后调用Thread的start()方法来启动线程。
start()方法对Runale进行 了 一些 必要的初始化,然后调用Runable的run方法。
将原main函数改写如下:

  1. <SPAN style="FONT-SIZE: 14px">package thread;  
  2. public class Main {  
  3. public static void main(String[] arges)  
  4. {  
  5. Thread t = new Thread(new LiftOff());  
  6. t.start();  
  7. System.out.println("Waiting for LiftOff");  
  8.   
  9.   
  10. }  
  11. }</SPAN>  
运行结果:
Waiting for LiftOff
#0(9), #0(8), #0(7), #0(6), #0(5), #0(4), #0(3), #0(2), #0(1), #0(Liftoff!), 


运行的结果和之前的例子类似,但“Waiting for LiftOff“出现的位置不同了。
原理:在程序的第五行声明了一个线程,并初始化,一个LiftOff对象作为参数传进去。
第六行通过线程调用启动了t线程,但main线程还可以继续干自己的事,cpu给的时间片还没用完,于是“Waiting for LiftOff”就先被打印出来了,之后时间片被用完了,资源交给t线程,运行的内容被打印出来了。
下面是在main中启动多个线程:
  1. <SPAN style="FONT-SIZE: 14px">package thread;  
  2. public class Main {  
  3.   
  4.   
  5. public static void main(String[] arges)  
  6. {  
  7. for(int i = 0; i < 5; i++)  
  8. new Thread(new LiftOff()).start();  
  9. System.out.println("Waiting for LiftOff");  
  10. }  
  11. }</SPAN>  
修改一下LiftOff类:
  1. <SPAN style="FONT-SIZE: 14px">package thread;  
  2. public class LiftOff implements Runnable {  
  3. private static int taskCount = 0;  
  4. private final int id = taskCount++;  
  5. public LiftOff() {}  
  6. public void run() {  
  7. System.out.println("startThreadId: " + id);  
  8. try {  
  9. Thread.sleep(1000);  
  10. catch (InterruptedException ignored) {  
  11. }  
  12. System.out.println("endTHreadId: " + id);  
  13. }  
  14. } </SPAN>  
运行结果:
startThreadId: 0
startThreadId: 1
startThreadId: 2
startThreadId: 3
Waiting for LiftOff
startThreadId: 4
endTHreadId: 0
endTHreadId: 1
endTHreadId: 2
endTHreadId: 3
endTHreadId: 4




运行的结果反映了多线程运行的时候线程的调度。调度的规则主要由线程管理器来决定,在多核心的计算机中,线程管理器会把线程交由不同的cpu来完成。
由于线程的调度机制并不是确定的,不同版本的jdk所得到的结果是不同的。
对于打印结果的理解:运行之后哦main线程尝试创建5个线程,但在创建#3进程的时候时间片用完了,main的Thread进入等待队列,接着时间片论转到最先进入线程队列的#0进程->#0时间片用完(线程还没销毁)->时间片轮转到#1->#1时间片用完....(看不懂的要回头学一下操作系统中进程管理的知识)。


四、使用Executors
线程池 Executor 框架提供。 Executor 框架将处理请求任务的提交和它的执行解耦。可以制定执行策略。线程池中执行线程可以重用已经存在的线程,而不是创建新的线程可以在处理多请求时抵消线程创建、消亡产生的开销
ExecutorService 的几个重要方法:
1、shutdown方法:这个方法会平滑地关闭ExecutorService,当我们调用这个方法时,ExecutorService停止接受任何新的任务且等待已经提交的任务执行完成(已经提交的任务会分两类:一类是已经在执行的,另一类是还没有开始执行的),当所有已经提交的任务执行完毕后将会关闭ExecutorService。
2、awaitTermination方法:这个方法有两个参数,一个是timeout即超时时间,另一个是unit即时间单位。这个方法会使线程等待timeout时长,当超过timeout时间后,会监测ExecutorService是否已经关闭,若关闭则返回true,否则返回false。一般情况下会和shutdown方法组合使用
直接看代码:
  1. <SPAN style="FONT-SIZE: 14px">package thread;  
  2. import java.util.concurrent.ExecutorService;  
  3. import java.util.concurrent.Executors;  
  4. public class Main {  
  5.   
  6.   
  7. public static void main(String[] arges)  
  8. {  
  9. //ExecutorService exec = Executors.newSingleThreadExecutor();   
  10. ExecutorService exec = Executors.newFixedThreadPool(3);  
  11. for(int i = 0; i <5; i++)  
  12. {  
  13. try{  
  14. exec.execute(new LiftOff());  
  15. //Thread.sleep(1000);   
  16. }catch(Exception e)  
  17. {  
  18. e.printStackTrace();  
  19. }  
  20. }  
  21. exec.shutdown();  
  22. System.out.println("Waiting for LiftOff");  
  23. }  
  24. }</SPAN>  
运行结果:
startThreadId: 0
startThreadId: 1
Waiting for LiftOff
startThreadId: 2
endThreadId: 0       
startThreadId: 3
endThreadId: 1       
startThreadId: 4
endThreadId: 2       
endThreadId: 3       
endThreadId: 4       




newCachedThreadPool()创建一个可根据需要创建新线程的线程池,newSingleThreadExecutor()约等于newFixedThreadPool(1)


SingleThreadExecutor运行结果:
Waiting for LiftOff
startThreadId: 0
endThreadId: 0       
startThreadId: 1
endThreadId: 1       
startThreadId: 2
endThreadId: 2       
startThreadId: 3
endThreadId: 3       
startThreadId: 4
endThreadId: 4       
    


CachedThreadPool运行结果:
startThreadId: 0
startThreadId: 1
startThreadId: 2
startThreadId: 3
Waiting for LiftOff
startThreadId: 4
endThreadId: 0       
endThreadId: 1       
endThreadId: 2       
endThreadId: 3       
endThreadId: 4       
     


Executors还是有点难理解,需要很多的实战才能有更好的体会,这里点到为止。




五、Callable 和 Future接口   
 Callable是类似于Runnable的接口,实现Callable接口的类和实现Runnable的类都是可被其它线程执行的任务。   
 Callable和Runnable有几点不同:   
 (1)Callable规定的方法是call(),Runnable规定的方法是run().   
 (2)Callable的任务执行后可返回值,而Runnable的任务是不能返回值的。   
 (3)call()方法抛出异常,而run()方法是不能抛出异常的。   
(4)运行Callable任务可拿到一个Future对象,   
 Future 表示异步计算的结果。它提供了检查计算是否完成的方法,以等待计算的完成,并检索计算的结果。   
 通过Future对象可了解任务执行情况,可取消任务的执行,还可获取任务执行的结果。   

代码示例:

  1. <SPAN style="FONT-SIZE: 14px">import java.util.concurrent.Callable;  
  2. import java.util.concurrent.ExecutorService;  
  3. import java.util.concurrent.Executors;  
  4. import java.util.concurrent.Future;  
  5. public class CallableTest {  
  6.     /** *//**    
  7.      * 自定义一个任务类,实现Callable接口    
  8.      */      
  9.     public static class MyCallableClass implements Callable{       
  10.         // 标志位        
  11.         private int flag = 0;       
  12.         public MyCallableClass(int flag){       
  13.             this.flag = flag;       
  14.         }       
  15.         public String call() throws Exception{       
  16.             if (this.flag == 0){       
  17.                 // 如果flag的值为0,则立即返回        
  18.                 return "flag = 0";       
  19.             }        
  20.             if (this.flag == 1){       
  21.                 // 如果flag的值为1,做一个无限循环        
  22.                 try {       
  23.                     while (true) {       
  24.                         System.out.println("looping.");       
  25.                         Thread.sleep(2000);       
  26.                     }       
  27.                 } catch (InterruptedException e) {    
  28.                 //如果线程被终止,打印提示   
  29.                     System.out.println("Interrupted");       
  30.                 }       
  31.                 return "false";       
  32.             } else {       
  33.                 // falg不为0或者1,则抛出异常        
  34.                 throw new Exception("Bad flag value!");       
  35.             }       
  36.         }       
  37.     }       
  38.            
  39.     public static void main(String[] args) {       
  40.         // 定义3个Callable类型的任务        
  41.         MyCallableClass task1 = new MyCallableClass(0);       
  42.         MyCallableClass task2 = new MyCallableClass(1);       
  43.         MyCallableClass task3 = new MyCallableClass(2);       
  44.                
  45.         // 创建一个执行任务的服务        
  46.         ExecutorService es = Executors.newFixedThreadPool(3);       
  47.         try {       
  48.             // 提交并执行任务,任务启动时返回了一个 Future对象,        
  49.             // 如果想得到任务执行的结果或者是异常可对这个Future对象进行操作        
  50.             Future future1 = es.submit(task1);       
  51.             // 获得第一个任务的结果,如果调用get方法,当前线程会等待任务执行完毕后才往下执行        
  52.             System.out.println("task1: " + future1.get());       
  53.                    
  54.             Future future2 = es.submit(task2);       
  55.             // 等待5秒后,再停止第二个任务。因为第二个任务进行的是无限循环        
  56.             Thread.sleep(6000);       
  57.             System.out.println("task2 cancel: " + future2.cancel(true));       
  58.                    
  59.             // 获取第三个任务的输出,因为执行第三个任务会引起异常        
  60.             // 所以下面的语句将引起异常的抛出        
  61.             Future future3 = es.submit(task3);       
  62.             System.out.println("task3: " + future3.get());       
  63.         } catch (Exception e){       
  64.             System.out.println(e.toString());       
  65.         }       
  66.         // 停止任务执行服务        
  67.         es.shutdownNow();       
  68.     }       
  69.   
  70.   
  71. }  
  72. </SPAN>  
  

运行结果:
task1: flag = 0
looping.
looping.
looping.
task2 cancel: true
Interrupted
java.util.concurrent.ExecutionException: java.lang.Exception: Bad flag value!

  评论这张
 
阅读(455)| 评论(0)
推荐 转载

历史上的今天

评论

<#--最新日志,群博日志--> <#--推荐日志--> <#--引用记录--> <#--博主推荐--> <#--随机阅读--> <#--首页推荐--> <#--历史上的今天--> <#--被推荐日志--> <#--上一篇,下一篇--> <#-- 热度 --> <#-- 网易新闻广告 --> <#--右边模块结构--> <#--评论模块结构--> <#--引用模块结构--> <#--博主发起的投票-->
 
 
 
 
 
 
 
 
 
 
 
 
 
 

页脚

网易公司版权所有 ©1997-2018