class Raii {
public: 
    // Store a pointer to the resource and initialize the resource. 
    Raii(Resource &resource) 
    :m_pRes (&resource){ 
        m_pRes->initialize ();
    }
    // Close the resource when the execution goes out of scope.
    virtual ~Raii() {
        m_pRes->close ();
    }
private: 
    // Pointer to the resource we're managing. 
    Resource *m_pRes; 
    // ... maybe need disallow copying and assignment ... 
};

MyResource res = null; 
try {
    res = new MyResource();
    // Use the resource 
} finally {
    //At exit point, close the resource.
    if (res != null) { res.close(); }
}

template <class LOCK>
class Guard {
public: 
// Store a pointer to the lock and acquire the lock. 
Guard (LOCK &lock)
:m_pLlock (&lock), m_bOwner (false) {
m_pLlock->acquire ();
m_bOwner = true; 
}
// Release the lock when the guard goes out of scope, 
// but only if <acquire> succeeded. 
virtual ~Guard () {
if (m_bOwner) m_pLlock->release ();
}
private: 
// Pointer to the lock we're managing. 
LOCK *m_pLlock; 
// Records if the lock is held by this object. 
bool m_bOwner; 
// ... maybe need disallow copying and assignment ... 
};

public int scopedLockSample() {
synchronized(this) {
try {
//do some work…
} catch( MyException1 e) {
//no need release lock explicitly
return -1; 
} catch( MyException2 e) {
//no need release lock explicitly
return -2; 
}
//other exceptions handling... 
}
return 0; 
}

class Thread_Condition {
public:
// Initialize the condition variable and associate it with the specified lock.
Thread_Condition (const Thread_Mutex &m) 
:m_obMutex(m) {
cond_init (&cond_, USYNC_THREAD, 0); 
}
// Destroy the condition variable. 
virtual ~Thread_Condition () {
cond_destroy (&cond_);
}
// Wait for the <Thread_Condition> to be notified
// or until <timeout> has elapsed. If <timeout> == 0 then wait indefinitely. 
void wait (Time_Value *timeout = 0) {
cond_timedwait(&cond_, &m_obMutex.m_lock,timeout == 0?0:timeout->msec ());
}
// Notify one thread waiting on <Thread_Condition>.
void notify () { cond_signal (&cond_); }
// Notify all threads waiting on <Thread_Condition>.
void notify_all () { cond_broadcast (&cond_);
}
private: 
// Solaris condition variable. 
cond_t cond_;
// Reference to mutex lock. 
const Thread_Mutex &m_obMutex; 
};

class Message_Queue {
public:
enum { MAX_MESSAGES = 100/* ... */ };
// The constructor defines the maximum number
// of messages in the queue. This determines when the queue is 'full.'
Message_Queue(size_t max_messages = MAX_MESSAGES); 
virtual ~Message_Queue();
// Put the <Message> at the tail of the queue. 
// If the queue is full, block until the queue is not full. 
/* synchronized */ 
void put (const Message &msg); 
// Get the <Message> from the head of the queue
// and remove it. If the queue is empty, block until the queue is not empty. 
/* synchronized */ 
Message get();
// True if the queue is empty, else false. 
/* synchronized */ 
bool empty () const; 
// True if the queue is full, else false. 
/* synchronized */ 
bool full () const; 
private:
// Put the <Message> at the tail of the queue, and
// get the <Message> at its head, respectively. 
// Note that, the internal methods are not synchronized. 
void put_i (const Message &msg); 
Message get_i ();
// True if the queue is empty, else false. 
bool empty_i () const; 
// True if the queue is full, else false. 
bool full_i () const; 
private: 
// Internal Queue representation omitted, could be a
// circular array or a linked list, etc.. ... 
// Current number of <Message>s in the queue. 
size_t message_count_; 
// The maximum number <Message>s that can be
// in a queue before it's considered 'full.'
size_t max_messages_; 
// Monitor lock that protects the queue's
// internal state from race conditions during concurrent access. 
mutable Thread_Mutex monitor_lock_; 
// Condition variable used in conjunction with <monitor_lock_> to make
// synchronized method threads wait until the queue is no longer empty. 
Thread_Condition not_empty_;
// Condition variable used in conjunction with <monitor_lock_> to make
// synchronized method threads wait until the queue is no longer full. 
Thread_Condition not_full_;
};

