java队列消息
Ⅰ 在java中怎么实现消息队列
java中的消息队列
消息队列是线程间通讯的手段：
importjava.util.*
publicclassMsgQueue{
privateVectorqueue=null;
publicMsgQueue(){
queue=newVector();
}
publicsynchronizedvoidsend(Objecto)
{
queue.addElement(o);
}
publicsynchronizedObjectrecv()
{
if(queue.size()==0)
returnnull;
Objecto=queue.firstElement();
queue.removeElementAt(0);//orqueue[0]=nullcanalsowork
returno;
}
}
因为java中是lockedbyobject的所以添加synchronized就可以用于线程同步锁定对象
可以作为多线程处理多任务的存放task的队列。他的client包括封装好的task类以及thread类
Java的多线程-线程间的通信2009-08-2521:58
1.线程的几种状态
线程有四种状态，任何一个线程肯定处于这四种状态中的一种：
1)产生（New）：线程对象已经产生，但尚未被启动，所以无法执行。如通过new产生了一个线程对象后没对它调用start()函数之前。
2)可执行（Runnable）：每个支持多线程的系统都有一个排程器，排程器会从线程池中选择一个线程并启动它。当一个线程处于可执行状态时，表示它可能正处于线程池中等待排排程器启动它；也可能它已正在执行。如执行了一个线程对象的start()方法后，线程就处于可执行状态，但显而易见的是此时线程不一定正在执行中。
3)死亡（Dead）：当一个线程正常结束，它便处于死亡状态。如一个线程的run()函数执行完毕后线程就进入死亡状态。
4)停滞（Blocked）：当一个线程处于停滞状态时，系统排程器就会忽略它，不对它进行排程。当处于停滞状态的线程重新回到可执行状态时，它有可能重新执行。如通过对一个线程调用wait()函数后，线程就进入停滞状态，只有当两次对该线程调用notify或notifyAll后它才能两次回到可执行状态。
2.classThread下的常用函数函数
2.1suspend()、resume()
1)通过suspend()函数，可使线程进入停滞状态。通过suspend()使线程进入停滞状态后，除非收到resume()消息，否则该线程不会变回可执行状态。
2)当调用suspend()函数后，线程不会释放它的“锁标志”。
例11：
{
publicstaticintshareVar=0;
publicTestThreadMethod(Stringname){
super(name);
}
publicsynchronizedvoidrun(){
if(shareVar==0){
for(inti=0;i<5;i++){
shareVar++;
if(shareVar==5){
this.suspend();//（1）
}}}
else{
System.out.print(Thread.currentThread().getName());
System.out.println("shareVar="+shareVar);
this.resume();//（2）
}}
}
publicclassTestThread{
publicstaticvoidmain(String[]args){
TestThreadMethodt1=newTestThreadMethod("t1");
TestThreadMethodt2=newTestThreadMethod("t2");
t1.start();//（5）
//t1.start();//（3）
t2.start();//（4）
}}
运行结果为：
t2shareVar=5
i.当代码（5）的t1所产生的线程运行到代码（1）处时，该线程进入停滞状态。然后排程器从线程池中唤起代码（4）的t2所产生的线程，此时shareVar值不为0，所以执行else中的语句。
ii.也许你会问，那执行代码（2）后为什么不会使t1进入可执行状态呢？正如前面所说，t1和t2是两个不同对象的线程，而代码（1）和（2）都只对当前对象进行操作，所以t1所产生的线程执行代码（1）的结果是对象t1的当前线程进入停滞状态；而t2所产生的线程执行代码（2）的结果是把对象t2中的所有处于停滞状态的线程调回到可执行状态。
iii.那现在把代码（4）注释掉，并去掉代码（3）的注释，是不是就能使t1重新回到可执行状态呢？运行结果是什么也不输出。为什么会这样呢？也许你会认为，当代码（5）所产生的线程执行到代码（1）时，它进入停滞状态；而代码（3）所产生的线程和代码（5）所产生的线程是属于同一个对象的，那么就当代码（3）所产生的线程执行到代码（2）时，就可使代码（5）所产生的线程执行回到可执行状态。但是要清楚，suspend()函数只是让当前线程进入停滞状态，但并不释放当前线程所获得的“锁标志”。所以当代码（5）所产生的线程进入停滞状态时，代码（3）所产生的线程仍不能启动，因为当前对象的“锁标志”仍被代码（5）所产生的线程占有。
#p#2.2sleep()
1)sleep()函数有一个参数，通过参数可使线程在指定的时间内进入停滞状态，当指定的时间过后，线程则自动进入可执行状态。
2)当调用sleep()函数后，线程不会释放它的“锁标志”。
例12：
{
{
publicstaticintshareVar=0;
publicTestThreadMethod(Stringname){
super(name);
}
publicsynchronizedvoidrun(){
for(inti=0;i<3;i++){
System.out.print(Thread.currentThread().getName());
System.out.println(":"+i);
try{
Thread.sleep(100);//（4）
}
catch(InterruptedExceptione){
System.out.println("Interrupted");
}}}
}
publicclassTestThread{publicstaticvoidmain(String[]args){
TestThreadMethodt1=newTestThreadMethod("t1");
TestThreadMethodt2=newTestThreadMethod("t2");
t1.start();（1）
t1.start();（2）
//t2.start();（3）
}}
运行结果为：
t1:0
t1:1
t1:2
t1:0
t1:1
t1:2
由结果可证明，虽然在run()中执行了sleep()，但是它不会释放对象的“锁标志”，所以除非代码(1)的线程执行完run()函数并释放对象的“锁标志”，否则代码（2）的线程永远不会执行。
如果把代码（2）注释掉，并去掉代码（3）的注释，结果将变为：
t1:0
t2:0
t1:1
t2:1
t1:2
t2:2
由于t1和t2是两个对象的线程，所以当线程t1通过sleep()进入停滞时，排程器会从线程池中调用其它的可执行线程，从而t2线程被启动。
例13：
{
publicstaticintshareVar=0;
publicTestThreadMethod(Stringname){
super(name);
}
publicsynchronizedvoidrun(){
for(inti=0;i<5;i++){
System.out.print(Thread.currentThread().getName());
System.out.println(":"+i);
try{
if(Thread.currentThread().getName().equals("t1"))
Thread.sleep(200);
else
Thread.sleep(100);
}
catch(InterruptedExceptione){
System.out.println("Interrupted");
}}
}}
publicclassTestThread{publicstaticvoidmain(String[]args){
TestThreadMethodt1=newTestThreadMethod("t1");
TestThreadMethodt2=newTestThreadMethod("t2");
t1.start();
//t1.start();
t2.start();
}}
运行结果为：
t1:0
t2:0
t2:1
t1:1
t2:2
t2:3
t1:2
t2:4
t1:3
t1:4
由于线程t1调用了sleep(200)，而线程t2调用了sleep(100)，所以线程t2处于停滞状态的时间是线程t1的一半，从从结果反映出来的就是线程t2打印两倍次线程t1才打印一次。
#p#2.3yield()
1)通过yield()函数，可使线程进入可执行状态，排程器从可执行状态的线程中重新进行排程。所以调用了yield()的函数也有可能马上被执行。
2)当调用yield()函数后，线程不会释放它的“锁标志”。
例14：
{
publicstaticintshareVar=0;
publicTestThreadMethod(Stringname){super(name);
}
publicsynchronizedvoidrun(){for(inti=0;i<4;i++){
System.out.print(Thread.currentThread().getName());
System.out.println(":"+i);
Thread.yield();
}}
}
publicclassTestThread{publicstaticvoidmain(String[]args){
TestThreadMethodt1=newTestThreadMethod("t1");
TestThreadMethodt2=newTestThreadMethod("t2");
t1.start();
t1.start();//（1）
//t2.start();（2）
}
}
运行结果为：
t1:0
t1:1
t1:2
t1:3
t1:0
t1:1
t1:2
t1:3
从结果可知调用yield()时并不会释放对象的“锁标志”。
如果把代码（1）注释掉，并去掉代码（2）的注释，结果为：
t1:0
t1:1
t2:0
t1:2
t2:1
t1:3
t2:2
t2:3
从结果可知，虽然t1线程调用了yield()，但它马上又被执行了。
2.4sleep()和yield()的区别
1)sleep()使当前线程进入停滞状态，所以执行sleep()的线程在指定的时间内肯定不会执行；yield()只是使当前线程重新回到可执行状态，所以执行yield()的线程有可能在进入到可执行状态后马上又被执行。
2)sleep()可使优先级低的线程得到执行的机会，当然也可以让同优先级和高优先级的线程有执行的机会；yield()只能使同优先级的线程有执行的机会。
例15：
{
publicstaticintshareVar=0;
publicTestThreadMethod(Stringname){
super(name);
}
publicvoidrun(){
for(inti=0;i<4;i++){
System.out.print(Thread.currentThread().getName());
System.out.println(":"+i);
//Thread.yield();（1）
/*（2）*/
try{
Thread.sleep(3000);
}
catch(InterruptedExceptione){
System.out.println("Interrupted");
}}}
}
publicclassTestThread{
publicstaticvoidmain(String[]args){
TestThreadMethodt1=newTestThreadMethod("t1");
TestThreadMethodt2=newTestThreadMethod("t2");
t1.setPriority(Thread.MAX_PRIORITY);
t2.setPriority(Thread.MIN_PRIORITY);
t1.start();
t2.start();
}
}
运行结果为：
t1:0
t1:1
t2:0
t1:2
t2:1
t1:3
t2:2
t2:3
由结果可见，通过sleep()可使优先级较低的线程有执行的机会。注释掉代码（2），并去掉代码（1）的注释，结果为：
t1:0
t1:1
t1:2
t1:3
t2:0
t2:1
t2:2
t2:3
可见，调用yield()，不同优先级的线程永远不会得到执行机会。
2.5join()
使调用join()的线程执行完毕后才能执行其它线程，在一定意义上，它可以实现同步的功能。
例16：
{
publicstaticintshareVar=0;
publicTestThreadMethod(Stringname){
super(name);
}
publicvoidrun(){
for(inti=0;i<4;i++){
System.out.println(""+i);
try{
Thread.sleep(3000);
}
catch(InterruptedExceptione){
System.out.println("Interrupted");
}
}
}
}
publicclassTestThread{
publicstaticvoidmain(String[]args){
TestThreadMethodt1=newTestThreadMethod("t1");
t1.start();
try{
t1.join();
}
catch(InterruptedExceptione){}
t1.start();
}
}
运行结果为：
0
1
2
3
0
1
2
3
#p#3.classObject下常用的线程函数
wait()、notify()和notifyAll()这三个函数由java.lang.Object类提供，用于协调多个线程对共享数据的存取。
3.1wait()、notify()和notifyAll()
1)wait()函数有两种形式：第一种形式接受一个毫秒值，用于在指定时间长度内暂停线程，使线程进入停滞状态。第二种形式为不带参数，代表waite()在notify()或notifyAll()之前会持续停滞。
2)当对一个对象执行notify()时，会从线程等待池中移走该任意一个线程，并把它放到锁标志等待池中；当对一个对象执行notifyAll()时，会从线程等待池中移走所有该对象的所有线程，并把它们放到锁标志等待池中。
3)当调用wait()后，线程会释放掉它所占有的“锁标志”，从而使线程所在对象中的其它synchronized数据可被别的线程使用。
例17：
下面，我们将对例11中的例子进行修改
{
publicstaticintshareVar=0;
publicTestThreadMethod(Stringname){
super(name);
}
publicsynchronizedvoidrun(){
if(shareVar==0){
for(inti=0;i<10;i++){
shareVar++;
if(shareVar==5){
try{
this.wait();//（4）
}
catch(InterruptedExceptione){}
}
}
}
if(shareVar!=0){
System.out.print(Thread.currentThread().getName());
System.out.println("shareVar="+shareVar);
this.notify();//（5）
}
}
}
publicclassTestThread{
publicstaticvoidmain(String[]args){
TestThreadMethodt1=newTestThreadMethod("t1");
TestThreadMethodt2=newTestThreadMethod("t2");
t1.start();//（1）
//t1.start();（2）
t2.start();//（3）
}}
运行结果为：
t2shareVar=5
因为t1和t2是两个不同对象，所以线程t2调用代码（5）不能唤起线程t1。如果去掉代码（2）的注释，并注释掉代码（3），结果为：
t1shareVar=5
t1shareVar=10
这是因为，当代码（1）的线程执行到代码（4）时，它进入停滞状态，并释放对象的锁状态。接着，代码（2）的线程执行run()，由于此时shareVar值为5，所以执行打印语句并调用代码（5）使代码（1）的线程进入可执行状态，然后代码（2）的线程结束。当代码（1）的线程重新执行后，它接着执行for()循环一直到shareVar=10，然后打印shareVar。
#p#3.2wait()、notify()和synchronized
waite()和notify()因为会对对象的“锁标志”进行操作，所以它们必须在synchronized函数或synchronizedblock中进行调用。如果在non-synchronized函数或non-synchronizedblock中进行调用，虽然能编译通过，但在运行时会发生IllegalMonitorStateException的异常。
例18：
{
publicintshareVar=0;
publicTestThreadMethod(Stringname){
super(name);
newNotifier(this);
}
publicsynchronizedvoidrun(){
if(shareVar==0){
for(inti=0;i<5;i++){
shareVar++;
System.out.println("i="+shareVar);
try{
System.out.println("wait......");
this.wait();
}
catch(InterruptedExceptione){}
}}
}
}
classNotifierextendsThread{
privateTestThreadMethodttm;
Notifier(TestThreadMethodt){
ttm=t;
start();
}
publicvoidrun(){
while(true){
try{
sleep(2000);
}
catch(InterruptedExceptione){}
/*1要同步的不是当前对象的做法*/
synchronized(ttm){
System.out.println("notify......");
ttm.notify();
}}
}
}
publicclassTestThread{
publicstaticvoidmain(String[]args){
TestThreadMethodt1=newTestThreadMethod("t1");
t1.start();
}
}
运行结果为：
i=1
wait......
notify......
i=2
wait......
notify......
i=3
wait......
notify......
i=4
wait......
notify......
i=5
wait......
notify......
4.wait()、notify()、notifyAll()和suspend()、resume()、sleep()的讨论
4.1这两组函数的区别
1)wait()使当前线程进入停滞状态时，还会释放当前线程所占有的“锁标志”，从而使线程对象中的synchronized资源可被对象中别的线程使用；而suspend()和sleep()使当前线程进入停滞状态时不会释放当前线程所占有的“锁标志”。
2)前一组函数必须在synchronized函数或synchronizedblock中调用，否则在运行时会产生错误；而后一组函数可以non-synchronized函数和synchronizedblock中调用。
4.2这两组函数的取舍
Java2已不建议使用后一组函数。因为在调用suspend()时不会释放当前线程所取得的“锁标志”，这样很容易造成“死锁”。
Ⅱ 到底什么是消息队列Java中如何实现消息队列
消息队列，顾名思义
首先是个队列。
队列的操作有入队和出队
也就是你有一个程序在产生内容然后入队（生产者）
另一个程序读取内容，内容出队（消费者）
这是最最基本的概念。
我想你应该是缺乏一个使用场景。
当你不需要立即获得结果，但是并发量又不能无限大的时候，差不多就是你需要使用消息队列的时候。
比如你写日志，因为可能一个客户端有多个操作去写，又有很多个客户端，显然并发不能无穷大，于是你就需要把写日志的请求放入到消息队列里，在消费者那边依次把队列中产生的日志写到数据库里。
至于怎么实现消息队列，其实你本身一个普通的队列就行呀~看你需要什么附加功能而已。
Ⅲ 到底什么是消息队列Java中如何实现消息队列
“消息队列”是在消息的传输过程中保存消息的容器。和我们学过的LinkedHashMap，TreeSet等一样，都是容器。既然是容器，就有有自己的特性，就像LinkedHashMap是以键值对存储。存取顺序不变。而消息队列，看到队列就可以知道。这个容器里面的消息是站好队的，一般遵从先进先出原则。
java中已经为我们封装好了很多的消息队列。在java 1.5版本时推出的java.util.concurrent中有很多现成的队列供我们使用。特性繁多，种类齐全。是你居家旅游开发必备QAQ。
下面简单列举这个包中的消息队列
:阻塞队列 BlockingQueue
数组阻塞队列 ArrayBlockingQueue
延迟队列 DelayQueue
链阻塞队列 LinkedBlockingQueue
具有优先级的阻塞队列 PriorityBlockingQueue
同步队列 SynchronousQueue
阻塞双端队列 BlockingDeque
链阻塞双端队列 LinkedBlockingDeque
不同的队列不同的特性决定了队列使用的时机，感兴趣的话你可以详细了解。具体的使用方式我就不赘述了
Ⅳ 到底什么是消息队列Java中如何实现消息队列
消息队列就是在完全处理完队列中最前面的数据之前，其他的数据信息会依次在队列中排好队，然后一个一个数据去处理
java的消息队列用别人写好的插件用就行了，java自带的sycronization虽然可以实现，但是扩展性很差，且使用效率也不行，其他的插件有很多，都是MQ，你消息队列MQ 就好了
Ⅳ 到底什么是消息队列Java中如何实现消息队列
通俗的说，就是一个容器，你把消息丢进去，不需要立即处理。然后有个程序去从你的容器里面把消息一条条读出来处理。
消息队列，可以是activeMQ，kafka之类的，也可以是数据库的一张任务表。
个人觉得消息队列，主要有两个作用：
- 降低耦合
- 消息可以暂时存在在消息队列中，等待消息接收者根据自身的负载处理能力控制处理消息的处理速度，减小在大并发访问时候的压力。
Ⅵ 到底什么是消息队列Java中如何实现消息队列
所谓队列，就是按照队首先出的规则建立的数据结构，消息队列就是根据消息到来后按照一定的规则进行排序，但一定是队首的消息先得到应答的队列。
比如：
public static String do_post(String url, List<NameValuePair> name_value_pair) throws IOException {
String body = "{}";
DefaultHttpClient httpclient = new DefaultHttpClient();
try {
HttpPost httpost = new HttpPost(url);
httpost.setEntity(new UrlEncodedFormEntity(name_value_pair, StandardCharsets.UTF_8));
HttpResponse response = httpclient.execute(httpost);
HttpEntity entity = response.getEntity();
body = EntityUtils.toString(entity);
} finally {
httpclient.getConnectionManager().shutdown();
}
return body;
}
public static String do_get(String url) throws ClientProtocolException, IOException {
String body = "{}";
DefaultHttpClient httpclient = new DefaultHttpClient();
try {
HttpGet httpget = new HttpGet(url);
HttpResponse response = httpclient.execute(httpget);
HttpEntity entity = response.getEntity();
body = EntityUtils.toString(entity);
} finally {
httpclient.getConnectionManager().shutdown();
}
return body;
}
Ⅶ 到底什么是消息队列Java中如何实现消息队列
消息队列，顾名思义首先是个队列。队列的操作有入队和出队也就是有一个程序在产生内容然后入队（生产者）另一个程序读取内容，内容出队（消费者）这是最最基本的概念。java中的消息队列消息队列是线程间通讯的手段：importjava.util.*p
Ⅷ java 中说的消息队列和窗口到底是什么意思
1.窗口有多种了，这个概念比较宽泛，有JOptionPane.showInputDialog("xxx");标准的弹出文本输入窗口，有showMessageDialog,showConfirmDialog,showOptionDialog对话框。还有装载组建的JFrame窗体。我想你想了解的是JFrame？JFrame就是一个窗体容器，把一些文本框了，按钮了，面板了，以一定的形式塞给JFrame显示出来。
2.消息队列（Vecotr）就是线程之间交互通讯的手段。
3.至于和线程的关系，那太多了，比如最简单了，一个窗体的运行，需要线程开启吧。
如开启个线程去运行javax.swing.SwingUtilities.invokeLater(xxxx)；
Ⅸ 到底什么是消息队列Java中如何实现消息队列
消息队列，顾名思义 首先是个队列。 队列的操作有入队和出队 也就是你有一个程序在产生内容然后入队（生产者） 另一个程序读取内容，内容出队（消费者） 这是最最基本的概念。 我想你应该是缺乏一个使用场景
Ⅹ 到底什么是消息队列Java中如何实现消息队列
消息队列就是在完全处理完队列中最前面的数据之前，其他的数据信息会依次在队列中排好队，然后一个一个数据去处理
java的消息队列用别人写好的插件用就行了，java自带的sycronization虽然可以实现，但是扩展性很差，且使用效率也不行，其他的插件有很多，都是MQ，你网络搜索消息队列MQ 就好了