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

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

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

接下来我们编写一个传统的涉及线程安全问题的程序样例。
我们开启两个线程，分别打印一个传入的数据，打印方式是一个一个字符的打印。

package cn.edu.hpu.test;

public class TraditionalThreadSynchronized {

    public static void main(String[] args) {
        new TraditionalThreadSynchronized().init();
    }
    
    public void init(){

        final Outputer outputer=new Outputer();
        
        new Thread(new Runnable(){
            public void run() {
                while(true){
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    outputer.output("ABCDEFGHIJKLNOPQRST");
                }
            }
        }    
        ).start();
        
        new Thread(new Runnable(){
            public void run() {
                while(true){
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    outputer.output("abcdefghijklmnopqrst");
                }
            }
        }    
        ).start();
    }
    
    class Outputer{
        public void output(String name){
            int len=name.length();
            for (int i = 0; i < len; i++) {
                System.out.print(name.charAt(i));
            }
            System.out.println();
        }
    }
}

我们运行一下这程序:

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

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

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

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

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

class Outputer{
    String key="lock";
    public void output(String name){
        int len=name.length();
        synchronized(key){
            for (int i = 0; i < len; i++) {
                System.out.print(name.charAt(i));
            }
            System.out.println();
        }
    }
}

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

class Outputer{
    public void output(String name){
        int len=name.length();
        synchronized(this){
            for (int i = 0; i < len; i++) {
                System.out.print(name.charAt(i));
            }
            System.out.println();
        }
    }
}

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

class Outputer{
    public synchronized void output(String name){
        int len=name.length();
        for (int i = 0; i < len; i++) {
            System.out.print(name.charAt(i));
        }
        System.out.println();
    }
}

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

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

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

转载请注明出处：http://blog.csdn.net/acmman/article/details/52763352