信号量与PV java

进程间通信:
进程通常分为就绪、运行和阻塞三个工作状态。三种状态在某些条件下可以转换,三者之间的转换关系如下:

进程三个状态之间的转换就是靠PV操作来控制的。PV操作主要就是P操作、V操作和信号量。其中信号量起到了至关重要的作用。

信号量
信号量是最早出现的用来解决进程同步与互斥问题的机制。 
信号量(Saphore)由一个值和一个指针组成,指针指向等待该信号量的进程。信号量的值表示相应资源的使用情况。信号量S>=0时,S表示可用资源的数量。执行一次P操作意味着请求分配一个资源,因此S的值减1;当S<0时,表示已经没有可用资源,S的绝对值表示当前等待该资源的进程数。请求者必须等待其他进程释放该类资源,才能继续运行。而执行一个V操作意味着释放一个资源,因此S的值加1;若S<0,表示有某些进程正在等待该资源,因此要唤醒一个等待状态的进程,使之运行下去。

注意,信号量的值只能由PV操作来改变。
  
 
关于PV操作容易产生的一些疑问:

1,S大于0那就表示有临界资源可供使用,为什么不唤醒进程?
S大于0的确表示有临界资源可供使用,也就是说这个时候没有进程被阻塞在这个资源上,所以不需要唤醒。

2,S小于0应该是说没有临界资源可供使用,为什么还要唤醒进程?
V原语操作的本质在于:一个进程使用完临界资源后,释放临界资源,使S加1,以通知其它的进程,这个时候如果S<0,表明有进程阻塞在该类资源上,因此要从阻塞队列里唤醒一个进程来“转手”该类资源。比如,有两个某类资源,四个进程A、B、C、D要用该类资源,最开始S=2,当A进入,S=1,当B进入S=0,表明该类资源刚好用完, 当C进入时S=-1,表明有一个进程被阻塞了,D进入,S=-2。当A用完该类资源时,进行V操作,S=-1,释放该类资源,因为S<0,表明有进程阻塞在该类资源上,于是唤醒一个。

3,如果是互斥信号量的话,应该设置信号量S=1,但是当有5个进程都访问的话,最后在该信号量的链表里会有4个在等待,也是说S=-4,那么第一个进程执行了V操作使S加1,释放了资源,下一个应该能够执行,但唤醒的这个进程在执行P操作时因S<0,也还是执行不了,这是怎么回事呢?
当一个进程阻塞了的时候,它已经执行过了P操作,并卡在临界区那个地方。当唤醒它时就立即进入它自己的临界区,并不需要执行P操作了,当执行完了临界区的程序后,就执行V操作。

4,S的绝对值表示等待的进程数,同时又表示临界资源,这到底是怎么回事?
当信号量S小于0时,其绝对值表示系统中因请求该类资源而被阻塞的进程数目.S大于0时表示可用的临界资源数。注意在不同情况下所表达的含义不一样。当等于0时,表示刚好用完。

某工厂有一个可以存放设备的仓库,总共可以存放10台设备。生产的每一台设备都必 须入库,销售部门可从仓库提出设备供应客户。设备的入库和出库都必须借助运输工具。现只有一台运输工具,每次只能运输一台设备。请设计一个能协调工作的自动调度管理系统。
参考答案: 第一步:确定进程 可以为入库(Pin)和出库(Pout)各设置一个进程 Pin进程:  生产了一台设备  使用运输工具入库 Pout进程:  使用运输工具出库

 提出设备供应客户 第二步:确定进程的同步、互斥关系  同步:当仓库中有空余位置存放设备时,设备才可以入库  同步:当仓库中有存放的设备时,设备才可以出库  互斥:运输工具是临界资源,要互斥访问 第三步:设置信号量  仓库中有空余位置数量,empty,初值10  仓库中有存放的设备数量,full,初值 0  为运输工具设置互斥信号量S,初值 1,表示当前可用 第四步:用伪代码描述

begin empty, full, S:semaphore;
empty := 10; full := 0; S := 1;
cobegin Pin ();
Pout (); coend;
end;
process Pin ( ) begin
L1: 生产了一台设备 P(empty);
P (S); 使用运输工具入库;
V (S);
V(full);
goto L1;
end;
process Pout ( ) begin
L2: P(full);
P (S); 使用运输工具出库; V (S); V(empty); 提出设备供应客户; goto L2; end;



