File: LockedExecutor.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 (57 lines) | stat: -rw-r--r-- 1,627 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
/*
  File: LockedExecutor.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
  21Jun1998  dl               Create public version
*/

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

/**
 * An implementation of Executor that 
 * invokes the run method of the supplied command within
 * a synchronization lock and then returns.
 * 
 * <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 LockedExecutor implements Executor {
  
  /** The mutex **/
  protected final Sync mutex_;

  /** 
   * Create a new LockedExecutor that relies on the given mutual
   * exclusion lock. 
   * @param mutex Any mutual exclusion lock.
   * Standard usage is to supply an instance of <code>Mutex</code>,
   * but, for example, a Semaphore initialized to 1 also works.
   * On the other hand, many other Sync implementations would not
   * work here, so some care is required to supply a sensible 
   * synchronization object.
   **/
 
  public LockedExecutor(Sync mutex) {
    mutex_ = mutex;
  }

  /** 
   * Execute the given command directly in the current thread,
   * within the supplied lock.
   **/
  public void execute(Runnable command) throws InterruptedException {
    mutex_.acquire();
    try {
      command.run();
    }
    finally {
      mutex_.release();
    }
  }

}