Java----线程协作的经典例子&生产者和消费者问题

讲一瞎背景故事：创建并启动两个任务，一个用来向账户中存款，另一个从同一账户中提款。当提款的数额大于账户的当前余额时，提款线程必须等待。不管什么时候，只要向账户新存入一笔资金，存储线程必须通知提款线程重新常识。如果余额扔未达到提款的数额，提款线程必须继续等待新的存款。

---

---

 再贴上一些相关的API图片

对于Condition的了解，我也不是很深。我觉得就是进程之间通信的条件吧。

再加上关于Java显式锁的API吧。

为了良心上过得去，加上这个。

这个是缀重要的。

---

代码加上注释了。我就不冗长的解释了。

package thread;

import java.util.concurrent.*;
import java.util.concurrent.locks.*;

public class ThreadCooperation {
    private static Account account = new Account();
    
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(2);
        
        System.out.println("Thread 1		Thread 2		Balance");
        executor.execute(new DepositTask());//存钱任务
        executor.execute(new WithdrawTask());//取钱任务
        executor.shutdown();
    }
    
    public static class DepositTask implements Runnable {
        @Override
        public void run() {
            try{
                while(true) {
                    account.deposit((int)(Math.random() * 10) + 1);
                    //如果不加这个休眠的话，电脑的运算速度会教你做人的。
                    Thread.sleep(1000);
                }
            } catch(Exception ex) {
                ex.printStackTrace();
            }
        }
    }
    
    public static class WithdrawTask implements Runnable {
        @Override
        public void run() {
            while(true) {
                account.withdraw((int)(Math.random() * 10) + 1);//疯狂取钱
            }
        }
    }
    
    private static class Account {
        private static Lock lock = new ReentrantLock();//锁 没毛病
        private static Condition newDeposit = lock.newCondition();
        private int balance = 0;//余额
        
        public int getBalance() {
            return balance;
        }
        
        public void withdraw(int amount) {//取钱
            lock.lock();
            //良好的编程习惯 lock之后 try...catch...finally里面解锁
            try{
                while(balance < amount) {
                    System.out.println("			Wait for a deposit.");
                    newDeposit.await();//没钱就等着
                }
                //当余额不足时，等下一笔存款到账，取钱的任务等待。
                balance -= amount;
                System.out.println("			Withdraw " + 
                        amount + "		" + getBalance());
                
            } catch (InterruptedException ex) {
                ex.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
        
        public void deposit(int amount) {//存钱
            lock.lock();
            try{
                balance += amount;
                System.out.println("Deposit " + 
                        amount + "					" + getBalance());
                
                //newDeposit.signalAll();
                newDeposit.signal();
            } catch (IllegalMonitorStateException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
    }
}

 

---

补充：

看了书后面又有一个问题，问的是   55~57行代码

while 关键字 换成if可不可以？？？

运行了一下，发现是不可以的。

这是为什么呢？？？

当存入一笔money之后，就会执行这里之后的代码。然而，我们判断balance<amount　用的是if　所以不会判断你存入money 之后 余额和要取钱的关系。所以就会透支了。

简单的说，我要取100块钱，account里面的balance只有一毛钱。所以只能等待，等下一笔钱存入。当下一笔钱存入之后，我没有判断，现在account里面的balance。（万一我又存了一毛呢？？？）。 就执行了balance -= amount； 所以透支了。

---

生产者 / 消费者

继续瞎讲：假设使用缓冲区存储整数。缓冲区的大小是受限的。缓冲区提供write(int) 方法将一个int 值添加到缓冲区中，还提供方法read() 从缓冲区中读取和删除一个int值。为了同步这个操作，使用具有两个条件的锁，notEmpty(缓冲区非空) 和 notFul(缓冲区未满)。

当任务向缓冲区添加一个int时， 如果缓冲区是满的，那么任务将会等待notFull条件。当任务从缓冲区中读取一个int时，如果缓冲区是空的，那么任务将等待notEmpty条件。

——《Java语言程序设计 进阶篇》

---

我的分析：我觉的书上是有点逆向思维的意思。我的理解notEmpty是对于消费者来说的， 生产者把int 放到buffer里面 就会告诉消费者notEmpty.singal();        当消费者要去一个空的buffer取值时，notEmpty就是false 就是一个假命题，所以要告诉消费者等待(notEmpty.await())。

同理，我再叨叨一遍生产者的notFull。生产者嘛，就是不停地生产int 放到buffer里面。生产者是个好同志，他每天忙于生产。怎样才能让他休息呢？很简单，buffer满了生产者就没有办法生产了（再生产就没地方放了，生产个锤子）。这个时候notFill.await()就让生产者休息。       那什么时候再工作呢？只要buffer有空间就生产。当消费者取走了一个int时，消费者不是小偷，取走了一个int要跟生产这说一声：“Buffer is notFull（notFull.signal()）.” 这时候勤劳的生产者同志就开始生产了。

配合着上面的图，我想应该能理解的更充分。这样代码应该能理解了。

package thread;

import java.util.LinkedList;
import java.util.concurrent.*;
import java.util.concurrent.locks.*;

public class ConsumerProducer {
    private static Buffer buffer = new Buffer();//缓冲
    
    public static void main(String[] args) {
        ExecutorService executor = 
                Executors.newFixedThreadPool(2);//两个线程
        executor.execute(new ProducerTask());//生产者
        executor.execute(new ConsumerTask());//消费者
        executor.shutdown();
    }
    
    private static class ProducerTask implements Runnable {
        @Override
        public void run() {
            try{
                int i = 1;
                while(true) {
                    System.out.println("Producer writes " + i);
                    buffer.write(i++);
                    Thread.sleep((int)(Math.random() * 4500));
                }
            } catch(InterruptedException ex) {
                ex.printStackTrace();
            }
        }
    }
    
    private static class ConsumerTask implements Runnable {
        @Override
        public void run() {
            try{
                while (true) {
                    System.out.println("			Consumer reads " + buffer.read());
                    Thread.sleep((int)(Math.random() * 5000));
                }
            } catch(InterruptedException ex) {
                ex.printStackTrace();
            }
        }
    }
    
    private static class Buffer {
        private static final int CAPACITY = 1;//buffer size
        private LinkedList<Integer> queue =
                new LinkedList<>();
        
        private static Lock lock = new ReentrantLock();
        
        private static Condition notEmpty = lock.newCondition();//告诉消费者buffer不空
        private static Condition notFull = lock.newCondition(); //告诉生产者buffer不是满的
        
        public void write(int value) {//生产者写
            lock.lock();
            try {
                while(queue.size() == CAPACITY) {
                    System.out.println("Wait for notFull condition");
                    notFull.await();//buffer满了 就等一等 等到notFull再生产
                }
                
                queue.offer(value);
                System.out.println(value + " in");//这个可以注释 测试用的 很有用
                notEmpty.signal();//既然生产了，就可以告诉消费者 消费了。
            } catch(InterruptedException ex){
                
            } finally {
                lock.unlock();
            }
        }
        
        public int read() {//消费者读
            int value = 0;
            lock.lock();
            try {
                while (queue.isEmpty()) {
                    System.out.println("			Wait for notEmpty condition");
                    notEmpty.await(); //空了 就告诉自己等一下，别吃了。
                }
                value = queue.remove();
                System.out.println(value + " out");//这个可以注释 测试用的 很有用
                notFull.signal();//消费了一个 告诉生产者 可以生产了。
            } catch (InterruptedException ex) {
                ex.printStackTrace();
            } finally {
                lock.unlock();
            }
            return value;
        }
    }
}