精华内容
下载资源
问答
  • 基本的配置直接看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。

     

     

     

     

     

    展开全文
  • Q:什么是同步逻辑和异步逻辑? A:同步逻辑是时钟之间有固定的因果关系;异步逻辑是各时钟之间没有固定的因果关系。 Q:什么是同步电路和异步电路? A:同步电路:存储电路中所有触发器的时钟输入端都接同一...

    Q:什么是同步逻辑和异步逻辑?

    A:同步逻辑是时钟之间有固定的因果关系;异步逻辑是各时钟之间没有固定的因果关系。

     

    Q:什么是同步电路和异步电路?

    A:同步电路:存储电路中所有触发器的时钟输入端都接同一时钟脉冲源,因而所有触发器的状态变化都与所加的时钟脉冲信号同步;

          异步电路:电路中没有统一的时钟,有些触发器的时钟输入端与时钟脉冲源相连,这些触发器的状态变化与时钟脉冲同步,而其它触发器的状态变化不与时钟脉冲同步。

     

    同步就是双方有一个共同的时钟,当发送时,接收方同时准备接收;

    异步双方不需要共同的时钟,也就是接收方不知道对方什么时候发送,所以在发送信息中就要有提示接收方开始接收的信息,如开始位,结束时有停止位。

     

    展开全文
  • 在学习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

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

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

    首先是两者的不同

    • 同步通信要求接收端时钟频率和发送端时钟频率一致,发送端发送连续的比特流;异步通信时不要求接收端时钟和发送端时钟同步,发送端发送完一个字节后,可经过任意长的时间间隔再发送下一个字节。
    • 同步通信效率高;异步通信效率较低。
    • 同步通信较复杂,双方时钟的允许误差较小;异步通信简单,双方时钟可允许一定误差。
    • 同步通信可用于点对多点;异步通信只适用于点对点。

    异步通信

    异步通信中的接收方并不知道数据什么时候会到达,收发双方可以有各自自己的时钟。发送方发送的时间间隔可以不均,接收方是在数据的起始位和停止位的帮助下实现信息同步的。这种传输通常是很小的分组,比如一个字符为一组,为这个组配备起始位和结束位。所以这种传输方式的效率是比较低的,毕竟额外加入了很多的辅助位作为负载,常用在低速的传输中。

    以RS232协议规定为例,异步通信一个字符一个字符地传输,每个字符一位一位地传输,并且传输一个字符时,总是以“起始位”开始(低电平,逻辑值0),以“停止位”结束,字符之间没有固定的时间间隔要求。字符数据本身由5~8位数据位组成,接着字符后面是一位校验位(也可以没有校验位),最后是一位或一位半或二位停止位,停止位后面是不定长的空闲位。停止位和空闲位都规定为高电平(逻辑值1),这样就保证起始位开始处一定有一个下跳沿,

    举个例子,我们的键盘按下一个按键,发出一个字符信号,异步传输机制就会为它加上前后的辅助同步信息,帮助接收方识别到我们按下了哪一个按键。因为我们敲击键盘的节奏不固定,所以异步是一种很适合的方式

    同步通信

    同步通信中双方使用频率一致的时钟 ,它的分组相比异步则大得多,称为一个数据帧,通过独特的bit串作为启停标识。发送方要以固定的节奏去发送数据,而接收方要时刻做好接收数据的准备,识别到前导码后马上要开始接收数据了。同步这种方式中因为分组很大,很长一段数据才会有额外的辅助位负载,所以效率更高,更加适合对速度要求高的传输,当然这种通信对时序的要求也更高。
    同步通信是一种连续串行传送数据的通信方式,一次通信只传送一帧信息,由同步字符、数据字符和校验字符(CRC)组成。

    展开全文
  • 同步请求和异步请求的区别

    千次阅读 2019-04-01 08:50:15
    同步请求和异步请求的区别 先解释一下同步和异步的概念 同步是指:发送方发出数据后,等接收方发回响应以后才发下一个数据包的通讯方式。 异步是指:发送方发出数据后,不等接收方发回响应,接着发送下个数据包...
  • 同步通信是按照软件识别同步字符来实现数据的发送和接收异步通信是一种利用字符的再同步技术的通信方式。  同步通信  同步通信是一种连续串行传送数据的通信方式,一次通信只传送一帧信息。这里的信息帧与异步...
  • 同步通信和异步通信区别

    万次阅读 2020-08-27 21:57:32
    异步通信时不要求接收端时钟发送端时钟同步,发送端发送完一个字节后,可经过任意长的时间间隔再发送下一个字节。 2.同步通信效率高;异步通信效率较低。 3.同步通信较复杂,双方时钟的允许误差较小;异步通信...
  • 同步传输和异步传输的区别及优缺点同步传输以数据块为单位进行数据传输,数据块与数据块之间的时间间隔是固定的,每个数据块带有时序信息,接收方可以用时序信息进行校验。异步传输一般以字符为单位,接收方通过字符...
  • 同步通信和异步通讯

    2019-06-20 15:31:39
    异步通信时不要求接收端时钟发送端时钟同步,发送端发送完一个字节后,可经过任意长的时间间隔再发送下一个字节。 同步通信效率高;异步通信效率较低。 同步通信较复杂,双方时钟的允许误差较小;异步通信简单,...
  • 发送端可以在任意时刻开始发送字符,因此必须在每一个字符的开始结束的地方加上标志,即加上开始位停止位,以便使接收端能够正确地将每一个字符接收下来。异步通信的好处是通信设备简单、便宜,但传输效率较低...
  • 计算机网络 同步传输和异步传输

    千次阅读 2017-09-25 22:10:53
    为了正确的解释信号,接收方必须确切地知道信号应当何时接收和处理,因此定时是至关重要的。 在计算机网络中,定时的因素称为位同步同步是要接收方按照发送方发送的每个位的起止时刻和速率来接收数据,否则会产生...
  • 同步传输和异步传输

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

    千次阅读 2016-04-12 16:55:50
    同步,可以理解为在执行完一个函数或方法之后,一直等待系统返回值或消息,这时程序是出于阻塞的,只有接收到返回的值或消息后才往下执行其他的命令。 异步,执行完函数或方法后,不必阻塞性地等待返回值...
  • 为了正确的解释信号,接收方必须确切地知道信号应当何时接收和处理,因此定时是至关重要的。 在计算机网络中,定时的因素称为位同步同步是要接收方按照发送方发送的每个位的起止时刻和速率来接收数据,否则会产生...
  • 同步通讯和异步通讯

    千次阅读 2010-10-18 09:11:00
    同步通信和异步通信 串行通信的数据是逐位传送的,发送方发送的每一位都具有因定的时间间隔,这就要求接收方也要按照发送方同样的时间间隔来接收每一位。不仅如此,接收方还要确定一个信息组的开始结束。为此,...
  • IOS 同步请求和异步请求

    千次阅读 2013-12-27 08:34:29
    首先是 同步请求和异步请求 同步请求, 使用主线程一次性获得所有请求数据,这就导致一个比较容易出现的问题 当请求的数据比较大时,就会出现卡顿现象,也就是阻塞主线程,这对于 用户体验来说不太好 异步请求 ...
  • 通过ajax向后台发送和接收数据时,常常会出现同步异步问题。这篇文章给大家介绍Ajax同步和异步问题浅析,需要的朋友参考下
  • 利用socket实现服务端/客户端的通信,可参照本人博客:https://blog.csdn.net/s1314_JHC/article/details/80914044 包括以下功能: 1.服务端与客户端的同步收发 ...3.服务端异步接收多个客户端的数据

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 209,531
精华内容 83,812
关键字:

同步接收和异步接收