AQS机制详解

心有九月星辰

于 2024-10-05 12:46:24 发布

阅读量401

点赞数 14

分类专栏： java并发文章标签： java 开发语言

本文链接：https://blog.csdn.net/m0_68082638/article/details/142710931

版权

java并发专栏收录该内容

5 篇文章 0 订阅

订阅专栏

案例一

public class AqsThread extends Thread {

    private Lock lock;

    public AqsThread(String name, Lock lock) {
        super(name);
        this.lock = lock;
    }

    @Override
    public void run() {
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "running");
        } finally {
            lock.unlock();
        }
    }
}

public class AqsDemo {

    public static void main(String[] args) {
        ReentrantLock lock = new ReentrantLock();
        AqsThread t1 = new AqsThread("t1", lock);
        AqsThread t2 = new AqsThread("t2", lock);
        
        t1.start();
        t2.start();
    }
}

执行案例的运行结果.(其中之一)

线程t1先执行lock操作,获取锁.然后线程t2执行lock操作.然后t1进行unlock操作,然后t2获取锁成功,接着执行unlock操作.

t1线程调用lock.lock方法，方法调用顺序.

t2线程调用lock.lock方法，其方法调用顺序.

最后的结果是被阻塞.源码如下.

t1线程调用lock.unlock，其方法调用顺序.

t1线程中调用lock.unlock后，经过一系列的调用，最终的状态是释放了许可，因为调用了LockSupport.unpark。这时，t2线程就可以继续运行了。此时，会继续恢复t2线程运行环境，继续执行LockSupport.park后面的语句.

进一步调用.

t2线程调用lock.unlock，其方法调用顺序

t2线程执行lock.unlock后，最终达到的状态还是与之前的状态一样.

案例二

public class DepotDemo {

    private int size;
    private int capacity;
    private Lock lock;
    private Condition fullCondition;
    private Condition emptyCondition;

    public DepotDemo(int capacity) {
        this.capacity = capacity;
        lock = new ReentrantLock();
        fullCondition = lock.newCondition();
        emptyCondition = lock.newCondition();
    }

    public void produce(int no) {
        int left = no;
        lock.lock();
        try {
            while (left > 0) {
                while (size >= capacity)  {
                    System.out.println(Thread.currentThread().getName() + " before await");
                    fullCondition.await();
                    System.out.println(Thread.currentThread().getName() + " after await");
                }
                int inc = (left + size) > capacity ? (capacity - size) : left;
                left -= inc;
                size += inc;
                System.out.println("produce = " + inc + ", size = " + size);
                emptyCondition.signal();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void consume(int no) {
        int left = no;
        lock.lock();
        try {
            while (left > 0) {
                while (size <= 0) {
                    System.out.println(Thread.currentThread() + " before await");
                    emptyCondition.await();
                    System.out.println(Thread.currentThread() + " after await");
                }
                int dec = (size - left) > 0 ? left : size;
                left -= dec;
                size -= dec;
                System.out.println("consume = " + dec + ", size = " + size);
                fullCondition.signal();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

public class ReentrantLockTest {

    static class Consumer {
        private DepotDemo depot;

        public Consumer(DepotDemo depot) {
            this.depot = depot;
        }

        public void consume(int no) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    depot.consume(no);
                }
            }, no + " consume thread").start();
        }
    }

    static class Producer {
        private DepotDemo depot;

        public Producer(DepotDemo depot) {
            this.depot = depot;
        }

        public void produce(int no) {
            new Thread(new Runnable() {

                @Override
                public void run() {
                    depot.produce(no);
                }
            }, no + " produce thread").start();
        }
    }


}

class ReentrantLockDemo {
    public static void main(String[] args) throws InterruptedException {
        DepotDemo depot = new DepotDemo(500);
        new ReentrantLockTest.Producer(depot).produce(500);
        new ReentrantLockTest.Producer(depot).produce(200);
        new ReentrantLockTest.Consumer(depot).consume(500);
        new ReentrantLockTest.Consumer(depot).consume(200);
    }
}