About pessimistic locking element collections to prevent it being update by a new transaction

[Himai Minh]

Hi, I update the element collection example from JPA Pro,

@Entity
public class Employee {
    @Id @GeneratedValue(strategy=GenerationType.IDENTITY)
    private int id;
   ...
    @ElementCollection
    @CollectionTable(name="EMP_PHONE")
    @MapKeyColumn(name="PHONE_TYPE")
    @Column(name="PHONE_NUM")
    private Map<String, String> phoneNumbers;
....

    @Version
     private int versionid;

@Stateless
public class EmployeeService {
    @PersistenceContext(unitName="EmployeeService")
    protected EntityManager em;

    String defaultPhone= "999-999-9999";
     ...
    
    public void updatePhones(int id){
        Employee emp = em.find(Employee.class, id,LockModeType.PESSIMISTIC_READ);
        em.setProperty("javax.persistence.lock.scope", "EXTENDED");
        if (emp!=null){
           updateAPhoneToDefault(id);
        }
        else{
             System.out.println(" Employee emp "+ id +" is not found.");
        }
        
    }
    
    @TransactionAttribute(TransactionAttributeType.REQUIRES_NEW)
    public void updateAPhoneToDefault(int id){
        Employee emp = em.find(Employee.class, id);
        //update the phone number to default phone number 999-999-9999          
        Map<String, String> phonesMap = emp.getPhoneNumbers();
        phonesMap.put("home", defaultPhone);
    }
    

I locked the employee instance and the lock is extended to the element collection phones.
But why the new transaction (running the updateAPhoneToDefault()) can update the home phone number of that employee?

I assume the employee and the phones entities are locked and no other transaction can update it.

[Himai Minh]

I tried to use two stateful bean with extended persistence context. One bean lock the entity and a second bean tried to update the entity's phone collection.
But to my surprise, the second bean can update the phone  even though it is locked by the first bean.
Is there anything wrong with setting the lock scope in the following code?

@Stateful
public class PhoneService {
 
	@PersistenceContext(unitName="EmployeeService",  type=PersistenceContextType.EXTENDED)
	protected EntityManager em;
	

       //Even though the employee entity has been locked as well as its element collection, the phone in the collection can still be updated.
	public void updatePhones(int id, String phonenum){
		Employee emp = em.find(Employee.class, id);
     	if (emp!=null){
    		 //update the phone number  		
        	Map<String, String> phonesMap = emp.getPhoneNumbers();
            phonesMap.put("home", phonenum);
    	}
    	else{
    		 System.out.println(" Employee emp "+ id +" is not found.");
    	}
    	 
    }
}

@Stateful
public class EmployeeService {
    @PersistenceContext(unitName="EmployeeService", type=PersistenceContextType.EXTENDED)
    protected EntityManager em;

     ....
    //Lock the employee entity with id and extend the lock to its element collection
    public void lockPhonesCollection(int id){
    	Employee emp = em.find(Employee.class, id,LockModeType.PESSIMISTIC_WRITE);
        em.setProperty("javax.persistence.lock.scope", "EXTENDED"); 
    
    }

//Servlet that access the two beans.
else if (action.equals("updatePhones")){
            int employeeId = parseInt(request.getParameter("employeeId")); 
           String phoneChanged = request.getParameter("phonechanged");
          //One bean locks the employee entity and its element collection, phone. 
          //another bean updates the phone
           empService.lockPhonesCollection(employeeId);
            phoneService.updatePhones(employeeId, phoneChanged);

[Himai Minh]

I use PessimisticLockScope.EXTENDED instead of "EXTENDED". And I attempted to remove a phone in the collection.  But to my surprise, it does remove the phone.

@Stateful
public class EmployeeService {
    @PersistenceContext(unitName="EmployeeService", type=PersistenceContextType.EXTENDED)
    protected EntityManager em;
 ....
   
    public void getLock(int id){
    	Employee emp = em.find(Employee.class, id);
		em.lock(emp,LockModeType.PESSIMISTIC_WRITE);
		em.setProperty("javax.persistence.lock.scope", PessimisticLockScope.EXTENDED);
    }

@Stateful
public class PhoneService {
 
	@PersistenceContext(unitName="EmployeeService",  type=PersistenceContextType.EXTENDED)
	protected EntityManager em;
	
	public void updatePhones(int id, String phonenum){
		Employee emp = em.find(Employee.class, id);
	  	if (emp!=null){
    		    Map<String, String> phoneMaps= emp.getPhoneNumbers();
                    phoneMaps.remove("home");
    	         }
     	
    	  else{
    		   System.out.println(" Employee emp "+ id +" is not found.");
    	   }
    	 
    }

//Servlet
else if (action.equals("updatePhones")){
            int employeeId = parseInt(request.getParameter("employeeId")); 
            String nameChanged = request.getParameter("namechanged");
            String homephoneChanged = request.getParameter("homephonechanged");
            //This bean locks the entity and extends the lock to the collection
            empService.getLock(employeeId);
             //This bean actually removes the home phone
            phoneService.updatePhones(employeeId, homephoneChanged);
           
            

But still, to my surprise, I expect the phones collection is locked and no phone number is removed.
But actually the home phone is removed even though it is locked.

[Himai Minh]

I made one more try. I start a new transaction when I remove the home phone. I assume the new transaction cannot obtain the pessimistic lock on the element collection, phones and I assume the home phone cannot be removed in this new transaction. But still, to my surprise, the new transaction can remove the phone which is locked.

@Stateful
public class EmployeeService {
    @PersistenceContext(unitName="EmployeeService", type=PersistenceContextType.EXTENDED)
    protected EntityManager em;
 
    
  .....
   
    public void getLock(int id){
    	Employee emp = em.find(Employee.class, id);
		em.lock(emp,LockModeType.PESSIMISTIC_WRITE);
		em.setProperty("javax.persistence.lock.scope", PessimisticLockScope.EXTENDED);
    }
[code]

[code]
@Stateful
public class PhoneService {
 
	@PersistenceContext(unitName="EmployeeService",  type=PersistenceContextType.EXTENDED)
	protected EntityManager em;
	
	@TransactionAttribute(TransactionAttributeType.REQUIRES_NEW)
	public void updatePhones(int id, String phonenum){
		Employee emp = em.find(Employee.class, id);
	   	if (emp!=null){
    		 
           Map<String, String> phoneMaps= emp.getPhoneNumbers();
           phoneMaps.remove("home");
    	}
     	
    	else{
    		 System.out.println(" Employee emp "+ id +" is not found.");
    	}
    	 
    }
}

else if (action.equals("updatePhones")){
            int employeeId = parseInt(request.getParameter("employeeId")); 
            String nameChanged = request.getParameter("namechanged");
            String homephoneChanged = request.getParameter("homephonechanged");
            //I assume the employee and the related element collection phones are locked here.
            empService.getLock(employeeId);

            // a new transaction is used here and it can remove the phone even though the element collection phones is locked.
            phoneService.updatePhones(employeeId, homephoneChanged);
               
        }