Do I need to declare a transaction in this case?

Question

I am struggling to understand when it is necessary to declare my own transaction to ensure the data is properly updated.
For example, in the following code, which is part of a java bean in the EJB project, KeyFacade is a stateless session bean tied to the entity "Key". it is a standard EJB created with the netBeans 5.5 wizard. I have changed no defaults.
Do I need to declare a transaction, commit the transaction and close it when I use the "KeyFacade.edit(key);" in order to ensure the database is updated? Or is it automatically done because the .edit() method uses the entityManager and the persistence is container managed?
Would it make a difference if this bean was part of a WAR project?
    public BigInteger getNextKey(String tableName){
        KeyFacadeLocal KeyFacade = this.lookupKeyFacade();
        Key key = KeyFacade.findByTablename(tableName);
        long nextKey = key.getKeyvalue();
        BigInteger BINextKey =BigInteger.valueOf((int)nextKey);
        //  now update the table by incrementing the key value by 1
        long incrementKey = nextKey + 1;
        key.setKeyvalue(incrementKey);
        KeyFacade.edit(key);
        return BINextKey;
    }

Answer 1

808239 wrote:
I have a Map<Integer, List<T>> data, and all the lists are initialized using Collections.synchronizedList().Seems like overkill to me. Your Map also looks like a Multimap, of which there are several existing implementations.
When I do the traversal, I want to traverse ALL lists in the map at the same timeI suspect not. What you want to do is to traverse each one in sequence.
so I have to sync all lists as shown in the API doc as follows: ...Seems like overkill to me, and will probably result in a very slow Map (not that there's any problem with that if it's the right thing to do; in this case, I suspect it isn't).
Is this approach ok?What are you trying to achieve? If you need full consistency for your iterators (ie, a snapshot of the entire Map at the time the iterator is created), you have a two choices (assuming you don't want to deal with update journals):
1. Lock the Map.
2. Clone the Map (and your clone() method should be synchronized).
Of the two, the second seems best to me, but neither is all that wonderful.
However, if all you need is weak consistency - that is to say, what you return reflects the state of the Map when Iterator.next() is called - all you really need to do is make sure that your Lists are synchronized when you do the read.
Since the List updates are the responsibility of your Map (I'm still presuming this is some sort of Multimap implementation), there's no real need to synchronize them; just synchronize the Map's own update methods.
I'd also suggest that you make sure your getValue() method hands back an [url http://download.oracle.com/javase/6/docs/api/java/util/Collections.html#unmodifiableList%28java.util.List%29]unmodifiable List to clients; otherwise they could start adding or removing values themselves.
HIH
Winston