File: TimeoutSync.java

package info (click to toggle)
concurrent-dfsg 1.3.4-4
  • links: PTS, VCS
  • area: main
  • in suites: buster, jessie, jessie-kfreebsd, squeeze, stretch, wheezy
  • size: 976 kB
  • ctags: 2,018
  • sloc: java: 10,704; xml: 49; makefile: 12
file content (69 lines) | stat: -rw-r--r-- 1,950 bytes parent folder | download | duplicates (3)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
/*
  File: TimeoutSync.java

  Originally written by Doug Lea and released into the public domain.
  This may be used for any purposes whatsoever without acknowledgment.
  Thanks for the assistance and support of Sun Microsystems Labs,
  and everyone contributing, testing, and using this code.

  History:
  Date       Who                What
   1Aug1998  dl               Create public version
*/

package EDU.oswego.cs.dl.util.concurrent;

/**
 * A TimeoutSync is an adaptor class that transforms all
 * calls to acquire to instead invoke attempt with a predetermined
 * timeout value.
 *<p>
 * <b>Sample Usage</b>. A TimeoutSync can be used to obtain
 * Timeouts for locks used in SyncCollections. For example:
 * <pre>
 * Mutex lock = new Mutex();
 * TimeoutSync timedLock = new TimeoutSync(lock, 1000); // 1 sec timeouts
 * Set set = new SyncSet(new HashSet(), timedlock);
 * try {
 *   set. add("hi");
 * }
 * // SyncSets translate timeouts and other lock failures 
 * //   to unsupported operation exceptions, 
 * catch (UnsupportedOperationException ex) {
 *    System.out.println("Lock failure");
 * }
 * </pre>  
 *
 * <p>[<a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/intro.html"> Introduction to this package. </a>]
 * @see Sync
**/


public class TimeoutSync implements Sync {

  protected final Sync sync_;     // the adapted sync
  protected final long timeout_;  // timeout value

  /** 
   * Create a TimeoutSync using the given Sync object, and
   * using the given timeout value for all calls to acquire.
   **/

  public TimeoutSync(Sync sync, long timeout) {
    sync_ = sync;
    timeout_ = timeout;
  }

  public void acquire() throws InterruptedException {
    if (!sync_.attempt(timeout_)) throw new TimeoutException(timeout_);
  }

  public boolean attempt(long msecs) throws InterruptedException {
    return sync_.attempt(msecs);
  }

  public void release() {
    sync_.release();
  }

}