精华内容
下载资源
问答
  • PTP消息的同步接收和异步接收 1.PTP消息的同步接收 需要等待消息的到来,先接收,后发送 两种模型中同步接收消息的编程基本是相同的,步骤如下 1.通过JNDI查找获取JMS连接工厂 2.通过JMS工厂创建JMS连接 3.JMS...

    PTP消息的同步接收和异步接收

    1.PTP消息的同步接收
    需要等待消息的到来,先接收,后发送
    两种模型中同步接收消息的编程基本是相同的,步骤如下
    	1.通过JNDI查找获取JMS连接工厂
    	2.通过JMS工厂创建JMS连接
    	3.JMS连接创建JMS会话
    	4.通过JNDI查找获取JMS消息目的
    	5.JMS会话根据指定的JMS消息目的来创建一个JMS消息消费者
    	6.利用消息的消费者对象同步的接收消息
    	7.关闭JMS资源
    

    eg:新建SyConsumer类

    /*同步接受消息*/ 
    //先接收 后发送 等待消息队列里收到消息
    public class SyConsumer {
    	
    	//1.获取命名服务的Context对象(获取初始化容器)
    	private Context getInitalContext() throws Exception {
    		
    		final String INIT_FACTORY = "weblogic.jndi.WLInitialContextFactory";
    		
    		final String SERVER_URL = "t3://localhost:7001";
    		
    		Properties props = new Properties();
    		props.put(Context.INITIAL_CONTEXT_FACTORY, INIT_FACTORY);
    		props.put(Context.PROVIDER_URL, SERVER_URL);
    		
    		Context ctx = new InitialContext(props);
    		
    		return ctx;
    	}
    	
    	//2.同步接收PTP消息
    	public void reciveMessage() throws Exception {
    		//定义默认的连接工厂
    		final String CONNECTION_FACTORY = "weblogic.jms.ConnectionFactory";
    		//获取容器 实例化
    		Context ctx = getInitalContext();
    		//查找连接对象 通过JNDI查找获取JMS连接工厂
    		ConnectionFactory connFactory = (ConnectionFactory) ctx.lookup(CONNECTION_FACTORY);
    		//通过JNDI查找获取JMS消息目的
    		Destination dest = (Destination) ctx.lookup("MessageQueue");
    		//通过JMS工厂创建JMS连接
    		Connection conn = connFactory.createConnection();
    		//启动JMS连接,开始传输JMS消息
    		conn.start();
    		//JMS连接创建JMS会话
    		Session session = conn.createSession(false, Session.AUTO_ACKNOWLEDGE);
    		//利用JMS会话创建消息消费者对象
    		MessageConsumer receiver = session.createConsumer(dest);
    		//利用消息的消费者对象同步的接收消息
    		TextMessage msg = (TextMessage) receiver.receive();
    		System.out.println(msg);
    		System.out.println("同步接收到的消息:"+msg.getText());
    		//释放资源
    		session.close();
    		conn.close();
    		
    		
    	}
    	
    	//3.测试执行
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		//new自身一个对象
    		SyConsumer sc = new SyConsumer();
    		try {
    			sc.reciveMessage();
    		} catch (Exception e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    	}
    }
    
    
    2.PTP消息的异步接收
    无需等待消息的到来 先发送 后接收
    
    JMS消息的异步接收有点类似于AWT的事件编程,JMS消息消费者并不主动调用receive()方法去接收消息,
    	而是采用一种监听器的机制来监听消息目的。当有消息抵达消息目的时,JMS消费者将自动触发它所对应的监听器的监听方法。
    	
    JMS消息异步接收的编程必须实现消息监听器,异步接收不会阻塞线程,无需一直等待消息的到来,
    	如果JMS消息目的有多个消息到来,异步消费者上监听器的监听方法将自动被触发多次。
    	如果线程程序没有其他事情可做,而且又没有接收到消息,程序将直接退出。
    

    eg:新建AsyncConSumer类实现MessageListener监听接口

    public class AsyncConSumer implements MessageListener {
    
    	//3.PTP异步接收消息
    	public AsyncConSumer() throws Exception {
    
    		final String CONNECTION_FACTORY_JNDI = "weblogic.jms.ConnectionFactory";
    		Context ctx = getInitalContext();
    		ConnectionFactory connFactory = (ConnectionFactory) ctx.lookup(CONNECTION_FACTORY_JNDI);
    		Connection conn = connFactory.createConnection();
    		Destination dest = (Destination) ctx.lookup("MessageQueue");
    		conn.start();
    		Session session = conn.createSession(false, Session.AUTO_ACKNOWLEDGE);
    		MessageConsumer receiver = session.createConsumer(dest);
    		//设置一个消息的监听器
    		receiver.setMessageListener(this);
    		//接收时让线程睡眠多长时间 10s
    		Thread.sleep(10000);
    		
    		session.close();
    		conn.close();
    		
    	}
    	
    	//1.获取命名服务的Context对象(获取初始化容器)
    	private Context getInitalContext() throws Exception {
    		
    		final String INIT_FACTORY = "weblogic.jndi.WLInitialContextFactory";
    		
    		final String SERVER_URL = "t3://localhost:7001";
    		
    		Properties props = new Properties();
    		props.put(Context.INITIAL_CONTEXT_FACTORY, INIT_FACTORY);
    		props.put(Context.PROVIDER_URL, SERVER_URL);
    		
    		Context ctx = new InitialContext(props);
    		
    		return ctx;
    	}
    		
    	@Override//2.监听器
    	public void onMessage(Message msg) {
    		// TODO Auto-generated method stub
    		TextMessage message = (TextMessage) msg; 
    		System.out.println(message);
    		
    		try {
    			System.out.println("异步接收到的消息"+message.getText());
    		} catch (JMSException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    		
    	}
    
    	//4.测试
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		try {
    			//由于构造方法 new的时候会初始化
    			AsyncConSumer consumer = new AsyncConSumer();
    		} catch (Exception e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    	}
    }
    
    
    展开全文
  • 我现在是在客户端和服务端都是采用同步接收和发送数据的方式,例如服务端接收数据的代码是: private void waitConn() { ConnServer = new UdpClient(1899); IPEndPoint iep = new IPEndPoint(IPAddress.Any,...
  • 在学习activemq的时候有个问题很困扰我,众所周知jms是异步通信,但为什么大量网页和例子里都说明activemq有同步接收消息和异步接收消息。难道activemq不是jms的实现吗,而且网页上也没人对此进行说明,经过大量查阅...

    一、jms同步? 
    在演示示例之前先解释一个问题。在学习activemq的时候有个问题很困扰我,众所周知jms是异步通信,但为什么大量网页和例子里都说明activemq有同步接收消息和异步接收消息。难道activemq不是jms的实现吗,而且网页上也没人对此进行说明,经过大量查阅资料和代码试验,终于搞清楚是怎么回事了,是我理解有误,此同步非彼同步也。我们先来看看同步、异步的概念(摘自http://www.cnblogs.com/candle806/archive/2013/02/19/2917155.html)。 
    异步:两个通信应用之间可以不用同时在线等待,任何一方只需各自处理自己的业务,比如发送方发送消息以后不用登录接收方的响应,可以接着处理其他的任务。也就是说发送方和接收方都是相互独立存在的,发送方只管方,接收方只能接收,无须去等待对方的响应。 
    同步:两个通信应用服务之间必须要进行同步,两个服务之间必须都是正常运行的。发送程序和接收程序都必须一直处于运行状态,并且随时做好相互通信的准备。发送程序首先向接收程序发起一个请求,称之为发送消息,发送程序紧接着就会堵塞当前自身的进程,不与其他应用进行任何的通信以及交互,等待接收程序的响应,待发送消息得到接收程序的返回消息之后会继续向下运行,进行下一步的业务处理。 
    jms是异步通信,发送方发送消息后就可以继续其它业务,而不用阻塞等等接收方响应。但接收方在接收消息上有两种模式:一种是同步接收消息,一种是异步接收消息。下面的示例中也会分别演示

    • 同步接收消息:接收者主动接收消息,若消息队列中没有消息则阻塞等待,当然也有其它方法可以规定等待时间或是不等待。
    • 异步接收消息:当消息队列有消息时会调用接收者的onMessage方法,接收者不用阻塞等待,可执行其它业务。 
      二、消息模型 
      jms支持两类消息传输模型:点对点模型(p2p)和发布/订阅模型(pub/sub) 
      1、p2p模型 
      p2p模型 
      点对点消息传送模型允许JMS客户端通过队列(queue)和这个虚拟通道来同步和异步发送、接收消息。消息生产者称为发送者(sender),消息消费者称为接收者(receiver)。传统上,点对点模型是一个基于拉取(pull)或轮询(polling)的消息传送模型,这种模型从队列中请求消息,而不是自动地将消息推送到客户端。 
      特点: 
      (1)发送到队列的消息被一个而且仅仅一个接收者所接收; 
      (2)队列保留信息,只到被消费或超时,接收者可用离线,上线时可消费消息。 
      (3)一旦消息被消费,就不会在队列中; 
      2、Pub/Sub模型 
      Pub/Sub模型 
      在发布/订阅模型中,消息会被发布到一个名为主题(topic)的虚拟通道中。消息生产者称为发布者(Publisher),而消息消费者称为订阅者(subscriber)。与点对点模型不同,使用发布/订阅模型发布到一个主题的消息,能够由多个订阅者所接收。有时候,也称这项技术为广播(broadcasting)消息。每个订阅者会接收到每条消息的一个副本。总的来说,发布/订阅消息传送模型基本上是一个基于推送(push)的模型,其中消息自动地向消费者广播,无需请求或轮询主题来获得新消息。 
      特点: 
      (1) 每个消息可以有多个消费者 
      (2)发布者和订阅者之间有时间上的依赖性。针对某个主题(Topic)的订阅者,它必须创建一个订阅者之后,才能消费发布者的消息,而且为了消费消息,订阅者必须保持运行的状态。 
      (3)为了缓和这样严格的时间相关性,JMS允许订阅者创建一个可持久化的订阅。这样,即使订阅者没有被激活(运行),它也能接收到发布者的消息。 
      三、点对点模型示例 
      1、下载activemq,有window和linux两个版本,此处为linux版本 
      2、解压文件,得到以下目录: 
      这里写图片描述 
      3、启动:到bin目录下,有三种启动方式 
      1) 普通启动 ./activemq start 
      2) 启动并指定日志文件 ./activemq start >tmp/smlog 
      3) 后台启动方式nohup ./activemq start >/tmp/smlog 
      运行截图如下: 
      这里写图片描述
      4、ActiveMQ自带了一套管理系统,访问http://ip:8161/admin/,输入用户名密码即可登录: 
      这里写图片描述
      5、实现,登录管理器后我们可以新建队列、topic,但为了更好理解Activemq,我们在程序中实现新建队列、topic。 
      首先新建一个生产者类(ActivemqQueueProducer.java),代码如下:
    package com.css.sword.service;
    
    import javax.jms.*;
    
    
    import org.apache.activemq.ActiveMQConnectionFactory;
    
    public class ActivemqQueueProducer {
        private  Session session;
        private  MessageProducer producer ;
        private Connection connection;
    
    
        public  void initialize() throws JMSException
        {
            ConnectionFactory connectFactory = new ActiveMQConnectionFactory(
            "tcp://localhost:61616");
            connection = connectFactory.createConnection();
            //session = connection.createSession(true, Session.AUTO_ACKNOWLEDGE);//支持事务
            session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);//不支持事务
    
            Destination destination =  session.createQueue("queue1");
            producer = session.createProducer(destination);
            connection.start();
    
        }
    
        public void sendText(String Message)
        {
            try {
                TextMessage text = session.createTextMessage(Message);
                producer.send(text);
                System.out.println("Sending message:"+text.getText());     
    
    
            } catch (JMSException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
    
        }
    
        public void submit() throws JMSException
        {
            session.commit();
        }
        // 关闭连接     
        public void close() throws JMSException {     
            System.out.println("Producer:->Closing connection");     
            if (producer != null)     
                producer.close();     
            if (session != null)     
                session.close();     
            if (connection != null)     
                connection.close();     
        }   
    
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59

    为了同时演示同步消息接收和异步消息接收,我们新建两个类(ActivemqQueueConsumer.Java和ActivemqQueueConsumerAsyn.Java),同步和异步的区别在于: 
    同步:使用Message message = consumer.receive()接收消息 
    异步:实现接口MessageListener,注册监听器 consumer.setMessageListener(this); //(异步接收) ,实现 onMessage方法

    同步ActivemqQueueConsumer.java

    package com.css.sword.service;
    
    import javax.jms.*;
    
    import org.apache.activemq.ActiveMQConnectionFactory;
    
    /**
     * <p>Title:ActivemqQueueConsumer</p>
     * <p>Description: 模拟同步接收消息</p> 
     * @author yuanxj
     * @date 2016-1-20
     */
    public class ActivemqQueueConsumer {
    
        private String name = "";
    
    
        private String subject = "TOOL.DEFAULT";     
    
        private Destination destination = null;     
    
        private Connection connection = null;     
    
        private Session session = null;     
    
        private MessageConsumer consumer = null; 
        ActivemqQueueConsumer(String name){
            this.name=name;
        }
    
        public  void initialize() throws JMSException
        {
        ConnectionFactory connectFactory = new ActiveMQConnectionFactory(
    "tcp://localhost:61616");
            Connection connection = connectFactory.createConnection();
            session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
            Destination destination =  session.createQueue("queue1");
            consumer = session.createConsumer(destination);
            connection.start();
    
        }
    
        public void recive()
        {
            try {
                initialize();
                System.out.println("Consumer("+name+"):->Begin listening...");     
                int count=0;
                while(count<10)
                {
                    Message message = consumer.receive(); //主动接收消息(同步)
                    System.out.println("consumer recive:"+((TextMessage)message).getText());
                    count++;
                    System.out.println(count);
    
                }
                } catch (JMSException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }     
        }
    
        public void submit() throws JMSException
        {
            session.commit();
        }
         // 关闭连接     
        public void close() throws JMSException {     
            System.out.println("Consumer:->Closing connection");     
            if (consumer != null)     
                consumer.close();     
            if (session != null)     
                session.close();     
            if (connection != null)     
                connection.close();     
        } 
    
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79

    异步ActivemqQueueConsumerAsyn.java

    package com.css.sword.service;
    
    import javax.jms.Connection;
    import javax.jms.ConnectionFactory;
    import javax.jms.Destination;
    import javax.jms.JMSException;
    import javax.jms.Message;
    import javax.jms.MessageConsumer;
    import javax.jms.MessageListener;
    import javax.jms.Session;
    import javax.jms.TextMessage;
    
    import org.apache.activemq.ActiveMQConnectionFactory;
    
    /**
     * <p>Title:ActivemqQueueConsumerAsyn</p>
     * <p>Description: 异步接收信息</p>   
     * @author yuanxj
     * @date 2016-1-20
     */
    public class ActivemqQueueConsumerAsyn implements MessageListener{
        private String name = "";
        private Connection connection = null;        
        private Session session = null;       
        private MessageConsumer consumer = null; 
        ActivemqQueueConsumerAsyn(String name){
            this.name=name;
        }
    
        public  void initialize() throws JMSException
        {ConnectionFactory connectFactory = new ActiveMQConnectionFactory(
    "tcp://localhost:61616");
            Connection connection = connectFactory.createConnection();
            session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
            Destination destination =  session.createQueue("queue1");
            consumer = session.createConsumer(destination);
            connection.start();
    
        }
    
        public void recive()
        {
            try {
                initialize();
                System.out.println("Consumer("+name+"):->Begin listening...");     
                // 开始监听     
                consumer.setMessageListener(this);  //(异步接收)   
    
                } catch (JMSException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }     
        }
    
        @Override
        public void onMessage(Message arg0) {
            // TODO Auto-generated method stub
            try{
                if(arg0 instanceof TextMessage)
                {   
                    TextMessage txtMsg = (TextMessage) arg0; 
                    System.out.println("consumer("+name+")异步 recive:"+txtMsg.getText());
                    Thread.sleep(500);
                }
            }catch(Exception e)
            {
                e.printStackTrace();
            }
    
        }
        public void submit() throws JMSException
        {
            session.commit();
        }
         // 关闭连接     
        public void close() throws JMSException {     
            System.out.println("Consumer:->Closing connection");     
            if (consumer != null)     
                consumer.close();     
            if (session != null)     
                session.close();     
            if (connection != null)     
                connection.close();     
        } 
    
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87

    测试类:TestActiveMqQueue.java

    package com.css.sword.service;
    
    import javax.jms.JMSException;
    
    public class TestActiveMqQueue {
    
        public static void main(String[] args) throws InterruptedException, JMSException
    {
        ActivemqQueueProducer producer = new ActivemqQueueProducer();
        ActivemqQueueConsumer consumer = new ActivemqQueueConsumer("1");
        ActivemqQueueConsumerAsyn consumer1 = new ActivemqQueueConsumerAsyn("2");
            producer.initialize();
    
    
            Thread.sleep(500);   
            for(int i=0;i<5;i++)
            {
                producer.sendText("Hello, world!"+i); 
            }
    
            //producer.submit();//如果开启事务需使用
           // producer.close();
            System.out.println("consumer1开始监听");
            consumer.recive();
            consumer.close();
            System.out.println("consumer1接收完毕!");
    
    
            for(int i=0;i<10;i++)
            {
                producer.sendText("Hello, world!"+i); 
            }
            //producer.submit();//如果开启事务需使用
            System.out.println("consumer2开始监听");
            consumer1.recive();
            System.out.println("consumer2接收完毕!");
    
        }
    
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41

    6、结果 
    可以看到程序先向队列发送5条记录,如果同步接收类中的循环条件记录大于5和等于5,可看到如下结果: 
    同步 
    异步 
    可明显看出大于5时,消费者阻塞等待接收,而异步则不阻塞,可进行其它业务。 
    事务的控制语句为: session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);如果是false表示不支持事务,如果是true表示支持事务。如果支持事务则需submit提交,否则不入队列。可通过控制台观察结果 
    提交前
    提交后
    每一项的说明如下: 
    Number Of Consumers 消费者 这个是消费者端的消费者数量

    Number Of Pending Messages 等待消费的消息 这个是当前未出队列的数量。可以理解为总接收数-总出队列数 
    Messages Enqueued 进入队列的消息 进入队列的总数量,包括出队列的。 这个数量只增不减 
    Messages Dequeued 出了队列的消息 可以理解为是消费这消费掉的数量 。 
    7、遇到的问题 
    启动mq的时候没报错但也没成功,可能的原因: 
    (1) 注意jdk和activemq版本兼容问题; 
    (2) 注意jvm虚拟内存小的问题; 

    转自:http://blog.csdn.net/asdfsadfasdfsa/article/details/53583741

    展开全文
  • 基本的配置直接看QT的示例代码就行了,接收的时候分同步接收和异步接收。 异步接收: //.h中声明 QByteArray rxData; //cpp构造函数中绑定接收事件 connect(serial0, &QSerialPort::readyRead, this, &...

    串口用了无数次,没想到到QT这蹩脚了。基本的配置直接看QT的示例代码就行了,接收的时候分同步接收和异步接收。

    异步接收:

    //.h中声明
    QByteArray rxData;
    
    //cpp构造函数中绑定接收事件
    connect(serial0, &QSerialPort::readyRead, this, &SerialBoard::readData);
    
    //直接读取全部数据
    void SerialBoard::readData()
    {
        rxData = serial0->readAll();
    } 

    异步有个问题,当数据较多时,readAll不能一次全读完,因为接收数据也需要时间,但是readyRead不能设置触发阈值,接收到数据就触发readData事件了。

    QT示例中又block传输方法,在单独线程中

    
     
    while (serial.waitForReadyRead(10))
         responseData += serial.readAll();

    嗯,不错,但感觉这只适合传输文件之类的,当进入readData槽后再wait时有新的数据进来就不会再次触发槽函数,而是wait返回true接收数据,没数据后只能等wait 10ms超时后返回false才返回,显然有点拖慢系统的速度。我的协议中只是有些命令数据稍大,看了看别人的例子,可以用阻塞和非阻塞接收数据。阻塞就是加延时,然后再读数。我采用加定时器同步接收

     

    
     
        //.h中加一个
    QTimer *rxTimer;
    //cpp构造函数中增加定时器初始化,单次定时,超时触发槽函数,槽函数自己注册
        connect(serial0, &QSerialPort::readyRead, this, &SerialBoard::readData);
        rxTimer = new QTimer(this);
        QObject::connect( rxTimer, &QTimer::timeout,this,&SerialBoard::CheckData);
        rxTimer->setSingleShot(true);
        rxTimer->setInterval(0);

     

    
     

     

    void SerialBoard::readData()
    {
        //数据追加
        rxData += serial0->readAll();
        //rxTimer->setInterval(0);
        //开启10ms定时器,10ms内没再次接收到数据就超时了
        rxTimer->start(10);
    
     
    }
    void SerialBoard::CheckData()
    {
        //超时,表示此次传输完成,开始处理数据包,这里是校验接收的数据是否正确,然后将结果用回调方式传出去
        rxTimer->stop();
        errordata=0;
        if(rxData.size() != TESTSIZE)
        {
           errordata = TESTSIZE - rxData.size();
        }
        qDebug() << "serial0 Data size " + QString::number(rxData.length(),10);
        for(int i=0;i<rxData.size();i++)
        {
            if(rxData[i] != (char)(i&0xFF))
            {
                errordata++;
            }
        }
        m_psink->OnReaddataFinished("serial0 rx/total:"+QString::number(errordata,10)+"/" + QString::number(TESTSIZE,10)+"\n");
    }

    暂时先这么用着,感觉还有点不完美,以后再追加。

    =继续补充==================================================================================

    在使用中发现 串口缓冲区并没有起到作用

    serial0->setReadBufferSize(2000);

    设置的2000个字节缓冲,事实没有read完数据,后面的数据会丢掉很多,可能底层驱动没做内存缓冲,硬件FIFO肯定比较小了。

    于是槽函数做缓冲,数据处理定时处理。

    connect(serial0, &QSerialPort::readyRead, this, &SerialTelephone::readData);

        //100ms定时器---------------------------------------------------
        m_pTimer = new QTimer(this);
        connect(m_pTimer, SIGNAL(timeout()), this, SLOT(Timer1Handle()));
        m_pTimer->start(100);

    void SerialTelephone::readData()
    {
        rxData += serial0->readAll();
    //    QString text = "telephone board rx: ";
    //    QByteArray str = rxData.toHex().toUpper();
    //    for(int i = 0; i < str.size(); i+=2)
    //        text = text + " 0x" + str.at(i) + str.at(i+1);
    //    qDebug() << text;

        timeoutCount++;
    }

    void SerialTelephone::Timer1Handle()
    {
        if(timeoutCount > 0)
        {
            while(0 == decode(rxData));

        }
    }

    decode处理数据时,需要拆包处理,因为100ms可能收到多个数据包,有不完整的数据包时需要剔除数据,配合协议来完善,例如经典的使用0x7E包头,内容0x7D 0x5E替换0x7E,0x7D 0x5D 替换0x7D。

     

     

     

     

     

    展开全文
  • 1.异步接收,主要设置messageListener。,然后编写onmessage方法,很简单 a.客户端发送5条消息 1 package ch02.chat; 2 3 import javax.jms.JMSException; 4 5 public class ClientTest3 { 6 ...

    来点实在的代码,用例子来说明:

    1.异步接收,主要设置messageListener。,然后编写onmessage方法,很简单

    a.客户端发送5条消息

     1 package ch02.chat;
     2 
     3 import javax.jms.JMSException;
     4 
     5 public class ClientTest3 {
     6 
     7     public static void main(String[] args) throws JMSException {
     8         // TODO Auto-generated method stub
     9         JMSTopic jt=new JMSTopic();
    10         jt.setSession();
    11         //发送5个消息到queue2
    12         for(int i=0;i<10;i++)
    13         {
    14             jt.writeMessage("queue2", "xo"+i,4);
    15             
    16         }
    17         
    18 
    19     }
    20 
    21 }
    View Code

    b.接收端接收5条消息

     1 package ch02.chat;
     2 
     3 import javax.jms.JMSException;
     4 import javax.jms.Message;
     5 import javax.jms.MessageListener;
     6 import javax.jms.TextMessage;
     7 
     8 public class ClientTest3Response {
     9     
    10 
    11     public static void main(String[] args) throws JMSException {
    12         // TODO Auto-generated method stub
    13         JMSTopic jt=new JMSTopic();
    14         jt.setSession();
    15         
    16         //异步接收信息,监听queue2
    17         
    18         System.out.println("异步接收前");
    19     
    20         
    21         
    22         jt.receiveMsg("queue2", new  MessageListener() {
    23             
    24             @Override
    25             //当topic, queue2中有信息的时候
    26             public void onMessage(Message message) {
    27                 
    28                 TextMessage mm=(TextMessage)message;
    29                 try {
    30                     System.out.println("接收到信息"+mm.getText());
    31                 } catch (JMSException e) {
    32                     // TODO Auto-generated catch block
    33                     e.printStackTrace();
    34                 }
    35                 
    36             }
    37         });
    38         
    39         System.out.println("异步接收后");
    40         
    41         }
    42     }
    View Code

    执行结果如下:

    异步接收前
    异步接收后
    接收到信息xo0
    接收到信息xo1
    接收到信息xo2
    接收到信息xo3
    接收到信息xo4
    接收到信息xo5
    接收到信息xo6
    接收到信息xo7
    接收到信息xo8
    接收到信息xo9

     

    同步的以后再写好累。

    转载于:https://www.cnblogs.com/hansongjiang/p/4077270.html

    展开全文
  • 同步通信和异步通信区别

    千次阅读 2020-08-27 21:57:32
    异步通信时不要求接收端时钟发送端时钟同步,发送端发送完一个字节后,可经过任意长的时间间隔再发送下一个字节。 2.同步通信效率高;异步通信效率较低。 3.同步通信较复杂,双方时钟的允许误差较小;异步通信...
  • 区别:1、异步复制是Master将事件写入binlog,自身并不知道slave是否...相关学习推荐:mysql教程(视频)mysql同步复制和异步复制的区别:异步复制MySQL复制默认是异步复制,Master将事件写入binlog,提交事务,自身并...
  • 区别:1、异步复制是Master将事件写入binlog,自身并不知道slave是否...相关学习推荐:mysql教程(视频)mysql同步复制和异步复制的区别:异步复制MySQL复制默认是异步复制,Master将事件写入binlog,提交事务,自身并...
  • 同步通信和异步通信

    万次阅读 2018-09-02 09:53:14
    异步通信时不要求接收端时钟发送端时钟同步,发送端发送完一个字节后,可经过任意长的时间间隔再发送下一个字节。 同步通信效率高;异步通信效率较低。 同步通信较复杂,双方时钟的允许误差较小;异步通信简单,...
  • 同步通信和异步通讯

    2019-06-20 15:31:39
    异步通信时不要求接收端时钟发送端时钟同步,发送端发送完一个字节后,可经过任意长的时间间隔再发送下一个字节。 同步通信效率高;异步通信效率较低。 同步通信较复杂,双方时钟的允许误差较小;异步通信简单,...
  • 同步通信 异步通信 异步通信:通信双方始终允许存在一定误差; 同步通信:双方始终的允许误差较小 Sap 系统中的同步通信 异步通信 同步通信: 是指一次性的功能调用,即当调用者向被调用方发送请求时,...
  • 同步请求和异步请求的区别

    千次阅读 2019-04-01 08:50:15
    同步请求和异步请求的区别 先解释一下同步和异步的概念 同步是指:发送方发出数据后,等接收方发回响应以后才发下一个数据包的通讯方式。 异步是指:发送方发出数据后,不等接收方发回响应,接着发送下个数据包...
  • Java中交互方式分为同步和异步两种,同步交互指发送一条请求,需要等待返回,然后才能够发送下一条请求,有一个等待过程。(请求状态一致,数据状态一致;页面整体刷新,同步在后台处理结束后需要重新刷新或转发处理...
  • 同步请求和异步请求

    2019-09-28 15:23:15
    同步请求:发送方发送数据后,等接收方回响应以后才发下一个数据包通讯方式。 异步请求:发送方发送数据后,不等接收方回响应就发送下一个数据包通讯。 转载于:...
  • 同步传输和异步传输

    2018-05-17 09:57:14
    每次异步传输的信息都以一个起始位开头,它通知接收方数据已经到达了,这就给了接收方响应、接收和缓存数据比特的时间;在传输结束时,一个停止位表示该次传输信息的终止。异步传输的实现比较容易,由于每...
  • 同步通讯和异步通讯

    千次阅读 2010-10-18 09:11:00
    同步通信和异步通信 串行通信的数据是逐位传送的,发送方发送的每一位都具有因定的时间间隔,这就要求接收方也要按照发送方同样的时间间隔来接收每一位。不仅如此,接收方还要确定一个信息组的开始和结束。为此,...
  • 为了正确的解释信号,接收方必须确切地知道信号应当何时接收和处理,因此定时是至关重要的。 在计算机网络中,定时的因素称为位同步同步是要接收方按照发送方发送的每个位的起止时刻和速率来接收数据,否则会产生...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,475
精华内容 990
关键字:

同步接收和异步接收