可嵌入式JMS消息队列FFMQ

最新推荐文章于 2024-08-14 20:05:38 发布
最新推荐文章于 2024-08-14 20:05:38 发布
阅读量1.5k 收藏 1
点赞数
分类专栏： 队列 文章标签： FIFO JMS 嵌入队列


经过几个开源项目比较，最终发现合适的项目FFMQ：http://sourceforge.net/projects/ffmq/，项目大小才600KB，支持JMS1.1规范。
以下代码仅用于供测试参考，不具备生产环境下的严谨，具体FFMQ配置请看说明文档(下载包中有)。

启动：

import java.io.FileInputStream;
import java.util.Properties;

import net.timewalker.ffmq3.listeners.ClientListener;
import net.timewalker.ffmq3.listeners.tcp.io.TcpListener;
import net.timewalker.ffmq3.local.FFMQEngine;
import net.timewalker.ffmq3.management.destination.definition.QueueDefinition;
import net.timewalker.ffmq3.management.destination.definition.TopicDefinition;
import net.timewalker.ffmq3.utils.Settings;

/**
 * Embedded FFMQ sample
 */
public class EmbeddedFFMQSample implements Runnable
{
    private FFMQEngine engine;
    
    public void run()
    {
        try
        {
            // Create engine settings
            Settings settings = createEngineSettings();
            
            // Create the engine itself
            engine = new FFMQEngine("myLocalEngineName", settings);
            // -> myLocalEngineName will be the engine name.
            // - It should be unique in a given JVM
            // - This is the name to be used by local clients to establish
            // an internal JVM connection (high performance)
            // Use the following URL for clients : vm://myLocalEngineName
            //
            
            // Deploy the engine
            System.out.println("Deploying engine : "+engine.getName());
            engine.deploy();
            // - The FFMQ engine is not functional until deployed.
            // - The deploy operation re-activates all persistent queues
            // and recovers them if the engine was not properly closed.
            // (May take some time for large queues)

            // Adding a TCP based client listener
            System.out.println("Starting listener ...");
            ClientListener tcpListener = new TcpListener(engine,"0.0.0.0",10002,settings,null);
            tcpListener.start();
            
            // This is how you can programmatically define a new queue
            if (!engine.getDestinationDefinitionProvider().hasQueueDefinition("foo1"))
            {
                QueueDefinition queueDef = new QueueDefinition(settings);
                queueDef.setName("foo2");
                queueDef.setMaxNonPersistentMessages(0);
                queueDef.setOverflowToPersistent(false);
                queueDef.setPreAllocateFiles(true);
                queueDef.setTemporary(false);
                queueDef.setUseJournal(true);
                queueDef.setAutoExtendAmount(128);
                queueDef.setInitialBlockCount(32);
                queueDef.setMaxBlockCount(1024);
                queueDef.check();
                engine.createQueue(queueDef);
            }
            
            // You could also define a queue using some java Properties
            if (!engine.getDestinationDefinitionProvider().hasQueueDefinition("foo2"))
            {
                Properties queueProps = new Properties();
                queueProps.put("name", "foo2");
                queueProps.put("persistentStore.useJournal", "false");
                queueProps.put("memoryStore.maxMessages", "1000");
                QueueDefinition queueDef2 = new QueueDefinition(new Settings(queueProps));
                engine.createQueue(queueDef2);
            }
            
            if(!engine.getDestinationDefinitionProvider().hasTopicDefinition("foox")) {
                TopicDefinition topicDef = new TopicDefinition(settings);
                topicDef.setName("foox");
                topicDef.setMaxNonPersistentMessages(0);
                topicDef.setOverflowToPersistent(false);
                topicDef.setPreAllocateFiles(true);
                topicDef.setTemporary(false);
                topicDef.setUseJournal(true);
                topicDef.check();
                engine.createTopic(topicDef);
            }
            
            // Run for some time
            System.out.println("Running ...");
            Thread.sleep(60*1000);
            
            // Stopping the listener
            System.out.println("Stopping listener ...");
            tcpListener.stop();
            
            // Undeploy the engine
            System.out.println("Undeploying engine ...");
            engine.undeploy();
            // - It is important to properly shutdown the engine 
            // before stopping the JVM to make sure current transactions 
            // are nicely completed and storages properly closed.
            
            System.out.println("Done.");
        }
        catch (Exception e)
        {
            // Oops
            e.printStackTrace();
        }
    }
    
