「java多线程生产者」java多线程实现的代码

本篇文章给大家谈谈java多线程生产者，以及java多线程实现的代码对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。

本文目录一览：

• 1、对于java多线程线程的几点疑惑（生产者消费者） ？
• 2、java多线程关于消费者和生产者，求源程序，求大神解答。愿意提高报酬
• 3、关于Java多线程实现生产者和消费者的问题
• 4、java多线程，怎么算出最佳的生产消费的配比比例？
• 5、java 多线程 为什么不会打印一个生产者之后再打一个消费者 而是等生产者打印完才打生产者 求详解 谢谢

对于java多线程线程的几点疑惑（生产者消费者） ？

看了代码, 确实是shutdownNow()的问题, 可以使用shutdown(), 不要用shutdownNow()

shutdown()是表示service不再接收线程了, 即不要再submit线程进来了

shutdownNow()则是终止所有现在运行着的线程

submit不用说就是加入一个线程并运行, 但是要注意submit接收的是runnable或者callable, 你可以传一个实现runnable的类的对象进来, 也就是你的producer那样, 也可以传一个Thread进来, 因为Thread实际上也是一个实现了runnable的类

newCachedThreadPool()不用多说就是new一个线程池, 方便执行线程, 不用总是去生成线程, 因为这样很耗资源, 一般来说推荐用CachedThreadPool, 动态扩充的

又看了下代码, 你是要5秒钟后终止所有线程, 所以用shutdownNow()是正确的...., 你那些异常是producer和consumer里的sleep被interrupt后跑出的异常, 你可以在对应的异常捕获里写, 不是main函数sleep被interrupt了, interrupt就相当于终止线程了(是终止线程的一种方式)

class Consumer implements Runnable {

public void run() {

try {

while (true) {

// 消费苹果

System.out.println("消费者准备消费苹果: "

+ System.currentTimeMillis());

basket.consume();

System.out.println("消费者消费苹果完毕: "

+ System.currentTimeMillis());

// 休眠1000ms

Thread.sleep(1000);

}

} catch (InterruptedException ex) {

System.out.println("Consumer interrupted");

}

}

}

在这里捕获

java多线程关于消费者和生产者，求源程序，求大神解答。愿意提高报酬

自己看代码体会吧

import java.util.concurrent.BlockingQueue;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import java.util.concurrent.LinkedBlockingQueue;

public class BlockingQueueTest {

 public static void main(String[] args) {

  ExecutorService service = Executors.newCachedThreadPool();

  BlockingQueueString blockingQueue = new LinkedBlockingQueueString(100);

  System.out.println("blockingQueue now contains "  + blockingQueue.size() + " unit");

  service.submit(new Consumer1(blockingQueue));

  gap(blockingQueue);

  service.submit(new Productor2(blockingQueue));

  gap(blockingQueue);

  service.submit(new Productor3(blockingQueue));

  gap(blockingQueue);

  service.submit(new Productor4(blockingQueue));

  gap(blockingQueue);

  service.submit(new Productor5(blockingQueue));

  gap(blockingQueue);

  service.shutdown();

 }

 private static void gap(BlockingQueueString blockingQueue) {

  try {

   Thread.sleep(1000);

  } catch (InterruptedException e) {

   // TODO Auto-generated catch block

   e.printStackTrace();

  }

  System.out.println("blockingQueue now contains "  + blockingQueue.size() + " unit");

 }

}

class Consumer1 implements Runnable{

 BlockingQueueString blockingQueue;

 public Consumer1(BlockingQueueString blockingQueue) {

  super();

  this.blockingQueue = blockingQueue;

 }

 @Override

 public void run() {

  // TODO Auto-generated method stub

  System.out.println("Consumer1 start: need 10 units");

  for(int i = 0; i  10; i++){

   try {

    blockingQueue.take();

   } catch (InterruptedException e) {

    // TODO Auto-generated catch block

    e.printStackTrace();

   }

  }

  System.out.println("Consumer1 end: has got 10 units");

 }

}

class Productor2 implements Runnable{

 BlockingQueueString blockingQueue;

 public Productor2(BlockingQueueString blockingQueue) {

  super();

  this.blockingQueue = blockingQueue;

 }

 @Override

 public void run() {

  // TODO Auto-generated method stub

  System.out.println("Productor2 start: put 5 units");

  for(int i = 0; i  5; i++){

   try {

    blockingQueue.put("Object");

   } catch (InterruptedException e) {

    // TODO Auto-generated catch block

    e.printStackTrace();

   }

  }

  System.out.println("Productor2 end: has put 5 units");

 }

}

