ReentrantLock笔记(一) -- 基本使用

ReentrantLock基本使用

交替输出

ReentrantLock lock = new ReentrantLock(true);//true为公平锁，false或缺省为非公平锁
Runnable r = () -> {
    while (!Thread.currentThread().isInterrupted()) {
        lock.lock();
        try {
            System.out.println("当前线程：" + Thread.currentThread().getName());
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        } finally {
            lock.unlock();
        }
    }
};
new Thread(r).start();
Thread.sleep(10);
new Thread(r).start();
Thread.sleep(10);
new Thread(r).start();

生产者、消费者

ReentrantLock lock = new ReentrantLock();
LinkedList queue = new LinkedList<Object>();
Condition notEmpty = lock.newCondition();
Condition notFull = lock.newCondition();
int max = 5;
new Thread(() -> {
    while (!Thread.currentThread().isInterrupted()) {
        lock.lock();
        try {
            while (queue.isEmpty()) {
                try {
                    System.out.println("消费者等待...");
                    notEmpty.await();
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
            queue.poll();
            System.out.println("消费者消费一个，剩余：" + queue.size());
            notFull.signalAll();
        } finally {
            lock.unlock();
        }
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}).start();

new Thread(() -> {
    while (!Thread.currentThread().isInterrupted()) {
        lock.lock();
        try {
            while (queue.size() >= max) {
                try {
                    System.out.println("生产者等待...");
                    notFull.await();
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
            queue.add(1);
            System.out.println("生产者生产一个，总数：" + queue.size());
            notEmpty.signalAll();
        } finally {
            lock.unlock();
        }
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}).start();

自定义锁

    class Mutex implements Lock, java.io.Serializable {
       // 内部类，自定义同步器
       private static class Sync extends AbstractQueuedSynchronizer {
         // 是否处于占用状态
         protected boolean isHeldExclusively() {
           return getState() == 1;
         }
         // 当状态为0的时候获取锁
         public boolean tryAcquire(int acquires) {
           assert acquires == 1; // Otherwise unused
           if (compareAndSetState(0, 1)) {
             setExclusiveOwnerThread(Thread.currentThread());
             return true;
           }
           return false;
         }
         // 释放锁，将状态设置为0
         protected boolean tryRelease(int releases) {
           assert releases == 1; // Otherwise unused
           if (getState() == 0) throw new IllegalMonitorStateException();
           setExclusiveOwnerThread(null);
           setState(0);
           return true;
         }
         // 返回一个Condition，每个condition都包含了一个condition队列
         Condition newCondition() { return new ConditionObject(); }
       }
       // 仅需要将操作代理到Sync上即可
       private final Sync sync = new Sync();
       public void lock()                { sync.acquire(1); }
       public boolean tryLock()          { return sync.tryAcquire(1); }
       public void unlock()              { sync.release(1); }
       public Condition newCondition()   { return sync.newCondition(); }
       public boolean isLocked()         { return sync.isHeldExclusively(); }
       public boolean hasQueuedThreads() { return sync.hasQueuedThreads(); }
       public void lockInterruptibly() throws InterruptedException {
         sync.acquireInterruptibly(1);
       }
       public boolean tryLock(long timeout, TimeUnit unit)
           throws InterruptedException {
         return sync.tryAcquireNanos(1, unit.toNanos(timeout));
       }
     }