Java 等待和通知的多线程\u问题

我正在研究以下问题的更简单版本：

并以以下方式简化了问题：

SO: input pipe is PIPE4 and output pipe is PIPE0
S1: input pipe is PIPE0 and output pipe is PIPE1
S2: input pipe is PIPE1 and output pipe is PIPE2
S3: input pipe is PIPE2 and output pipe is PIPE3
S4: input pipe is PIPE3 and output pipe is PIPE4

我得到的输出：

WHO CAME??
Pipe4 and Pipe0:Position0
GRANTING ACCESS TO
Pipe4 and Pipe0
WHO CAME??
Pipe0 and Pipe1:Position1
SLEEPING : 1
RELIEVING
NOTIFIED
Final Capacity at 0 is 4
4,4,3,1,2   
*/

每次它在这一点上卡住。。有人能帮我吗

任何帮助都将不胜感激 多谢各位

我也附上代码：

package Thread;

import java.util.ArrayList;

class Connection
{
String in_pipe;
String out_pipe;

//true: Available && false: Occupied
static boolean available[]={true,true,true,true,true};

public Connection(String in_pipe,String out_pipe)
{
    this.in_pipe=in_pipe;
    this.out_pipe=out_pipe;
}

public void setAvailability(boolean status,int in_pipe_number,int out_pipe_number)
{
    available[in_pipe_number]=status;
    available[out_pipe_number]=status;
}

public boolean getAvailability(int pipe_number)
{
    return available[pipe_number];
}

public String getInPipe()
{
    return in_pipe;
}

public String getOutPipe()
{
    return out_pipe;
}

}

/-----------------------------------------------------------------------------/

类站实现可运行 { 静态int泵容量[]={5,4,3,1,2}

Thread t;
boolean flag_in=false;
boolean flag_out=false;
Connection station_connection;
int index;

int input_number,output_number; 

public void setPumpCapacity(int capacity,int pipe_number)
{
    pump_capacity[pipe_number]=capacity;
}

public int getPumpCapacity(int pipe_number)
{
    return pump_capacity[pipe_number];
}

public Station(Connection station_connection,int index)
{
    this.station_connection=station_connection;
    this.index=index;
    t=new Thread(this);
}

public void checkAccess()
{
    //boolean access_granted=false;
    //long thread_waiting;

    String input=station_connection.getInPipe();
    input_number=Integer.parseInt(input.substring(input.length()-1));

    String output=station_connection.getOutPipe();
    output_number=Integer.parseInt(output.substring(output.length()-1));

    System.out.println("WHO CAME??\n"+"Pipe"+input_number+"\t\t"+"Pipe"+output_number+"\t\tPosition"+index);

    if((station_connection.getAvailability(input_number))&&(station_connection.getAvailability(output_number)))
    {
        //access_granted=true;
        grantAccess(input_number,output_number);
    }
    else
    {
        synchronized(this)
        {
            //access_granted=false;
            try 
            {
                System.out.println("SLEEPING : "+index);
                wait();
                //thread_waiting=t.getId();
            } 
            catch (InterruptedException e) 
            {
                    e.printStackTrace();
            }
        }
    }
}

public void grantAccess(int input_number,int output_number)
{
    if(getPumpCapacity(index)>0)
    {
        System.out.println("GRANTING ACCESS TO\n"+"Pipe"+input_number+"\t\t"+"Pipe"+output_number);
        station_connection.setAvailability(false, input_number, output_number);
    }
}

@Override
public void run() 
{
    long id=t.getId();
    if(getPumpCapacity(index)>0)
    {
        setPumpCapacity(getPumpCapacity(index)-1,index);
        try 
        {
            Thread.sleep(5000);
        } 
        catch (InterruptedException e) 
        {
            System.out.println("Catch Exception : "+e.getMessage());
        }
        finally
        {
            System.out.println("Final Capacity at "+index+" = "+getPumpCapacity(index));
            for(int i=0;i<5;i++)
            {
                System.out.print(pump_capacity[i]+"\t");
            }
            System.out.println();
        }
    }
    relieveAccess(input_number,output_number,id);       
}

public void relieveAccess(int in_number,int out_number,long thread_id)
{
    System.out.println("RELIEVING");
    station_connection.setAvailability(true, in_number, out_number);
    synchronized(this)
    {
        notify();
        System.out.println("NOTIFIED");
    }
    /*
    for (Thread th : Thread.getAllStackTraces().keySet()) 
    {  
        if(th.getId()==thread_id)
        {
            System.out.println("Close");
            th.destroy();
        }
    }
    */
}

线程t；
布尔标志_in=false；
布尔标志_out=false；
连接站\u连接；
整数指数；
int输入_数，输出_数；
公共真空设置泵容量（内部容量、内部管道号）
{
泵容量[管道数量]=容量；
}
公共int getPumpCapacity（int管道编号）
{
回流泵容量[管道编号]；
}
公共站（连接站\连接，int索引）
{
这个。站点连接=站点连接；
这个。索引=索引；
t=新螺纹（本螺纹）；
}
公共void checkAccess（）
{
//boolean access_grated=false；
//长时间的等待；
字符串输入=station_connection.getInPipe（）；
input_number=Integer.parseInt（input.substring（input.length（）-1））；
字符串输出=station_connection.getOutPipe（）；
output_number=Integer.parseInt（output.substring（output.length（）-1））；
System.out.println（“谁来了？”\n“+”管道“+输入\编号+”\t\t“+”管道“+输出\编号+”\t\t位置“+索引）；
if（（站点连接.getAvailability（输入编号））&（站点连接.getAvailability（输出编号）））
{
//允许访问=真；
grantAccess（输入号、输出号）；
}
其他的
{
已同步（此）
{
//允许访问=错误；
尝试
{
System.out.println（“休眠：+索引”）；
等待（）；
//线程_waiting=t.getId（）；
} 
捕捉（中断异常e）
{
e、 printStackTrace（）；
}
}
}
}
公共无效授权访问（整数输入\编号，整数输出\编号）
{
如果（getPumpCapacity（索引）>0）
{
System.out.println（“授予对\n”+“管道”+输入\u编号+“\t\t”+“管道”+输出\u编号的访问权”）；
站点连接。设置可用性（假、输入号、输出号）；
}
}
@凌驾
公开募捐
{
long id=t.getId（）；
如果（getPumpCapacity（索引）>0）
{
setPumpCapacity（getPumpCapacity（索引）-1，索引）；
尝试
{
睡眠（5000）；
} 
捕捉（中断异常e）
{
System.out.println（“捕获异常：+e.getMessage（））；
}
最后
{
System.out.println（“在“+index+”=“+getPumpCapacity（index））时的最终容量）；
对于（inti=0；iAnalyze），状态是什么，您希望是什么状态？嗨，我也附加了代码，我正在检查状态，但也没有帮助。
static Connection connection[]={new Connection("Pipe4","Pipe0"),
    new Connection("Pipe0","Pipe1"),
    new Connection("Pipe1","Pipe2"),
    new Connection("Pipe2","Pipe3"),
    new Connection("Pipe3","Pipe4"),
    };

public void initialize()
{
    for(int i=0;i<5;i++)
    {
        pipe_connection.add(connection[i]);
    }
}

public static void main(String[] args) 
{
    PipeSystem ob=new PipeSystem();
    ob.initialize();

    Station st[]=new Station[5];
    for(int i=0;i<5;i++)
    {
        st[i]=new Station(connection[i],i);
        st[i].checkAccess();
        st[i].t.start();
    }
}