Java多个线程对一个int成员m做加1或减1操作,要求0<=m<=10。

题目:多个线程,有些线程对int成员m加1,有些线程这个int成员减1,要求m最小不能小于0,最大不能超过10.

思路:(1)首先定位问题实质,这道题就是多线程里面经典的“生产者-消费者问题”。
     (2)对于此问题的描述是:有一块生产者和消费者共享的有界缓冲区,生产者往缓冲区放入产品,消费者从缓冲区取走产品,这个过程可以无休止的执行,不能因缓冲区满生产者放不进产品而终止,也不能因缓冲区空消费者无产品可取而终止.
     (3)显然这个"有界缓冲区"就是指题目中的m(0<=m<=10),而不断对m加1的线程可以理解为生产者,不断对m减1的线程就是消费者.
     (4)由于是多线程运行的,所以就要考虑同步问题,即生产者线程当缓冲区m已满时放弃自己的执行权,进入等待状态,并通知消费者线程执行。
        消费者线程当缓冲区m已空时放弃自己的执行权,进入等待状态,并通知生产者线程执行.

实现:
(1)第一种方法我采用任何一个对象都内置的wait()/notify()方法.
wait()表示:当缓冲区已满或已经空的时候,生产者或消费者线程停止自己的执行,放弃当前所持有的锁,进入等待池,让另一个线程执行.
notify()/notifyAll()表示:当生产者或消费者对缓冲区放入或取出一个产品时,向另一个/所有其他正在等待池中的线程发出可执行通知.

Java代码如下:

package com.test.thread;

public class BufferArea {
    private int m = 0;

    public static void main(String[] args) {
        BufferArea buffer = new BufferArea();
        // Five Consumer and two Producer
        new Thread(new Consumer(buffer), "Consumer 1").start();
        new Thread(new Consumer(buffer), "Consumer 2").start();
        new Thread(new Consumer(buffer), "Consumer 3").start();
        new Thread(new Consumer(buffer), "Consumer 4").start();
        new Thread(new Consumer(buffer), "Consumer 5").start();
        new Thread(new Producer(buffer), "Producer 1").start();
        new Thread(new Producer(buffer), "Producer 2").start();

    }

    public void increase() {

        m++;
        System.out.println("BufferArea Size:"+m);
    }

    public void decrease() {

        m--;
        System.out.println("BufferArea Size:"+m);
    }

    public int getSize() {

        return m;
    }

}

class Producer implements Runnable {
    BufferArea buffer;

    public Producer(BufferArea buffer) {
        this.buffer = buffer;
    }

    @Override
    public void run() {
        while (true) {
            // 获得缓冲区buffer的锁
            synchronized (buffer) {
                while (buffer.getSize() == 10) {
                

                    try {
                        System.out.println("---WARN:BufferArea is Full!---"+Thread.currentThread().getName()
                                + " go into waiting set!");
                     //释放缓冲区buffer的锁,当前线程进入等待池
                        buffer.wait();
                    
                    } catch (InterruptedException e) {

                        e.printStackTrace();
                    }

                }
                buffer.increase();
                // 向等待池中的一个线程发出唤醒通知
                buffer.notify();

            }

        }

    }
}

class Consumer implements Runnable {
    BufferArea buffer;

    public Consumer(BufferArea buffer) {
        this.buffer = buffer;
    }

    @Override
    public void run() {
        while (true) {
            synchronized (buffer) {
                while (buffer.getSize() == 0) {
                
                    try {
                        System.out.println("---WARN:BufferArea is Empty!---"+Thread.currentThread().getName()
                                + " go into waiting set!");
                        buffer.wait();
                        
                    } catch (InterruptedException e) {

                        e.printStackTrace();
                    }

                }
                buffer.decrease();
                buffer.notify();

            }

        }

    }

}

 

(2)第二种方法可以采用JDK5.0集成的BlockingQueue,它内部已经实现了一个同步的队列。它内置的方法有

put()和take().put()方法可以将元素放入到队列中,当容量最大时,自动阻塞。take()方法就是取出队列头的元素,容量为0的时候,自动阻塞。这个代码实现起来比上面的还简单,都不用加同步语句快了,就略过先。Tongue

posted @ 2009-11-23 11:51  Chris Wang  阅读(1747)  评论(0编辑  收藏  举报