java多生产者多消费者

1. java多生产者-多消费者问题（+高分哦！）

生产者向阻塞队列中放入随即整数（可以为两个消费者提供不同的队列），消费者从队列中取出元素进行判断，可以用BlockingQueue实现同步，很方便，质数和平方数判断在写个静态方法即可~自己想想看，需要代码就说下
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

public class Procer extends Thread
{
private List<BlockingQueue<Integer>> queueList;

public Procer(List<BlockingQueue<Integer>> bQueueList)
{
this.queueList = bQueueList;
}

public void run()
{
int count = 0;
while (count++ < 10)
{
int randomInt = (int) (Math.random() * 100 + 1);
try
{
for(BlockingQueue<Integer> queue:queueList)
{
queue.put(randomInt);
}
System.out.println(randomInt + " is put..");
}
catch (InterruptedException e)
{
Thread.currentThread().interrupt();
}
}
}

public static void main(String[] args)
{
BlockingQueue<Integer> bQueue = new LinkedBlockingQueue<Integer>();
BlockingQueue<Integer> bQueueCopy = new LinkedBlockingQueue<Integer>();
List<BlockingQueue<Integer>> list=new ArrayList<BlockingQueue<Integer>>();
list.add(bQueue);
list.add(bQueueCopy);
new Procer(list).start();
new Procer(list).start();
new Procer(list).start();
new PrimeConsumer(bQueue).start();
new SquareConsumer(bQueueCopy).start();
}
}

class PrimeConsumer extends Thread
{
private BlockingQueue queue;

public PrimeConsumer(BlockingQueue<Integer> bQueue)
{
this.queue = bQueue;
}

public void run()
{
do
{
try
{
int i = (Integer) queue.take();
if (CheckNumber.isPrime(i))
{
System.out.println(i + " is prime..");
}
}
catch (InterruptedException e)
{
Thread.currentThread().interrupt();
}
}
while (queue.size() != 0);
}
}

class SquareConsumer extends Thread
{
private BlockingQueue queue;

public SquareConsumer(BlockingQueue<Integer> bQueue)
{
this.queue = bQueue;
}

public void run()
{
do
{
try
{
int i = (Integer) queue.take();
if (CheckNumber.isSquare(i))
{
System.out.println(i + " is square..");
}
}
catch (InterruptedException e)
{
Thread.currentThread().interrupt();
}
}
while (queue.size() != 0);
}
}

class CheckNumber
{
public static boolean isPrime(int n)
{
if (n == 1)
return false;
for (int i = 2; i < n / 2 + 1; i++)
{
if (n % i == 0)
{
return false;
}
}
return true;
}

public static boolean isSquare(int n)
{
int l = (int) Math.sqrt(n);
for (int i = 1; i <= l; i++)
{
if (i * i == n)
{
return true;
}
}
return false;
}
}
都写在一个类里了，比较乱，测试正确~

2. JAVA 多线程 两个生产者100个包子，容器30，4个消费者

public class Test {
public static void main(String[] args) {
Runnable ticket=new TrainTicket();
Thread seller1=new Thread(ticket);
Thread seller2=new Thread(ticket);
seller1.start();
seller2.start();
}
}
class TrainTicket implements Runnable{
//100张卖完改1000吧假设座位号1-1000；回
public int n=1000;

@Override
public void run() {
while(n>0){
System.out.println(Thread.currentThread().getName()+"卖座位：答"+n);
n--;
}
}
}

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

我大致看了下，看到你同步语句块的是对synchronized (this)，那就是说是对生产者线程版本身，消费者线程本身进权行同步，而不是对缓冲区进行互斥同步，还有我不知道你为什么要while(!Thread.interrupted())
这么写 ，你可以参考下这篇 http://jaychang.javaeye.com/blog/680857

4. • 利用java多线程及同步机制实现生产者-消费者模型

制片人：时存在的产品的时候，
消费者生产的产品是不够的：消费类产品
关键：当产品到达上限，停止生产，通知消费者的消费
关键2：当达到下限，停止消费，并通知生产者生产
共享数据：

代码
进口的java.util.ArrayList;
BR />公共类ProcerAndConsumer {
ArrayList的产品=新的ArrayList （）;
MAX = 10;
布尔取消;

同步失效产生（）{
int的大小= procts.size（）;
（大小<MAX）{
procts.add（大小+“”）;
} {
notifyAll（）的;
}
}

同步的无效消耗（）{
（procts.isEmpty（））{
尝试{
的wait（）;
}（InterruptedException的E）{
e.printStackTrace（）;
}
}
System.out.println（ “消费procts.remove：”+（0））;
}

私有类生产扩展Thread {
@覆盖
公共无效的run（）{...... />（取消）{
农产品（）;
}
}
}

私人阶层的消费扩展Thread {
@覆盖
公共无效的run（）{
（取消）{
消耗（）;
}
}
}
/>无效取消（）{
取消= TRUE;
}

的公共ProcerAndConsumer（）{
新的消费者（）。开始（）;
新的的监制（）。开始（）;}

公共静态无效的主要（字符串[] ARGS）{
新ProcerAndConsumer（）;
}

}

5. java实现生产者和消费者问题的几种方式

