Java并发编程之——Lock(重入锁，读写锁)及Condition示例

　　在JDK5的并发包中有一个子包为java.concurrent.locks，它下面定义了三个接口Lock,ReadWriteLock,Condition,分别为重入锁，读写锁，锁条件判断

LOCK:

Lock与java关键字（synchronized）具有相同的功能，但它更加灵活。ReentrantLock作为Lock接口的实现类，被作为Java语言中synchronized功能的替代，它们具有相同的内存意义，相同的锁定，但在争用条件下却有更好的性能，此为它还有synchronized没有提供的其它特性。但就实际应用来说，由于内部锁是内置于Java虚拟机中的，它能够进行优化，因此未来的性能改进可能更倾向于内部锁，而不是重入锁。综上所述，除非你的应用程序需要发在Java 5.0上，或者需要使用重入锁的可伸缩性，否则就应该选择内部锁。

总之，ReentrantLock锁与Java内在锁相比有下面的特点：

1）ReentrantLock必须在 finally 块中释放锁，而使用synchronized同步，JVM 将确保锁会获得自动释放。

2）与目前的 synchronized 实现相比，争用下的 ReentrantLock 实现更具可伸缩性。

3）对于ReentrantLock ，可以有不止一个条件变量与它关联。（Condition后面会说到）

4）允许选择想要一个公平锁，还是一个不公平锁。(new ReentrantLock(false)非公平锁，非公平锁执行效率会更高)

5）除非你对 Lock 的某个高级特性有明确的需要，或者有明确的证据表明在特定情况下，同步已经成为可伸缩性的瓶颈，否则还是应当继续使用synchronized。

6）Lock 类只是普通的类，JVM 不知道具体哪个线程拥有 Lock 对象。而且，几乎每个开发人员都熟悉 synchronized，它可以在 JVM 的所有版本中工作。

Condition:

类似于java中原来线程交互所用的wait,notify和notifyAll方法在新的并发包中基于重入锁机制引入了Condition接口，Condition 将 Object 监视器方法（wait、notify 和 notifyAll）分解成截然不同的对象，以便通过将这些对象与任意 Lock 实现组合使用，为每个对象提供多个等待 set（wait-set），就是多路等待。Condition 的方法与 wait 、notify 和 notifyAll 方法类似，分别命名为 await 、 signal和singalAll因为它们不能覆盖Object上的对应方法。

下面是一个多路条件等待按顺序执行的例子，给定一个0,按1，2，3，这样的顺序依次加一次，总共加10次，并输出每次加后的结果，模拟让多线程来做：

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ConditionTest {

    /**
     * @param args
     */
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(new Runnable() {

                @Override
                public void run() {
                    new Test1().sub1();

                }
            }).start();

            new Thread(new Runnable() {

                @Override
                public void run() {
                    new Test1().sub2();

                }
            }).start();

            new Thread(new Runnable() {

                @Override
                public void run() {
                    new Test1().sub3();

                }
            }).start();
        }
    }

}

class Test1 {
    public static int i = 0;
    public static int conNum = 1;
    //此处注意锁和condition也要定义成静态的，不然就有多把锁和condition了,相当于没加一样。
    public static Lock lock = new ReentrantLock(false);
    public static Condition con1 = lock.newCondition();
    public static Condition con2 = lock.newCondition();
    public static Condition con3 = lock.newCondition();

    // 方法1对i进行加1
    public  void sub1() {
        lock.lock();
        try {
            while (conNum != 1) {
                try {
                    con1.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            i++;
            System.out.print(i + ",");
            conNum = 2;
            con2.signal();
        } finally {
            lock.unlock();
        }

    }

    // 方法2对i加2
    public void sub2() {
        lock.lock();

        try {
            while (conNum != 2) {
                try {
                    con2.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            i = i + 2;
            System.out.print(i + ",");
            conNum = 3;
            con3.signal();
        } finally {
            lock.unlock();
        }

    }

    // 方法3对i加3;
    public void sub3() {
        lock.lock();
        try {
            while (conNum != 3) {
                try {
                    con3.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            i = i + 3;
            System.out.print(i + ",");
            conNum = 1;
            con1.signal();
        } finally {
            lock.unlock();
        }

    }

}

 

ReadWriteLock:

ReadWriteLock 维护了一对相关的锁，一个用于只读操作，另一个用于写入操作。只要没有 writer，读取锁可以由多个 reader 线程同时保持。写入锁是独占的。从理论上说，使用读写锁所允许的并发性增强将带来更大的性能提高。与互斥锁相比，使用读-写锁能否提升性能则取决于读写操作期间读取数据相对于修改数据的频率，以及数据的争用——即在同一时间试图对该数据执行读取或写入操作的线程数。

下面一个示例，模拟各有10个线程对数据源数据进行读写，从输出结果可以看出实现了有序的读写

public class LockTest {
    /**
     * @param args
     */
    public static void main(String[] args){
        //10个读线程
      for(int i=0;i<10;i++){
          new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"读取到的数据为："+new Data().get());
            }
        }).start();
      }
      //10个写线程
      for(int i=0;i<10;i++){
          final int num = i;
          new Thread(new Runnable() {
            @Override
            public void run() {
                new Data().set("world"+num);
            }
        }).start();
      }
    }
    
    
    
}
//数据源 
class Data{
    private static String name="hello";
    ReadWriteLock rwl = new ReentrantReadWriteLock();
    public String get(){
        rwl.readLock().lock();
        System.out.println(Thread.currentThread().getName()+"--读取数据前：");
        
        try{try {
            Thread.sleep(new Random().nextInt(3000));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return name;
        }finally{
            System.out.println(Thread.currentThread().getName()+"--已经读取完");
            rwl.readLock().unlock();
        }
        
        }
    
    public void set(String name){
        rwl.writeLock().lock();
        try{
        System.out.println(Thread.currentThread().getName()+">写入数据前");
        try {
            Thread.sleep(new Random().nextInt(3000));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        this.name = name;
        System.out.println(Thread.currentThread().getName()+">写完数据");
        }finally{
            rwl.writeLock().unlock();
        }
        
    }
}