File: LayeredSync.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 (90 lines) | stat: -rw-r--r-- 2,223 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
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
/*
  File: LayeredSync.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 class that can be used to compose Syncs.
 * A LayeredSync object manages two other Sync objects,
 * <em>outer</em> and <em>inner</em>. The acquire operation
 * invokes <em>outer</em>.acquire() followed by <em>inner</em>.acquire(),
 * but backing out of outer (via release) upon an exception in inner.
 * The other methods work similarly.
 * <p>
 * LayeredSyncs can be used to compose arbitrary chains
 * by arranging that either of the managed Syncs be another
 * LayeredSync.
 *
 * <p>[<a href="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/intro.html"> Introduction to this package. </a>]
**/


public class LayeredSync implements Sync {

  protected final Sync outer_;
  protected final Sync inner_;

  /** 
   * Create a LayeredSync managing the given outer and inner Sync
   * objects
   **/

  public LayeredSync(Sync outer, Sync inner) {
    outer_ = outer;
    inner_ = inner;
  }

  public void acquire() throws InterruptedException {
    outer_.acquire();
    try {
      inner_.acquire();
    }
    catch (InterruptedException ex) {
      outer_.release();
      throw ex;
    }
  }

  public boolean attempt(long msecs) throws InterruptedException {

    long start = (msecs <= 0)? 0 : System.currentTimeMillis();
    long waitTime = msecs;

    if (outer_.attempt(waitTime)) {
      try {
        if (msecs > 0)
          waitTime = msecs - (System.currentTimeMillis() - start);
        if (inner_.attempt(waitTime))
          return true;
        else {
          outer_.release();
          return false;
        }
      }
      catch (InterruptedException ex) {
        outer_.release();
        throw ex;
      }
    }
    else
      return false;
  }

  public void release() {
    inner_.release();
    outer_.release();
  }

}