生产者消费者问题是多线程的一个经典问题，它描述是有一块缓冲区作为仓库，生产者可以将产品放入仓库，消费者则可以从仓库中取走产品。
解决生产者/消费者问题的方法可分为两类：
采用某种机制保护生产者和消费者之间的同步；
在生产者和消费者之间建立一个管道。
第一种方式有较高的效率，并且易于实现，代码的可控制性较好，属于常用的模式。第二种管道缓冲区不易控制，被传输数据对象不易于封装等，实用性不强。
在Java中有四种方法支持同步，其中前三个是同步方法，一个是管道方法。
wait()
/
notify()方法
await()
/
signal()方法
BlockingQueue阻塞队列方法
PipedInputStream
/
PipedOutputStream
通过
wait()
/
notify()方法实现：
wait()
/
nofity()方法是基类Object的两个方法：
wait()方法：当缓冲区已满/空时，生产者/消费者线程停止自己的执行，放弃锁，使自己处于等等状态，让其他线程执行。
notify()方法：当生产者/消费者向缓冲区放入/取出一个产品时，向其他等待的线程发出可执行的通知，同时放弃锁，使自己处于等待状态。
通过await()
/
signal()方法实现：
await()和signal()的功能基本上和wait()
/
nofity()相同，完全可以取代它们，但是它们和新引入的锁定机制Lock直接挂钩，具有更大的灵活性。通过在Lock对象上调用newCondition()方法，将条件变量和一个锁对象进行绑定，进而控制并发程序访问竞争资源的安全。
通过BlockingQueue方法实现：
它是一个已经在内部实现了同步的队列，实现方式采用的是我们第2种await()
/
signal()方法。它可以在生成对象时指定容量大小。它用于阻塞操作的是put()和take()方法：
put()方法：类似于我们上面的生产者线程，容量达到最大时，自动阻塞。
take()方法：类似于我们上面的消费者线程，容量为0时，自动阻塞。

6. java多生产者和消费者问题，重复生产消费

我晕看了好久,别人写的代码看的真是辛苦,也没注释...修改了一堆括号!!

妥妥的没问题,你的资源用的数组,换句话说,

你数组被A1线程增加索引1,然后B过来拿走索引1;数组里面此刻是什么?当然是0了啊;因为你递减了...

然后A2被拿到执行权,怎么样?是不是还去增加索引1??明白了?

如果你想要不重复,就别递减就行了!

另外你这么改,有什么问题看的很醒目,知道发生在哪个线程上!

7. Java培训都学哪些知识

1、 java语法。
通过任何一本Java入门书籍，都可以学会Java的基本语法。千万不要认为，你把书上的例子程序都能写出来就算学会了Java语法。要想真正掌握，还需要做大量的测试题。对语法不准确的理解，会使你写的代码出现逻辑错误。而这些错误会使你在真正的项目开发中吃尽苦头：你认为正确才会写上去。而在几十万行代码中找出几行有逻辑错误的代码，非常困难。因为你几乎不会怀疑你认为正确的代码存在错误。
2、 常用类。
永远不要写别人已经实现的代码。有很多功能，用JDK中现有的类就可以完成。你需要熟悉JDK.可以通过研究JDK帮助文档和JDK源代码的方式，逐渐了解，你需要的类都在什么地方。一方面，要熟悉有哪些可以直接使用的资源，另一方面，学习一下，SUN公司的工程师怎样写代码。
3、 IDE 集成开发环境。
现在企业最常用的是IBM公司的eclipse ,类似的还有JBuilder 、Idea,NetBeans等等。毕竟，只有5％的顶尖高手在使用简单的文本编辑器在写Java代码。多数程序员都是在使用这些东西。
4、 数据库。
MySql,Oracle,DB2.小项目多数使用MySql这样的免费数据库。大一些的项目会考虑使用Oracle或者DB2. Java项目很少使用SqlServer。因此，你还需要学习数据库方面的一些知识。可以从SQL语言开始。这些数据库都支持标准SQL.学会基本的SQL,参考具体的数据库手册，就可以完成一般的项目开发了。当然，要想使你的程序运行的效率更高，需要更深入的学习。大部分的程序优化，都是从这部分开始的。
5、 JDBC Java数据库连接。
使用Java程序操作数据库。这部分非常重要。几乎所有的企业项目都会用到。
6、 HTML CSS Javascript。
HTML-- 超文本标记语言。
CSS --层叠样式表。
JavaScript--是一种由Netscape的LiveScript发展而来的脚本语言。
准确的说，这些东西和Java语言本身关系不大。但是，现在的企业项目，以B/S结构的居多。因此，我们的Java程序，会有大量的机会和它们打交道。需要提前准备一下。
7、你需要学习如何使用及管理WEB服务器，例如tomcat，并且知道如何在其基础上扩展和维护WEB程序，如何使用它的附加服务，如连接池。
8、 JSP Servlet。
这两个是初级Java程序员必须掌握的基本技能，是所有B/S结构框架的基础。相应的，还需要学习EL以及JSTL(StandardTagLibraries)和可以选择的第三方TagLibraries,以提高表示层的处理能力。
9、企业流行框架 Struts,Spring,Hibernate等。
10、Java设计模式。
有一些特殊的功能，只有按照特定的设计模式才能实现。如果你有了5万行以上的代码经验，可以开始研究一下设计模式。
11、你还要跟上技术发展的步伐，了解在Java项目中使用的新技术。如Ajax等。
还有很多要学习的内容。先介绍这么多吧，自己学习这些内容，估计需要2年左右。如果有个好的指导老师，在培训学校进行系统学习，则需要3－5个月。
如果选择培训，一定要选择拥有多年JAVA项目开发经验、测试经验、及项目管理经验，采用“教”“练”结合，用真实项目案例进行训练的教学方式。让学员掌握实用的技能，在毕业后就有着实战项目开发经验，立刻上岗，成为诸多企业抢手的人才。