君子博学而日参省乎己 则知明而行无过矣

博客园 首页 新随笔 联系 订阅 管理
JAVA并发设计模式学习笔记（一）—— JAVA多线程编程

这个专题主要讨论并发编程的问题，所有的讨论都是基于JAVA语言的（因其独特的内存模型以及原生对多线程的支持能力），不过本文传达的是一种分析的思路，任何有经验的朋友都能很轻松地将其扩展到任何一门语言。 

注：本文的主要参考资料为结城浩所著《JAVA多线程设计模式》。 

线程的英文名Thread，原意指“细丝”。在多线程程序中，若要追踪各个线程的轨迹，就会派生出一系列错综复杂的乱线团。假设在运行过程中，如果有人问到“请问现在执行到代码的哪一部分了？”，你需要多个手指头才能指出正确的地方。 

当应用程序的规模、复杂程度达到一定程度时，并发设计是一个必将考虑到的问题，以下是一些常见的应用： 

  • GUI：以word为例，我们正在编辑一份大型的文档，此时执行“查找”操作；当word进行查找时，同时会出现一个“停止查找”的按钮，用户可以随时停止。此时就用到了多线程，其中一个线程在后台执行查找，另一个线程显示“停止查找”的按钮，一旦按下，则立即停止查找。两个操作交由不同的线程来处理，各线程可以专心负责自己的功能，因此也是模块化设计思想的一种体现。
  • 比较耗时的I/O处理：由于磁盘、网络的IO操作消耗的时间远大于内存处理，如果在此段时间内，程序仅仅是等待而无法执行其它处理，性能会大打折扣。如果事先能将I/O处理和非I/O处理区分开来，这样就能够利用进行I/O处理时CPU空闲的间隙，进行其它处理了。
  • 一个Server与多个Client：大部分Server都要求能够同时服务于1个以上的Client。Server本身并不知道何时会有Client接入，并且在Server中直接引入多个Client的设计，并不是十分优雅的方案；因此不妨设计成一旦有Client连接到Server，就会生成自动出来迎接这个Client的线程。这样一来，Server端的程序就可以简单地设计成好像只服务一个Client。当然，从J2SE 1.4开始，已经加入了新的NIO类库，不必利用线程也能进行兼具性能和扩充性的I/O处理，详情可参考JDK。


至于JAVA中线程的编码方式，无非是继承自抽象类Thread或者实现Runnable接口，想必各位读者都很熟悉了，这里就不复述了。 

在多线程程序里，多个线程既然可以自由操作，当然就可能同时操作到同一实例。这个情况又是会造成不必要的麻烦。例如经典的银行取款问题，其“确认可用余款”这一部分的代码应该该为： 

Java代码  收藏代码
  1. if(可用余额大于欲提取金额)  
  2. {  
  3.   从可用余额中减掉欲提取金额  
  4. }  


这段逻辑本身并没有问题。先确认可用余额，再检查是否允许提取输入金额，如果系统决定可以领取，则从可用余额中减掉此金额，保证不会发生可用余额变为负数的情况。 

但是，同时若有2个以上的线程执行这个程序的代码，可用余额可能会变成负数。比如： 

Java代码  收藏代码
  1. 初始化……  
  2. 可用余额 = 1000元  
  3. 欲提取金额 = 1000元  
  4. 线程A——可用余额大于欲提取金额？  
  5. 线程A——是  
  6. <<<此时切换成线程B>>>  
  7. 线程B——可用余额大于欲提取金额？  
  8. 线程B——是  
  9. 线程B——从可用余额中减掉欲提取金额  
  10. 线程B——可用余额变为0元  
  11. <<<此时切换成线程A>>>  
  12. 线程A——从可用余额中减掉欲提取金额  
  13. 线程A——可用余额变为-1000元  


我们发现，由于时间差，可能会发生线程B夹在线程A的“确认可用余额”和“减去可用余额”之间的情况，这就会导致出现金额为负数的情况。 

JAVA中使用synchronized来实现共享互斥，这就好比十字路口的红绿灯处理一样；当直向行车时绿灯时，另一边的横向车灯一定是红灯。synchronized也采用类似的“交通管制”的方式来实现线程间的互斥。 

