Java模拟生产者消费者问题

Java模拟生产者消费者问题
一、Syncronized方法详解

解决生产者消费这问题前，先来了解一下Java中的syncronized关键字。

synchronized关键字用于保护共享数据。请大家注意"共享数据"，你一定要分清哪些数据是共享数据，如下面程序中synchronized关键字保护的不是共享数据（其实在这个程序中synchronized关键字没有起到任何作用，此程序的运行结果是不可预先确定的）。这个程序中的t1,t2是 两个对象（pp1,pp2）的线程。JAVA是面向对象的程序设计语言，不同的对象的数据是不同的，pp1,pp2有各自的run()方法，而
synchronized使同一个对象的多个线程，在某个时刻只有其中的一个线程可以访问这个对象的synchronized数据。每个对象都有一个"锁标志"，当这个对象的一个线程访问这个对象的某个synchronized数据时，这个对象的所有被synchronized修饰的数据将被上锁（因为" 锁标志"被当前线程拿走了），只有当前线程访问完它要访问的synchronized数据时，当前线程才会释放"锁标志"，这样同一个对象的其它线程才有机会访问synchronized数据。

package SyncronizedMenthodTest;
 
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.PrintStream;
 
public
classPrintProgram implements Runnable {
 
    public
synchronized void show() {
        PrintStreamps =
null;
        try {
            ps = new PrintStream(new File("Test.txt"));
            for (int
i = 0; i < 100;
i++) {
                ps.append("这是" + Thread.currentThread().getName() +
"输出的" +
i + "\n");
            }
 
        }catch(IOException
e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally{
            ps.close();
        }
    }
 
    @Override
    public
void run() {
        show();
    }
 
    public
static void main(String[]
args) {
        PrintProgrampp1=
newPrintProgram();
        PrintProgrampp2=
newPrintProgram();
        Threadt1 = new Thread(pp1);
        t1.setName("线程1");
        Threadt2 = new Thread(pp2);
        t2.setName("线程2");
        t1.start();
        t2.start();
    }
 
}
 

得到Test.txt中内容为：

但如果改为如下代码，则结果将不同:

package SyncronizedMenthodTest;
 
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.PrintStream;
 
public
classPrintProgram implements Runnable {
 
    public
synchronized void show() {
        PrintStreamps =
null;
        try {
            ps = new PrintStream(new File("Test.txt"));
            for (int
i = 0; i < 100;
i++) {
                ps.append("这是" + Thread.currentThread().getName() +
"输出的" +
i
                        +"\n");
            }
 
        }catch(IOException
e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally{
            ps.close();
        }
    }
 
    @Override
    public
void run() {
        show();
    }
 
    public
static void main(String[]
args) {
        PrintProgrampp1 =
newPrintProgram();
        Threadt1 = new Thread(pp1);
        t1.setName("线程1");
        t1.start();
        Threadt2 = new Thread(pp1);
        t2.setName("线程2");
        t2.start();
    }
 
}
结果如下：

因为这里的synchronized保护的是共享数据。t1,t2是同一个对象（pp1）的两个线程，当其中的一个线程（例如：t2）开始执行run()方法时，由于run()受synchronized保护，所以同一个对象的其他线程（t1）无法访问synchronized方法（run方法）。只有当 t2执行完后t1才有机会执行。

二、 Java模拟生产者消费者问题
         了解了Java的syncronized关键字，那么生产者消费者问题也迎刃而解了。例如题目如下：

解决方案：

---------------

产品

---------------

package ProducerAndConsumerProblem;
 
public
classProduce {
 
    /*
     * 生产者生产的产品
     */
    private String
name;
    private
double price;
 
    @Override
    public String toString() {
        return
"Produce [name="+
name+ ", price=" +
price+ "]";
    }
 
    public Produce(String
name, double
price) {
        super();
        this.name =
name;
        this.price =
price;
    }
 
    public Produce() {
        super();
    }
 
    public String getName() {
        return
name;
    }
 
    public
void setName(String name) {
        this.name =
name;
    }
 
    public
double getPrice() {
        return
price;
    }
 
    public
void setPrice(double
price) {
        this.price =
price;
    }
 
}
 

---------------

店员

---------------

package ProducerAndConsumerProblem;
 
public
classClerk {
    // 店员用于存放生产者生产的产品，最多放20个
    // 相当于一个缓冲区
    static
final int n = 20;
    private
static Produce[] produce =
new Produce[n];
 
    private
static int produceNumber= 0;
    static
int inIndex = 0;
    static
int outIndex = 0;
 
    private
static Object obj =
new Object();
 
    public
static Produce getProduce(int
index) {
        return
produce[index];
    }
 
    public
static void setProduce(Produce
produce, int
index) {
        Clerk.produce[index] =
produce;
    }
 
    public
static Object getObj() {
        return
obj;
    }
 
    public
static void setObj(Object
obj) {
        Clerk.obj =
obj;
    }
 
    public
synchronized void addProduce() {
 
        if (produceNumber>= 20) {
            try {
                wait();
            }catch(InterruptedException
e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }else{
            System.out.println(Thread.currentThread().getName()
                    +"生产了一个产品,放在店员" +
inIndex+
"那儿");
            Produceproduce=
newProduce();
            Clerk.setProduce(produce,
inIndex);
            inIndex = (inIndex + 1) %
n;
            produceNumber++;
            notifyAll();
        }
    }
 
    public
synchronized void getProduce() {
        if (produceNumber<= 0) {
            try {
                wait();
            }catch(InterruptedException
e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }else{
            System.out.println(Thread.currentThread().getName()+
"从"
                    +outIndex+
"号店员那儿取走一件商品");
            Clerk.setProduce(null,
outIndex);
            outIndex = (outIndex + 1) %
n;
            produceNumber--;
            notifyAll();
        }
    }
 
}
---------------

生产者

---------------

package ProducerAndConsumerProblem;
 
public
classProducer implementsRunnable {
 
    Clerkclerk=null;
 
    public Producer(Clerk
clerk) {
        this.clerk =
clerk;
    }
 
    @Override
    public
void run() {
        while (true) {
            try {
                Thread.sleep(1000);
            }catch(InterruptedException
e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            clerk.addProduce();
           
        }
    }
}
---------------

消费者

---------------

package ProducerAndConsumerProblem;
 
public
classConsumer implementsRunnable {
 
    Clerkclerk= null;
 
    public Consumer(Clerk
clerk) {
        this.clerk =
clerk;
    }
 
    @Override
    public
void run() {
        while (true) {
            try {
                Thread.sleep(1000);
            }catch(InterruptedException
e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            clerk.getProduce();
        }
    }
 
}
---------------

主函数

---------------

package ProducerAndConsumerProblem;
 
public
classTest {
    public
static void main(String[]
args) {
        Clerkclerk=new Clerk();
        Consumerconsumer=
newConsumer(clerk);
        Threadt1 = new Thread(consumer);
        t1.setName("消费者");
        Producerproducer=
newProducer(clerk);
        Threadt2 =new Thread(producer);
        t2.setName("生产者");
        t1.start();
        t2.start();
    }
}
---------------

显示结果

---------------