这儿我用Debug看了，貌似进入死循环了

import java.nio.Buffer;
import java.nio.IntBuffer;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class SuperThread {
//定义缓冲区的读写锁
private Lock bufferLock = new ReentrantLock();

// 共享缓冲区
public static IntBuffer buffer = IntBuffer.allocate(5);
//生产者数组

public int array[] = {1,5,6,9,8,11,13,10,7,3};
//生产者执行的次数
public static int count = 0;
//两个生产者取出数据的累加
public static int consumerSum = 0;
//记录消费者取数次数
public static int consumerCount = 0;
//存放从缓冲区中取得的数据
private static int consumerData;
//定义线程名
public String nameString;
//线程互斥信号，值为 0 表示生产者进程，值为 1 表示消费者进程
public static int mutex = 0;
/* 构造函数 */
public SuperThread(String name){
//主要完成一些变量的初始化
}
/* 获得线程名 */
public String getNameString() {
return nameString;
}
/* 设置线程名 */
public void setNameString(String nameString) {
this.nameString = nameString;
}
/* 获得互斥信号 */
public static int getMutex() {
return mutex;
}
/* 设置互斥信号 */
public static void setMutex(int mutex) {
SuperThread.mutex = mutex;
}
/* 判断是否有线程访问缓冲区，没有则对线程进行加锁 */
public boolean wait(int mutex){
if (mutex == 1) {
return false;
}else {
return true;
}
}
/* 释放进程操作完成信号，其实本质就是修改mutex的信号值 */
public static void signal(){
mutex = 0;
}
public boolean isBufferEmpty(){//判断缓冲区是否为空
int count = 0;
for (int i = 0; i < buffer.capacity(); i++) {
if (buffer.get(i) == 0) {//根据缓冲区中的0的个数来判断，若缓冲区0的个数为5（缓冲区容量为5），则为空
count ++;
}
}
if (count == 5) {
return true;
}else {
return false;
}
}
public boolean isBufferFull(){//判断缓冲区是否为满
int count = 0;
for (int i = 0; i < buffer.capacity(); i++) {
if (buffer.get(i) != 0) {//根据缓冲区中不为0的个数来判断，若缓冲区不为0的个数小于5（缓冲区容量为5）则不为满
count ++;
}
}
if (count < 5) {
return false;
}else {
return true;
}

}
/* 消费数，即在缓冲区中取数 */
public void consume(){
if (wait(mutex) && !isBufferEmpty()) {
bufferLock.lock();//对该程序段加锁，防止其他线程访问缓冲区
try {
setMutex(1);//将线程互斥信号值mutex设置为1，使之互斥
int index = 0;//存放顺序查找第一个为0的数的下摆
int i;
for (i = 0; i < buffer.capacity(); i++) {//顺序查找第一个为 0的数
if (buffer.get(i) == 0) {
index = i;
break;
}else if(buffer.get(4) > 0){//缓冲区为满的情况
index = 5;
}
}
consumerData = getBufferData(index-1);//取数据
consumerCount ++;
if (consumerCount <= 2 ) {
consumerSum = consumerSum + consumerData;//计算两次取数 之和
if (consumerCount == 2) {
System.out.println("消费者取数之和为："+consumerSum);
consumerSum = 0;
consumerCount = 0;
}
}
buffer.put(index-1, 0);//将已取过数的缓冲区重新置0
//consumerPrintBufferData();//输出取数后的缓冲区
signal();//释放互斥信号，将mutex设置为0
}finally{
bufferLock.unlock();//解锁
}
}
}
/* 消费者取得缓冲区数据*/
public int getBufferData(int index){
//完成取数操作
return buffer.get(index);
}
/* 生产数，即向缓冲区中存数*/
public void produce(){
if (wait(mutex) && !isBufferFull()) {
bufferLock.lock();//对该程序段加锁，防止其他线程访问缓冲区
try{
setMutex(1);//将线程互斥信号值mutex设置为1，使之互斥
int index = 0;
for (int i = 0; i < buffer.capacity(); i++){//寻找存数的位置
if (buffer.get(i) == 0) {
index = i;
break;
}
}
putBufferData(index);//向缓冲区中存入数据
signal();//释放互斥信号，将mutex设置为0
}finally{
bufferLock.unlock();//解锁
}
}
}
/* 生产者向公共缓冲区放数据*/
public void putBufferData(int index){
buffer.put(array[index]);//完成想缓冲区存数操作
}
}

public class Test{
public static void main(String[] args) {

Producer producer = new Producer("producer");
Consumer consumer1 = new Consumer("consumer1");
Consumer consumer2 = new Consumer("consumer2");

new Thread(producer).start();
new Thread(consumer1).start();
new Thread(consumer2).start();
}
}
后面是测试包含main方法的类，producer和consumer中run方法只是执行superthread中prduce和consum方法，执行producer线程后貌似执行consumer1线程时总是break;