上述银行存取款的互斥实现如下 

Java代码  收藏代码
  1. public class Bank  
  2. {  
  3.     private int money;  
  4.     private String name;  
  5.   
  6.     public Bank(String name, int money)  
  7.     {  
  8.         this.money = money;  
  9.         this.name = name;  
  10.     }  
  11.   
  12.     // 存款  
  13.     public synchronized void deposit(int m)  
  14.     {  
  15.         money += m;  
  16.     }  
  17.   
  18.     // 取款  
  19.     public synchronized void withdraw(int m)  
  20.     {  
  21.         if (money >= m)  
  22.         {  
  23.             money -= m;  
  24.             return true;  // 已取款  
  25.         }  
  26.         else  
  27.         {  
  28.             return false; // 余额不足  
  29.         }  
  30.     }  
  31.   
  32.     public String getName()  
  33.     {  
  34.         return name;  
  35.     }  
  36. }  


当一个线程正在执行Bank实例的deposit或withdraw方法时，其他线程就不能执行同一实例的deposit以及withdraw方法。欲执行的线程必须排队等候。 

也许会注意到，Bank类里还有一个非synchronized的方法——getName。无论其它线程是否正在执行同一实例的deposit、withdraw或者getName方法，都不妨碍它的执行。 

synchronized阻挡的几种使用方式，如下 
synchronized局部阻挡：如果需要“管制”的不是整个方法，而是方法的一部分，就使用此类阻挡，代码如下 

Java代码  收藏代码
  1. synchronized(表达式)  
  2. {  
  3.     ……  
  4. }  



synchronized实例方法阻挡：如果需要“管制”的是整个实例方法，而是方法的一部分，就使用此类阻挡，代码如下 

Java代码  收藏代码
  1. synchronized void method()  
  2. {  
  3.     ……  
  4. }  


这段代码在功能上与如下代码有异曲同工之妙 

Java代码  收藏代码
  1. void method()  
  2. {  
  3.     synchronized(this)      
  4.     {  
  5.         ……  
  6.     }  
  7. }  



synchronized类方法阻挡：如果需要“管制”的是类方法，就使用此类阻挡，代码如下 

Java代码  收藏代码
  1. class Something  
  2. {  
  3.     static synchronized void method()  
  4.     {  
  5.         ……  
  6.     }  
  7. }  


这段代码在功能上与如下代码有异曲同工之妙 

Java代码  收藏代码
  1. class Something  
  2. {  
  3.     static void method()  
  4.     {  
  5.         synchronized(Something.class)  
  6.         {  
  7.             ……  
  8.         }  
  9.     }  
  10. }  


从上面可以看出，synchronized类阻挡其实质是用类对象作为锁定的对象去进行互斥的。 

线面讲讲线程的协调。上面所说的是最简单的共享互斥，只要有线程再执行就乖乖地等候；现实工作中，我们需要的往往不止于此，比如： 

  • 若空间有空闲则继续写入，若没有则等候。
  • 空间有空闲时，及时通知等待线程。


线程协调的具体实现将在下一章中介绍。 

JAVA中提供了wait、notify、notifyAll以支持此类条件处理。这里要注意到以下几点： 

  • 如欲执行某一实例的wait方法，则首先必须获得该实例的锁；一旦进入wait set（线程的休息间），则自动释放该锁。
  • 使用notify方法时，会从锁定实例的wait set中唤醒一个线程。同样的，线程必须首先获得锁定，才能调用notyfy方法。被唤醒的线程并不是立即就可以执行的，因为在此刻，notify的线程还一直占有锁。另外，假设执行notify时，wait set里有多于一个的线程在等待，具体选择那个线程是无法得知的，因此应用程序最好不要写成会因所选线程而有所变动的方式。
  • notifyAll与notify基本相同，唯一区别在于它是唤醒所有线程而非一个。一般来说，使用notifyAll写的程序会更健壮一点。

转载：http://grunt1223.iteye.com/blog/876245

posted on 2013-09-14 22:21  刺猬的温驯  阅读(3631)  评论(0)  编辑  收藏  举报