java里信号量操作,线程信号量操作

为兼容jdk1.5之前版本的信号量操作：

1.Semahpore

2package com.jzy.thread;

import java.util.Random;

import java.util.Vector;

//信号量

public class Semahpore {

private Vector locks=new Vector(); //保存线程

private int permitNum=1; //允许的的信号量数

private int nowPermitNum=1; //现在的信号量数

private boolean isAllowGrow=false; //是否自动增长信号量数

private boolean fair=false; //是否公平

Random random=new Random();

public Semahpore(int permitNum,boolean isAllowGrow,boolean fair){

this.permitNum=permitNum;

nowPermitNum=permitNum;

this.isAllowGrow=isAllowGrow;

this.fair=fair;

}

public Semahpore(int permitNum,boolean fair){

this(permitNum, true, fair);

}

public Semahpore(int permitNum){

this(permitNum, false);

}

// 消费者希望从信号量中获取一个信号许可，如果目前仍然存在可用许可，

//则消费者顺利执行，否则消费者线程阻塞等待，直到生产者生产资源，产生新的许可

public void acquier(){

if(nowPermitNum>0){

nowPermitNum--;

}else{

Object obj=new Object();

locks.add(obj);

synchronized (obj) {

try {

obj.wait();

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

}

}

}

// 生产者已经生产了新的可供消费资源，向信号量中增加一个可用许可

public void relase(){

if(locks.size()>0){

int index=0;

if(!fair){

index=Math.abs(random.nextInt())%locks.size();

}

Object obj=locks.get(index);

locks.remove(index);

synchronized (obj) {

obj.notify();

}

}else if(isAllowGrow||nowPermitNum

nowPermitNum++;

}

}

}

2.TestCustomerAndPudctionpackage com.jzy.thread;

import java.util.Random;

import java.util.UUID;

import java.util.Vector;

public class TestCustomerAndPudction {

/**

* @param args

*/

public static void main(String[] args) {

final Vector buffer = new Vector(); //保存生产者产生的数据

final Random random = new Random();

final Semahpore sem = new Semahpore(0,true,true);

final int x = Math.abs(random.nextInt()) % 100; //定义消费者等待时间

final int y = Math.abs(random.nextInt()) % 1000; //定义生产者等待时间

Thread c1 = new Thread() {

public void run() {

while (true) {

System.out.println("消费者1请求获取资源");

sem.acquier();

String str = buffer.get(0).toString();

System.out.println("消费者1获取资源是" + str);

try {

Thread.sleep(100 + x);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

}

}

};

Thread c2 = new Thread() {

public void run() {

while (true) {

System.out.println("消费者2请求获取资源");

sem.acquier();

String str = buffer.get(0).toString();

System.out.println("消费者2获取资源是" + str);

try {

Thread.sleep(100 + x);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

}

}

};

Thread c3 = new Thread() {

public void run() {

while (true) {

System.out.println("消费者3请求获取资源");

sem.acquier();

String str = buffer.get(0).toString();

System.out.println("消费者3获取资源是" + str);

try {

Thread.sleep(100 + x);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

}

}

};

c1.start();

c2.start();

c3.start();

Thread p1 = new Thread() {

public void run() {

while (true) {

try {

Thread.sleep(1000 + y);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

String str=UUID.randomUUID().toString();

buffer.add(str);

System.out.println("生产者1生产了资源："+str);

sem.relase();

}

}

};

Thread p2 = new Thread() {

public void run() {

while (true) {

try {

Thread.sleep(1000 + y);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

String str=UUID.randomUUID().toString();

buffer.add(str);

System.out.println("生产者2生产了资源："+str);

sem.relase();

}

}

};

p1.start();

p2.start();

}

}