    private Settings createEngineSettings()
    {
        // Various ways of creating engine settings
        
        // 1 - From a properties file
        Properties externalProperties = new Properties();
        try
        {
            FileInputStream in = new FileInputStream("D:\\ffmq3-distribution-3.0.5-dist\\conf\\ffmq-server.properties");
            externalProperties.load(in);
            in.close();
        }
        catch (Exception e)
        {
            throw new RuntimeException("Cannot load external properties",e);
        }
        Settings settings = new Settings(externalProperties);
        
        // 2 - Explicit Java code
// Settings settings = new Settings();
// 
// settings.setStringProperty(FFMQCoreSettings.DESTINATION_DEFINITIONS_DIR, ".");
// settings.setStringProperty(FFMQCoreSettings.BRIDGE_DEFINITIONS_DIR, ".");
// settings.setStringProperty(FFMQCoreSettings.TEMPLATES_DIR, ".");
// settings.setStringProperty(FFMQCoreSettings.DEFAULT_DATA_DIR, ".");
// ...
        
        return settings;
    }
    
    public static void main(String[] args)
    {
        System.setProperty("FFMQ_BASE", "D:\\ffmq3-distribution-3.0.5-dist");
        
        new EmbeddedFFMQSample().run();
    }
}


模拟发送:

import java.util.Hashtable;
import java.util.Random;

import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.MessageProducer;
import javax.jms.Queue;
import javax.jms.Session;
import javax.jms.TextMessage;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;

import net.timewalker.ffmq3.FFMQConstants;

public class Sender implements Runnable {

    public static void main(String[] args) throws Exception {
        new Thread(new Sender("queue/foo1", "1")).start();
        new Thread(new Sender("queue/foo2", "2")).start();
        Thread.sleep(10000);
        run = false;
        Thread.sleep(1000);
    }
    
    private static volatile boolean run = true;
    private String queueName;
    private String qtmId;

    private Sender(String queueName, String qtmId) {
        super();
        this.queueName = queueName;
        this.qtmId = qtmId;
    }

    @Override
    public void run() {
        try {
            // Create and initialize a JNDI context
            Hashtable<String,String> env = new Hashtable<>();
            env.put(Context.INITIAL_CONTEXT_FACTORY, FFMQConstants.JNDI_CONTEXT_FACTORY);
            env.put(Context.PROVIDER_URL, "tcp://localhost:10002");
            Context context = new InitialContext(env);

            // Lookup a connection factory in the context
            ConnectionFactory connFactory = (ConnectionFactory)context.lookup(FFMQConstants.JNDI_CONNECTION_FACTORY_NAME);

            // Obtain a JMS connection from the factory
            Connection conn = connFactory.createConnection("test","test");
            conn.start();
            
            Destination dest1=(Queue) context.lookup(queueName);

            Session session=conn.createSession(false,Session.AUTO_ACKNOWLEDGE);

            
            Random rnd = new Random(System.currentTimeMillis());
            long ms = (long)rnd.nextFloat() * 10 * 1000;
            if(ms > 8000) {
                ms /= 2;
            } else if(ms < 1000) {
                ms = 1500;
            }
            
            int i = 1;
            
            MessageProducer p = session.createProducer(dest1);
            while (run) {
                TextMessage msg = session.createTextMessage();
                String t = "[" + qtmId + "] Hello " + queueName + " " + i++;
                System.out.println("sended..." + t);
                msg.setStringProperty("QTMID", qtmId);
                msg.setText(t);
                p.send(msg);
                Thread.sleep(ms);
            }
            p.close();
            session.close();
            
            conn.close();
            context.close();
        } catch (NamingException e) {
            e.printStackTrace();
        } catch (JMSException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
    }

}

模拟接收：

import java.util.Hashtable;

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.Queue;
import javax.jms.Session;
import javax.jms.TextMessage;
import javax.naming.Context;
import javax.naming.InitialContext;

import net.timewalker.ffmq3.FFMQConstants;


public class Receiver implements Runnable {

    private static volatile boolean run = true;
    
