{

using namespace boost;

try {

for(int i=0; ;++i)

{

sbq.push(i);

//sbq << i;

//mos << "push(" << i << ") " << sbq.size() <<"\n";

this_thread::sleep_for(chrono::milliseconds(200));

}

}

catch(sync_queue_is_closed&)

{

//mos << "closed !!!\n";

}

catch(...)

{

//mos << "exception !!!\n";

}

the_ostream &/*mos*/,

boost::queue_front<int> sbq)

{

using namespace boost;

try {

for(int i=0; ;++i)

{

int r;

sbq.pull(r);

//sbq >> r;

//mos << i << " pull(" << r << ") " << sbq.size() <<"\n";

this_thread::sleep_for(chrono::milliseconds(250));

}

}

catch(sync_queue_is_closed&)

{

//mos << "closed !!!\n";

}

catch(...)

{

//mos << "exception !!!\n";

}

{

using namespace boost;

try {

for(int i=0; ;++i)

{

int r;

queue_op_status st = sbq.try_pull(r);

if (queue_op_status::closed == st) break;

if (queue_op_status::success == st) {

//mos << i << " try_pull(" << r << ")\n";

}

this_thread::sleep_for(chrono::milliseconds(250));

}

}

catch(...)

{

//mos << "exception !!!\n";

}

{

using namespace boost;

try {

for(int i=0; ;++i)

{

int r;

queue_op_status res = sbq.wait_pull(r);

if (res==queue_op_status::closed) break;

//mos << i << " wait_pull(" << r << ")\n";

this_thread::sleep_for(chrono::milliseconds(250));

}

}

catch(...)

{

//mos << "exception !!!\n";

}

{

using namespace boost;

#ifdef XXXX

recursive_mutex terminal_mutex;

externally_locked_stream<std::ostream> mcerr(std::cerr, terminal_mutex);

externally_locked_stream<std::ostream> mcout(std::cout, terminal_mutex);

externally_locked_stream<std::istream> mcin(std::cin, terminal_mutex);

#else

the_ostream &mcerr = std::cout;

the_ostream &mcout = std::cerr;

//the_istream &mcin = std::cin;

#endif

queue_adaptor<sync_queue<int> > sbq;

{

mcout << "begin of main" << std::endl;

scoped_thread<> t11(boost::thread(producer, boost::ref(mcerr), concurrent::queue_back<int>(sbq)));

scoped_thread<> t12(boost::thread(producer, boost::ref(mcerr), concurrent::queue_back<int>(sbq)));

scoped_thread<> t2(boost::thread(consumer, boost::ref(mcout), concurrent::queue_front<int>(sbq)));

this_thread::sleep_for(chrono::seconds(1));

mcout << "closed()" << std::endl;

sbq.close();

mcout << "closed()" << std::endl;

} // all threads joined here.

mcout << "end of main" << std::endl;

return 0;