#include "Message_Queue.h"
Message_Queue::Message_Queue (size_t max_messages) 
:not_full_(monitor_lock_),
not_empty_(monitor_lock_),
max_messages_(max_messages), 
message_count_(0) {
}
bool Message_Queue::empty () const {
Guard<Thread_Mutex> guard (monitor_lock_); 
return empty_i ();
}
bool Message_Queue::full () const {
Guard<Thread_Mutex> guard (monitor_lock_);
return full_i ();
}
void Message_Queue::put (const Message &msg) {
// Use the Scoped Locking idiom to acquire/release the < monitor_lock_> upon
// entry/exit to the synchronized method. 
Guard<Thread_Mutex> guard (monitor_lock_);
// Wait while the queue is full. 
while (full_i ()) {
// Release < monitor_lock_> and suspend the
// calling thread waiting for space in the queue. 
// The <monitor_lock_> is reacquired automatically when <wait> returns. 
not_full_.wait ();
}
// Enqueue the <Message> at the tail. 
put_i (msg); 
// Notify any thread waiting in <get> that the queue has at least one <Message>.
not_empty_.notify ();
} // Destructor of <guard> releases <monitor_lock_>.
Message Message_Queue::get () {
// Use the Scoped Locking idiom to acquire/release the <monitor_lock_> upon
// entry/exit to the synchronized method. 
Guard<Thread_Mutex> guard (monitor_lock_);
// Wait while the queue is empty. 
while (empty_i ()) {
// Release <monitor_lock_> and suspend the
// calling thread waiting for a new <Message> to
// be put into the queue. The <monitor_lock_> is
// reacquired automatically when <wait> returns. 
not_empty_.wait ();
}
// Dequeue the first <Message> in the queue and update the <message_count_>.
Message m = get_i ();
// Notify any thread waiting in <put> that the
// queue has room for at least one <Message>.
not_full_.notify ();
return m; 
} // Destructor of <guard> releases <monitor_lock_>.
bool Message_Queue::empty_i () const {
return message_count_ == 0; 
}
bool Message_Queue::full_i () const {
return message_count_ == max_messages_; 
}
Message_Queue::~Message_Queue() {
}

public class Message {
    private static int OBJ_COUNT = 0;
    public int obj_index_;
    Message(){
        synchronized(Message.class) {
            OBJ_COUNT++;
            obj_index_ = OBJ_COUNT;
        }
    }
    
    @Override
    public String toString() {
        return "message["+obj_index_+"]";
    }
}

public class MessageQueue {
private int message_count_;
private int max_messages_;
private Message[] buffer_;

private int in_ = 0, out_ = 0;
public MessageQueue(int max_messages) {
max_messages_   = max_messages;
message_count_  = 0;
buffer_          = new Message[max_messages_];
}

synchronized boolean full () {
return full_i ();
}
synchronized  void put (Message msg) {
while (full_i ()) {
try { 
    System.out.println("thread["+
      Thread.currentThread().getId()+
      "]"+
      "release monitor lock, wait for space in the queue");
                wait(); 
            } catch (InterruptedException e) {
                //do something.
            } finally { 
                //do something.
            } 
}//end while.
put_i(msg);
notifyAll();
}
synchronized  Message get() {
while (empty_i ()) {
  try { 
      System.out.println("thread["+
        Thread.currentThread().getId()+
        "]"+
        "release monitor lock, wait for message in the queue");
                wait(); 
                } catch (InterruptedException e) {
                //do something.
                } finally { 
                //do something.
                } 
}//end while.
Message m = get_i ();
notifyAll();
return m;
}
private boolean empty_i () {
return message_count_ == 0;
}
private boolean full_i () {
return message_count_ == max_messages_;
}
private void put_i (Message msg) {
    System.out.println("thread ["+
        Thread.currentThread().getId()+
        "] put message <"+
        msg+
        ">" +
        "to the queue");
buffer_[in_] = msg; 
            in_ = (in_ + 1) % max_messages_;  
            message_count_++; 
}
private Message get_i() {
         Message msg = buffer_[out_]; 
            out_= (out_ + 1) % max_messages_;
            message_count_--;
            System.out.println("thread ["+
                Thread.currentThread().getId()+
                "] get message <"+
                msg+
                ">" +
                "from the queue");
    return msg;
}
}