/**
* 空余位置
*/
public class AvailablePositionSemaphore {

private int num = 0;

public AvailablePositionSemaphore(int num) {
this.num = num;
}

public synchronized int p_AvailablePosition() throws InterruptedException {
if (num >= 10) {
wait();
}
return num--;
}

public synchronized int v_AvailablePosition() {
this.notify();
return num++;
}
}



/**
* 设备数量
*/
public class EquipmentSemaphore {

private int num = 0;

public EquipmentSemaphore(int num){
this.num = num;
}

public synchronized int p_Equipment() {
if (num > 0) {
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
return num--;
}

public synchronized int v_Equipment() {
this.notify();
return num++;
}
}



public class ToolSemaphore {

private int num = 0;

public ToolSemaphore(int num) {
this.num = num;
}

public synchronized int p_Tool() {
if (num <= 0) {
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
return num--;
}

public synchronized int v_Tool() {
this.notify();
return num++;
}
}



public class ProducerThread extends Thread {

private AvailablePositionSemaphore availablePositionSemaphore;
private EquipmentSemaphore equipmentSemaphore;
private ToolSemaphore toolSemaphore;

public ProducerThread(AvailablePositionSemaphore availablePositionSemaphore, EquipmentSemaphore equipmentSemaphore,
ToolSemaphore toolSemaphore) {
this.availablePositionSemaphore = availablePositionSemaphore;
this.equipmentSemaphore = equipmentSemaphore;
this.toolSemaphore = toolSemaphore;
}

public void buildNew() {
System.out.println("buildNew begin");
try {
Thread.sleep(1000L);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("buildNew end");
}

@Override
public void run() {
while (true) {
try {
buildNew();
int num1 = availablePositionSemaphore.p_AvailablePosition();
int num2 = toolSemaphore.p_Tool();
toolSemaphore.v_Tool();
equipmentSemaphore.v_Equipment();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}

}



public class ConsumerThread extends Thread {

private AvailablePositionSemaphore availablePositionSemaphore;
private EquipmentSemaphore equipmentSemaphore;
private ToolSemaphore toolSemaphore;

public ConsumerThread(AvailablePositionSemaphore availablePositionSemaphore, EquipmentSemaphore equipmentSemaphore,
ToolSemaphore toolSemaphore) {
this.availablePositionSemaphore = availablePositionSemaphore;
this.equipmentSemaphore = equipmentSemaphore;
this.toolSemaphore = toolSemaphore;
}

public void sell() {
System.out.println("sell begin");
try {
Thread.sleep(1000L);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("sell end");
}

@Override
public void run() {
while (true) {
try {
Thread.sleep(2000L);
int num1 = equipmentSemaphore.p_Equipment();
int num2 = toolSemaphore.p_Tool();
sell();
toolSemaphore.v_Tool();
availablePositionSemaphore.v_AvailablePosition();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}

}




public static void main(String[] args) {
// TODO Auto-generated method stub
AvailablePositionSemaphore a1 = new AvailablePositionSemaphore(10);
EquipmentSemaphore a2 = new EquipmentSemaphore(0);
ToolSemaphore a3 = new ToolSemaphore(1);
ProducerThread producer = new ProducerThread(a1, a2, a3);
ConsumerThread consumer = new ConsumerThread(a1, a2, a3);
producer.start();
consumer.start();
}

<think>嗯,用户想了解生产者消费者问题中的信号量P操作和V操作的用法,以及实现机制和代码示例。首先,我需要回顾一下生产者消费者问题的基本概念。根据引用[4],这个问题涉及到两个线程,生产者和消费者,共享一个固定大小的缓冲区。关键是要保证生产者在缓冲区满时不添加数据,消费者在缓冲区空时不消费数据,避免死锁。 接下来,信号量的作用。引用[1]提到信号量用于避免死锁,控制资源访问和进程同步。在生产者消费者问题中,通常需要三个信号量:mutex用于互斥访问缓冲区,empty和full分别表示空槽位和已填充槽位的数量。引用[2]和[3]详细说明了Linux和Java中如何用信号量实现PV操作。例如,生产者需要先等待empty信号量(P操作),然后获取mutex,生产数据后释放mutex和full(V操作)。消费者则相反,等待full,获取mutex,消费后释放mutex和empty。 用户可能需要代码示例。引用[2]提供了Python伪代码,但用户可能需要更具体的语言比如Java或C。根据引用[3],Java中使用Semaphore类来实现。需要展示如何初始化信号量,以及生产者和消费者的代码结构,注意P操作对应acquire(),V操作对应release(),并且要处理中断异常。 还要注意,PV操作必须成对出现,避免死锁。比如,生产者先P(empty)再P(mutex),顺序不能颠倒,否则可能导致死锁。引用[5]强调了互斥访问和等待条件的重要性。 用户可能的疑问包括:为什么需要三个信号量?如果只用mutex会怎样?这时候需要解释empty和full控制缓冲区状态,而mutex确保互斥。如果缺少empty和full,生产者和消费者无法正确等待,可能导致忙等或死锁。 最后,代码示例部分需要确保正确性,比如在Java中使用try-finally块保证mutex释放,以及正确处理中断。同时,提醒用户在实际应用中可能需要更复杂的逻辑,比如多个生产者和消费者的情况。</think>### 生产者-消费者问题中的信号量机制及实现 生产者-消费者问题的核心是通过信号量(Semaphore)的P操作(等待)和V操作(释放)实现**互斥访问**和**同步控制**,确保缓冲区在多线程环境下安全操作。以下是具体实现机制和代码示例: --- #### 一、信号量作用及分类 1. **互斥信号量(`mutex`)** - 确保同一时刻仅一个线程(生产者或消费者)访问缓冲区,防止数据竞争。 - 初始值设为1,表示临界区未被占用[^1]。 2. **资源信号量(`empty`和`full`)** - `empty`:表示缓冲区中剩余的空槽位数量,初始值为缓冲区总容量$n$[^4]。 - `full`:表示缓冲区中已填充的槽位数量,初始值为0[^5]。 --- #### 二、P操作V操作的逻辑 1. **生产者逻辑** - **P(empty)**:检查是否有空槽位。若无,则阻塞等待消费者释放资源。 - **P(mutex)**:获取缓冲区访问权限,进入临界区。 - 生产数据并放入缓冲区。 - **V(mutex)**:释放缓冲区访问权限。 - **V(full)**:通知消费者有新增数据可消费[^2]。 2. **消费者逻辑** - **P(full)**:检查是否有数据可消费。若无,则阻塞等待生产者生产。 - **P(mutex)**:获取缓冲区访问权限,进入临界区。 - 从缓冲区取出数据并消费。 - **V(mutex)**:释放缓冲区访问权限。 - **V(empty)**:通知生产者有空槽位可用[^3]。 --- #### 三、代码示例(Java实现) ```java import java.util.concurrent.Semaphore; class Buffer { private static final int BUFFER_SIZE = 5; private int[] buffer = new int[BUFFER_SIZE]; private int in = 0, out = 0; // 定义信号量 private Semaphore mutex = new Semaphore(1); // 互斥信号量 private Semaphore empty = new Semaphore(BUFFER_SIZE); // 空槽位 private Semaphore full = new Semaphore(0); // 已填充槽位 // 生产者方法 public void produce(int item) throws InterruptedException { empty.acquire(); // P(empty):等待空槽位 mutex.acquire(); // P(mutex):获取缓冲区访问权 buffer[in] = item; in = (in + 1) % BUFFER_SIZE; System.out.println("生产: " + item); mutex.release(); // V(mutex):释放缓冲区 full.release(); // V(full):通知消费者有数据 } // 消费者方法 public int consume() throws InterruptedException { full.acquire(); // P(full):等待有数据可消费 mutex.acquire(); // P(mutex):获取缓冲区访问权 int item = buffer[out]; out = (out + 1) % BUFFER_SIZE; System.out.println("消费: " + item); mutex.release(); // V(mutex):释放缓冲区 empty.release(); // V(empty):通知生产者有空槽位 return item; } } // 测试代码 public class ProducerConsumerDemo { public static void main(String[] args) { Buffer buffer = new Buffer(); // 生产者线程 new Thread(() -> { for (int i = 0; i < 10; i++) { try { buffer.produce(i); Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } } }).start(); // 消费者线程 new Thread(() -> { for (int i = 0; i < 10; i++) { try { buffer.consume(); Thread.sleep(200); } catch (InterruptedException e) { e.printStackTrace(); } } }).start(); } } ``` --- #### 四、关键点分析 1. **PV操作的顺序** - 生产者必须先执行`P(empty)`再执行`P(mutex)`,否则可能导致死锁(例如缓冲区已满时生产者仍持有`mutex`锁)[^4]。 - 消费者同理,必须先`P(full)`再`P(mutex)`。 2. **信号量的原子性** - PV操作是原子性的,通过操作系统底层支持实现,确保线程安全。 3. **扩展性** - 若需支持多个生产者或消费者,只需调整线程数量,但需保证信号量逻辑不变[^5]。 ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值