可嵌入式JMS消息队列FFMQ



经过几个开源项目比较,最终发现合适的项目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();
        }
    
    }
}





#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); }
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值