生产者与消费者以及ActiveMQ
一、 多线程实现生产者与消费者
1.1 生产者与消费者头文件
#pragma once
#include <iostream>
#include <mutex>
#include <thread>
#include <condition_variable>
class ProAndConClass
{
public:
ProAndConClass();
~ProAndConClass();
void printThread();
void addThread(int num);
bool g_flag = false;
private:
std::condition_variable g_cond_add_enable; //计算条件变量
std::condition_variable g_cond_print_enable;//打印条件
std::mutex g_mutex;
int g_value = 0;
bool g_print_able = false; //是否可以打印
};
1.2 实现cpp文件
#include "ProduceAndConsume.h"
//若不在堆上创建类的实例。需要将如下变量定义在全局数据区,不能放在类的内部，类成员变量可能分配在堆或者栈上，而线程是独享栈区的
//std::condition_variable g_cond_add_enable; //计算条件变量
//std::condition_variable g_cond_print_enable;//打印条件
//std::mutex g_mutex;
//int g_value = 0;
//bool g_print_able = false; //是否可以打印
ProAndConClass::ProAndConClass()
{
}
ProAndConClass::~ProAndConClass()
{
}
void ProAndConClass::addThread(int numThread)
{
std::cout << "add thread begin" << std::endl;
while (g_value < numThread)
{
std::unique_lock<std::mutex>my_lock(g_mutex);
g_cond_add_enable.wait(my_lock,
[=] {
return !g_print_able;
});
g_value++;
g_print_able = true;
std::cout << "++add thread" << g_value << std::endl;
g_cond_print_enable.notify_one(); //增加打印
}
//g_flag = false;
std::cout << "add thread leave"<<std::endl;
}
void ProAndConClass::printThread()
{
std::cout << "print thread begin" << std::endl;
while (g_flag)
{
std::unique_lock<std::mutex> my_lock(g_mutex);
g_cond_print_enable.wait(my_lock,
[=] {
return g_print_able;
});
g_print_able = false;
std::cout << "-- print thread" << g_value << std::endl;
g_cond_add_enable.notify_one();//通知增加线程
}
std::cout << "print thread leave" << std::endl;
}
1.3 主函数main
void testProAndCon()
{
ProAndConClass *proandcon = new(std::nothrow)ProAndConClass();//分配在堆上
proandcon->g_flag = true;
/*ProAndConClass proandcon;//如此,需要把变量定义到全局数据段.因为这种形式对象构
//造在栈区，而线程独享栈区
proandcon.g_flag = true;*/
//线程的初始化三种方式：普通函数、类成员函数、函数对象
std::thread thread_add(&ProAndConClass::addThread, proandcon, 10); // 生产者
std::thread thread_print(&ProAndConClass::printThread, proandcon); //消费者
//getchar();
Sleep(1000);
if (thread_add.joinable())
{
std::cout << "join add thread" << std::endl;
thread_add.join();
}
if (thread_print.joinable())
{
std::cout << "join print thread" << std::endl;
thread_print.join();
}
return;
}
1.4 生产者消费者小结
使用两个线程，一个生产一个消费。两个线程是独享栈区的，所以测试的变量要放在他们可以共同可以操作的到的地方。
二、基于生产者消费者的MQ
2.1 代码调用过程
//Mq也分为生产者和消费者两个类
class
HelloWorldProducer : public Runnable {
private:
Connection* connection;
Session* session;
Destination* destination;
MessageProducer* producer;
int numMessages;
bool useTopic;
bool sessionTransacted;
std::string brokerURI;
private:
HelloWorldProducer(const
HelloWorldProducer&);
HelloWorldProducer& operator=(const
HelloWorldProducer&);
public:
HelloWorldProducer(const std::string&
brokerURI, int numMessages, bool useTopic = false, bool sessionTransacted =
false) :
connection(NULL),
session(NULL),
destination(NULL),
producer(NULL),
numMessages(numMessages),
useTopic(useTopic),
sessionTransacted(sessionTransacted),
brokerURI(brokerURI) {
}
virtual ~HelloWorldProducer(){
cleanup();
}
void close() {
this->cleanup();
}
virtual void run() {
try {
//1 Create a ConnectionFactory
auto_ptr<ConnectionFactory>
connectionFactory(
ConnectionFactory::createCMSConnectionFactory(brokerURI));
// 2Create a Connection
connection =
connectionFactory->createConnection();
connection->start();
// 3Create a Session
if (this->sessionTransacted) {
session =
connection->createSession(Session::SESSION_TRANSACTED);
} else {
session = connection->createSession(Session::AUTO_ACKNOWLEDGE);
}
// 4Create the destination (Topic or Queue)
if (useTopic) {
destination =
session->createTopic("TEST.FOO");
} else {
destination =
session->createQueue("TEST.FOO");
}
// 5Create a MessageProducer from the Session to the Topic
or Queue
producer =
session->createProducer(destination);
producer->setDeliveryMode(DeliveryMode::NON_PERSISTENT);
//6 Create the Thread Id String
string threadIdStr =
Long::toString(Thread::currentThread()->getId());
//7 Create a messages
string text = (string) "Hello
world! from thread " + threadIdStr;
for (int ix = 0; ix <
numMessages; ++ix) {
std::auto_ptr<TextMessage>
message(session->createTextMessage(text));
message->setIntProperty("Integer", ix);
printf("Sent message #%d
from thread %s\n", ix + 1, threadIdStr.c_str());
producer->send(message.get());
}
} catch (CMSException& e) {
e.printStackTrace();
}
}
private:
void cleanup() {
if (connection != NULL) {
try {
connection->close();
} catch (cms::CMSException& ex)
{
ex.printStackTrace();
}
}
// Destroy resources.
try {
delete destination;
destination = NULL;
delete producer;
producer = NULL;
delete session;
session = NULL;
delete connection;
connection = NULL;
} catch (CMSException& e) {
e.printStackTrace();
}
}
};
//消费者类
class
HelloWorldConsumer : public ExceptionListener,
public
MessageListener,
public Runnable {
private:
CountDownLatch latch;
CountDownLatch doneLatch;
Connection* connection;
Session* session;
Destination* destination;
MessageConsumer* consumer;
long waitMillis;
bool useTopic;
bool sessionTransacted;
std::string brokerURI;
private:
HelloWorldConsumer(const
HelloWorldConsumer&);
HelloWorldConsumer& operator=(const
HelloWorldConsumer&);
public:
HelloWorldConsumer(const std::string&
brokerURI, int numMessages, bool useTopic = false, bool sessionTransacted =
false, int waitMillis = 30000) :
latch(1),
doneLatch(numMessages),
connection(NULL),
session(NULL),
destination(NULL),
consumer(NULL),
waitMillis(waitMillis),
useTopic(useTopic),
sessionTransacted(sessionTransacted),
brokerURI(brokerURI) {
}
virtual ~HelloWorldConsumer() {
cleanup();
}
void close() {
this->cleanup();
}
void waitUntilReady() {
latch.await();
}
virtual void run() {
try {
//1 Create a ConnectionFactory
auto_ptr<ConnectionFactory>
connectionFactory(
ConnectionFactory::createCMSConnectionFactory(brokerURI));
// 2Create a Connection
connection =
connectionFactory->createConnection();
connection->start();
connection->setExceptionListener(this);
//3 Create a Session
if (this->sessionTransacted ==
true) {
session =
connection->createSession(Session::SESSION_TRANSACTED);
} else {
session =
connection->createSession(Session::AUTO_ACKNOWLEDGE);
}
//4 Create the destination (Topic or Queue)
if (useTopic) {
destination =
session->createTopic("TEST.FOO");
} else {
destination =
session->createQueue("TEST.FOO");
}
//5 Create a MessageConsumer from the Session to the Topic
or Queue
consumer =
session->createConsumer(destination);
consumer->setMessageListener(this);
std::cout.flush();
std::cerr.flush();
//6 Indicate we are ready for messages.
latch.countDown();
// 7Wait while asynchronous messages come in.
doneLatch.await(waitMillis);
} catch (CMSException& e) {
// Indicate we are ready for
messages.
latch.countDown();
e.printStackTrace();
}
}
//8 Called from the consumer since this class is a registered
MessageListener.
virtual void onMessage(const Message*
message) {
static int count = 0;
try {
count++;
const TextMessage* textMessage =
dynamic_cast<const TextMessage*> (message);
string text = "";
if (textMessage != NULL) {
text =
textMessage->getText();
} else {
text = "NOT A
TEXTMESSAGE!";
}
printf("Message #%d Received:
%s\n", count, text.c_str());
} catch (CMSException& e) {
e.printStackTrace();
}
// Commit all messages.
if (this->sessionTransacted) {
session->commit();
}
// No matter what, tag the count down
latch until done.
doneLatch.countDown();
}
// If something bad happens you see it here
as this class is also been
// registered as an ExceptionListener with
the connection.
virtual void onException(const
CMSException& ex AMQCPP_UNUSED) {
printf("CMS Exception
occurred. Shutting down
client.\n");
ex.printStackTrace();
exit(1);
}
private:
void cleanup() {
if (connection != NULL) {
try {
connection->close();
} catch (cms::CMSException& ex)
{
ex.printStackTrace();
}
}
// Destroy resources.
try {
delete destination;
destination = NULL;
delete consumer;
consumer = NULL;
delete session;
session = NULL;
delete connection;
connection = NULL;
} catch (CMSException& e) {
e.printStackTrace();
}
}
};
//main
int main(int
argc AMQCPP_UNUSED, char* argv[] AMQCPP_UNUSED) {
activemq::library::ActiveMQCPP::initializeLibrary();
{
std::cout <<
"=====================================================\n";
std::cout << "Starting the
example:" << std::endl;
std::cout << "-----------------------------------------------------\n";
std::string brokerURI =
"failover:(tcp://localhost:61616"
// "?wireFormat=openwire"
//
"&transport.useInactivityMonitor=false"
//
"&connection.alwaysSyncSend=true"
// "&connection.useAsyncSend=true"
//
"?transport.commandTracingEnabled=true"
//
"&transport.tcpTracingEnabled=true"
//
"&wireFormat.tightEncodingEnabled=true"
")";
bool useTopics = true;
bool sessionTransacted = false;
int numMessages = 2000;
long long startTime =
System::currentTimeMillis();
HelloWorldProducer producer(brokerURI, numMessages, useTopics);
HelloWorldConsumer consumer(brokerURI,
numMessages, useTopics, sessionTransacted);
// Start the consumer thread.
Thread consumerThread(&consumer);
consumerThread.start();
// Wait for the consumer to indicate that
its ready to go.
consumer.waitUntilReady();
// Start the producer thread.
Thread producerThread(&producer);
producerThread.start();
// Wait for the threads to complete.
producerThread.join();
consumerThread.join();
long long endTime =
System::currentTimeMillis();
double totalTime = (double)(endTime -
startTime) / 1000.0;
consumer.close();
producer.close();
std::cout << "Time to completion
= " << totalTime << " seconds." << std::endl;
std::cout <<
"-----------------------------------------------------\n";
std::cout << "Finished with the
example." << std::endl;
std::cout << "=====================================================\n";
}
activemq::library::ActiveMQCPP::shutdownLibrary();
}
// END SNIPPET:
demo