{

void put( const item& item )

{

boost::unique_lock<boost::mutex> lock(mutex);

while ( item_in )

cond_full.wait(lock);

item_ = item;

item_in = true;

cond_empty.notify_one();

}

void print()

{

boost::unique_lock<boost::mutex> lock(mutex);

while ( !item_in )

cond_empty.wait(lock);

item_in = false;

std::cout << item_.i << std::endl;

cond_full.notify_one();

}

//Mutex to protect access to the queue

boost::mutex mutex;

//Condition to wait when the queue is empty

boost::condition_variable cond_empty;

//Condition to wait when the queue is full

boost::condition_variable cond_full;

bool item_in;

//Items to fill

item item_;

{

//Erase previous shared memory and schedule erasure on exit

struct shm_remove

{

shm_remove() { shared_memory_object::remove("MySharedMemory"); }

~shm_remove(){ shared_memory_object::remove("MySharedMemory"); }

} remover;

//Create a shared memory object.

shared_memory_object shm(create_only,"MySharedMemory",read_write);

try

{

//Construct the shared structure in memory

queue *q = new (addr) queue;

do

{

q->print();

} while ( true );

}

catch(boost::thread_interrupted&)

{

std::cout << "interrupted" << std::endl;

}

catch(...)

{

std::cout << "exception" << std::endl;

}

{

addr = new queue();

boost::thread t(printThread);

// give the thread time to create the shm

boost::this_thread::sleep( boost::posix_time::milliseconds( 1000 ) );

try

{

//Obtain a pointer to the shared structure

queue *q = static_cast<queue*>(addr);

item i;

i.i = 42;

q->put( i );

++i.i;

q->put( i );

// give the printThread time to "process" the item

boost::this_thread::sleep( boost::posix_time::milliseconds( 1000 ) );

t.interrupt();

t.join();

}

catch(...)

{

std::cout << "exception" << std::endl;

return -1;

}