Mercurial Hosting > nabble

comparison src/fschmidt/util/locks/TimedLock.java @ 68:00520880ad02

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
add fschmidt source
author Franklin Schmidt <fschmidt@gmail.com>
date Sun, 05 Oct 2025 17:24:15 -0600
parents
children
comparison
equal deleted inserted replaced
67:9d0fefce6985 68:00520880ad02
1 /*
2 Copyright (c) 2008 Franklin Schmidt <fschmidt@gmail.com>
3
4 Permission is hereby granted, free of charge, to any person obtaining a copy
5 of this software and associated documentation files (the "Software"), to deal
6 in the Software without restriction, including without limitation the rights
7 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
8 copies of the Software, and to permit persons to whom the Software is
9 furnished to do so, subject to the following conditions:
10
11 The above copyright notice and this permission notice shall be included in
12 all copies or substantial portions of the Software.
13
14 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
17 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
18 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
19 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
20 THE SOFTWARE.
21 */
22
23 package fschmidt.util.locks;
24
25 import java.util.Set;
26 import java.util.HashSet;
27 import java.util.Collections;
28 import java.util.concurrent.TimeUnit;
29 import java.util.concurrent.locks.Lock;
30 import org.slf4j.Logger;
31 import org.slf4j.LoggerFactory;
32
33
34 public final class TimedLock extends ProxyLock {
35 private static final Logger logger = LoggerFactory.getLogger(TimedLock.class);
36
37 private static long timeoutDefault = 10L*60L*1000L; // 10 minutes
38 private static long waitTimeDefault = 60L*1000L; // 1 minutes
39
40 public static long getTimeoutDefault() {
41 return timeoutDefault;
42 }
43
44 public static void setTimeoutDefault(long timeoutDefault) {
45 TimedLock.timeoutDefault = timeoutDefault;
46 }
47
48 public static long getWaitTimeDefault() {
49 return waitTimeDefault;
50 }
51
52 public static void setWaitTimeDefault(long waitTimeDefault) {
53 TimedLock.waitTimeDefault = waitTimeDefault;
54 }
55
56 private static Set<TimedLock> locks = Collections.synchronizedSet(new HashSet<TimedLock>());
57 private int count = 0;
58 private final Object sync = new Object();
59 private long whenLocked;
60 private long whenChecked;
61 private long timeout = timeoutDefault;
62 private long waitTime = waitTimeDefault;
63 private Thread thread = null;
64
65 public TimedLock(Lock lock) {
66 super(lock);
67 }
68
69 public long getTimeout() {
70 return timeout;
71 }
72
73 public void setTimeout(long timeout) {
74 this.timeout = timeout;
75 }
76
77 public long getWaitTime() {
78 return waitTime;
79 }
80
81 public void setWaitTime(long waitTime) {
82 this.waitTime = waitTime;
83 }
84
85 private void locked() {
86 synchronized(sync) {
87 if( count++ == 0 ) {
88 whenLocked = System.currentTimeMillis();
89 whenChecked = whenLocked;
90 thread = Thread.currentThread();
91 if( !locks.add(this) )
92 throw new RuntimeException();
93 }
94 }
95 }
96
97 public boolean tryLock() {
98 if( !super.tryLock() )
99 return false;
100 locked();
101 return true;
102 }
103
104 public boolean tryLock(long time,TimeUnit unit)
105 throws InterruptedException
106 {
107 long t = TimeUnit.MILLISECONDS.convert(time,unit);
108 while( t > waitTime ) {
109 if( super.tryLock(waitTime,TimeUnit.MILLISECONDS) ) {
110 locked();
111 return true;
112 }
113 t -= waitTime;
114 check();
115 }
116 if( super.tryLock(t,TimeUnit.MILLISECONDS) ) {
117 locked();
118 return true;
119 }
120 return false;
121 }
122
123 public void lockInterruptibly()
124 throws InterruptedException
125 {
126 while(true) {
127 if( super.tryLock(waitTime,TimeUnit.MILLISECONDS) ) {
128 locked();
129 return;
130 }
131 check();
132 }
133 }
134
135 public void lock() {
136 try {
137 lockInterruptibly();
138 } catch(InterruptedException e) {
139 throw new RuntimeException(e);
140 }
141 }
142
143 public void unlock() {
144 synchronized(sync) {
145 if( --count == 0 ) {
146 if( !locks.remove(this) )
147 throw new RuntimeException();
148 thread = null;
149 }
150 }
151 super.unlock();
152 }
153
154 private void check() {
155 long now = System.currentTimeMillis();
156 long tooOld = now - timeout;
157 TimedLock[] a = locks.toArray(new TimedLock[0]);
158 for( int i=0; i<a.length; i++ ) {
159 TimedLock tl = a[i];
160 if( tl.whenChecked < tooOld ) {
161 StringBuilder buf = new StringBuilder();
162 buf.append("lock "+tl+" timed out, locked for "+(System.currentTimeMillis()-tl.whenLocked)+" millis");
163 buf.append("\n"+tl.thread);
164 for( StackTraceElement ste : tl.thread.getStackTrace() ) {
165 buf.append("\n\t"+ste);
166 }
167 logger.error(buf.toString());
168 tl.whenChecked = now;
169 }
170 }
171 }
172
173 }