Task vs Protected Type

[Sébastien <seb.morand@gmail.com>]

Hi guys,

I would like to understand a sentence of the wikibook.

In the presentation of Task and Protected we can see the following:
-------------------
-- CODE 1
-------------------
   task type Semaphore_Task_Type is
      entry Initialize (N : in Natural);
      entry Wait;
      entry Signal;
   end Semaphore_Task_Type;
   ...
   task body Semaphore_Task_Type is
      Count : Natural;
   begin
      accept Initialize (N : in Natural) do
         Count := N;
      end Initialize;
      loop
         select
            when Count > 0 =>
                accept Wait do
                   Count := Count - 1;
                end Wait;
         or
                accept Signal;
                Count := Count + 1;
         end select;
      end loop;
   end Semaphore_Task_Type;

-------------------
-- CODE 2
-------------------
   protected type Semaphore_Protected_Type is
      procedure Initialize (N : in Natural);
      entry Wait;
      procedure Signal;
   private
      Count : Natural := 0;
   end Semaphore_Protected_Type;
   ...
   protected body Semaphore_Protected_Type is
      procedure Initialize (N : in Natural) is
      begin
         Count := N;
      end Initialize;
      entry Wait
         when Count > 0 is
      begin
         Count := Count - 1;
      end Wait;
      procedure Signal is
      begin
         Count := Count + 1;
      end Signal;
   end Semaphore_Protected_Type;


Ok the two codes provides the same functionality but obviously not in 
the same way. In the first one, a thread is dedicated to manage the 
semaphore. In the second one, this is a protected type with exclusive 
mutex on entry and procedure and absolutly no thread implementation (as 
far as I understood internal mechanism of protected type)

The first one has the advantage to force the user to Initialize the task 
because of the first entry, but there is no such mechanism in the 
protected type.

So in the wikibook, there is this sentence:
"Alternatively, semaphore functionality can be provided by a protected 
object, with major efficiency gains."

This is between the two codes, letting the reader (me at least) 
understand protected type is a better approach, but I can't understand why.

For example, you have a web application and want to develop an object 
pool. You could use one of both example, since it's the same purpose 
with some GetObject and ReleaseObject enties/procedure in a task or in a 
protected. But which one is the better approach?

Thanks very much.
Sebastien