KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > apache > ojb > odmg > locking > ReadUncommittedStrategy


1 package org.apache.ojb.odmg.locking;
2
3 /* Copyright 2002-2005 The Apache Software Foundation
4  *
5  * Licensed under the Apache License, Version 2.0 (the "License");
6  * you may not use this file except in compliance with the License.
7  * You may obtain a copy of the License at
8  *
9  * http://www.apache.org/licenses/LICENSE-2.0
10  *
11  * Unless required by applicable law or agreed to in writing, software
12  * distributed under the License is distributed on an "AS IS" BASIS,
13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14  * See the License for the specific language governing permissions and
15  * limitations under the License.
16  */
17
18 import org.apache.ojb.odmg.TransactionImpl;
19
20 /**
21  * The implementation of the Uncommited Reads Locking strategy.
22  * This strategy is the loosest of them all. It says
23  * you shouldn't need to get any Read locks whatsoever,
24  * but since it will probably try to get them, it will
25  * always give it to them.
26  *
27  * Locks are obtained on modifications to the database and held until end of
28  * transaction (EOT). Reading from the database does not involve any locking.
29  *
30  * Allows:
31  * Dirty Reads
32  * Non-Repeatable Reads
33  * Phantom Reads
34  *
35  * @author Thomas Mahler & David Dixon-Peugh
36  */
37 public class ReadUncommittedStrategy extends AbstractLockStrategy
38 {
39     /**
40      * acquire a read lock on Object obj for Transaction tx.
41      * @param tx the transaction requesting the lock
42      * @param obj the Object to be locked
43      * @return true if successful, else false
44      * When we read Uncommitted, we don't care about Reader locks
45      */
46     public boolean readLock(TransactionImpl tx, Object JavaDoc obj)
47     {
48         return true;
49     }
50
51     /**
52      * acquire a write lock on Object obj for Transaction tx.
53      * @param tx the transaction requesting the lock
54      * @param obj the Object to be locked
55      * @return true if successful, else false
56      *
57      */
58     public boolean writeLock(TransactionImpl tx, Object JavaDoc obj)
59     {
60         LockEntry writer = getWriter(obj);
61         if (writer == null)
62         {
63             if (setWriter(tx, obj))
64                 return true;
65             else
66                 return writeLock(tx, obj);
67         }
68         if (writer.isOwnedBy(tx))
69         {
70             return true; // If I'm the writer, then I can write.
71 }
72         return false;
73     }
74
75     /**
76      * acquire a lock upgrade (from read to write) lock on Object obj for Transaction tx.
77      * @param tx the transaction requesting the lock
78      * @param obj the Object to be locked
79      * @return true if successful, else false
80      *
81      */
82     public boolean upgradeLock(TransactionImpl tx, Object JavaDoc obj)
83     {
84         LockEntry writer = getWriter(obj);
85         if (writer == null)
86         {
87             if (setWriter(tx, obj))
88                 return true;
89             else
90                 return upgradeLock(tx, obj);
91         }
92         if (writer.isOwnedBy(tx))
93         {
94             return true; // If I already have Write, then I've upgraded.
95 }
96         return false;
97     }
98
99     /**
100      * release a lock on Object obj for Transaction tx.
101      * @param tx the transaction releasing the lock
102      * @param obj the Object to be unlocked
103      * @return true if successful, else false
104      *
105      */
106     public boolean releaseLock(TransactionImpl tx, Object JavaDoc obj)
107     {
108         LockEntry writer = getWriter(obj);
109         if (writer != null && writer.isOwnedBy(tx))
110         {
111             removeWriter(writer);
112             return true;
113         }
114         // readlocks cannot (and need not) be released, thus:
115 return true;
116     }
117
118     /**
119      * checks whether the specified Object obj is read-locked by Transaction tx.
120      * @param tx the transaction
121      * @param obj the Object to be checked
122      * @return true if lock exists, else false
123      */
124     public boolean checkRead(TransactionImpl tx, Object JavaDoc obj)
125     {
126         return true;
127     }
128
129     /**
130      * checks whether the specified Object obj is write-locked by Transaction tx.
131      * @param tx the transaction
132      * @param obj the Object to be checked
133      * @return true if lock exists, else false
134      */
135     public boolean checkWrite(TransactionImpl tx, Object JavaDoc obj)
136     {
137         LockEntry writer = getWriter(obj);
138         return (writer != null && writer.isOwnedBy(tx));
139     }
140 }
141
Popular Tags