线程特征-锁

锁？

一提到线程里面锁，可能很多人想到synchronized这个关键字，可能想到生产者和消费者的故事，哲学家进餐的故事等等一系列的事情，但是其实线程中还有一个锁就是lock这个接口，其中jdk是这么解释的：Lock 实现提供了比使用 synchronized 方法和语句可获得的更广泛的锁定操作。此实现允许更灵活的结构，可以具有差别很大的属性，可以支持多个相关的 Condition 对象。
锁是控制多个线程对共享资源进行访问的工具。通常，锁提供了对共享资源的独占访问。一次只能有一个线程获得锁，对共享资源的所有访问都需要首先获得锁。不过，某些锁可能允许对共享资源并发访问，如 ReadWriteLock 的读取锁。
synchronized 方法或语句的使用提供了对与每个对象相关的隐式监视器锁的访问，但却强制所有锁获取和释放均要出现在一个块结构中：当获取了多个锁时，它们必须以相反的顺序释放，且必须在与所有锁被获取时相同的词法范围内释放所有锁。
虽然 synchronized 方法和语句的范围机制使得使用监视器锁编程方便了很多，而且还帮助避免了很多涉及到锁的常见编程错误，但有时也需要以更为灵活的方式使用锁。例如，某些遍历并发访问的数据结果的算法要求使用 “hand-over-hand” 或 “chain locking”：获取节点 A 的锁，然后再获取节点 B 的锁，然后释放 A 并获取 C，然后释放 B 并获取 D，依此类推。Lock 接口的实现允许锁在不同的作用范围内获取和释放，并允许以任何顺序获取和释放多个锁，从而支持使用这种技术。
随着灵活性的增加，也带来了更多的责任。不使用块结构锁就失去了使用 synchronized 方法和语句时会出现的锁自动释放功能。在大多数情况下，应该使用以下语句：

