java多线程之三

1、引言

1.1 什么时候会出现线程安全问题？
临界资源：虽然多个线程可以共享系统中的各种资源，但是对于一些资源一次只能被一个线程访问，这种资源叫做临界资源。对于临界资源不采取互斥的访问，可能会引发线程安全问题。

1.2 如何解决线程安全问题？
通常来说，是在访问临界资源的代码前面加上一个锁，当访问完临界资源后释放锁，让其他线程继续访问。在Java中，提供了两种方式来实现同步互斥访问：synchronized和Lock。

2、synchronized同步方法或者同步块
　　在了解synchronized关键字的使用方法之前，我们先来看一个概念：互斥锁，顾名思义：能到达到互斥访问目的的锁。举个简单的例子：如果对临界资源加上互斥锁，当一个线程在访问该临界资源时，其他线程便只能等待。
　　在Java中，可以使用synchronized关键字来标记一个方法或者代码块，当某个线程调用该对象的synchronized方法或者访问synchronized代码块时，这个线程便获得了该对象的锁，其他线程暂时无法访问这个方法，只有等待这个方法执行完毕或者代码块执行完毕，这个线程才会释放该对象的锁，其他线程才能执行这个方法或者代码块。

2.1 synchronized方法

下面这段代码中两个线程分别调用insertData对象插入数据：

 public class Test {        
        public static void main(String[] args) {  
            final InsertData insertData = new InsertData();      
            new Thread() {  
                public void run() {  
                    insertData.insert(Thread.currentThread());  
                };  
            }.start();        
            new Thread() {  
                public void run() {  
                    insertData.insert(Thread.currentThread());  
                };  
            }.start();  
        }  
    }        
    class InsertData {  
        private ArrayList<Integer> arrayList = new ArrayList<Integer>();  
        public void insert(Thread thread) {  
            for (int i = 0; i < 5; i++) {  
                System.out.println(thread.getName() + "在插入数据" + i);  
                arrayList.add(i);  
            }  
        }  
    }  

此时程序的输出结果为：  
Thread-0在插入数据0  
Thread-1在插入数据0  
Thread-1在插入数据1  
Thread-0在插入数据1  
Thread-1在插入数据2  
Thread-0在插入数据2  
Thread-1在插入数据3  
Thread-0在插入数据3  
Thread-1在插入数据4  
Thread-0在插入数据4

说明两个线程在同时执行insert方法。
而如果在insert方法前面加上关键字synchronized的话，运行结果为：

    public synchronized void insert(Thread thread) {  
        for (int i = 0; i < 5; i++) {  
            System.out.println(thread.getName() + "在插入数据" + i);  
            arrayList.add(i);  
        }  
    }  

Thread-0在插入数据0  
Thread-0在插入数据1  
Thread-0在插入数据2  
Thread-0在插入数据3  
Thread-0在插入数据4  
Thread-1在插入数据0  
Thread-1在插入数据1  
Thread-1在插入数据2  
Thread-1在插入数据3  
Thread-1在插入数据4  

从上输出结果说明，Thread-1插入数据是等Thread-0插入完数据之后才进行的。说明Thread-0和Thread-1并不是同时执行insert方法的。这就是synchronized方法。对于同步方法而言，同步监视器是this，也就是对象本身。

不过有几点需要注意：

　　1）当一个线程正在访问一个对象的synchronized方法，那么其他线程不能访问该对象的其他synchronized方法。需要阻塞等待，直到前面的线程从同步代码块或方法中退出，释放掉了该对象级别锁。这个原因很简单，因为一个对象只有一把锁，当一个线程获取了该对象的锁之后，其他线程无法获取该对象的锁，所以无法访问该对象的其他synchronized方法。

　　2）当一个线程正在访问一个对象的synchronized方法，那么其他线程能访问该对象的非synchronized方法。这个原因很简单，访问非synchronized方法不需要获得该对象的锁。

　　3）如果一个线程A需要访问对象object1的synchronized方法fun1，另外一个线程B需要访问对象object2的synchronized方法fun1，即使object1和object2是同一类型），也不会产生线程安全问题，因为他们访问的是不同的对象，所以不存在互斥问题。

2.2.synchronized代码块

synchronized(synObject) {  
...
}

