java多线程常用关键字与方法介绍（二）

一、ReentrantLock类

服务类：

public class MyService {    private Lock lock = new ReentrantLock();    public void methodA() {        lock.lock();        for (int i = 0; i < 10; i++) {            System.out.println(Thread.currentThread().getName() + "-" + i);        }        lock.unlock();    }}

线程类

public class MyThread extends Thread{    private MyService service;    public MyThread(MyService service) {        super();        this.service = service;    }    @Override    public void run() {        service.methodA();    }}

调用类

public class Main {    public static void main(String[] args){        MyService myService = new MyService();        MyThread myThread1 = new MyThread(myService);        MyThread myThread2 = new MyThread(myService);        MyThread myThread3 = new MyThread(myService);        myThread1.start();        myThread2.start();        myThread3.start();    }}

说明：

ReentrantLock的lock.lock()方法与synchronized 关键词以及Object.lock()效果类似。myThread1 与myThread2 与 myThread3 同步运行。 既然ReentrantLock与Object.lock()都是显示的调用锁，那么他俩有什么区别呢？ReentrantLock是JDK1.5之后才出现的类，他自然比Object.lock()更加进步。首先要解释一下“公平锁”与“非公平锁”的概念，当一个线程获取锁后获得执行机会，其他的线程尝试获取该锁时，发现锁被占用，因此进入等待队列。“非公平锁”机制就是当获得锁的线程执行完毕释放锁之后，JVM会在等待队列中随机挑选一个等待线程给他获取锁的机会，而“公平锁”机制就是JVM会在等待队列中挑选队头的线程给他获取锁的机会，也就是FIFO先进先出的顺序。公平锁：private ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);非公平锁(默认就是)：private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();private ReentrantReadWriteLock lock = new ReentrantReadWriteLock(false);

二、ReentrantReadWriteLock类

public class MyService {    private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();    public void read() {        try {            lock.readLock().lock();            System.out.println("获得读锁" + Thread.currentThread().getName() + "-" + System.currentTimeMillis());            Thread.sleep(5000);        }catch (InterruptedException e){            e.printStackTrace();        }finally {            lock.readLock().unlock();        }    }    public void write(){        try {            lock.writeLock().lock();            System.out.println("获得写锁" + Thread.currentThread().getName() + "-" + System.currentTimeMillis());            Thread.sleep(5000);        }catch (InterruptedException e){            e.printStackTrace();        }finally {            lock.writeLock().unlock();        }    }}

说明

读读共享、写写互斥、读写互斥。

三、Condition

public class MyService {    private ReentrantLock lock = new ReentrantLock();    public Condition conditionA = lock.newCondition();    public Condition conditionB = lock.newCondition();    public void methodA() {        try {            lock.lock();            conditionA.await();        }catch (InterruptedException e){            e.printStackTrace();        }finally {            lock.unlock();        }    }    public void methodB(){        try {            lock.lock();            conditionB.await();        }catch (InterruptedException e){            e.printStackTrace();        }finally {            lock.unlock();        }    }    public void signalAllA(){        try {            lock.lock();            conditionA.signalAll();        } finally {            lock.unlock();        }    }    public void signalAllB(){        try {            lock.lock();            conditionB.signalAll();        } finally {            lock.unlock();        }    }}

说明

在上一片博文[java多线程常用关键字与方法介绍（一）]中，提到wait()和notify()方法实现的等待/通知模式，而Condition 的await()和signal()方式也可以实现等待/通知模式。那么他俩有什么不一样呢？wait()和notify()是Object的方法，当多个线程中多个不同的方法调用wait()时，当新的线程调用notifyAll()时会唤醒所wait线程，但是当我们只想唤醒执行某一类方法的线程时，例如只想唤醒执行上述代码的methodA()方法的线程时，该怎么办呢？这时，我们的Condition类就派上用场了，一个Lock对象里可以创建多个Condition实例（即对象监视器），那么线程就可以注册在指定的Condition中，从而当多个线程进入wait时，可以更加精确的有选择性的唤醒某些线程。