由我看来管程不只是将分散的对信号量操作集中起来

更重要是的它的这三个特性：

  （1）模块化。管程是一个基本程序单位，可以单独编译;
  （2）抽象数据类型。管程是中不仅有数据，而且有对数据的操作;
  （3）信息掩蔽。管程外可以调用管程内部定义的一些函数，但函数的具体实现外部不可见;

这不就是“类”么

生产者/消费者问题使用信号量的解法：

    //生产者进程
    producer
    {
     while(true)   
     {   
            produce(&item);
            p(s1);   
            p(mutex);   
            buffer[in]:=item;   
            in:=(in+1) mod k;   
            v(mutex);   
            v(s2);   
        }   
    }   

    //消费者进程
    consumer   
    {   
        while(true)   
        {   
            p(s2);   
            p(mutex);   
            item:=buffer[out];   
            out:=(out+1) mod k;   
            v(mutex);   
            v(s1);   
            consume(&item);
        }   
    }  

生产者/消费者问题使用管程的解法：

    //管程
    //假设已实现一基本管程monitor，提供enter,leave,signal,wait等操作
    buffer
    {
        procedure deposit(item);
        {
            if(count=k) monitor.wait(notfull);
            buf[in]=item;
            in:=(in+1) mod k;
            count++;
            monitor.signal(notempty);
        }
        procedure fetch();
        {
            if(count=0) monitor.wait(notempty);
            item=buf[out];
            in:=(in+1) mod k;
            count--;
            monitor.signal(notfull);
            return(item);
        }
    }

    //生产者进程
    producer
    {
         while (true)
         {
             produce(&item);
             buffer.enter();
             buffer.deposit(item);
             buffer.leave();
         }
    }

    //消费者进程
    consumer
    {
        while (true)
        {
            buffer.enter();
            item=buffer.fetch();
            buffer.leave();
            consume(&item);
        }
    }

非常明显，这个管程实际上就是为临界区单独实现了一个类

管程 = 临界区类，这就是我的理解