    public static void main(String[] args) throws Exception {
        new Thread(new Receiver()).start();
        Thread.sleep(10000);
        run = false;
        Thread.sleep(2000);
    }
    
    private Connection conn;
    private Session session;
    private MessageConsumer consumer;
    
    private void init() throws Exception {
            // Create and initialize a JNDI context
            Hashtable<String,String> env = new Hashtable<>();
            env.put(Context.INITIAL_CONTEXT_FACTORY, FFMQConstants.JNDI_CONTEXT_FACTORY);
            env.put(Context.PROVIDER_URL, "tcp://localhost:10002");
            Context context = new InitialContext(env);
            
            // Lookup a connection factory in the context
            ConnectionFactory connFactory = (ConnectionFactory)context.lookup(FFMQConstants.JNDI_CONNECTION_FACTORY_NAME);
            Destination dest1=(Queue) context.lookup("queue/foo2");
            context.close();
            
            
            // Obtain a JMS connection from the factory
            conn = connFactory.createConnection("test", "test");
            
            conn.start();
            
            session = conn.createSession(false, Session.AUTO_ACKNOWLEDGE);
            consumer = session.createConsumer(dest1);
            
            System.err.println("INIT.........");
    }
    
    private void destory() {
        try {
            consumer.close();
            session.close();
            conn.stop();
            conn.close();
            System.err.println("EXIT........REC");
        } catch (JMSException e) {
            e.printStackTrace();
        }
    }

    public void run() {
            try {
                init();
                
//                consumer.setMessageListener(new MessageListener() {
//                    @Override
//                    public void onMessage(Message m) {
//                        try {
//                            System.err.println("receive: " + ((TextMessage) m).getText());
//                        } catch (JMSException e) {
//                            e.printStackTrace();
//                        }
//                    }
//                });
                while(run) {
//                    Thread.sleep(500);
                    Message m = consumer.receive(500);
                    if(m != null) {
                        System.err.println("receive: " + ((TextMessage) m).getText());
                    }
                }

            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                destory();
            }
        
    }

}

主题订阅：

package topic;

import java.util.Hashtable;

import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageListener;
import javax.jms.Session;
import javax.jms.TextMessage;
import javax.jms.Topic;
import javax.jms.TopicConnection;
import javax.jms.TopicConnectionFactory;
import javax.jms.TopicSession;
import javax.jms.TopicSubscriber;
import javax.naming.Context;
import javax.naming.InitialContext;

import net.timewalker.ffmq3.FFMQConstants;

public class SubClient implements Runnable {

    private String topicName;
    private String qtmId;
    private TopicConnection conn;
    private TopicSession session;    
    private TopicSubscriber subscriber;
    
    public static void main(String[] args) throws Exception {
        for(int i = 1; i < 5; i++) {
            new Thread(new SubClient("topic/foox", String.valueOf(i))).start();
        }
        System.out.println(Thread.currentThread() + " EEXIT");
    }
    
    private SubClient(String topicName, String qtmId) {
        super();
        this.topicName = topicName;
        this.qtmId = qtmId;
    }

    private void init() throws Exception {
        // Create and initialize a JNDI context
        Hashtable<String,String> env = new Hashtable<>();
        env.put(Context.INITIAL_CONTEXT_FACTORY, FFMQConstants.JNDI_CONTEXT_FACTORY);
        env.put(Context.PROVIDER_URL, "tcp://localhost:10002");
        Context context = new InitialContext(env);
        
        // Lookup a connection factory in the context
        TopicConnectionFactory connFactory = (TopicConnectionFactory)context.lookup(FFMQConstants.JNDI_TOPIC_CONNECTION_FACTORY_NAME);
        Topic topic = (Topic) context.lookup(topicName);
        context.close();
        
        // Obtain a JMS connection from the factory
        conn = connFactory.createTopicConnection("test","test");
        
        session = conn.createTopicSession(false, Session.AUTO_ACKNOWLEDGE);
        String selector = "(QTMID = '" + qtmId + "')";
        System.out.println("Selector: " + selector);
        subscriber = session.createSubscriber(topic, selector, false);
        
        System.err.println("INIT.........");
    }
    
