`
dev_liu
  • 浏览: 112503 次
  • 性别: Icon_minigender_1
  • 来自: 成都
最近访客 更多访客>>
社区版块
存档分类
最新评论

今天把多线程的发送搞定了一半.而且实现了服务器和客户端不在一个主机了

    博客分类：
  • JMS
多线程JMSthread活动Apache 
阅读更多

public class Sendert {
 QueueConnectionFactory  queueConnectionFactory = null;
  QueueConnection         queueConnection = null;
    QueueSession            queueSession = null;
    Queue                   queue = null;
   QueueSender             queueSender = null;
      final String            MSG_TEXT1 =
          new String("Here is a client-acknowledge message 4tetrtretertert4t45ewrwerwrgergrt4rqwerew5t479347597505890 34535&%^*&$&^$^%$&%&*)_*)&^*%*^$&$^(*&(*&(*%*%&^%*%^%*&^*&^&*^*&^*&^");
      final String            MSG_TEXT2 =
       new String("Here is a Message  327893475984 ryeirrfr9urtyureyt&&&&&&&)))__^&&&))gerg)%%^%^%^%&(*(*(*)*(**)(*)*)*)T^HJCJBDKJFBKJJDOAIWEU(Q&#(&E(*&#Q*E&QEUODIJEDLJLHDKGDUWTE&QE");
      TextMessage         message1 = null;
      TextMessage         message2 =null;

 public Sendert() throws JMSException, NamingException {

  javax.naming.Context ictx = new InitialContext(JMSConstant.getProp());

  queueConnectionFactory = (QueueConnectionFactory) ictx.lookup("qcf");

  queueConnection = queueConnectionFactory.createQueueConnection("user1",
    "user1");
  queueSession = queueConnection.createQueueSession(false,
    Session.CLIENT_ACKNOWLEDGE);
  queue = (Queue) ictx.lookup("queue");
  ictx.close();
  System.out.println("  SENDER: Created client-acknowledge session");
  queueSender = queueSession.createSender(queue);
  message1 = queueSession.createTextMessage();
  message2 = queueSession.createTextMessage();
  message1.setIntProperty("sessionID", 1);
  message2.setIntProperty("sessionID", 2);
 }
 
   class AsynSender implements Runnable
  {
   public void run ()
   {   
    
       try {
            
             for(int i=0;i<10;i++){
              message1.setText("i"+MSG_TEXT1);
              message2.setText("i"+MSG_TEXT2);
             System.out.println("  SENDER: Sending message: "
                 + message1.getText()+i);
             queueSender.send(message1);
             queueSender.send(message2);
             }
         } catch (JMSException e) {
             System.out.println("Exception occurred: " + e.toString());
           
         }
//         finally {
//          if(queueSender!=null){
//           try{queueSender.close();
//           
//          }catch(JMSException e){}
//          if(queueSession!=null)
//           {
//           try{
//           queueSession.commit();
//           }catch(JMSException e){}
//          }
//             if (queueConnection != null)
//             {
//                 try {
//                     queueConnection.close();
//                 } catch (JMSException e) {}
//             }
//         }
//         }
         }
  }
  
 public void run_threads() {
  AsynSender tt = new AsynSender();
  for (int i = 0; i < 5; i++)
   {   new Thread(tt).start();
   
   
   
   System.out.println("go");}
//  try{
//   tt.join();
//   
//  }catch(InterruptedException je){}
  System.out.println("go2");
  }
  
     
 
 void close() throws JMSException {
  queueSender.close();
  queueSession.close();
   queueConnection.close();
 }


    public static void main(String[] args) throws JMSException, NamingException {
     int count=0;
  Sendert se = new Sendert();
  se.run_threads();
  Thread tt=Thread.currentThread();
  System.out.println("count==: "+tt.activeCount());
//  tt.g
//  System.out.println("tt==: "+tt);
//  myLable:{
//   count=tt.activeCount();
//  }
//  for(;;){
//    break myLable;
//  }
//  while(true){
//   
//  
//  if(tt.activeCount()==3) 
//        se.close();
//  else break myLable;;}
//  se.close();
  System.out.println("count==: "+tt.activeCount());
 }

}
 

说明.就是一个内部类,更好的封装了一个可以实现多线程的run方法..不过多线程有个问题..我无法知道子线程什么时候完毕,然后调用close()方法关闭所以对象...搞了几个小时,判断活动的线程,join().好象都不行.

分享到：
| 学习一门新东西需要慢慢来.
评论
2 楼 dev_liu 2007-01-05  
package duoxianchengtest;

/**
*
*/

import java.io.IOException;
import java.util.ArrayList;
import java.util.Properties;
import java_cup.runtime.Symbol;
import javax.jms.JMSException;
import javax.jms.Queue;
import javax.jms.QueueConnection;
import javax.jms.QueueConnectionFactory;
import javax.jms.QueueSender;
import javax.jms.QueueSession;
import javax.jms.Session;
import javax.jms.TextMessage;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

/**
*
* @author Owner
*
*/

public class Sendert {



private static transient final Log log = LogFactory.getLog(Sendert.class);

    QueueConnection        queueConnection = null;
    QueueSession            queueSession = null;
    QueueSender             queueSender = null;
      final String       MSG_TEXT1 =
          new String("Here is a client-acknowledge message 4tetrtretertert4t45ewrwerwrgergrt4rqwerew5t479347597505890 34535&%^*&$&^$^%$&%&*)_*)&^*%*^$&$^(*&(*&(*%*%&^%*%^%*&^*&^&*^*&^*&^");
      final String       MSG_TEXT2 =
      new String("Here is a Message  327893475984 ryeirrfr9urtyureyt&&&&&&&)))__^&&&))gerg)%%^%^%^%&(*(*(*)*(**)(*)*)*)T^HJCJBDKJFBKJJDOAIWEU(Q&#(&E(*&#Q*E&QEUODIJEDLJLHDKGDUWTE&QE");
      TextMessage         message1 = null;
      TextMessage         message2 = null;
      static long time1;
      static long time4;
public Sendert() throws JMSException, NamingException {

time1 = System.currentTimeMillis();
// javax.naming.Context ictx = new InitialContext(JMSConstant.getProp());
/**
  * 直接创建一个Properties,把jndi配置属性key,value放进去.可以省去读取jdni.properties的时间和大量代码.
  */
Properties pr =new Properties();
pr.put("82.0.176.214","16400");
javax.naming.Context  ictx = new InitialContext(pr);
QueueConnectionFactory  queueConnectionFactory = (QueueConnectionFactory) ictx.lookup("qcf");

queueConnection = queueConnectionFactory.createQueueConnection("user1","user1");
queueSession = queueConnection.createQueueSession(false,
Session.CLIENT_ACKNOWLEDGE);
Queue queue = (Queue) ictx.lookup("queue");
ictx.close();

queueSender = queueSession.createSender(queue);
message1 = queueSession.createTextMessage();
message2 = queueSession.createTextMessage();
message1.setIntProperty("sessionID", 1);
message2.setIntProperty("sessionID", 2);
}

class AsynSender extends Thread {

public void run () {   

      try {
           
            for(int i=0;i<5;i++){
            message1.setText("i"+MSG_TEXT1);
            message2.setText("i"+MSG_TEXT2);
System.out.println("  message1: "  + message1.getText());
System.out.println("  message2: "  + message2.getText());
            queueSender.send(message1);
            queueSender.send(message2);
            }
        } catch (JMSException e) {
            System.out.println("Exception occurred: " + e.toString());
          
        }
      }
}

        /**
         * 由于是多线程,无法控制每个线程同时完成,所以会发生没有发送消息完毕而关闭连接的情况
         * 省去下面注释的代码.
         */
//         finally {
//         if(queueSender!=null){
//         try{queueSender.close();
//        
//         }catch(JMSException e){}
//         if(queueSession!=null)
//         {
//         try{
//         queueSession.commit();
//         }catch(JMSException e){}
//         }
//             if (queueConnection != null)
//             {
//                 try {
//                     queueConnection.close();
//                 } catch (JMSException e) {}
//             }
//         }
//         }
 
public void run_threads() {
AsynSender[] tt = new AsynSender[1000];
for (int i = 0; i < tt.length; i++)
       {
tt[i] = new AsynSender();
tt[i].start();

// new Thread(tt).setPriority(Thread.MAX_PRIORITY);
// new Thread(tt).start();

  log.info("run"+Thread.activeCount());
System.out.println("go");
}

for (int i = 0; i < tt.length; i++) {
System.out.println("go1");
try {
tt[i].join();//让子线程发送消息完毕后,才执行主控线程,关闭发送器,连接,会话对象

} catch (InterruptedException je) {}


System.out.println("go2");
}
}
     
/**
* 创建方法close()关闭消息发送器,会话,连接对象.
*
* @throws JMSException
*/
void close() throws JMSException {
queueSender.close();
queueSession.close();
queueConnection.close();
}

/**
*
* @param args
* @throws JMSException
* @throws NamingException
* @throws IOException
* 主控线程,当子线程发送消息完毕后.调用close()方法关闭消息发送器,会话,连接对象.
* 最后打印出发送消息的时间.和一些活动的线程测试.
*
*/
    public static void main(String[] args) throws JMSException, NamingException, IOException {
    System.out.println(" sender: Created client-acknowledge session");
Sendert se = new Sendert();
long time4 = System.currentTimeMillis();
se.run_threads();
      System.out.println("count==: "+Thread.activeCount());

      se.close();//发送消息完毕关闭消息发送器,会话,连接对象.


// System.out.println("tt==: "+tt);
// myLable:{
// count=tt.activeCount();
// }
// for(;;){
// break myLable;
// }
// while(true){
//
//
// if(tt.activeCount()==3)
//        se.close();
// else break myLable;;}
// System.in.read();

// try{Thread.sleep(10000);
// }catch(InterruptedException e){};

long time = System.currentTimeMillis();
long time2= time-time1;
System.out.println("count==: "+Thread.activeCount());
System.out.println("time=:"+time);//当前时间
System.out.println("time1=:"+time1);//程序初始化时间
System.out.println("time2=:"+time2);//程序执行耗费时间
System.out.println("time4=:"+time4);//程序初始化耗费时间
log.info("time4="+(time4-time1));
System.out.println("count==: "+Thread.activeCount()); //当前线程活动数
}

}
1 楼 dev_liu 2007-01-05  
这个问题终于解决了..做一个线程组...然后在for()循环里调用join().这样就ok了直到所有的发送消息线程执行完毕后执行主控线程..嘿嘿....
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    多线程实现服务器和客户端聊天.pdf

    在多线程实现服务器和客户端聊天中，套接字编程.play a crucial role.套接字是一种通信端点，用于在网络中传输数据。服务器端和客户端都需要创建套接字来建立连接。在该代码中，使用了Winsock2库来实现套接字编程。 ...

    QT 多线程TCP服务器与客户端

    QT框架中的多线程TCP服务器与客户端编程是一个关键的领域，尤其在开发高效、响应迅速的网络应用时。本文将深入探讨如何利用QT库，特别是QT5.11.1版本，来构建多线程的TCP服务器和客户端，以及QThread在其中的作用。 ...

    MFC实现多个客户端通过服务器进行通信的Socket多线程编程

    比如客户端A向客户端B发送消息，服务器接收到客户端A发过来消息内容和客户端B信息之后，通过转发表查找到客户端B的Socket，将内容转发给客户端B，实现客户端之间的通信。 3.运行程序时先运行服务端，再运行客户端。 ...

    c#多线程socket开发（一个服务器对多个客户端）

    使用C#语言开发多线程Socket服务器端程序可以实现一个服务器同时与多个客户端连接对话，提高了服务器的处理能力和响应速度。同时，该程序也可以实现服务器端的负载均衡和failover机制，以便提高服务器的可用性和可靠...

    socket 一个服务器对应多个客户端使用多线程

    在标题"socket 一个服务器对应多个客户端使用多线程"中，提到的是使用Socket编程来设计一个服务器，该服务器能够同时处理来自多个客户端的连接请求，这通常被称为“一对一”或“一对多”模型。在Linux环境下，这种...

    多线程下载服务器与客户端

    本文将深入探讨如何在Linux环境下使用C语言实现一个多线程下载服务器和客户端，以实现类似迅雷的分块下载功能，提高下载速度。 首先，让我们了解一下多线程的概念。在计算机编程中，多线程是一种并发执行任务的方式...

    QT5多线程TCP服务器和客户端demo

    本示例将深入探讨如何利用QT5实现多线程TCP服务器和客户端。 一、QT5中的多线程 在QT5中，QThread类提供了多线程支持。通过继承QThread或者使用 moveToThread() 方法，我们可以将对象移动到新的线程中运行，避免...

    MFC实现多个客户端通过服务器进行通信的Socket的多线程编程

    2.通过在服务器端维护一张转发表来实现各个客户端之间的通信，比如客户端A要给客户端B发送消息，首先客户端A把消息内容和客户端B的信息发给服务器，服务器在转发表中找到与客户端B建立的Socket，然后将消息内容转发...

    C#SOCKET 客户端与主机通讯多线程实现

    在这个“C# SOCKET 客户端与主机通讯多线程实现”主题中，我们将深入探讨如何利用C#的Socket类以及多线程技术来构建一个可靠的通信系统。 首先，我们要理解Socket的工作原理。Socket是网络编程中的一个抽象概念，它...

    VB6用winsock实现多线程客户端登录与短信发送

    标题中的“VB6用winsock实现多线程客户端登录与短信发送”指的是使用Visual Basic 6（VB6）编程语言，结合Winsock控件来构建一个支持多线程的客户端应用，该应用能够进行登录操作并能发送短信。Winsock是Windows上...

    基于Qt实现的多线程客户端与服务器

    【基于Qt实现的多线程客户端与服务器】项目是一个典型的分布式系统应用，它结合了Qt库、C++编程语言和多线程技术，用于构建一个高速公路智能收费系统。在这个系统中，多线程技术被用来提升程序的并发处理能力，确保...

    练习多线程客户端与服务器端

    - 在一个线程中，客户端可以发送数据到服务器，并通过另一个线程接收服务器的响应，这样可以实现发送和接收的并行操作。 - 完成通信后，客户端关闭连接。 5. **线程同步与通信**： 在多线程环境中，可能会出现...

    服务器多线程多客户端程序

    在这个场景中，我们探讨的是一个基于C#语言实现的服务器程序，它能够处理来自多个客户端的并发请求，同时利用了C#中的`Dictionary`类进行数据管理。下面我们将详细讨论这些知识点。 1. **多线程**： - **线程基础*...

    C#.net4.0 采用多线程 基于Socket的聊天室服务器和客户端

    在服务器端，每当有新的客户端连接请求时，都会创建一个新的线程来处理这个连接，这样可以确保服务器能够同时处理多个客户端的请求，提高了系统的并发性能。多线程的使用涉及到Thread类和Mutex、Semaphore等同步机制...

    用Python语言实现多线程客户端与服务端的对话程序

    本人在学习到socket的时候开贴记录顺便练习一下，下面的代码能够实现搭建一个多台客户端电脑与服务器主机的连续对话。一、程序功能可以实现多台电脑互通消息，且利用多线程实现一台服务器与多台客户端的连续对话二、...

    用Python套接字实现服务器和客户端的一对多通信（简易的聊天程序）

    在本文中，我们将深入探讨如何使用Python的套接字库实现一个简单的聊天程序，该程序支持服务器与多个客户端之间的通信。这个系统的核心是利用套接字进行网络通信，并结合多线程来处理并发连接。 首先，我们要理解套...

    编写简单的HTTP 1.0客户端/服务器程序：.编写多线程Web服务器：编写简单的RMI程序

    在高并发场景下，多线程技术使得服务器能同时处理多个请求，提高服务效率。在Java中，可以使用Thread类或Runnable接口来创建线程。服务器需要监听特定端口，接收到请求后，创建新的线程来处理，从而避免了单线程模型...

    QT多线程TCP服务器客户端通讯程序

    在QT网络编程中，服务器往往需要和多个客户端保持连接，因此，我在熟悉多线程编程过程中，在TCP服务每接收到一个客户端连接请求，就新建一个线程。客户端也是在新建的线程中维护的。 程序的思路如下： 程序使用了非...

    C#TCP协议服务器客户端通信源码（服务器多线程处理数据）

    代码会清晰地展示如何建立连接、发送和接收数据，以及如何在服务器端使用多线程处理并发的客户端连接。 多线程在服务器端的作用在于提高服务的并发能力，使得服务器可以同时处理多个客户端的请求，而不至于因为单...

    服务器为每一个连接客户端产生一个线程，这样接受多个连接

    在本篇文章中，我们将深入探讨一种常见的服务器端技术：通过为每个连接的客户端创建一个独立的线程来处理客户端请求的方式。这种技术通常用于实现支持多客户端并发连接的网络服务器。下面将详细介绍这种方法的工作...

Magicbox
Global site tag (gtag.js) - Google Analytics