java多线程都有几种方式实现？？
有三种：(1)继承Thread类，重写run函数创建：class xx extends Thread{ public void run(){Thread.sleep(1000)//线程休眠1000毫秒，sleep使线程进入Block状态，并释放资源}}开启线程：对象.start()//启动线程，run函数运行(2)实现Runnable接口，重写run函数开启线程：Thread t = new Thread(对象)//创建线程对象t.start()(3)实现Callable接口，重写call函数Callable是类似于Runnable的接口，实现Callable接口的类和实现Runnable的类都是可被其它线程执行的任务。 Callable和Runnable有几点不同:①Callable规定的方法是call()，而Runnable规定的方法是run(). ②Callable的任务执行后可返回值，而Runnable的任务是不能返回值的③call()方法可抛出异常，而run()方法是不能抛出异常的。 ④运行Callable任务可拿到一个Future对象，Future表示异步计算的结果。它提供了检查计算是否完成的方法,以等待计算的完成,并检索计算的结果.通过Future对象可了解任务执行情况,可取消任务的执行,还可获取任务执行的结果
生产者-消费者”问题 用C语言编写
#include #include #include #include #include #define PRODUCER 10//生产者数量 #define CONSUMER 8//消费者数量 #define BUFFER 20//缓冲区数量 sem_t empty,full;//同步信号量 pthread_mutex_t mutex;//互斥信号量 int buffer[BUFFER]; //缓冲区 int producer_id=0,consumer_id=0;//生产者消费者ID int index_in=0,index_out=0;//生产者 消费者 存放 消费的位置 void print()//输出缓冲区 { int i; printf("Buffer:\n"); for(i=0;i<20;i++) { printf("___"); } printf("\n"); for(i=0;i<20;i++) printf("|%d|",buffer[i]); printf("\n"); for(i=0;i<20;i++) { printf("———"); } printf("\n"); } void *Producer()//生产者函数 { int ID=++producer_id; while(1) { sleep(3); sem_wait(&empty); pthread_mutex_lock(&mutex); index_in=index_in%BUFFER; printf("Producer %d in %d.\n",ID,index_in); buffer[index_in]=1;//缓冲区置0 print();//输出缓冲区情况 index_in++; pthread_mutex_unlock(&mutex); sem_post(&full); } } void *Consumer()//消费者函数 { int ID=++consumer_id; while(1) { sleep(3); sem_wait(&full); pthread_mutex_lock(&mutex); index_out=index_out%BUFFER; printf("\033[01;34mConsumer %d in %d\033[0m\n",ID,index_out); buffer[index_out]=0;//缓冲区置0 print();//输出缓冲区情况 index_out++; pthread_mutex_unlock(&mutex); sem_post(&empty); } } int main() { //freopen("text.txt","w",stdout); int rthread[18],i; pthread_t producer[PRODUCER];//生产者 pthread_t consumer[CONSUMER];//消费者 int sinit1=sem_init(&empty,0,BUFFER);//初始化同步信号量 int sinit2=sem_init(&full,0,0); int minit =pthread_mutex_init(&mutex,NULL);//初始化互斥信号量 if(sinit1 && sinit2) { printf("sem initialize failed /n"); exit(1); } if(minit) { printf("sem initialize failed /n"); exit(1); } for(i=0;i<PRODUCER;i++)//创建生产者线程 { rthread[i]=pthread_create(&producer[i], NULL, Producer, NULL); if(rthread[i]) { printf("producer %d create failed /n", i); exit(1); } } for(i=0;i<CONSUMER;i++)//创建消费者线程 { rthread[i]=pthread_create(&consumer[i], NULL, Consumer,NULL); if(rthread[i]) { printf("consumer %d create failed /n", i); exit(1); } } for(i=0;i<PRODUCER;i++)//销毁生产者线程 { pthread_join(producer[i],NULL); } for(i=0;i<CONSUMER;i++)//销毁生产者线程 { pthread_join(consumer[i],NULL); } exit(0); }
用c语言或c++编写编程实现生产者消费者或读写者的同步问题
实现一个队列CQueue
CQueue提供两个公有成员函数
addTail()：往队列尾部增加一个元素
removeHead()：读出并移除队列的第一个元素
生产者：两个线程通过调用CQueue::addTail()往队列中增加元素
消费者：一个线程通过调用CQueue::removeHead()从队列中读取元素
#include
#include
#include
#include
using namespace std;
#define P(sem) WaitForSingleObject(sem,INFINITE)
#define V(sem) ReleaseSemaphore(sem,1,NULL)
class CQueue
{
public:
void addTail();//往队列尾部增加一个元素
void removeHead();//读出并移除队列的第一个元素
private:
list L;
};
CQueue buffer;//全局的缓冲区
const int buf_size = 10;//缓冲区大小
static int GOODS_ID = 0;//商品序号
const int producers = 3;//生产者数量
const int consumers = 8;//消费者数量
void ProducerThread(void* param);
void ConsumerThread(void* param);
HANDLE empty,occupy,op_mutex;
int main()
{
int i;
int p_id[producers],c_id[consumers];
occupy = CreateSemaphore(NULL,0,buf_size,NULL);//占用位置
empty = CreateSemaphore(NULL,buf_size,buf_size,NULL);//空余位置
op_mutex = CreateSemaphore(NULL,1,1,NULL);//操作互斥量
for(i=0;i<producers;++i)
{
p_id[i] = i+1;
_beginthread(ProducerThread,0,p_id+i);
}
for(i=0;i<consumers;++i)
{
c_id[i] = i+1;
_beginthread(ConsumerThread,0,c_id+i);
}
while(getchar()=='\n') break;
return 0;
}
void CQueue::addTail()
{
L.insert(L.end(),++GOODS_ID);
}
void CQueue::removeHead()
{
cout<<*L.begin()<<endl;
L.erase(L.begin());
}
void ProducerThread(void* param)
{
int id = *(int*)param;
while(1)
{
P(empty);
P(op_mutex);
Sleep(100);
buffer.addTail();
printf("Producer_%d produced %d\n",id,GOODS_ID);
V(op_mutex);
V(occupy);
}
}
void ConsumerThread(void* param)
{
int id = *(int*)param;
while(1)
{
P(occupy);
P(op_mutex);
Sleep(100);
printf("Consumer_%d consumed ",id);
buffer.removeHead();
V(op_mutex);
V(empty);
}
}
编程牛人，江湖救急 用C++实现生产者消费者问题
以LAMP兄弟连的课程安排来说主要学习一下内容：
1.SpringSecurity：目前最主流的JavaEE安全解决方案，基于Spring。为基于JavaEE企业开发提供全面安全服务。
2.WebSphere：企业级应用服务器。包含了编写、运行和监视全天候的工业强度的随需应变 Web应用程序和跨平台、跨产品解决方案所需要的整个中间件基础设施。
3.负载均衡：高并发解决方案。能利用一个集群中的多台单机，响应更多的并发请求。
4.分布式系统：由网络互联的多处理机体系结构上执行任务的系统。可有效提高系统的可扩展性、稳定性和执行效率
Java实现线程同步的几种方式
java中多线程的实现方法有两种：1.直接继承thread类；2.实现runnable接口；同步的实现方法有五种：1.同步方法；2.同步代码块；3.使用特殊域变量(volatile)实现线程同步；4.使用重入锁实现线程同步；5.使用局部变量实现线程同步 。
其中多线程实现过程中需注意重写或者覆盖run()方法，而对于同步的实现方法中使用较常使用的是利用synchronized编写同步方法和代码块。
Java 线程同步几种方式
（1）同步方法：
即有synchronized关键字修饰的方法。 由于java的每个对象都有一个内置锁，当用此关键字修饰方法时，内置锁会保护整个方法。在调用该方法前，需要获得内置锁，否则就处于阻塞状态。
（2）同步代码块
即有synchronized关键字修饰的语句块。被该关键字修饰的语句块会自动被加上内置锁，从而实现同步
（3）使用特殊域变量(Volatile)实现线程同步
a.volatile关键字为域变量的访问提供了一种免锁机制
b.使用volatile修饰域相当于告诉虚拟机该域可能会被其他线程更新
c.因此每次使用该域就要重新计算，而不是使用寄存器中的值
d.volatile不会提供任何原子操作，它也不能用来修饰final类型的变量
（4）使用重入锁实现线程同步
在JavaSE5.0中新增了一个java.util.concurrent包来支持同步。ReentrantLock类是可重入、互斥、实现了Lock接口的锁， 它与使用synchronized方法和快具有相同的基本行为和语义，并且扩展了其能力。
（5）使用局部变量实现线程同步
读者优先与写者优先有什么区别
读者写者问题是这样一种情况，就是允许对资源进行两种类型的操作（读和写）。而写操作是排他的（排斥读者，同样排斥其他写者），读操作是共享的（多个读者可读，排斥写者）。这就存在两种策略：1.读者优先（强读者同步Strong reader synchronization）：总是给读者优先权，只要写者当前没有进行写操作，读者就能获得访问权。这种情况存在于读者很多，写者不经常更新的时候使用，如图书馆参考数据库采用读者优先比较好。2.写者优先（强写者同步Strong writer synchronization）：通常把优先权交给写者，而将读者延迟到所有等待的或活动的写者都完成了为止。这种情况存在于经常更新的系统，而读者对最新信息感兴趣，如机票预定系统，写者进行机票价格的更新，读者获取当前机票价。简单的说就是资源没人占用，则谁先到先用，用的时候上锁，读者上读者锁，写者上写者锁。1.假设先来的读者上读者锁，接下来再a）来读者，可以读资源，将读者计数器+1，b）来写者则等待（阻塞或者不断尝试）直到读者释放资源（计数器为0），选取一个写者开始写2.若先来的是写者上写者锁，这时候又来了比如N个读者，M个写者等待（写者锁排他），这时候要是a）读者优先，则写者释放锁后，让等候的N个读者先读（其他写者接着等着等，变为情况1），这时候要是b）写者优先，则写者释放锁后，让等候的M个中的一个写者写，读者接着等待直到没有写者为止（等的的M个写者全写完还有中途再来的写者）。读者写者问题本身就存在着饿死的情况。
利用记录型信号量（集）解决读者-写者问题。
设置互斥信号量wmutex 表示写者间、读者和写者间互斥
用readcount变量来记录读者数
Var rmutex,wmutex: semaphore:=1,1 ;
readcount :integer :=0 ;
begin
parbegin
reader:begin
repeat
P(rmutex)
if readcount=0 then P(wmutex);
readcount=readcount+1;
V(rmutex)
read text
P(rmutex)
readcount=readcount+1;
if readcount=0 then V(wmutex);
V(rmutex)
until false
writer:begin
repeat
P(wmutex);
write text;
V(wmutex);
until false
end
parend
end
操作系统 判断题 生产者消费者问题
一、明确定义要理解生产消费者问题，首先应弄清PV操作的含义：PV操作是由P操作原语和V操作原语组成（原语是不可中断的过程），对信号量进行操作，具体定义如下： P（S）：①将信号量S的值减1，即S=S-1； ②如果S³0，则该进程继续执行；否则该进程置为等待状态，排入等待队列。 V（S）：①将信号量S的值加1，即S=S+1； ②如果S>0，则该进程继续执行；否则释放队列中第一个等待信号量的进程。这只是书本的定义，对于这部分内容，老师先不要急于解释上面的程序流程，而是应该让学生首先知道P操作与V操作到底有什么作用。P操作相当于申请资源，而V操作相当于释放资源。所以要学生记住以下几个关键字：P操作-----à申请资源V操作----à释放资源二、形象启发为此举两个生活中的例子：例一：在公共电话厅打电话公共电话厅里有多个电话，如某人要打电话，首先要进行申请，看是否有电话空闲，若有，则可以使用电话，如果电话亭里所有电话都有人正在使用，那后来的人只有排队等候。当某人用完电话后，则有空电话腾出，正在排队的第一个人就可以使用电话。这就相当于PV操作：某人要打电话，首先要进行申请，相当于执行一次P操作，申请一个可用资源（电话）；某人用完电话，则有空电话腾出，相当于执行一次V操作，释放一个可用资源（电话）。在多媒体课件中，这部分内容充分通过动画效果，演示整个申请电话资源（P操作）与释放电话资源（V操作）的过程，同时显示当前可用的资源个数（电话个数）。课件直观生动，一目了然，学生非常容易接受，并且理解深刻。三、分层解剖在理解了PV操作的的含义后，就必须讲解利用PV操作可以实现进程的两种情况：互斥和同步。根据互斥和同步不同的特点，就有利用PV操作实现互斥与同步相对固定的结构模式。这里就不详细讲解了。但生产者-消费者问题是一个有代表性的进程同步问题，要学生透彻理解并不容易。但是如果我们将问题细分成三种情况进行讲解，理解难度将大大降低。1）一个生产者，一个消费者，公用一个缓冲区。可以作以下比喻：将一个生产者比喻为一个生产厂家，如伊利牛奶厂家，而一个消费者，比喻是学生小明，而一个缓冲区则比喻成一间好又多。第一种情况，可以理解成伊利牛奶生产厂家生产一盒牛奶，把它放在好又多一分店进行销售，而小明则可以从那里买到这盒牛奶。只有当厂家把牛奶放在商店里面后，小明才可以从商店里买到牛奶。所以很明显这是最简单的同步问题。解题如下：定义两个同步信号量：empty——表示缓冲区是否为空，初值为1。full——表示缓冲区中是否为满，初值为0。生产者进程while(TRUE){生产一个产品; P(empty); 产品送往Buffer; V(full);}消费者进程while(TRUE){P(full); 从Buffer取出一个产品; V(empty); 消费该产品;2）一个生产者，一个消费者，公用n个环形缓冲区。 第二种情况可以理解为伊利牛奶生产厂家可以生产好多牛奶，并将它们放在多个好又多分店进行销售，而小明可以从任一间好又多分店中购买到牛奶。同样，只有当厂家把牛奶放在某一分店里，小明才可以从这间分店中买到牛奶。不同于第一种情况的是，第二种情况有N个分店（即N个缓冲区形成一个环形缓冲区），所以要利用指针，要求厂家必须按一定的顺序将商品依次放到每一个分店中。缓冲区的指向则通过模运算得到。 解题如下： 定义两个同步信号量：empty——表示缓冲区是否为空，初值为n。full——表示缓冲区中是否为满，初值为0。 设缓冲区的编号为1～n-1，定义两个指针in和out，分别是生产者进程和消费者进程使用的指针，指向下一个可用的缓冲区。 生产者进程while(TRUE){ 生产一个产品; P(empty); 产品送往buffer（in）； in=(in+1)mod n； V(full); }消费者进程while(TRUE){ P(full); 从buffer（out）中取出产品； out=(out+1)mod n； V(empty); 消费该产品; }3）一组生产者，一组消费者，公用n个环形缓冲区第三种情况，可以理解成有多间牛奶生产厂家，如蒙牛，达能，光明等，消费者也不只小明一人，有许许多多消费者。不同的牛奶生产厂家生产的商品可以放在不同的好又多分店中销售，而不同的消费者可以去不同的分店中购买。当某一分店已放满某个厂家的商品时，下一个厂家只能把商品放在下一间分店。所以在这种情况中，生产者与消费者存在同步关系，而且各个生产者之间、各个消费者之间存在互斥关系,他们必须互斥地访问缓冲区。解题如下：定义四个信号量：empty——表示缓冲区是否为空，初值为n。full——表示缓冲区中是否为满，初值为0。mutex1——生产者之间的互斥信号量，初值为1。mutex2——消费者之间的互斥信号量，初值为1。设缓冲区的编号为1～n-1，定义两个指针in和out，分别是生产者进程和消费者进程使用的指针，指向下一个可用的缓冲区。 生产者进程while(TRUE){ 生产一个产品; P(empty); P(mutex1)； 产品送往buffer（in）； in=(in+1)mod n； V(mutex1); V(full); }消费者进程while(TRUE){ P(full); P(mutex2)； 从buffer（out）中取出产品； out=(out+1)mod n； V（mutex2）； V(empty);
java 线程同步并发怎么控制
synchronized 方法
通过在方法声明中加入 synchronized关键字来声明 synchronized 方法。如：
public synchronized void getResult();
synchronized方法控制对类成员变量的访问。它是如何来避免类成员变量的访问控制呢？我们知道方法使用了synchronized关键字表明该方法已加锁，在任一线程在访问改方法时都必须要判断该方法是否有其他线程在“独占”。每个类实例对应一个把锁，每个synchronized方法都必须调用该方法的类实例的锁方能执行，否则所属线程阻塞，方法一旦执行，就独占该锁，直到从该方法返回时才将锁释放，被阻塞的线程方能获得该锁。
为某临界区设置一把锁W，当W=1时，表示关锁；
答：整型信号量：lock(W): while W=1 do no-op W:=1;
unlock(W): W:=0;
记录型信号量：lock(W): W:=W+1;
if(W>1) then block(W, L)
unlock(W): W:=W-1;
if(W>0) then wakeup(W, L)
例子：
Var W:semaphore:=0；
begin
repeat
lock(W);
critical section
unlock(W);
remainder section
until false;
end
怎样用C++实现生产者消费者的模拟
多线程你需要用到Mutex和Waitcondition这两个同步。请参考以下代码：
// 首先你要有一个生产者和消费者公用的Buffer，它要求用mutex和condition variable来实现锁
struct BoundedBuffer {
int* buffer;
int capacity;
int front;
int rear;
int count;
std::mutex lock;
std::condition_variable not_full;
std::condition_variable not_empty;
BoundedBuffer(int capacity) : capacity(capacity), front(0), rear(0), count(0) {
buffer = new int[capacity];
}
~BoundedBuffer(){
delete[] buffer;
}
void deposit(int data){
std::unique_lock l(lock);
not_full.wait(l, [this](){return count != capacity; });
buffer[rear] = data;
rear = (rear + 1) % capacity;
++count;
not_empty.notify_one();
}
int fetch(){
std::unique_lock l(lock);
not_empty.wait(l, [this](){return count != 0; });
int result = buffer[front];
front = (front + 1) % capacity;
--count;
not_full.notify_one();
return result;
}
};
// 这里以下是实现。
void consumer(int id, BoundedBuffer& buffer){
for(int i = 0; i < 50; ++i){
int value = buffer.fetch();
std::cout << "Consumer " << id << " fetched " << value << std::endl;
std::this_thread::sleep_for(std::chrono::milliseconds(250));
}
}
void producer(int id, BoundedBuffer& buffer){
for(int i = 0; i < 75; ++i){
buffer.deposit(i);
std::cout << "Produced " << id << " produced " << i << std::endl;
std::this_thread::sleep_for(std::chrono::milliseconds(100));
}
}
int main(){
BoundedBuffer buffer(200);
std::thread c1(consumer, 0, std::ref(buffer));
std::thread c2(consumer, 1, std::ref(buffer));
std::thread c3(consumer, 2, std::ref(buffer));
std::thread p1(producer, 0, std::ref(buffer));
std::thread p2(producer, 1, std::ref(buffer));
c1.join();
c2.join();
c3.join();
p1.join();
p2.join();
return 0;
}
用C语言实现--生产者与消费者的问题(PV操作)
这个问题蛮好的
我给你个程序
给我加分啊
#include
#include
#include
typedef
HANDLE
Semaphore;
//
信号量的Windows原型
#define
P(S)
WaitForSingleObject(S,
INFINITE)
//
定义Windows下的P操作
#define
V(S)
ReleaseSemaphore(S,
1,
NULL)
//
定义Windows下的V操作
#define
rate
1000
#define
CONSUMER_NUM
10
/*
消费者个数
*/
#define
PRODUCER_NUM
10
/*
生产者个数
*/
#define
BUFFER_NUM
4
/*
缓冲区个数
*/
char
*thing[10]
=
{"猪脸",
"牛鞭",
"羊腰",
"驴蹄",
"狼心",
"狗肺",
"猴肝",
"老虎屁股",
"大象肚",
"河马大肠"};
struct
Buffer
{
int
product[BUFFER_NUM];
//
缓冲区
int
start,
end;
//
两个指针
}
g_buf;
Semaphore
g_semBuffer,
g_semProduct,
g_mutex;
//
消费者线程
DWORD
WINAPI
Consumer(LPVOID
para)
{
//
i表示第i个消费者
int
i
=
*(int
*)para;
int
ptr;
//
待消费的内容的指针
printf("
猪头-%03d:
猪头我来啦！\n",
i);
Sleep(300);
while
(1)
{
printf("
猪头-%03d:
我要吃.........!\n",
i);
//
等待产品
P(g_semProduct);
//
有产品，先锁住缓冲区
g_buf
P(g_mutex);
//
记录消费的物品
ptr
=
g_buf.start;
//
再移动缓冲区指针
g_buf.start
=
(g_buf.start+1)%BUFFER_NUM;
//
让其他消费者或生产者使用
g_buf
V(g_mutex);
printf("
猪头-%03d:
我吃
buf[%d]
=
%s\n",
i,
ptr,
thing[g_buf.product[ptr]]);
Sleep(rate*rand()%10+110);
//
消费完毕，并释放一个缓冲
printf("
猪头-%03d:
我爽了！
buf[%d]
=
%s\n",
i,
ptr,
thing[g_buf.product[ptr]]);
V(g_semBuffer);
}
return
0;
}
//
生产者线程
DWORD
WINAPI
Producer(LPVOID
para)
{
int
i
=
*(int
*)para
-
CONSUMER_NUM;
int
ptr;
int
data;
//
产品
printf("工作狂-%03d:
我来啦！\n",
i);
Sleep(300);
while
(1)
{
printf("工作狂-%03d:
我干干干…………\n",
i);
Sleep(rate*rand()%10+110);
data
=
rand()%10;
printf("工作狂-%03d:
搞出一个东西
data
=
%s!\n",
i,
thing[data]);
//
等待存放空间
P(g_semBuffer);
//
有地方，先锁住缓冲区
g_buf
P(g_mutex);
//
记录消费的物品
ptr
=
g_buf.end;
//
再移动缓冲区指针
g_buf.end
=
(g_buf.end+1)%BUFFER_NUM;
//
让其他消费者或生产者使用
g_buf
V(g_mutex);
printf("工作狂-%03d:
搁到
buf[%d]
=
%s\n",
i,
ptr,
thing[data]);
g_buf.product[ptr]
=
data;
Sleep(rate/2*rand()%10+110);
//
放好了完毕，释放一个产品
printf("工作狂-%03d:
buf[%d]
=
%s
放好了，大家吃！\n",
i,
ptr,
thing[g_buf.product[ptr]]);
V(g_semProduct);
}
return
0;
}
int
main(int
argc,
char
*argv[])
{
//
线程技术，前面为消费者线程，后面为生产者线程
HANDLE
hThread[CONSUMER_NUM+PRODUCER_NUM];
//
线程计数
//srand(time());
DWORD
tid;
int
i=0;
//
初始化信号量
g_mutex
=
CreateSemaphore(NULL,
BUFFER_NUM,
BUFFER_NUM,
"mutexOfConsumerAndProducer");
g_semBuffer
=
CreateSemaphore(NULL,
BUFFER_NUM,
BUFFER_NUM,
"BufferSemaphone");
g_semProduct
=
CreateSemaphore(NULL,
0,
BUFFER_NUM,
"ProductSemaphone");
if
(
!g_semBuffer
||
!g_semProduct
||
!g_mutex)
{
printf("Create
Semaphone
Error!\n");
return
-1;
}
int
totalThreads
=
CONSUMER_NUM+PRODUCER_NUM;
//
开启消费者线程
printf("先请猪头们上席！\n");
for
(i=0;
i<CONSUMER_NUM;
i++)
{
hThread[i]
=
CreateThread(NULL,
0,
Consumer,
&i,
0,
&tid);
if
(
hThread[i]
)
WaitForSingleObject(hThread[i],
10);
}
printf("厨子们就位！\n");
for
(;
i<totalThreads;
i++)
{
hThread[i]
=
CreateThread(NULL,
0,
Producer,
&i,
0,
&tid);
if
(
hThread[i]
)
WaitForSingleObject(hThread[i],
10);
}
//
生产者和消费者的执行
WaitForMultipleObjects(totalThreads,
hThread,
TRUE,
INFINITE);
return
0;
}
windows下怎么获取信号量当前值
在windows中获取信号量当前值的方法：
1、分别创建进程A和B
2、进程A 创建一个叫 test 的信号量 mutex1 = CreateSemaphore(..."test"...);
3、进程B 打开该 test 信号量 mutex2 = OpenSemaphore(..."test"...);（ 1 ） CreateSemaphore()
HANDLE WINAPI CreateSemaphore(
_In_opt_ LPSECURITY_ATTRIBUTES lpEventAttributes,
_In_ LONG lInitialCount,
_In_ LONG lMaximumCount,
_In_opt_ LPCTSTR lpName
);
lpEventAttributes ：事件对象的安全属性，一般置为NULL ；
lInitialCount ：表示一开始可以使用的资源数目，即当前资源计数；
lMaximumCount ：信号量对象可以处理的最大资源数量；
lpName ：创建有名的信号量对象，用于进程间的共享；
如果该信号量对象已经存在，那么 Create Semaphore会返回该内核对象的句柄，并通过系统返回错误 ERROR_ALREADY_EXISTS ，通过 GetLastError （）获得。
因为系统会维护内核对象的一个使用计数，每被引用一次，计数递增1，调用 CloseHandle()函数“关闭”对象，会从进程的句柄表中删除该对象的句柄索引，对象的使用计数递减1，如果计数未递减至0，该对象不会被销毁，只有计数递减至0，说明对该对象的所有引用都已关闭，系统才会销毁该对象。然后系统底层会维护这个内核对象，当所有进程都没有引用这个内核对象的时候会释放掉。最后的出来的当量信号值为信号量。
计算机*作系统中，若P、V*作的信号量S初值为2，当前值为-1，则表示有____个等待进程
有1个等待进程。信号量(Semaphore)，是可以用来保证两个或多个关键代码段不被并发调用。在进入一个关键代码段之前，线程必须获取一个信号量；一旦该关键代码段完成了，那么该线程必须释放信号量。其它想进入该关键代码段的线程必须等待直到第一个线程释放信号量。为了完成这个过程，需要创建一个信号量VI，然后将Acquire Semaphore VI以及Release Semaphore VI分别放置在每个关键代码段的首末端。初值为2，表示初始时有两个可用的资源。现在为-1，就说明这两个可用资源已经被占用了，有一个进程还在等待资源。扩展资料：对信号量有4种操作(#include)：1、 初始化（initialize），也叫做建立（create） int sem_init(sem_t *sem, int pshared, unsigned int value);2、等信号（wait），也可叫做挂起（suspend）int sem_wait(sem_t *sem);3、给信号（signal）或发信号（post） int sem_post（sem_t *sem）;4、清理（destroy） int sem_destory(sem_t *sem)。参考资料来源：百度百科-信号量