class Productor3 implements Runnable{

 BlockingQueueString blockingQueue;

 public Productor3(BlockingQueueString blockingQueue) {

  super();

  this.blockingQueue = blockingQueue;

 }

 @Override

 public void run() {

  // TODO Auto-generated method stub

  System.out.println("Productor3 start: put 5 units");

  for(int i = 0; i  5; i++){

   try {

    blockingQueue.put("Object");

   } catch (InterruptedException e) {

    // TODO Auto-generated catch block

    e.printStackTrace();

   }

  }

  System.out.println("Productor3 end: has put 5 units");

 }

}

class Productor4 implements Runnable{

 BlockingQueueString blockingQueue;

 public Productor4(BlockingQueueString blockingQueue) {

  super();

  this.blockingQueue = blockingQueue;

 }

 @Override

 public void run() {

  // TODO Auto-generated method stub

  System.out.println("Productor4 start: put 100 units");

  for(int i = 0; i  100; i++){

   try {

    blockingQueue.put("Object");

   } catch (InterruptedException e) {

    // TODO Auto-generated catch block

    e.printStackTrace();

   }

  }

  System.out.println("Productor4 end: has put 100 units");

 }

}

class Productor5 implements Runnable{

 BlockingQueueString blockingQueue;

 public Productor5(BlockingQueueString blockingQueue) {

  super();

  this.blockingQueue = blockingQueue;

 }

 @Override

 public void run() {

  // TODO Auto-generated method stub

  System.out.println("Productor5 start: put 10 units");

  for(int i = 0; i  100; i++){

   try {

    blockingQueue.put("Object");

   } catch (InterruptedException e) {

    // TODO Auto-generated catch block

    e.printStackTrace();

   }

  }

  System.out.println("Productor5 end: has put 10 units");

 }

}

每个线程是隔了1s启动的, 结果

blockingQueue now contains 0 unit

Consumer1 start: need 10 units

blockingQueue now contains 0 unit

Productor2 start: put 5 units

Productor2 end: has put 5 units

blockingQueue now contains 0 unit

Productor3 start: put 5 units

Productor3 end: has put 5 units

Consumer1 end: has got 10 units

blockingQueue now contains 0 unit

Productor4 start: put 100 units

Productor4 end: has put 100 units

blockingQueue now contains 100 unit

Productor5 start: put 10 units

blockingQueue now contains 100 unit

关于Java多线程实现生产者和消费者的问题

你看你试试这个把那个消费者类里和生产者类private myProAndCon mpc;去掉

然后到class myProAndCon 这个主类里面添加private myProAndCon mpc;

这样就可以mpc就不会每次都是新创建的一个新类，而是共享一个类

你再试试

java多线程，怎么算出最佳的生产消费的配比比例？

这和生产者和消费者线程耗时有关，

最简单的一个公式：

生产者线程数*消费者平均耗时=消费者线程数*生产者平均耗时

得出： 生产者线程数/消费者线程数=消费者平均耗时/生产者平均耗时。

得出比例后就需要确定具体的线程数了，线程数需要根据业务量大小确实，这个没办法根据公式计算。同时，线程数还受到应用类型和cpu核心数的影响，一般说来，大家认为线程池的大小经验值应该这样设置：（其中N为CPU的个数）

如果是CPU密集型应用，则线程池大小设置为N+1

如果是IO密集型应用，则线程池大小设置为2N+1

总之线程的配置是一个比较繁琐的过程，需要通过不断的试验找到最佳的配置。

java 多线程 为什么不会打印一个生产者之后再打一个消费者 而是等生产者打印完才打生产者 求详解 谢谢

楼主，你的代码写的不对。

应该这样做，生产者每生产一个，生产完成后就通知消费者消费，这样才能做到生产一个消费一个。

解决的方法：

1、生产的地方加上同步等待，生产时当检查到库存有货，则等待(wait)消费者消费后再生产；生产时如果库存没货，则直接生产，生产完成则通知(notifyAll)消费者消费。

2、消费的地方加上同步等待，消费时如果发现没有库存，则等待(wait)生产者生产后再消费；消费时如果有库存，则直接消费，消费后通知(notifyAll)生产者生产。

代码我就不帮你写了，你上面的大概功能都能写出来，相信这两个细节问题你肯定能修改好。

具体修改的地方，就是你上面的类SyncStack中的pop、push方法修改。

有问题欢迎提问，满意请采纳！

java多线程生产者的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于java多线程实现的代码、java多线程生产者的信息别忘了在本站进行查找喔。