Question

我在使用2个线程之间的信号量设置临界区时遇到问题。我正在使用信号量来获取（发送）我的客户线程并在我的柜员线程中释放。然而，当我运行我的程序时，它总是挂起，我不知道为什么。我尝试了几件事，我不确定是什么问题。

我正在尝试使用存款信号量来设置客户线程和柜员线程的关键部分。

import java.util.concurrent.Semaphore;

public class Threads {

// private int customerNumber = 0;
 private static Semaphore deposit = new Semaphore (0, true);



public static void main(String[] args) 

{
    final int customerThreads = 5;
    final int tellerThreads = 2;
    final int loanThreads = 1;

    Customer thr[] = new Customer[customerThreads]; // make 5 customer threads
    Thread cThread[] = new Thread[customerThreads]; // made 5 threads

    for (int i= 0; i < customerThreads; i++)
    {
        thr[i]= new Customer(i);
        cThread[i] = new Thread(thr [i]);
        cThread[i].start();

    }
    for ( int i = 0; i < customerThreads; i++ )
    {
        try {
            cThread[i].join ();
            System.out.println("Customer"+i + "joined from main");

        }
        catch (InterruptedException e)
        {

        }
    }

    Teller thr1[] = new Teller[tellerThreads];
    Thread tThread[] = new Thread[tellerThreads];
    for (int b = 0; b< tellerThreads; b++)
    {
        thr1[b] = new Teller(b);
        tThread[b]= new Thread(thr1 [b]);
        tThread[b].start();
    }

    LoanOfficer thr2[] = new LoanOfficer[loanThreads];
    Thread lThread[] = new Thread[loanThreads];
    for(int c = 0; c< loanThreads; c++)
    {
        thr2[c] = new LoanOfficer(c);
        lThread[c] = new Thread(thr2 [c]);
        lThread[c].start();           
    }               
    // TODO code application logic here
}



static class Customer implements Runnable
{
private int customerNumber = 0;
private int balance = 0;

Customer(int cn)
{
   this.customerNumber = cn;
   balance = 1000;
   System.out.println("Customer"+ customerNumber + "created");
}

public void run()
{
    try
    {
    Thread.sleep(200);
    deposit.acquire();
    }
    catch(InterruptedException e)
    {
        Thread.currentThread().interrupt();
        e.printStackTrace();
    }
    //System.out.println("Customer"+ customerNumber + "created");
   // try

  }
   public void post()
    {

    }

 }

 static class Teller implements Runnable 
 {
 private int tellerNumber = 0;

 Teller(int tn)
 {
    this.tellerNumber = tn;
    System.out.println("Teller"+ tellerNumber +"created");
}

public void run()
{
    deposit.release();
 //        try
 //        {
 //            
 //           // deposit.release();
 //            
 //           Thread.sleep(100);
 //       // deposit.acquire();
 //        }
 //        catch(InterruptedException e)
 //        {
 //            deposit.release();
 //        }

    //System.out.println("Teller"+ tellerNumber +"created");
   }

   public void post()
   {

  }
 }

 static class LoanOfficer implements Runnable
 {
private int loanNumber = 0;
LoanOfficer(int tn)
{
    this.loanNumber = tn;
    System.out.println("LoanOfficer"+loanNumber+"created");
}
public void run()
{
    //System.out.println("LoanOfficer"+loanNumber+"created");
}
public void post()
{

}
}


}

Answer 1

您没有许可证实例化信号量，如下所示：

private static Semaphore deposit = new Semaphore (0, true);

因此，当您尝试调用acquire时，您将无法获得执行权限，因此阻止执行。所以尝试至少有1个许可证，所以一次只有1个线程可以执行，你从信号量获得许可证。你也可以稍后再增加它。

private static Semaphore deposit = new Semaphore (1, true);

参阅文档here

程序线程在使用信号量时挂起

1 个答案: