/openjdk7/jdk/src/macosx/classes/com/apple/laf/ |
H A D | AquaFileSystemModel.java | 436 private final Object lock = new Object(); field in class:AquaFileSystemModel.DoChangeContents 445 synchronized(lock) { 452 synchronized(lock) {
|
/openjdk7/jdk/src/macosx/classes/sun/java2d/ |
H A D | OSXOffScreenSurfaceData.java | 51 Object lock; field in class:OSXOffScreenSurfaceData 453 return this.lock; 471 this.lock = new Object();
|
/openjdk7/jdk/src/macosx/classes/sun/lwawt/macosx/ |
H A D | CWarningWindow.java | 51 private final Lock lock = new Lock(); field in class:CWarningWindow 207 synchronized (lock) { 214 synchronized (lock) { 221 synchronized (lock) { 281 synchronized (lock) { 349 synchronized (lock) { 406 synchronized (lock) { 418 synchronized (lock) {
|
/openjdk7/hotspot/src/share/vm/runtime/ |
H A D | vframe.hpp | 241 // 2) the monitor lock 251 MonitorInfo(oop owner, BasicLock* lock, bool eliminated, bool owner_is_scalar_replaced) { argument 260 _lock = lock; 273 BasicLock* lock() const { return _lock; } function in class:MonitorInfo
|
H A D | mutex.cpp | 60 // is indeed the last thread to have acquired the lock. 82 // 2. Minimize lock migration 85 // 5. Minimize outer lock hold times 118 // a successor, so the successor can (re)compete for ownership of the lock. 123 // the lock it will decrement the AcquireCounter field. When the count 125 // the lock directly to some thread on the EntryList, and then move itself to the 129 // bounded producer-consumer relationships, so lock domination is not usually 131 // a fair lock from a fast lock, but not vice-versa. 136 // We use OnDeck as a pseudo-lock t 899 void Monitor::lock (Thread * Self) { function in class:Monitor 948 void Monitor::lock() { function in class:Monitor 1259 contains(Monitor* locks, Monitor * lock) argument [all...] |
H A D | mutexLocker.cpp | 149 void assert_locked_or_safepoint(const Monitor * lock) { argument 150 // check if this thread owns the lock (common case) 152 assert(lock != NULL, "Need non-NULL lock"); 153 if (lock->owned_by_self()) return; 158 if (op != NULL && op->calling_thread() == lock->owner()) return; 159 fatal(err_msg("must own lock %s", lock->name())); 163 void assert_lock_strong(const Monitor * lock) { argument 165 assert(lock ! [all...] |
/openjdk7/jdk/src/solaris/native/java/net/ |
H A D | bsd_close.c | 54 pthread_mutex_t lock; /* fd lock */ member in struct:__anon957 110 pthread_mutex_init(&fdTable[i].lock, NULL); 147 pthread_mutex_lock(&(fdEntry->lock)); 152 pthread_mutex_unlock(&(fdEntry->lock)); 164 pthread_mutex_lock(&(fdEntry->lock)); 184 pthread_mutex_unlock(&(fdEntry->lock)); 208 pthread_mutex_lock(&(fdEntry->lock)); 240 pthread_mutex_unlock(&(fdEntry->lock));
|
H A D | linux_close.c | 53 pthread_mutex_t lock; /* fd lock */ member in struct:__anon958 130 pthread_mutex_lock(&(fdEntry->lock)); 135 pthread_mutex_unlock(&(fdEntry->lock)); 147 pthread_mutex_lock(&(fdEntry->lock)); 167 pthread_mutex_unlock(&(fdEntry->lock)); 191 pthread_mutex_lock(&(fdEntry->lock)); 223 pthread_mutex_unlock(&(fdEntry->lock));
|
/openjdk7/jdk/test/java/lang/management/ThreadMXBean/ |
H A D | SynchronizationStatistics.java | 368 private void checkInfo(StatThread t, Thread.State s, Object lock, argument 392 !info.getLockName().equals(lock.toString())) { 395 ". Expected to be " + lockName + " - " + lock.toString()); 410 if (lockObj == null || !lockObj.equals(lock.toString())) { 413 ". Expected to be " + lock.toString());
|
/openjdk7/corba/src/share/classes/com/sun/corba/se/impl/oa/poa/ |
H A D | POAImpl.java | 224 // Master lock for all POA synchronization. See lock and unlock. 285 void lock() method in class:POAImpl 372 // The POA lock must be held when this method is called. 459 lock() ; 581 poa.lock() ; 613 // Make a copy since we can't hold the lock while destroying 647 // Note that we must lock the parent before the child. 648 // The parent lock is required (if poa is not the root) 651 parent.lock() ; [all...] |
/openjdk7/corba/src/share/classes/com/sun/corba/se/impl/orbutil/ |
H A D | ObjectStreamClass_1_3_1.java | 362 * after the lock on the global class descriptor table has been 371 * does not have to hold onto a global class descriptor table lock while the 377 synchronized (lock) { 1107 /* Internal lock object. */ 1108 private Object lock = new Object(); field in class:ObjectStreamClass_1_3_1
|
/openjdk7/hotspot/agent/src/share/native/jvmdi/ |
H A D | sa.cpp | 185 JVMDI_RawMonitor lock; member in class:MonitorLocker 187 MonitorLocker(JVMDI_RawMonitor lock) { argument 188 this->lock = lock; 189 if (lock != NULL) { 190 jvmdi->RawMonitorEnter(lock); 194 if (lock != NULL) { 195 jvmdi->RawMonitorExit(lock); 520 // Create event lock 523 stop("Unable to create Serviceability Agent's event lock"); [all...] |
/openjdk7/jdk/src/share/classes/java/util/concurrent/ |
H A D | ScheduledThreadPoolExecutor.java | 836 private final ReentrantLock lock = new ReentrantLock(); field in class:ScheduledThreadPoolExecutor.DelayedWorkQueue 861 private final Condition available = lock.newCondition(); 873 * Call only when holding lock. 891 * Call only when holding lock. 912 * Resize the heap array. Call only when holding lock. 943 final ReentrantLock lock = this.lock; 944 lock.lock(); 948 lock [all...] |
H A D | ThreadPoolExecutor.java | 284 * pauseLock.lock(); 295 * pauseLock.lock(); 304 * pauseLock.lock(); 447 * to be generally preferable to use a lock. Among the reasons is 574 * to simplify acquiring and releasing a lock surrounding each 578 * non-reentrant mutual exclusion lock rather than use 580 * reacquire the lock when they invoke pool control methods like 582 * the thread actually starts running tasks, we initialize lock 641 public void lock() { acquire(1); } method in class:ThreadPoolExecutor.Worker 700 mainLock.lock(); [all...] |
/openjdk7/jdk/src/share/classes/javax/crypto/ |
H A D | Cipher.java | 237 private final Object lock; field in class:Cipher 259 this.lock = null; 272 this.lock = null; 282 this.lock = new Object(); 705 synchronized (lock) { 810 synchronized (lock) {
|
/openjdk7/hotspot/src/share/vm/gc_implementation/g1/ |
H A D | ptrQueue.hpp | 59 // its buffer in the destructor (since that obtains a lock which may not 63 // If there is a lock associated with this buffer, this is that lock. 77 // Associate a lock with a ptr queue. 78 void set_lock(Mutex* lock) { _lock = lock; } argument
|
/openjdk7/hotspot/src/share/vm/oops/ |
H A D | markOop.hpp | 39 // hash:25 ------------>| age:4 biased_lock:1 lock:2 (normal object) 40 // JavaThread*:23 epoch:2 age:4 biased_lock:1 lock:2 (biased object) 46 // unused:25 hash:31 -->| unused:1 age:4 biased_lock:1 lock:2 (normal object) 47 // JavaThread*:54 epoch:2 unused:1 age:4 biased_lock:1 lock:2 (biased object) 51 // unused:25 hash:31 -->| cms_free:1 age:4 biased_lock:1 lock:2 (COOPs && normal object) 52 // JavaThread*:54 epoch:2 cms_free:1 age:4 biased_lock:1 lock:2 (COOPs && biased object) 62 // - the biased lock pattern is used to bias a lock toward a given 63 // thread. When this pattern is set in the low three bits, the lock 66 // lock i 314 encode(BasicLock* lock) argument [all...] |
/openjdk7/hotspot/src/cpu/zero/vm/ |
H A D | cppInterpreter_zero.cpp | 232 monitor->lock()->set_displaced_header(disp); 235 monitor->lock()->set_displaced_header(NULL); 376 BasicLock *lock = monitor->lock(); local 377 markOop header = lock->displaced_header(); 382 if (Atomic::cmpxchg_ptr(header, rcvr->mark_addr(), lock) != lock) {
|
/openjdk7/jdk/src/macosx/native/com/sun/media/sound/ |
H A D | PLATFORM_API_MacOSX_MidiUtils.c | 624 /* queue->lock while the condition variabale reference is stored as handle */ 647 void MIDI_WaitOnConditionVariable(void* cond, void* lock) { argument 648 if (cond && lock) { 649 pthread_mutex_lock(lock); 650 pthread_cond_wait((pthread_cond_t*) cond, (pthread_mutex_t*) lock); 651 pthread_mutex_unlock(lock); 675 pthread_mutex_t* lock = (pthread_mutex_t*) malloc(sizeof(pthread_mutex_t)); local 676 pthread_mutex_init(lock, NULL); 678 return (void *)lock; 681 void MIDI_DestroyLock(void* lock) { argument 689 MIDI_Lock(void* lock) argument 695 MIDI_Unlock(void* lock) argument [all...] |
/openjdk7/jdk/src/share/demo/jvmti/mtrace/ |
H A D | mtrace.c | 119 jrawMonitorID lock; member in struct:__anon541 137 error = (*jvmti)->RawMonitorEnter(jvmti, gdata->lock); 147 error = (*jvmti)->RawMonitorExit(jvmti, gdata->lock); 784 error = (*jvmti)->CreateRawMonitor(jvmti, "agent data", &(gdata->lock));
|
/openjdk7/jdk/src/share/native/java/util/zip/ |
H A D | zip_util.h | 216 void *lock; /* read lock */ member in struct:jzfile
|
/openjdk7/jdk/src/share/classes/sun/nio/ch/ |
H A D | FileChannelImpl.java | 962 // The lock list in J2SE 1.4/5.0 was local to each FileChannel instance so 1001 public FileLock lock(long position, long size, boolean shared) method in class:FileChannelImpl 1021 n = nd.lock(fd, true, position, size, shared); 1063 result = nd.lock(fd, false, position, size, shared); 1097 // -- File lock support -- 1100 * A simple file lock table that maintains a list of FileLocks obtained by a
|
/openjdk7/corba/src/share/classes/com/sun/corba/se/impl/io/ |
H A D | ObjectStreamClass.java | 166 // the init() method used a private member variable lock, to 381 * after the lock on the global class descriptor table has been 439 * does not have to hold onto a global class descriptor table lock while the 445 synchronized (lock) { 1528 /* Internal lock object. */ 1529 private Object lock = new Object(); field in class:ObjectStreamClass
|
/openjdk7/hotspot/src/share/vm/compiler/ |
H A D | compileBroker.hpp | 84 Monitor* lock() const { return _lock; } function in class:CompileTask 188 CompileQueue(const char* name, Monitor* lock) { argument 190 _lock = lock; 197 Monitor* lock() const { return _lock; } function in class:CompileQueue
|
/openjdk7/hotspot/src/share/vm/gc_implementation/parallelScavenge/ |
H A D | gcTaskManager.hpp | 226 static SynchronizedGCTaskQueue* create(GCTaskQueue* queue, Monitor * lock) { argument 227 return new SynchronizedGCTaskQueue(queue, lock); 238 Monitor * lock() const { function in class:SynchronizedGCTaskQueue 242 // These check that you hold the lock 245 guarantee(own_lock(), "don't own the lock"); 249 guarantee(own_lock(), "don't own the lock"); 253 guarantee(own_lock(), "don't own the lock"); 257 guarantee(own_lock(), "don't own the lock"); 261 guarantee(own_lock(), "don't own the lock"); 265 guarantee(own_lock(), "don't own the lock"); 409 Monitor * lock() const { function in class:GCTaskManager 778 static Mutex* lock() { function in class:MonitorSupply [all...] |