syschronized后面的synObject是同步监视器，线程在执行同步代码块之前必须先获得对同步监视器锁定。
比如上面的insert方法可以改成以下形式：

 class InsertData {  
        private ArrayList<Integer> arrayList = new ArrayList<Integer>();  
        private Object object = new Object();       
        public void insert(Thread thread){  
            synchronized (object) {  
                for(int i=0;i<100;i++){  
                    System.out.println(thread.getName()+"在插入数据"+i);  
                    arrayList.add(i);  
                }  
            }  
        }  
    }  

从上面可以看出，synchronized代码块使用起来比synchronized方法要灵活得多。因为也许一个方法中只有一部分代码只需要同步，如果此时对整个方法用synchronized进行同步，会影响程序执行效率。而使用synchronized代码块就可以避免这个问题，synchronized代码块可以实现只对需要同步的地方进行同步。

对于同步方法，锁是当前实例对象。对于静态同步方法，锁是当前对象的Class对象。对于同步方法块，锁是Synchonized括号里配置的对象。当一个线程访问同步代码块时，它首先必须得到锁，退出或抛出异常时必须释放锁。

3、Lock

从jdk1.5之后，java提供了另外的一种线程同步方式：通过显示定义同步锁对象来实现同步。Lock允许更加灵活方便的使用，lock锁可以被中断，支持定时锁，最后在finally中释放锁就好。

    //定义锁对象
    ReentrantLock lock = new ReentrantLock();  
    lock.lock();  
    try{  
        //处理任务  
    }catch(Exception ex){  

    }finally{  
        lock.unlock();   //释放锁  
    }  

Lock和synchronized的比较:
1）Lock是一个接口，而synchronized是Java中的关键字，synchronized是内置的语言实现；

2）synchronized在发生异常时，会自动释放线程占有的锁，因此不会导致死锁现象发生；而Lock在发生异常时，如果没有主动通过unLock()去释放锁，则很可能造成死锁现象，因此使用Lock时需要在finally块中释放锁；

3）Lock可以让等待锁的线程响应中断，而synchronized却不行，使用synchronized时，等待的线程会一直等待下去，不能够响应中断；

4）通过Lock可以知道有没有成功获取锁，而synchronized却无法办到。

5）Lock可以提高多个线程进行读操作的效率

　　在性能上来说，如果竞争资源不激烈，两者的性能是差不多的，而当竞争资源非常激烈时（即有大量线程同时竞争），此时Lock的性能要远远优于synchronized。所以说，在具体使用时要根据适当情况选择

4、锁的相关概念介绍

1.可重入锁
　　如果锁具备可重入性，则称作为可重入锁。像synchronized和ReentrantLock都是可重入锁，可重入性在我看来实际上表明了锁的分配机制：基于线程的分配，而不是基于方法调用的分配。举个简单的例子，当一个线程执行到某个synchronized方法时，比如说method1，而在method1中会调用另外一个synchronized方法method2，此时线程不必重新去申请锁，而是可以直接执行方法method2。

2.可中断锁
可中断锁：顾名思义，就是可以相应中断的锁。在Java中，synchronized就不是可中断锁，而Lock是可中断锁。如果某一线程A正在执行锁中的代码，另一线程B正在等待获取该锁，可能由于等待时间过长，线程B不想等待了，想先处理其他事情，我们可以让它中断自己或者在别的线程中中断它，这种就是可中断锁。

3.公平锁
　　公平锁即尽量以请求锁的顺序来获取锁。比如同是有多个线程在等待一个锁，当这个锁被释放时，等待时间最久的线程（最先请求的线程）会获得该所，这种就是公平锁。非公平锁即无法保证锁的获取是按照请求锁的顺序进行的。这样就可能导致某个或者一些线程永远获取不到锁。在Java中，synchronized就是非公平锁，它无法保证等待的线程获取锁的顺序。而对于ReentrantLock和ReentrantReadWriteLock，它默认情况下是非公平锁，但是可以设置为公平锁。

4.读写锁
　　读写锁将对一个资源（比如文件）的访问分成了2个锁，一个读锁和一个写锁。正因为有了读写锁，才使得多个线程之间的读操作不会发生冲突。ReadWriteLock就是读写锁，它是一个接口，ReentrantReadWriteLock实现了这个接口。可以通过readLock()获取读锁，通过writeLock()获取写锁。