生产消费模型-lock和synchronized实现

生产消费模型-lock和synchronized实现

lock实现AB循环输出

同一Lock锁双条件分别控制AB线程

public class TestThread {

    public static void main(String[] args) {
        //new出可重入lock锁
        Lock lock = new ReentrantLock();
        //构建条件a
        Condition a = lock.newCondition();
        //构建条件b
        Condition b = lock.newCondition();
        //线程A-生产者
        Thread threadA = new Thread(new Runnable() {
            @Override
            public void run() {
                lock.lock();
                try {
                    while (true) {
                        System.out.println("A");
                        //生产A后，唤醒消费者B,然后自己等待
                        b.signalAll();
                        a.await();
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }

            }
        });
        //线程B-消费者
        Thread threadB = new Thread(new Runnable() {
            @Override
            public void run() {
                lock.lock();
                try {
                    while (true) {
                        System.out.println("B");
                        //消费B后，唤醒生产者A,然后自己等待
                        a.signalAll();
                        b.await();
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }
            }

        });
        threadA.start();
        threadB.start();
    }
}

同一Lock锁单条件控制

public class TestThread {

    public static void main(String[] args) {
        //new出可重入lock锁
        Lock lock = new ReentrantLock();
        //构建条件a
        Condition a = lock.newCondition();
        //线程A-生产者
        Thread threadA = new Thread(new Runnable() {
            @Override
            public void run() {
                lock.lock();
                try {
                    while (true) {
                        System.out.println("A");
                        //生产A后，唤醒所有消费者,然后自己等待
                        a.signalAll();
                        a.await();
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }

            }
        });
        //线程B-消费者
        Thread threadB = new Thread(new Runnable() {
            @Override
            public void run() {
                lock.lock();
                try {
                    while (true) {
                        System.out.println("B");
                        //消费B后，唤醒所有生产者,然后自己等待
                        a.signalAll();
                        a.await();
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }
            }

        });
        threadA.start();
        threadB.start();
    }
}

synchronized实现AB循环输出

对同一对象加锁来控制双线程的输出，当然也可以使用双对象加锁来实现，我这就不写具体实现了

public class TestThread {

    public static void main(String[] args) {
        Object lockObject = new Object();
        Thread threadA = new Thread(new Runnable() {
            @Override
            public void run() {
                while (true){
                    synchronized (lockObject){
                        System.out.println("A");
                        //生产A后，唤醒所有消费者,然后自己等待

                        lockObject.notifyAll();
                        try {
                            lockObject.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        });
        Thread threadB = new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    synchronized (lockObject) {
                        System.out.println("B");
                        //消费B后，唤醒所有生产者,然后自己等待
                        lockObject.notifyAll();
                        try {
                            lockObject.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        });
        threadA.start();
        threadB.start();

    }
}