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

1.Semahpore

2

package 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<permitNum){
            nowPermitNum++;
        }
    }
}

2.TestCustomerAndPudction

package 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();
    }
}