Databases
StackOverflow2013
Postsdbo
PO
 

Note that there are some explanatory texts on larger screens.

plurals
  1. PO
    primarykey
    data
    text
    <blockquote> <p>If a synchronized method calls another non-synchronized method, is there a lock on the non-synchronized method</p> </blockquote> <p>Yes and no.</p> <p>If you are in a <code>synchronized</code> method, then calls to other methods that are also <code>synchronized</code> by other threads are locked. However calls to non-synchronized methods by other threads are <em>not</em> locked -- anyone can call them at the same time.</p> <pre><code>public synchronized void someSynchronizedMethod() { ... someNonSynchronizedMethod(); ... } // anyone can call this method even if the someSynchronizedMethod() method has // been called and the lock has been locked public void someNonSynchronizedMethod() { ... } </code></pre> <p>Also, if you call <code>someSynchronizedMethod()</code> but happen to be within the <code>someNonSynchronizedMethod()</code> method, you still hold the lock. The lock is enabled when you enter a synchronized block and is disabled when you exit that method. You can call all sorts of other unsynchronized methods and they will still be locked.</p> <p>But you are asking two different things in your question:</p> <blockquote> <p>In Java, if a synchronized method contains a call to a non-synchronized, can another method still access the non-synchronized method at the same time?</p> </blockquote> <p>Yes. Other methods can access non-synchronized methods.</p> <blockquote> <p>Basically what I'm asking is everything in the synchronized method have a lock on it (including calls to other synchronized methods)? </p> </blockquote> <p>Uh, yes. Other calls to <em>synchronized</em> methods are locked. But non-synchronized methods are not locked.</p> <p>Also, remember that if the method is <code>static</code> then the lock is on the <code>Class</code> object in the <code>ClassLoader</code>.</p> <pre><code>// this locks on the Class object in the ClassLoader public static synchronized void someStaticMethod() { </code></pre> <p>If the method is an instance method then the lock is on the instance of the class.</p> <pre><code>// this locks on the instance object that contains the method public synchronized void someInstanceMethod() { </code></pre> <p>There are 2 different locks in those 2 cases.</p> <p>Lastly, when you are dealing with <code>synchronized</code> instance methods, each <em>instance</em> of the class is what is locked. This means that two threads could be in the same <code>synchronized</code> method at the same time with different <em>instances</em>. But if 2 threads try to operate on <code>synchronized</code> methods on the same instance, one will block until the other one exits the method.</p>
    singulars
    1. This table or related slice is empty.
    1. POIf a synchronized method calls another non-synchronized method, is there a lock on the non-synchronized method
      singulars
      1. PTQuestion
    1. PTAnswer
    1. USGray
    1. USGray
    plurals
    1. This table or related slice is empty.
    1. This table or related slice is empty.
    1. This table or related slice is empty.
    1. This table or related slice is empty.
    1. VO
      singulars
      1. PO
      1. This table or related slice is empty.
      1. VTUpMod
    2. VO
      singulars
      1. PO
      1. This table or related slice is empty.
      1. VTUpMod
    3. VO
      singulars
      1. PO
      1. This table or related slice is empty.
      1. VTUpMod
    1. COSo I guess it would not be a good idea to call non-synchronized methods within synchronized ones...because they can be called at the same time by some other method.
      singulars
      1. PO
      1. USdido
    2. COIf this causes 2 threads to access data that needs to be synchronized, then yes, it is not a good idea. However, this happens all of the time with `toString()` and other methods. It just depends on your object and the use case.
      singulars
      1. PO
      1. USGray
    3. COI would just like to throw in here, also, that a synchronized method can be called simultaneously any number of times, as long as it is called on different objects. The lock applies to the specific object - the instance of the class - unless the method is static. I think it's easy to forget this, since many people (including all the current posters) speak of a lock on the method as though it applied regardless of the object instance.
      singulars
      1. PO
      1. USarcy
 

Querying!

 
Guidance
A row detail

Detail views are divided into sections. All the information in the data section comes from columns in the selected row. The other sections display data from other, related rows.

Related data can be related in a to-one or a to-many fashion. Captions of data related in a to-many fashion link to a list view showing a filtered view of the table.

Try moving around until you find a non-empty to-many entry and click on the label to get to one. You can move back to the root by clicking on the database name in the header.

SQuiL has stopped working due to an internal error.

If you are curious you may find further information in the browser console, which is accessible through the devtools (F12).

Reload