Java Web服务并发问题

Question

I have a java method calling on a web service and making changes to the database based on the response. My task is to eliminate concurrency errors when several users use this application simultaneously.

I was trying to use various types of database locking all day but nothing worked. I finally tried to use synchronized in the process request method and it all worked.

My whole application is single-threaded. Why does synchronized solve this?

Edit: Added Code.

public class ProcessMakePaymentServlet extends HttpServlet {

    private DbBean db = new DbBean();

    protected synchronized void processRequest(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {

        // defining variables...

        try {

            // initialize parameters for invoking remote method

            db.connect(); 
            startTransaction(); //autocommit=0; START TRANSACTION;
            // process debit
            //this method gets the method using a select...for update. 
            //it then updates it with the new value
            successfulDebit = debitAccount(userId, amt);
            if (successfulDebit) {
                // contact payment gateway by invoking remote pay web service method here.

                // create new instances of remote Service objects
                org.tempuri.Service service = new org.tempuri.Service();
                org.tempuri.ServiceSoap port = service.getServiceSoap();

                // invoke the remote method by calling port.pay().
                // port.pay() may time out if the remote service is down and throw an exception
                successfullyInformedPaymentGateway = port.pay(bankId, bankPwd, payeeId, referenceId, amt);

                if (successfullyInformedPaymentGateway) {
                    // insert payment record
                    recordPaymentMade(userId, amt, referenceId); 
                    //call to the database to record the transaction. Simple update statement.
                    out.println("<br/>-----<br/>");
                    //getTotalPaymentMade does a select to sum all the payment amounts
                    out.println("Total payment made so far to gateway: " + getTotalPaymentMade());
                    commitTransaction();// calls COMMIT
                    db.close(); //connection closed.
                } else {
                    rollbackTransaction();//calls ROLLBACK
                    db.close();
                    successfulDebit = false;
                    out.println("<br/>-----<br/>");
                    out.println("Incorrect bank details.");
                }
            } else {
                rollbackTransaction();//calls ROLLBACK
                db.close();
                out.println("<br/>-----<br/>");
                out.println("Invalid payment amount.");
            }


        } catch (Exception ex) {
            try {
                rollbackTransaction();//calls ROLLBACK
                db.close();
            } catch (Exception ex1) {
            }
        }

  }

Answer 1

My whole application is single-threaded. Why does synchronized solve this?

No it is not single threaded. The web service is called by multiple threads receiving the client requests.

The web service method implementation must take care of all synchronization issues same as in a servlet implementation receiving multiple requests, care must be taken to ensure thread safety.

In your case, by adding synchronized you made sure that concurrent processing of web service client request did not result in corruption due to thread issues and you are esentially serializing the client requests (and there of access to the DB).

You have not posted any code to see what you are doing wrong, but since synchronized at the web method level solves your problem, you either did not do the synchronized at the DB level as you say properly or threading issues corrupted common variables at the web service layer accessing the DB.

By synchronizing at the web method, the code is thread safe, but the performance will deteriorate since you will serve 1 client at a time.

Depends on what your requirements are

Answer 2

Just move private DbBean db = new DbBean(); into the servlet method, this should solve the problem concurrency problem:

protected void processRequest(HttpServletRequest request, ...) {

  // defining variables...
  DbBean db = new DbBean();

...
}

Nevertheless, you should properly clean all database resources in a finally block. A fairly simplified example, but I hope you get what I mean:

protected void processRequest(HttpServletRequest request, ...) {

  // defining variables...
  DbBean db = null;
  boolean commit = false;

  try {
    db = new DbBean();
  } catch (SomeException e) {
    commit = false;
  } finally{
    db.release(commit); /* close database connection => java.sql.Connection#close() */
  }

...
}