    private void destory() {
        try {
            subscriber.close();
            session.close();
            conn.stop();
            conn.close();
            System.err.println(Thread.currentThread() + " Client EXIT........REC");
        } catch (JMSException e) {
            e.printStackTrace();
        }
    }
    
    @SuppressWarnings("static-access")
    @Override
    public void run() {
        try {
            init();
            
            subscriber.setMessageListener(new MessageListener() {
                @Override
                public void onMessage(Message m) {
                    try {
                        System.err.println(Thread.currentThread() + " Client " + qtmId + " Subscriber receive: " + ((TextMessage) m).getText());
                    } catch (JMSException e) {
                        e.printStackTrace();
                    }
                }
            });
            
            conn.start();
            
            Thread.currentThread().sleep(10000);
    
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            destory();
        }
    
    }

}

持久订阅：

package topic;

import java.util.Hashtable;

import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageListener;
import javax.jms.Session;
import javax.jms.TextMessage;
import javax.jms.Topic;
import javax.jms.TopicConnection;
import javax.jms.TopicConnectionFactory;
import javax.jms.TopicSession;
import javax.jms.TopicSubscriber;
import javax.naming.Context;
import javax.naming.InitialContext;

import net.timewalker.ffmq3.FFMQConstants;

public class SubServer implements Runnable {

    private String topicName;
    
    /**
     * @param args
     */
    public static void main(String[] args) throws Exception {
        new Thread(new SubServer("topic/foox")).start();
        System.out.println(Thread.currentThread() + " main exit");
    }

    private TopicConnection conn;
    private TopicSession session;    
    private TopicSubscriber subscriber;
    
    
    
    private SubServer(String topicName) {
        super();
        this.topicName = topicName;
    }

    private void init() throws Exception {
            // Create and initialize a JNDI context
            Hashtable<String,String> env = new Hashtable<>();
            env.put(Context.INITIAL_CONTEXT_FACTORY, FFMQConstants.JNDI_CONTEXT_FACTORY);
            env.put(Context.PROVIDER_URL, "tcp://localhost:10002");
            Context context = new InitialContext(env);
            
            // Lookup a connection factory in the context
            TopicConnectionFactory connFactory = (TopicConnectionFactory)context.lookup(FFMQConstants.JNDI_TOPIC_CONNECTION_FACTORY_NAME);
            Topic topic = (Topic) context.lookup(topicName);
            context.close();
            
            // Obtain a JMS connection from the factory
            conn = connFactory.createTopicConnection("test","test");
            conn.setClientID("SERVER");
            
            session = conn.createTopicSession(false, Session.AUTO_ACKNOWLEDGE);            
            subscriber = session.createDurableSubscriber(topic, "DB");            
            System.out.println("INIT........." + subscriber);
    }
    
    private void destory() {
        try {
            subscriber.close();
            session.close();
            conn.stop();
            conn.close();
            System.err.println(Thread.currentThread() + " EXIT........REC");
        } catch (JMSException e) {
            e.printStackTrace();
        }
    }
    
