12-案例实现

案例实现

根据如下步骤实现本案例。

1．创建 Producer 类并实现 Runnable 接口：

public class Producer implements Runnable {

2．声明一个私有的 buffer 属性，其类型为 LinkedTransferQueue ：

private LinkedTransferQueue<String> buffer;

3．声明一个私有的 String 类型属性，将其命名为 name ，作为生产者的名称：

private String name;

4．实现构造器并初始化这些属性：

public Producer(String name, LinkedTransferQueue<String> buffer){
  this.name=name;
  this.buffer=buffer;
}

5．实现 run() 方法。用 buffer 对象的 put() 方法在缓冲区里存储10000个字符串，然后打印一条信息以表明该方法执行结束：

@Override
public void run() {
  for (int i=0; i<10000; i++) {
    buffer.put(name+": Element "+i);
  }
  System.out.printf("Producer: %s: Producer done\n",name);
}

6．创建 Consumer 类并实现 Runnable 接口：

public class Consumer implements Runnable {

7．声明一个私有的 buffer 属性，其类型为 LinkedTransferQueue ：

private LinkedTransferQueue<String> buffer;

8．声明一个私有的 String 类型属性，并命名为 name 作为消费者的名称：

private String name;

9．实现构造器并初始化这些属性：

public Consumer(String name, LinkedTransferQueue<String> buffer){
  this.name=name;
  this.buffer=buffer;
}

10．实现 run() 方法。用 buffer 对象的 take() 方法从缓冲区里取出10000个字符串，然后打印一条信息来表明该方法执行结束：

@Override
public void run() {
  for (int i=0; i<10000; i++){
    try {
      buffer.take();
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
  }
  System.out.printf("Consumer: %s: Consumer done\n",name);
}

11．实现本案例的主类，创建 Main 类并添加 main() 方法：

public class Main {
  public static void main(String[] args) {

12．声明常量 THREADS ，将其设置为100。创建一个 LinkedTransferQueue 变量，并命名为 buffer ：

final int THREADS=100;
LinkedTransferQueue<String> buffer=new LinkedTransferQueue<>();

13．创建一个大小为100的线程数组，用来执行100次生产任务：

Thread producerThreads[]=new Thread[THREADS];

14．创建一个大小为100的线程数组，用来执行100次消费任务：

Thread consumerThreads[]=new Thread[THREADS];

15．创建并启动100个 Consumer 对象，将它们存储到上面创建的数组中：

for (int i=0; i<THREADS; i++){
  Consumer consumer=new Consumer("Consumer "+i,buffer);
  consumerThreads[i]=new Thread(consumer);
  consumerThreads[i].start();
}

16．创建并启动100个 Producer 对象，将它们存储到上面创建的数组中：

for (int i=0; i<THREADS; i++) {
  Producer producer=new Producer("Producer: "+ i , buffer);
  producerThreads[i]=new Thread(producer);
  producerThreads[i].start();
}

17．用 join() 方法等待线程结束：

for (int i=0; i<THREADS; i++){
  try {
    producerThreads[i].join();
    consumerThreads[i].join();
  } catch (InterruptedException e) {
    e.printStackTrace();
  }
}

18．打印 buffer 的大小和结束信息：

System.out.printf("Main: Size of the buffer: %d\n",
                  buffer.size());
System.out.printf("Main: End of the example\n");