synchronized message queue operations in multi-thread

I have a requirement to have a queue to communicate among a set of
sender threads and a receiver thread.

I have decided to have a ConcurrentLinkedQueue object an a Semaphore
object for a maximum size to allow the threads to operate on the
queue.
I am planning to write my message queue class to support synchronized
(share) queue operations.

public class MyQueue
{
    private final Semaphore sem ;
    private final ConcurrentLinkedQueue<MyObject> updateQueue;
    NotificationQueue()
    {
        sem = new Semaphore (QUEUE_SIZE,true);
        updateQueue = new ConcurrentLinkedQueue<MyObject> ();
    }

    public boolean getObject(MyObject obj)
   {

         boolean flag = false;
         obj = updateQueue.poll();

          if(obj != null)
           {
                flag = true;
                sem.release();
           }

          return ;
}

  public boolean putObject(MyObject obj)
   {
        sem.tryAcquire();
        boolean update = false;

        update= updateQueue.put(obj);
        if(!update)
             sem.release();

        return update;
   }//end of the method
}//end of the class

In the above class, if the sender thread wants to pass an object, it
would call the 'putObject' method. In the putObject method, I will
call the 'tryAcquire' and then put the object in the queue. If the
operation is not successful, I will call the 'release' method.

And in the receiver thread, I will try to get the object, if the
object is not null, I will call the 'release' method.

Question i) Is the semaphore method calls (tryAcquire and release)
accurate in the context of the queue operations that I am trying to
do??

Question ii)
And I am also planning to have an infinite 'while' loop in the
receiver thread to check whether there is any object in the queue,
like as follows,
          //in the receiver thread
          ....
          MyObj obj = null;
          boolean flag = false;
          while(true)
           {
              flag = myQueue.getObject(obj)

              //if there is object..
              if (flag)
                 //do something...

           }//end of while loop
          ....

Will this above receiver thread implementation give any performance
issue? Or is there any better solution for this?

Thanks for any suggestion.