    @SuppressWarnings("static-access")
    @Override
    public void run() {
        try {
            init();
            
            subscriber.setMessageListener(new MessageListener() {
                @Override
                public void onMessage(Message m) {
                    try {
                        System.err.println(Thread.currentThread() + " DurableSubscriber receive: " + ((TextMessage) m).getText());
                    } catch (JMSException e) {
                        e.printStackTrace();
                    }
                }
            });
    
            conn.start();
            
            Thread.currentThread().sleep(10000);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            destory();
        }
    
    }
}





kefon
关注
专栏目录
jms的一些实现
yandao的博客
09-09 639
JMS JMS实现（Provider implementations） 要使用JMS，必须要有相应的实现来管理session以及队列，从Java EE1.4开始，所有的Java EE应用服务器必须包含一个JMS实现。 以下是一些JMS实现： JMS服务提供者 JMS产品 简述 Apache ActiveMQ ActiveMQ是Apache下的开源项目，完全支持JMS1.1和J2EE1.4规范的JMS Provider实现。 Apache kafka Kafka是Apache下的一个子项目
RPC,RMI,CORBA,DCOM,SOAP,JMS及JMS的实现（通讯）
daiyuntao841226的专栏
06-23 988
RMI 和 RPC均可以均提供远程方法访问的基础通信和参数引用要求的串行化机制，RPC和RMI之间的一个重要差别是RPC用快速而不够可靠的UDP协议， RMI用低速而可靠的TCP/IP协议。另外 RMI 调用远程对象方法，允许方法返回 Java 对象以及基本数据类型。而 RPC 不支持对象的概念， 传送到 RPC 服务的消息由外部数据表示 (External Data Representati
FFMQ-开源
04-24
[移至GITHUB] https://github.com/timewalker74/ffmq FFMQ是全Java，轻量级和超快速的JMS 1.1服务器。
java 可嵌入消息队列_javajuc消息队列，java并发包消息队列详解
weixin_34206263的博客
02-25 367
之前给大家介绍一下什么是javajuc，那么接下来要介绍的就是javajuc消息队列方面的内容，一起来了解一下吧。消息队列经常用于有生产者和消费者两类角色的多线程同步场景，BlockingQueue也是java.util.concurrent下的主要用来控制线程同步的工具，主要的方法就是put、take一对阻塞存取；add、poll一对非阻塞存取，下面来看看详细介绍。1、插入add(anObjec...
嵌入式-消息队列
最新发布
m0_74969398的博客
08-14 219
1.设计一个消息队列程序,发送时,通过键盘来指定消息标识。接收时,通过键盘来指定要接收的消息。msg_snd.c文件。msg_rcv.c文件。
java嵌入式持久化消息队列SMQ，改造自FQueue
ma_nong33的博客
02-15 774
之前项目中一直使用ConcurrentLinkedQueue做为缓冲队列（主要是单个项目内，单条改批量的场景，多个项目间使用的是rocketmq），虽然用着方便但是是纯内存的，SMQ使用时只有三个方法，向队列放入数据、从队列取出数据、获取队列大小（一般只在监控队列是否积压时使用，判断队列是否有数据，使用获取队列数据是否为null进行判断）。4、添加了内存队列，这个主要解决同一个机器创建了大量队列（上千）时，队列消息消费较快，因为使用了内存映射磁盘（每隔10ms就会调用force()同步磁盘），
JAVA消息队列-JMS
weixin_40213204的博客
04-19 274
首先要知道什么是JMS 1、JMS是啥 JMS 全称叫 Java Message Service ,也就是Java消息系统应用程序接口，是一个Java平台中关于面向消息中间件（MOM）的API，用于两个应用程序之间，或分布式系统中发送消息，进行异步通信。Java消息服务是一个与具体平台无关的API，绝大多数MOM提供商都对JMS提供支持（百度是这么说的）。 简单来说：两个应用程序之间需要进...
Task5 | CFA (Amos+Mplus) | 五因素心智觉知度量表：正念是什么？
feihuanwuying的博客
01-28 7096
验证性因子分析：五因素心智觉知度量表（FFMQ）1 文章介绍及背景 1 文章介绍及背景 Observe：FFMQ1 + FFMQ6 + FFMQ11 + FFMQ15 + FFMQ20 + FFMQ26 + FFMQ31 + FFMQ36 Describe：FFMQ2 + FFMQ7 + FFMQ12 + FFMQ16 + FFMQ22 + FFMQ27 + FFMQ32 + FFMQ37 Act...
嵌入式实验（消息队列）
07-08
#include #include #include "vxWorks.h" #include "msgQLib.h" #include "taskLib.h" /*#include "memPartLib.h"*/ #include "memLib.h" /*宏定义*/ #define MAX_MSGS (10) /* the length of msg*/ #define MAX_MSG_LEN sizeof(MESSAGE) /*the length of message*/ #define STACK_SIZE 20000 /*the stack size of task*/ #define DELAY_TICKS 50 /*the time of sending message*/ #define MAX_point 5 /*用户从系统内存池中获得内存的最大次数*/ #define size_1 30 /*用户分区的分配的大小*/ #define size_2 40 /*全局变量*/ int tidtask1; int tidtask2; int tidtask3; SEM_ID syncSemId; SEM_ID waitSemId; MSG_Q_ID myMsgQId1; MSG_Q_ID myMsgQId2; MSG_Q_ID myMsgQId3; typedef struct _MESSAGE { int mSendId; /*发送任务 ID*/ int mRecvId; /*接收任务 ID*/ int mData; /*消息中传递的数据*/ char Data[14]; } MESSAGE; /*内存管理*/ char* usermem1; char* usermem2; MESSAGE *point1[MAX_point]; MESSAGE *point2[MAX_point]; MESSAGE *point3[MAX_point]; int point1_index=0; int point2_index=0; int point3_index=0; PART_ID partid1; PART_ID partid2; #define MID_MESSAGE(id) (id) /*函数声明*/ int start(void); int task1(void); int task2(void); int task3(void); template T* mymalloc(unsigned nBytes); void myfree(void); void bye(void); /***************************************[progStart]*******************************************/ /*启动程序，创建息队例，任务*/ int start(void) { tidtask1=taskSpawn("tTask1", 220, 0, STACK_SIZE, (FUNCPTR)task1,0,0,0,0,0,0,0,0,0,0); usermem1=malloc(200); partid1=memPartCreate(usermem1,200); usermem2=malloc(400); partid2=memPartCreate(usermem2,400); return; } /**************************************[test_end]********************************************/ /*是否相等，相等返回1*/ int test_end(char *end,char *target) { int ret; if(!strcmp(end,target)) ret=1; else ret=0; return ret; } /****************************************[task1]***********************************************/ /*管理Task。负责系统启动时同步系统中其他Task的启动同步，利用信号量的semFlush()完成。同时接收各*/ /*Task的告警信息，告警信息需编号以logmsg方式输出。本task负责系统结束时的Task删除处理*/ int task1(void) { int singal; int message; MESSAGE *rxMsg=mymalloc(26); /*define messages,and alloc memory*/ memset(rxMsg,0,26); syncSemId=semBCreate(SEM_Q_FIFO,SEM_EMPTY); /*creat semaphore*/ waitSemId=semBCreate(SEM_Q_PRIORITY,SEM_EMPTY); myMsgQId1=msgQCreate(MAX_MSGS,MAX_MSG_LEN,MSG_Q_PRIORITY); /*create msgQ*/ myMsgQId2=msgQCreate(MAX_MSGS,MAX_MSG_LEN,MSG_Q_PRIORITY); myMsgQId3=msgQCreate(MAX_MSGS,MAX_MSG_LEN,MSG_Q_PRIORITY); tidtask2=taskSpawn("tTask2", 200, 0, STACK_SIZE, (FUNCPTR)task2,0,0,0,0,0,0,0,0,0,0); /*create task*/ tidtask3=taskSpawn("tTask3", 210, 0, STACK_SIZE, (FUNCPTR)task3,0,0,0,0,0,0,0,0,0,0); printf("Please input one of the following commands:add,sub,multiply,divide,testcommand\n"); /*the command we should put into the console*/ semFlush(syncSemId); /*release semaphore*/ semGive(waitSemId); while(1) { singal=1; msgQReceive(myMsgQId1,(char*)&rxMsg,sizeof(rxMsg),WAIT_FOREVER); if(rxMsg->mRecvId==MID_MESSAGE(3)) /*receive MsgQ from task3*/ { singal=test_end(rxMsg->Data,"wrong length")-1; logMsg("task3 receiveing a:%s\n",rxMsg->Data); /*put the warn from task3*/ logMsg("Please reput the other command!\n"); msgQReceive(myMsgQId1,(char*)&rxMsg,MAX_MSG_LEN,WAIT_FOREVER); /*recive MsgQ from task3*/ } if(rxMsg->mRecvId==MID_MESSAGE(2)) /*receive MsgQ from task2*/ { message=test_end(rxMsg->Data,"sysend"); if(message) { /*if the message from task2 is "sysend" and did not receive the warn from task3, close the system*/ if(singal) { bye(); } } else {/*if the message from task2 is "sysend" and receive the warn from task3, reput the command*/ if(singal) logMsg("task2 receiveing a %s\n",rxMsg->Data); logMsg("please reput the correct command!\n"); } } } return; } /********************************************************************************************/ int change_buf(char *command) { int ret; if(!strcmp(command,"add")) ret=1; else if(!strcmp(command,"sub")) ret=2; else if(!strcmp(command,"multiply")) ret=3; else if(!strcmp(command,"divide")) ret=4; else if(!strcmp(command,"testcommand")) ret=5; else ret=0; return ret; } /****************************************[task2]*********************************************/ /*console 命令行接收Task。接收并分析console发来的命令行及参数。自行设置5种以上命令，并根据命*/ /*令的内容向Task3发送激励消息。同时实现系统退出命令，使系统采用适当方式安全退出。收到非法命令*/ /*向Task1告警*/ int task2(void) { char buf[100]; int command; char *str=mymalloc(35); MESSAGE *txMsg=mymalloc(26); memset(str,0,35); memset(txMsg,0,26); txMsg->mSendId=MID_MESSAGE(2); txMsg->mRecvId=MID_MESSAGE(2); FOREVER { semTake(syncSemId,WAIT_FOREVER); semTake(waitSemId,WAIT_FOREVER); gets(buf); command=change_buf(buf);/*change the commands into numbers*/ switch(command) { case 0:/*receive uncorrect command*/ txMsg->mData=0; strcpy(txMsg->Data,"wrong command");/*send warn to task1*/ msgQSend(myMsgQId1,(char*)&txMsg,sizeof(txMsg),WAIT_FOREVER,MSG_PRI_NORMAL); break; case 1:/*receive add command*/ strcpy(str,"This an add caculate!\0"); txMsg->mData=1; break; case 2:/*receive sub command*/ strcpy(str,"This a sub caculate!\0"); txMsg->mData=2; break; case 3:/*receive multiply command*/ strcpy(str,"This a multiply caculate!\0"); txMsg->mData=3; break; case 4:/*receive divide command*/ strcpy(str,"This a divide caculate!\0"); txMsg->mData=4; break; case 5:/*receive testcommand,send a long string to task3*/ strcpy(str,"This a testcommand to warn task1!\0"); txMsg->mData=5; break; default: break; } if(txMsg->mData!=0) {/*send along string to task3,and send a message to taks3*/ msgQSend(myMsgQId3,(char*)&str,sizeof(str),WAIT_FOREVER,MSG_PRI_NORMAL); msgQSend(myMsgQId3,(char*)&txMsg,sizeof(txMsg),WAIT_FOREVER,MSG_PRI_NORMAL); } semGive(waitSemId); semGive(syncSemId); taskDelay(DELAY_TICKS); if(txMsg->mData!=0) {/*send sysend to task1 to let task1 close system*/ strcpy(txMsg->Data,"sysend"); msgQSend(myMsgQId1,(char*)&txMsg,sizeof(txMsg),WAIT_FOREVER,MSG_PRI_NORMAL); } } return; } /****************************************[task3]********************************************/ /*console输出Task。接收需打印输出的字串消息（命令），输出到console。收到长度为0或超常字串向*/ /*Task1告警*/ int task3(void) { int firstData=100; int secondData=10; MESSAGE *rxMsg=mymalloc(26); MESSAGE *txMsg=mymalloc(26); char *rstr=mymalloc(35); memset(txMsg,0,26); memset(txMsg,0,26); memset(rstr,0,35); txMsg->mSendId=MID_MESSAGE(3); txMsg->mRecvId=MID_MESSAGE(3); while(1) { semTake(syncSemId,WAIT_FOREVER); msgQReceive(myMsgQId3,(char*)&rstr,sizeof(rstr),WAIT_FOREVER); if(strlen(rstr)=26) {/*make sure whether the string is too long or short*/ strcpy(txMsg->Data,"wrong length"); msgQSend(myMsgQId1,(char*)&txMsg,sizeof(txMsg),WAIT_FOREVER,MSG_PRI_NORMAL); /*msgQReceive(myMsgQId3,(char*)&rxMsg,sizeof(rxMsg),WAIT_FOREVER);*/ } semTake(waitSemId,WAIT_FOREVER); msgQReceive(myMsgQId3,(char*)&rxMsg,sizeof(rxMsg),WAIT_FOREVER); if(rxMsg->mData!=5) {/*when it is not testcommand,printf these*/ printf("%s\n",rstr); printf("there are two datas!\n"); printf("firstData:100\n"); printf("secondData:10\n"); } switch(rxMsg->mData) { case 1:/*printf add caculate*/ printf("The result is:%d\n",firstData+secondData); break; case 2:/*printf sub caculate*/ printf("The result is:%d\n",firstData-secondData); break; case 3:/*printf multiply caculate*/ printf("The result is:%d\n",firstData*secondData); break; case 4:/*printf divide caculate*/ printf("The result is:%d\n",firstData/secondData); break; case 5: break; default: break; } semGive(waitSemId); semGive(syncSemId); taskDelay(DELAY_TICKS); } return; } template T* mymalloc(unsigned nBytes) { T* point; int i=0; /*用户分区一是否能分配的标志位*/ int j=0; /*用户分区二是否能分配的标志位*/ if(nBytes=size_1 && nBytes=size_2) && point3_index<MAX_point) /*若用户分区二不能分配，由系统内存池来分配，且只能从系统内存池中分配MAX_point次*/ { point=malloc(nBytes); point3[point3_index]=point; printf("the number of the point3_index is:%d\n",point3_index); point3_index++; } return point; } void myfree(void) { int i=0; for (i=0;i<point1_index;i++) { memPartFree(partid1,point1[i]); } for (i=0;i<point2_index;i++) { memPartFree(partid2,point2[i]); } for (i=0;i<point3_index;i++) { free(point3[i]); } free(usermem1); free(usermem2); printf("The memory have freed!\n"); } void bye(void) { myfree(); logMsg("Bye-bye\n"); taskDelete(tidtask2); taskDelete(tidtask3); msgQDelete(myMsgQId1); msgQDelete(myMsgQId2); msgQDelete(myMsgQId3); semDelete(syncSemId); taskDelete(tidtask1); }
嵌入式消息队列artemis
weixin_43964005的博客
07-19 992
1.依赖引入 <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <!-- springboot
java实现消息队列的两种方式(小结)
08-26
本文主要介绍了两种java实现消息队列的方式，利用Spring消息模板发送消息和Apache ActiveMQ官方实例发送消息，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
抢占式OS消息队列例程
08-05
嵌入式操作系统
消息队列的简单讲解
08-17
消息队列的简单讲解
具有Eclipse和嵌入式JBoss HornetQ Server的简单JMS 1.1生产者和使用者示例
从零开始的教程世界
07-08 211
Before going to through this post, please read my previous post at “JMS API 1.1 Producer and Consumer” to understand some baby steps to develop JMS 1.1 Producer and Consumer programs. 在阅读这篇文章之前，请阅读我以前...
java并发包消息队列及在开源软件中的应用-BlockingQueue
e891377的专栏
04-27 829
BlockingQueue也是java.util.concurrent下的主要用来控制线程同步的工具。 主要的方法是：put、take一对阻塞存取；add、poll一对非阻塞存取。 插入: 1)add(anObject):把anObject加到BlockingQueue里,即如果BlockingQueue可以容纳,则返回true,否则抛出异常,不好         2)
力扣热门100题之盛最多水的容器，2024年最新学习路线+知识点梳理
2401_84264010的博客
04-19 344
人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！解释：图中垂直线代表输入数组 [1,8,6,2,5,4,8,3,7]。在此情况下，容器能够容纳水（表示为蓝色部分）的最大值为 49。输入：[1,8,6,2,5,4,8,3,7]输入：height = [1,1]解法2：双重for循环暴力破解。
Java版本HTTPSQS 纯java实现、 一个jar包、支持嵌入式启动、完全兼容HTTPSQS、TPS 1w+
gredn的专栏
08-24 584
最近完善一下原创 java版本 HTTPSQS （纯java+leveldb） 增加了一个内置TCPServer, 方便java用户调用的时候提升TPS并发； 增加了embeded 启动方式可以嵌入其他java项目； 测试：4核心8G阿里云服务器 PUT&GET 请求 12000+ /s    同样服务器环境远比 GO语言实现的性能高，和HTTPSQS相比性能损失可以忽略。 htt
在Spring框架中使用嵌入的消息队列代理服务（一）
foo1st的专栏
05-06 331
本文介绍了在Spring框架（Spring MVC和Spring Boot）中如何使用嵌入的ActiveMQ Broker消息队列服务。
嵌入式（消息队列和信号灯/量）
afddasfa的博客
10-09 293
消息队列，信号灯
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值