【Java从零到架构师第1季】【并发 Concurrent 03】线程间通信_ReentrantLock_线程池

---

持续学习&持续更新中…

守破离

---

线程间通信

1. 调用wait、notify、notifyAll方法的obj对象必须是同一个
2. 调用wait、notify、notifyAll方法的线程必须拥有该obj对象的内部锁

线程间通信—示例

注意：

• 消费者线程和生产者线程中调用obj.wait、obj.notify、obj.notifyAll方法时，使用的obj必须是同一个对象。

• 消费者线程和生产者线程必须持有obj的内部锁（监视锁），才能成功调用wait、notify、notifyAll方法，否则会出现异常。

代码：

Producer：

public class Producer implements Runnable{
    private Drop drop;
    public Producer(Drop drop) {
        this.drop = drop;
    }
    @Override
    public void run() {
        String[] foods = {"beef", "bread", "apple", "cookie", "banana"};
        for (String food : foods) {
            try {
                Thread.sleep(1500);
            } catch (InterruptedException e) {}
            drop.add(food);
        }
        drop.add(null);
    }
}

Consumer：

public class Consumer implements Runnable {
    private Drop drop;
    public Consumer(Drop drop) {
        this.drop = drop;
    }
    @Override
    public void run() {
        String food;
        while ((food = drop.get()) != null) {
//            try {
//                Thread.sleep(1500);
//            } catch (InterruptedException e) {}
            System.out.println("消费了：" + food);
        }
    }
}

Drop：

version1：

public class Drop {
    private String food;
    // isEmpty：true：消费者需要等待生产者
    // isEmpty：false：生产者需要等待消费者
    private boolean isEmpty = true;
    public synchronized void add(String food) {
        if(isEmpty) { // 如果没有food
            this.food = food; // 直接生产food
            isEmpty = false; // 生产了food之后，就不为空了
            notifyAll(); // 生产好food后，就可以通知消费者线程消费food了
        }else { // 如果food还有，还没有被消费者消费完毕
            try { // 等待消费者消费完毕food
                wait();
            } catch (InterruptedException e) {}
            this.food = food; // 消费者消费完food后，就可以生产food了
            isEmpty = false; // 生产了food之后，就不为空了
            notifyAll(); // 就可以通知消费者线程消费food了
        }
    }
    public synchronized String get() {
        if(isEmpty) { // 如果此时没有food，也就是生产者线程还没有生产完毕food
            try { // 等待生产者生产food
                wait();
            } catch (InterruptedException e) {}
        } // 当生产者生产好了food之后，就可以消费food了
        // 此时有food可以消费
        isEmpty = true; // 消费了food，那么就应该为空了
        notifyAll(); // 通知生产者线程，我已经消费了food，你可以继续生产food了
        return food;
    }
}

老师课件上写的while(empty)是为了防止wait时出现异常（如果wait时出现了异常并且不做任何处理的话，那么程序就会按顺序执行下去，那样的话程序就会出现bug；因此使用while循环：如果wait时出现了异常还会继续wait）

在wait时应该使用while循环来防止wait失败（如果wait出现异常，还得继续wait）

version2（使用while循环代替if循环）：

public class Drop {
    private String food;
    // isEmpty：true：消费者需要等待生产者
    // isEmpty：false：生产者需要等待消费者
    private boolean isEmpty = true;

    // 使用while循环代替if循环、使用while循环执行wait方法的目的是：
    // 当wait时出现异常，还会继续wait，而不是执行之后的代码

    public synchronized void add(String food) {
        if(isEmpty) { // 如果没有food
            this.food = food; // 直接生产food
            isEmpty = false; // 生产了food之后，就不为空了
            notifyAll(); // 生产好food后，就可以通知消费者线程消费food了
        }else { // 如果food还有，还没有被消费者消费完毕
            while(!isEmpty) {
                try { // 等待消费者消费完毕food
                    wait();
                } catch (InterruptedException e) {}
            }
            this.food = food; // 消费者消费完food后，就可以生产food了
            isEmpty = false; // 生产了food之后，就不为空了
            notifyAll(); // 就可以通知消费者线程消费food了
        }
    }
    public synchronized String get() {
        while(isEmpty) { // 如果此时没有food，也就是生产者线程还没有生产完毕food
            try { // 等待生产者生产food
                wait();
            } catch (InterruptedException e) {}
        } // 当生产者生产好了food之后，就可以消费food了
        // 此时有food可以消费
        isEmpty = true; // 消费了food，那么就应该为空了
        notifyAll(); // 通知生产者线程，我已经消费了food，你可以继续生产food了
        return food;
    }
}

测试：

    public static void main(String[] args) {
        /*
            1.调用wait、notify、notifyAll方法的obj对象必须是同一个
            2.调用wait、notify、notifyAll方法的线程必须拥有该obj对象的内部锁
         */
        Drop drop = new Drop();
        Consumer consumer = new Consumer(drop);
        Producer producer = new Producer(drop);
        new Thread(consumer).start();
        new Thread(producer).start();
    }

可重入锁ReentrantLock

    public static void main(String[] args) {
    	// 可重入锁，有些地方叫做递归锁
        // synchronized是可重入的
        synchronized ("1") {
            synchronized ("1") {
                System.out.println("1");
            }
        }
    }

我们可以认为：每一个线程都有属于自己的锁持有计数器

ReentrantLock的使用

public class Station implements Runnable {
    private final ReentrantLock lock = new ReentrantLock();
    private int tickets = 100;

    public boolean saleTicket() {
        try{
            lock.lock();

            if (tickets < 1) return false;
            tickets--;
            System.out.println(Thread.currentThread().getName() + "卖了一张票，还剩" + tickets + "张票。");
            return tickets > 0;
        }finally {
            lock.unlock();
        }
    }

    @Override
    public void run() {
        while (saleTicket()) ;
    }
}

线程池

线程池—基本使用

    public static void main(String[] args) {
        final ExecutorService pool = Executors.newFixedThreadPool(5);
        for (int i = 1; i <= 10; i++) {
            pool.execute(() -> {
                System.out.println(Thread.currentThread().getName());
            });
        }
        pool.shutdown();
    }

参考

小码哥-李明杰: Java从0到架构师①零基础高效率入门.

---

本文完，感谢您的关注支持！

---