{"id":276,"date":"2011-06-10T21:13:18","date_gmt":"2011-06-10T21:13:18","guid":{"rendered":"https:\/\/kari.world.ikari.fi\/2011\/06\/10\/speculate-but-dont-guess-measure-to-see\/"},"modified":"2011-06-10T21:13:18","modified_gmt":"2011-06-10T21:13:18","slug":"speculate-but-dont-guess-measure-to-see","status":"publish","type":"post","link":"https:\/\/kari.world.ikari.fi\/?p=276","title":{"rendered":"Speculate, but don’t guess, measure to see"},"content":{"rendered":"

How synchronized<\/code> keyword behaves in methods. I’ve heard speculation that doFoo1()<\/code> would result into more compact byte code, but I don’t buy that.<\/p>\n

Assumption:<\/b>
\nByte code in both cases, is same.<\/p>\n

So we have this sample,<\/p>\n

[code lang=”java”]
\nclass SyncMe {<\/p>\n

synchronized void doFoo1() {
\n int x = 0;
\n }<\/p>\n

void doFoo2() {
\n synchronized (this) {
\n int x = 0;
\n }
\n }
\n}
\n[\/code]<\/p>\n

And the result is, javap -c SyncMe<\/code><\/p>\n

[code lang=”java”]
\nclass SyncMe {
\n SyncMe();
\n Code:
\n 0: aload_0
\n 1: invokespecial #1 \/\/ Method java\/lang\/Object.””:()V
\n 4: return<\/p>\n

synchronized void doFoo1();
\n Code:
\n 0: iconst_0
\n 1: istore_1
\n 2: return<\/p>\n

void doFoo2();
\n Code:
\n 0: aload_0
\n 1: dup
\n 2: astore_1
\n 3: monitorenter
\n 4: iconst_0
\n 5: istore_2
\n 6: aload_1
\n 7: monitorexit
\n 8: goto 16
\n 11: astore_3
\n 12: aload_1
\n 13: monitorexit
\n 14: aload_3
\n 15: athrow
\n 16: return
\n Exception table:
\n from to target type
\n 4 8 11 any
\n 11 14 11 any
\n}
\n[\/code]<\/p>\n

Result:<\/b>
\nHowly cotton ball. They really ARE<\/b> different. Based on this is more adviceable to use synchronized<\/code> keyword in method, than adding blocks manually inside the method.<\/p>\n

TIP:<\/b>
\nSo how you do that, in practise. Answer is simple, use good approach of using small<\/b> methods.<\/p>\n

[code lang=”java”]
\nclass SyncProper {
\n int x;<\/p>\n

synchronized void resetX() {
\n x = 0;
\n }<\/p>\n

void doGood() {
\n \/\/ do stuff
\n resetX();
\n \/\/ do more stuff
\n }<\/p>\n

void doBad() {
\n \/\/ do stuff
\n synchronized (this) {
\n x = 0;
\n }
\n \/\/ do more stuff
\n }
\n}
\n[\/code]<\/p>\n

And as simple as that, simple and clean code, relying good programming patterns, leads into best optimized code.<\/p>\n

[code lang=”java”]
\nclass SyncProper {
\n int x;<\/p>\n

SyncProper();
\n Code:
\n 0: aload_0
\n 1: invokespecial #1 \/\/ Method java\/lang\/Object.””:()V
\n 4: return<\/p>\n

synchronized void resetX();
\n Code:
\n 0: aload_0
\n 1: iconst_0
\n 2: putfield #2 \/\/ Field x:I
\n 5: return<\/p>\n

void doGood();
\n Code:
\n 0: aload_0
\n 1: invokevirtual #3 \/\/ Method resetX:()V
\n 4: return<\/p>\n

void doBad();
\n Code:
\n 0: aload_0
\n 1: dup
\n 2: astore_1
\n 3: monitorenter
\n 4: aload_0
\n 5: iconst_0
\n 6: putfield #2 \/\/ Field x:I
\n 9: aload_1
\n 10: monitorexit
\n 11: goto 19
\n 14: astore_2
\n 15: aload_1
\n 16: monitorexit
\n 17: aload_2
\n 18: athrow
\n 19: return
\n Exception table:
\n from to target type
\n 4 11 14 any
\n 14 17 14 any
\n}
\n[\/code]<\/p>\n

As class file size, doing it good way, resulted into class file of size 344<\/b> bytes, and using bad way resulted 390<\/b> bytes. Naturally those were measure by using exactly same length class\/field\/method names to avoid variance due to that. Notice, however, that good way has one extra method (resetX()<\/code>), but it still manages to be much smaller. Do you still need more proof to prefer small maintainable methods? If you code in the manner what JVM likes, you will make code more clean, and very likely also faster, since, for example, in this case code for managing synchronized<\/code> is externalized into native code (well, I’m guessing here) or at least closer to JIT\/JVM machine.<\/p>\n

So follow da-leader, and doGood()<\/b>. Don’t speculate, trust the results.<\/p>\n

References:<\/b>
\nStackoverlow: What is the difference between synchronized(this) and synchronized method<\/a>
\nStackoverflow: synchronized block vs synchronized method?<\/a>
\nIBM developerWorks: Java bytecode: Understanding bytecode makes you a better programmer<\/a>
\nCode Impossible: Java Bytecode Fundamentals<\/a><\/p>\n","protected":false},"excerpt":{"rendered":"

How synchronized keyword behaves in methods. I’ve heard speculation that doFoo1() would result into more compact byte code, but I don’t buy that. Assumption: Byte code in both cases, is same. So we have this sample, [code lang=”java”] class SyncMe { synchronized void doFoo1() { int x = 0; } void doFoo2() { synchronized (this)…<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[7],"tags":[],"class_list":["post-276","post","type-post","status-publish","format-standard","hentry","category-java"],"_links":{"self":[{"href":"https:\/\/kari.world.ikari.fi\/index.php?rest_route=\/wp\/v2\/posts\/276","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/kari.world.ikari.fi\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/kari.world.ikari.fi\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/kari.world.ikari.fi\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/kari.world.ikari.fi\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=276"}],"version-history":[{"count":0,"href":"https:\/\/kari.world.ikari.fi\/index.php?rest_route=\/wp\/v2\/posts\/276\/revisions"}],"wp:attachment":[{"href":"https:\/\/kari.world.ikari.fi\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=276"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/kari.world.ikari.fi\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=276"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/kari.world.ikari.fi\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=276"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}