public class ConditionTest {

 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();
       }
     }
   }

  public ReentrantReadWriteLock.WriteLock writeLock() { return writerLock; }
    public ReentrantReadWriteLock.ReadLock  readLock()  { return readerLock; }

public class RreadWriteLockTest {

  ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
  public int i  = 0;
//读取
 public void read() throws InterruptedException{
  readWriteLock.readLock().lock();//获取读锁
  System.out.println("read thread:"+Thread.currentThread().getName());
  Thread.sleep(10000);
  System.out.println("read:"+i);
  readWriteLock.readLock().unlock();
 }
//写入
 public void write() throws InterruptedException{
  
  readWriteLock.writeLock().lock();//获取写锁
  System.out.println("write thread:"+Thread.currentThread().getName());
  Thread.sleep(10000);
  i = 2;
  System.out.println("write:"+i);
readWriteLock.writeLock().unlock();
 }
}
测试代码：
1 测试两个同时读的，结果都能同时读取。
2 测试一个读，一个写的，需要其中一个释放锁之后才能进行另外一个操作
public static void main(String[] args) throws InterruptedException {
  final RreadWriteLockTest lockTest= new RreadWriteLockTest();
  new Thread(new Runnable() {
   
   @Override
   public void run() {
    try {
     lockTest.write();
    } catch (InterruptedException e) {
     e.printStackTrace();
    }
   }
  }).start();
  Thread.sleep(2000);
 new Thread(new Runnable() {
    @Override
    public void run() {
     try {
      lockTest.read();
     } catch (InterruptedException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
     }
    }
   }).start();
 }
打印如下：
write thread:Thread-0执行完之后(10秒之后)才执行read thread:Thread-1

注意：执行完以后一定要执行unlock，要不lock的计数没有-1，这样对应read或者write的操作将无法进行，一直等待。

举例来说：

public synchronized void method(){

    method body

}

等价于

public void method(){

    this.intrinsicLock.lock();

    try{

        method body;

    }finally(){

        this.intrinsicLock.unlock();

    }

}

从上面的代码示例可以看出，synchronized的使用方式是比较简单的。这也导致了大量的初学者在碰到java编程的时候落入陷阱里，认为既然synhronized可以搞定一切，那么不管三七二十一，只要有并发可能性的地方，就加上synchronized的关键字，这显然是不对的。在java对象中，这个java对象只有这一个内部锁，其中一个synchronized方法获取到了这个锁，另外一个synchronized方法的调用将被阻塞。

即

class sync{

    public synchronized void methodA(){};

    public synchronized void methodB(){};

    ... ...

}

methodA 和methodB在初始就是互斥的，如果methodA和methodB进入互相等待，就很容易出现死锁的情况。那如果碰到这种情况，应该怎么做了？常用的方式是在方法内部新建一个无意义的对象，然后对这个无意义的对象加锅。

另外需要注意的是将静态类声明为synchronized方法也是合法的。举例来说，如果Sync有一个static synchronized方法，那么这个方法被调用时,bank.class这个类对象本身在jvm中将被锁住

AtomicInteger，一个提供原子操作的Integer的类。在Java语言中，++i和i++操作并不是线程安全的，在使用的时候，不可避免的会用到synchronized关键字。而AtomicInteger则通过一种线程安全的加减操作接口。

来看AtomicInteger提供的接口。

//获取当前的值

public final int get()

//取当前的值，并设置新的值

 public final int getAndSet(int newValue)

//获取当前的值，并自增

 public final int getAndIncrement()

//获取当前的值，并自减

public final int getAndDecrement()

//获取当前的值，并加上预期的值

public final int getAndAdd(int delta)

... ...

我们在上一节提到的CAS主要是这两个方法

    public final boolean compareAndSet(int expect, int update) {
    return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
    }

    public final boolean weakCompareAndSet(int expect, int update) {
    return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
    }

这两个方法是名称不同，但是做的事是一样的，可能在后续的java版本里面会显示出区别来。

详细查看会发现，这两个接口都是调用一个unsafe的类来操作，这个是通过JNI实现的本地方法，细节就不考虑了。

下面是一个对比测试，我们写一个synchronized的方法和一个AtomicInteger的方法来进行测试，直观的感受下性能上的差异

结果

time elapse:31
time elapse:16
由此不难看出，通过JNI本地的CAS性能远超synchronized关键字

Reference

http://stackoverflow.com/questions/2443239/java-atomicinteger-what-are-the-differences-between-compareandset-and-weakcompar