【Java多线程与并发库】3.传统线程互斥技术

线程的同步互斥与通信
互斥的问题在使用线程的时候是我们必须要注意的。
例如两个线程同时开启，由于业务规则，需要访问同一个对象，要取得该对象
中的数据进行修改。
这样多个线程对同一个数据进行操作的实例有很多，例如银行交易。我们的账户中原来
有2000元，在同一时间，我们刷卡200购物，然后有人给我们转账500元，我们的账户余额
应该是2000-200+500=2300元。
但是，在类似上述场景的时候，我们不对线程做任何的操作，这个时候我们的数据可能就会出错。

只要涉及到多个线程操作相同数据的时候就会出现线程安全的问题。这是我们编写多线程程序的
时候特别需要注意的问题。

接下来我们编写一个传统的涉及线程安全问题的程序样例。

我们开启两个线程，分别打印一个传入的数据，打印方式是一个一个字符的打印。

1. package cn.edu.hpu.test;  
2.   
3. public class TraditionalThreadSynchronized {  
4.   
5.     public static void main(String[] args) {  
6.         new TraditionalThreadSynchronized().init();  
7.     }  
8.       
9.     public void init(){  
10.   
11.         final Outputer outputer=new Outputer();  
12.           
13.         new Thread(new Runnable(){  
14.             public void run() {  
15.                 while(true){  
16.                     try {  
17.                         Thread.sleep(10);  
18.                     } catch (InterruptedException e) {  
19.                         e.printStackTrace();  
20.                     }  
21.                     outputer.output("ABCDEFGHIJKLNOPQRST");  
22.                 }  
23.             }  
24.         }      
25.         ).start();  
26.           
27.         new Thread(new Runnable(){  
28.             public void run() {  
29.                 while(true){  
30.                     try {  
31.                         Thread.sleep(10);  
32.                     } catch (InterruptedException e) {  
33.                         e.printStackTrace();  
34.                     }  
35.                     outputer.output("abcdefghijklmnopqrst");  
36.                 }  
37.             }  
38.         }      
39.         ).start();  
40.     }  
41.       
42.     class Outputer{  
43.         public void output(String name){  
44.             int len=name.length();  
45.             for (int i = 0; i < len; i++) {  
46.                 System.out.print(name.charAt(i));  
47.             }  
48.             System.out.println();  
49.         }  
50.     }  
51. }  

发现除了完整打印大写和小写字符串之外，有些时候打印某个线程的字符时，转而打印其它线程的字符。

如果要求每一个线程在运行的时候，中途不被打断，我们就要实现线程的“原子性”。即是执行某个线程的时候，其它线程不能执行。

实现线程的“互斥性”，我们要给线程中需要独立执行的代码块或者方法加“线程锁”。

我们使用synchronized来给需要线程独立运行的代码来加锁。其中synchronized有一个参数，该参数要求
是一个线程公用的参数，该参数具有唯一性，只要该参数的引用没有被释放，其他使用到该参数的线程就不能进行。

因为我们所有的线程调用的都是同一个Outputer类，我们给该类一个参数，将该参数
作为线程锁的“钥匙”:

1. class Outputer{  
2.     String key="lock";  
3.     public void output(String name){  
4.         int len=name.length();  
5.         synchronized(key){  
6.             for (int i = 0; i < len; i++) {  
7.                 System.out.print(name.charAt(i));  
8.             }  
9.             System.out.println();  
10.         }  
11.     }  
12. }  

如果每一个线程自己new一个Outputer类，那我们刚刚的那个锁就失去作用了，因为每个线程的Outputer
类的key参数不是同一个了，这个时候我们将锁的参数改为该类本身:

1. class Outputer{  
2.     public void output(String name){  
3.         int len=name.length();  
4.         synchronized(this){  
5.             for (int i = 0; i < len; i++) {  
6.                 System.out.print(name.charAt(i));  
7.             }  
8.             System.out.println();  
9.         }  
10.     }  
11. }  

当然，我们只是想在调用Outputer类的output方法的时候实现互斥，合适的操做是给output方法加锁:

1. class Outputer{  
2.     public synchronized void output(String name){  
3.         int len=name.length();  
4.         for (int i = 0; i < len; i++) {  
5.             System.out.print(name.charAt(i));  
6.         }  
7.         System.out.println();  
8.     }  
9. }  

如果我们频繁在加锁的方法里再加锁的话，很有可能会发生“死锁”的现象。

最后，如果有类是静态类，调用的加锁方法又是静态方法，该类的其它非静态方法要与其互斥的话，
非静态方法中的synchronized(this)要改成synchronized(类名.class)。

最后，献上传统互斥技术的总结图:

出处：http://blog.csdn.net/acmman/article/details/52763352