lock+Condition

关键字 synchronized+wait/notify/notifyAll可以实现等待/通知模式，类ReentrantLock可以实现同样的功能，但需要借助Condition对象。Condition类是JDK5中出现的技术，使用它有更好的灵活性，比如可以实现多路通知功能，选择性的进行线程通知，在调度线程上更加灵活。

使用wait+notify/notifyAll方法进行通知时，被通知的线程却是由JVM随机选择的。但使用reentrantLock结合Condition类是可以实现选择性通知。

Object类中的wait()方法，相当于Condition类中的await()方法；Object类中的notify()方法，相当于Condition类中的signal()方法。Object类中的notifyAll方法，相当于Condition类中的signalAll()方法。

 打印 12A34B.......5152Z

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

public class Print12A_RC {
    
    private Lock lock =new ReentrantLock();
    private Condition con=lock.newCondition();
    private boolean isInt=true;
    private int i=1;
    private char ch ='A';
    public void printInt()
    {
        try {
            lock.lock();
            while(!isInt)
            {
                con.await();
            }
            System.out.print((i++)+""+(i++));
            isInt=false;
            con.signal();
        } catch (Exception e) {
        }
        finally
        {
            lock.unlock();
        }
    }
    
    public void printChar()
    {
        try {
            lock.lock();
            while(isInt)
            {
                con.await();
            }
            System.out.print((char)ch);
            ch++;
            isInt=true;
            con.signal();
            
            
        } catch (Exception e) {
        }
        finally {
            lock.unlock();
        }
    }
    
    public static void main(String[] args) {
        Print12A_RC rc=new Print12A_RC();
        Thread aThread=new Thread(new Runnable() {
            
            @Override
            public void run() {
                for(int i=0;i<26;i++)
                {
                    rc.printInt();
                }
            }
        });
        Thread bThread =new Thread(new Runnable() {
            
            @Override
            public void run() {
                for(int i=0;i<26;i++)
                {
                    rc.printChar();
                }
            }
        });
        aThread.start();
        bThread.start();
    }
}

 顺序打印，如123123123....

package multiMethod.reentrantLockCondition;

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

public class PrintByOrder {
    ReentrantLock lock =new ReentrantLock();
    Condition condition=lock.newCondition();
    int printnext=1;
    
    public void print1()
    {
        lock.lock();
        try{
            while(printnext!=1)
            {
                condition.await();
            }
            Thread.sleep(500);//不加此行会不打印，不知什么原因。
            System.out.print(1);
            printnext=2;
            condition.signalAll();
        }
        catch (Exception e) {
            // TODO: handle exception
        }
        finally{
            lock.unlock();
        }
    }
    
    public void print2()
    {
        lock.lock();
        try{
            while(printnext!=2)
            {
                condition.await();
            }
            System.out.print(2);
            printnext=3;
            condition.signalAll();
        }
        catch (Exception e) {
        }
        finally{
            lock.unlock();
        }
    }
    
    public void print3()
    {
        lock.lock();
        try{
            while(printnext!=3)
            {
                condition.await();
            }
            System.out.print(3);
            printnext=1;
            condition.signalAll();
        }
        catch (Exception e) {
            // TODO: handle exception
        }
        finally{
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        PrintByOrder order=new PrintByOrder();
        Runnable runnable1=new Runnable() {
            
            @Override
            public void run() {
                while(true){
                    order.print1();
                }
            }
        };
        
        Runnable runnable2=new Runnable() {
            
            @Override
            public void run() {
                while(true){
                    order.print2();
                }
            }
        };
        
        Runnable runnable3=new Runnable() {
            
            @Override
            public void run() {
                while(true){
                    order.print3();
                }
            }
        };
        
        new Thread(runnable1).start();
        new Thread(runnable2).start();
        new Thread(runnable3).start();
    }
}

读写锁，比上面的lock+condition提高效率。

ReentrantReadWriteLock会使用两把锁来解决问题，一个读锁，一个写锁
线程进入读锁的前提条件：
    没有其他线程的写锁，
    没有写请求或者有写请求，但调用线程和持有锁的线程是同一个

线程进入写锁的前提条件：
    没有其他线程的读锁
    没有其他线程的写锁

简单来说，就是读读共享，写写互斥，读写互斥。

另外，ReentrantReadWriteLock.readLock 无需newCondition，而ReentrantReadWriteLock.writeLock可以newCondition，用于多个读线程之间的通信。

import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReadWriteLock {
    private ReentrantReadWriteLock rw= new ReentrantReadWriteLock();
    
    public void readLock(){
        
        
        try {
            rw.readLock().lock();
            System.out.println("read before sleep:"+Thread.currentThread().getName()+":"+System.currentTimeMillis());
            Thread.sleep(2000);
            System.out.println("read after sleep:"+Thread.currentThread().getName()+":"+System.currentTimeMillis());
        } catch (Exception e) {
            // TODO: handle exception
        }finally{
            rw.readLock().unlock();
        }
    }
    
    public void writeLock(){
        
        
        try {
            rw.writeLock().lock();
            System.out.println("write before sleep:"+Thread.currentThread().getName()+":"+System.currentTimeMillis());
            Thread.sleep(2000);
            System.out.println("write after sleep:"+Thread.currentThread().getName()+":"+System.currentTimeMillis());
        } catch (Exception e) {
            // TODO: handle exception
        }finally{
            rw.writeLock().unlock();
        }
    }
    
    public static void main(String[] args) {
        ReadWriteLock rwl=new ReadWriteLock();
        Runnable runnable=new Runnable() {
            
            @Override
            public void run() {
                rwl.writeLock();
                rwl.readLock();

            }
        };
        Thread[] threads=new Thread[10];
        for(int i=0;i<5;i++)
        {
            threads[i]=new Thread(runnable);
        }
        for(int i=0;i<5;i++)
        {
            threads[i].start();
        }
    }

}