Java Lock对象

1. ReentrantLock类

ReentrantLock可以实现线程之间同步互斥，类似于synchronized同样的效果。

public class ThreadReentrantLock {

    public static void main(String[] args) {
        ThreadA threadA = new ThreadA();

        for (int i = 0; i < 3; i++) {
            Thread th = new Thread(threadA);
            th.setName("Thread" + i);
            th.start();
        }
    }

    static class ThreadA extends Thread {
        private Lock lock = new ReentrantLock();

        public void run() {
            System.out.println(currentThread().getName() + " run");
            try {
                lock.lock();
                System.out.println(currentThread().getName() + " begin");
                Thread.sleep(1000);
                System.out.println(currentThread().getName() + " end");
            } catch (InterruptedException e) {
            } finally {
                lock.unlock();
            }
        }
    }	
}

输出

2. Condition实现wait/notify功能

主要方法

• await()相当于wait()方法
• await(long time, TimeUnit unit)相当于wait(long)方法
• signal()相当于notify()方法
• signalAll()相当于notifyAll()方法

await()和signal()同样需要在lock.lock()之后调用，否则会报监视器出错。

public class ThreadCondition {

    public static void main(String[] args) {
        try {
            ThreadA threadA = new ThreadA();
            threadA.start();

            Thread.sleep(3000);

            threadA.singal();
        } catch (InterruptedException e) {
        }
    }

    static class ThreadA extends Thread {
        private Lock lock = new ReentrantLock();
        private Condition condition = lock.newCondition();

        public void run() {			
            try {
                lock.lock();
                System.out.println("ThreadA begin await " + System.currentTimeMillis());
                condition.await();
                System.out.println("ThreadA end await " + System.currentTimeMillis());
            } catch (InterruptedException e) {
            } finally {
                lock.unlock();
            }
        }

        public void singal() {
            lock.lock();
            System.out.println("ThreadA begin signal " + System.currentTimeMillis());
            condition.signal();
            System.out.println("ThreadA end signal " + System.currentTimeMillis());

            lock.unlock();
        }
    }
}

输出

3. ReentrantLock方法

• getHoldCount()查询当前线程保持此锁的个数，也就是调用lock()方法的次数。
• getQueueLength()返回正等待获取此锁定的线程数。
• getWaitQueueLength(Condition condition)返回等待与此锁相关的给定条件Condition的线程数。
• hasQueuedThread(Thread thread)查询指定的线程是否正在等待获取此锁。
• hasQueuedThreads()查询是否有线程正在等待获取此锁。
• hasWaiters(Condition condition)查询是否有线程正在等待与此锁有关的给定条件Condition。
• isFair()判断是否是公平锁。
• isHeldByCurrentThread()查询当前线程是否保持此锁。
• isLocked()查询此锁是否由任意线程保持。
• lockInterruptibly()当前线程未被中断，则获取锁定，如果中断则出现异常。
• tryLock()仅在当前锁未被另一个线程保持的情况下，才能获得该锁。
• tryLock(long timeout, TimeUnit unit)仅在给定等待时间内没有被另一线程保持，且当前线程未被中断，才能获得该锁。

4. ReentrantReadWriteLock读写锁

读写锁有两个锁，一个是读操作相关的锁，称为共享锁。另一个写操作相关的锁，叫排它锁。多个读锁之间不互斥，而读锁与写锁、写锁与写锁之间互斥。

public class ThreadReentrantReadWriteLock {	
    private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();

    public void read() {
        try {
            lock.readLock().lock();
            System.out.println(Thread.currentThread().getName()
                     + " read " + System.currentTimeMillis());
            Thread.sleep(1000);
        } catch (InterruptedException e) {
        } finally {
            lock.readLock().unlock();
        }
    }

    public void write() {
        try {
            lock.writeLock().lock();
            System.out.println(Thread.currentThread().getName()
                     + " write " + System.currentTimeMillis());
            Thread.sleep(1000);
        } catch (InterruptedException e) {			
        } finally {
            lock.writeLock().unlock();
        }
    }

    static class WriteThread extends Thread {
        private ThreadReentrantReadWriteLock service;

        public WriteThread(ThreadReentrantReadWriteLock service) {
            this.service = service;
        }

        public void run() {
            service.write();
        }
    }

    static class ReadThread extends Thread {
        private ThreadReentrantReadWriteLock service;

        public ReadThread(ThreadReentrantReadWriteLock service) {
            this.service = service;
        }

        public void run() {
            service.read();
        }
    }
}

调用两个读操作，两者几乎同时运行

public static void main(String[] args) {
    ThreadReentrantReadWriteLock service = new ThreadReentrantReadWriteLock();

    ReadThread readThread1 = new ReadThread(service);
    readThread1.setName("ReadThread1");
    readThread1.start();

    ReadThread readThread2 = new ReadThread(service);
    readThread2.setName("ReadThread2");
    readThread2.start();
}

输出

调用一个读、一个写操作，同一时间只允许一种操作

public static void main(String[] args) {
    ThreadReentrantReadWriteLock service = new ThreadReentrantReadWriteLock();

    WriteThread writeThread = new WriteThread(service);
    writeThread.setName("WriteThread");
    writeThread.start();

    ReadThread readThread = new ReadThread(service);
    readThread.setName("ReadThread");
    readThread.start();
}

输出

相关文章
Java wait和notify方法
Java Thread.join方法
Java Thread.sleep方法
Java Thread.Interrupt方法
Java Lock对象