StackOverflow2013

Note that there are some explanatory texts on larger screens.

plurals

PO
primarykey
Id
8724523
data
AcceptedAnswerId
0
AnswerCount
0
ClosedDate
CommentCount
0
CommunityOwnedDate
CreationDate
2012-01-04T09:23:11.067
FavoriteCount
0
LastActivityDate
2012-01-04T09:23:11.067
LastEditDate
LastEditorUserId
0
OwnerUserId
545680
ParentId
8721657
PostTypeId
2
Score
2
ViewCount
0
LastEditorDisplayName
text
Body
I find that the examples used to explain synchronization and volatility are contrived and difficult to understand the purpose of. Here are my preferred examples: Synchronized: <pre><code>private Value value; public void setValue(Value v) { value = v; } public void doSomething() { if(value != null) { doFirstThing(); int val = value.getInt(); // Will throw NullPointerException if another // thread calls setValue(null); doSecondThing(val); } } </code></pre> The above code is perfectly correct if run in a single-threaded environment. However with even 2 threads there is the possibility that <code>value</code> will be changed in between the check and when it is used. This is because the method <code>doSomething()</code> is not atomic. To address this, use synchronization: <pre><code>private Value value; private Object lock = new Object(); public void setValue(Value v) { synchronized(lock) { value = v; } } public void doSomething() { synchronized(lock) { // Prevents setValue being called by another thread. if(value != null) { doFirstThing(); int val = value.getInt(); // Cannot throw NullPointerException. doSecondThing(val); } } } </code></pre> Volatile: <pre><code>private boolean running = true; // Called by Thread 1. public void run() { while(running) { doSomething(); } } // Called by Thread 2. public void stop() { running = false; } </code></pre> To explain this requires knowledge of the Java Memory Model. It is worth reading about in depth, but the short version for this example is that Threads have their own copies of variables which are only sync'd to main memory on a synchronized block and when a volatile variable is reached. The Java compiler (specifically the JIT) is allowed to optimise the code into this: <pre><code>public void run() { while(true) { // Will never end doSomething(); } } </code></pre> To prevent this optimisation you can set a variable to be volatile, which forces the thread to access main memory every time it reads the variable. Note that this is unnecessary if you are using synchronized statements as both keywords cause a sync to main memory. I haven't addressed your questions directly as Francis did so. I hope these examples can give you an idea of the concepts in a better way than the examples you saw in the Oracle tutorial.
Tags
Title
singulars
PostAcceptedAnswerId
1. This table or related slice is empty.
PostParentId
1. POQuestions on Concurrency from Java Guide
 singulars
 PostTypePostTypeId
 PTQuestion
PostTypePostTypeId
1. PTAnswer
UserLastEditorUserId
1. This table or related slice is empty.
UserOwnerUserId
1. USBringer128
plurals
PostLinksPostIdRelatedPostId
1. This table or related slice is empty.
PostLinksRelatedPostIdPostId
1. This table or related slice is empty.
PostsAcceptedAnswerId
1. This table or related slice is empty.
PostsParentIdCreationDate
1. This table or related slice is empty.
VotesPostIdCreationDate
1. VO
 singulars
 PostPostId
 PO
 UserUserId
 This table or related slice is empty.
 VoteTypeVoteTypeId
 VTUpMod
CommentsPostId
1. This table or related slice is empty.

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.