Lock l = ...;      l.lock();     try {         // access the resource protected by this lock     } finally {         l.unlock();     }

这些内容主要集中在 java.util.concurrent.locks 下面的Condition、lock、ReadWriteLock三个接口上。上面已经根据jdk文档介绍了lock这个接口的基本内容，那么下面就来说说另外两个接口吧

Condition

Condition 将 Object 监视器方法（wait、notify 和 notifyAll）分解成截然不同的对象，以便通过将这些对象与任意 Lock 实现组合使用，为每个对象提供多个等待 set（wait-set）。其中，Lock 替代了 synchronized 方法和语句的使用，Condition 替代了 Object 监视器方法的使用。作为一个示例，假定有一个绑定的缓冲区，它支持 put 和 take 方法。如果试图在空的缓冲区上执行 take 操作，则在某一个项变得可用之前，线程将一直阻塞；如果试图在满的缓冲区上执行 put 操作，则在有空间变得可用之前，线程将一直阻塞。我们喜欢在单独的等待 set 中保存 put 线程和 take 线程，这样就可以在缓冲区中的项或空间变得可用时利用最佳规划，一次只通知一个线程。可以使用两个 Condition 实例来做到这一点。 

 class BoundedBuffer {   final Lock lock = new ReentrantLock();   final Condition notFull  = lock.newCondition();    final Condition notEmpty = lock.newCondition();    final Object[] items = new Object[100];   int putptr, takeptr, count;   public void put(Object x) throws InterruptedException {     lock.lock();     try {       while (count == items.length)          notFull.await();       items[putptr] = x;        if (++putptr == items.length) putptr = 0;       ++count;       notEmpty.signal();     } finally {       lock.unlock();     }   }   public Object take() throws InterruptedException {     lock.lock();     try {       while (count == 0)          notEmpty.await();       Object x = items[takeptr];        if (++takeptr == items.length) takeptr = 0;       --count;       notFull.signal();       return x;     } finally {       lock.unlock();     }   }  }

ReadWriteLock接口：
ReadWriteLock 维护了一对相关的锁，一个用于只读操作，另一个用于写入操作。只要没有 writer，读取锁可以由多个 reader 线程同时保持。写入锁是独占的。 所有 ReadWriteLock 实现都必须保证writeLock 操作的内存同步效果也要保持与相关 readLock 的联系。也就是说，成功获取读锁的线程会看到写入锁之前版本所做的所有更新。
下面写个存钱取钱的例子看看吧（lock接口的例子）：

package com.lilei;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;import java.util.concurrent.locks.Lock;import java.util.concurrent.locks.ReentrantLock;public class Test {    public static void main(String[] args) {        //创建并发访问的账户        MyCount myCount = new MyCount("95599200901215522", 10000);        //创建一个锁对象        Lock lock = new ReentrantLock();        ExecutorService pool = Executors.newCachedThreadPool();//创建一个尺寸可变的线程池        //创建一些并发访问用户，一个信用卡，存的存，取的取，好热闹啊        User u1 = new User("张三", myCount, -4000, lock);        User u2 = new User("张三他爹", myCount, 6000, lock);        User u3 = new User("张三他弟", myCount, -8000, lock);        User u4 = new User("张三", myCount, 800, lock);        //在线程池中执行各个用户的操作        pool.execute(u1);        pool.execute(u2);        pool.execute(u3);        pool.execute(u4);        //关闭线程池        pool.shutdown();    }}class User implements Runnable{    private String name;    private MyCount count;    private int iocash;    private Lock lock;    public User(String name, MyCount count, int iocash, Lock lock) {        super();        this.name = name;        this.count = count;        this.iocash = iocash;        this.lock = lock;    }    @Override    public void run() {        lock.lock();//获取锁        //执行现金业务        System.out.println(name + "正在操作" + count + "账户， 金额为" +        iocash + "，当前金额为" + count.getCash());        count.setCash(count.getCash() + iocash);        System.out.println(name + "操作" + count + "账户成功， 金额为" +        iocash + "，当前金额为" + count.getCash());        //释放锁，否则别的线程没有机会执行了        lock.unlock();    }}class MyCount{    private String oid;//账号    private int cash;//账户余额    public MyCount(String oid,int cash) {        this.oid = oid;        this.cash = cash;    }    public String getOid() {        return oid;    }    public void setOid(String oid) {        this.oid = oid;    }    public int getCash() {        return cash;    }    public void setCash(int cash) {        this.cash = cash;    }    @Override    public String toString() {        return "MyCount [oid=" + oid + ", cash=" + cash + "]";    }}

利用锁对象是不是方便了好多，是不是比直接在某个不知情的对象上清晰好多，但是一定要注意，获取了锁对象，用完了以后记得把锁释放掉，不然别人就用不了了。
下面的例子是ReadWriteLock（读写锁）：

package com.lilei;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;import java.util.concurrent.locks.ReadWriteLock;import java.util.concurrent.locks.ReentrantReadWriteLock;public class TestReadWriteLock {    public static void main(String[] args) {        //创建并发访问的账户        MyCount1 myCount = new MyCount1("95599200901215522", 10000);        //创建一个锁对象        ReadWriteLock lock = new ReentrantReadWriteLock(false);        //创建一个线程池        ExecutorService pool = Executors.newFixedThreadPool(2);        //创建一些并发访问用户，一个信用卡，存的存，取的取，好热闹啊        User1 u1 = new User1("张三", myCount, -4000, lock, false);        User1 u2 = new User1("张三他爹", myCount, 6000, lock, false);        User1 u3 = new User1("张三他弟", myCount, -8000, lock, false);        User1 u4 = new User1("张三", myCount, 800, lock, false);        User1 u5 = new User1("张三他爹", myCount, 0, lock, true);        pool.execute(u1);        pool.execute(u2);        pool.execute(u3);        pool.execute(u4);        pool.execute(u5);        //关闭线程池        pool.shutdown();    }}class User1 implements Runnable{    private String name; //用户名    private MyCount1 myCount; //所要操作的账户    private int iocash; //操作的金额，当然有正负之分了    private ReadWriteLock myLock; //执行操作所需的锁对象    private boolean ischeck; //是否查询    public User1(String name, MyCount1 myCount, int iocash,            ReadWriteLock myLock, boolean ischeck) {        super();        this.name = name;        this.myCount = myCount;        this.iocash = iocash;        this.myLock = myLock;        this.ischeck = ischeck;    }    @Override    public void run() {        if (ischeck) {            myLock.readLock().lock();//获取读锁            System.out.println("读：" + name + "正在查询" + myCount + "账户，当前金额为" + myCount.getCash());            //释放读锁            myLock.readLock().unlock();        }else {            myLock.writeLock().lock();//获取写锁            //执行现金业务            System.out.println("写：" + name + "正在操作" + myCount + "账户，金额为" + iocash + "，当前金额为" + myCount.getCash());            myCount.setCash(myCount.getCash() + iocash);            System.out.println("写：" + name + "操作" + myCount + "账户成功，金额为" + iocash + "，当前金额为" + myCount.getCash());            //释放写锁            myLock.writeLock().unlock();        }    }}class MyCount1{    private String oid;//账号    private int cash;//账户余额    public MyCount1(String oid,int cash) {        this.oid = oid;        this.cash = cash;    }    public String getOid() {        return oid;    }    public void setOid(String oid) {        this.oid = oid;    }    public int getCash() {        return cash;    }    public void setCash(int cash) {        this.cash = cash;    }    @Override    public String toString() {        return "MyCount [oid=" + oid + ", cash=" + cash + "]";    }}

实际开发中能用读写锁的尽量别用普通锁，也别用synchronized关键字，因为比如有十个线程来操作一组数据，操作的内容只有加和减，如果你用synchronized关键字的话效率很低，用读写锁就不一样了，用读写锁的话就分成两种操作，加减的操作了，是不是这样呢。