Java Memory Model - Visibility problem, fixing with volatile variable

刺骨的言语ヽ痛彻心扉 2022-09-05 04:24 127阅读 0赞

<table> 
 <tbody> 
  <tr> 
   <td> <h1>Java Memory Model - Visibility problem, fixing with volatile variable</h1> <p>[Last Updated: Mar 12, 2019]</p> </td> 
   <td> <p><a href="https://www.logicbig.com/tutorials/core-java-tutorial/java-multi-threading/java-memory-model.html" rel="nofollow">Previous Page</a><a href="https://www.logicbig.com/tutorials/core-java-tutorial/java-multi-threading/volatile-ref-object.html" rel="nofollow">Next Page</a></p> </td> 
  </tr> 
  <tr> 
   <td> <p>When variable reads and writes occur in different threads, the reader thread cannot always see the changes made by writer thread immediately. That is due to the underlying processor architecture as described in the last tutorial. In general, there is no guarantee that the reader thread will see a value written by another thread on a timely basis, or even at all.<br> According to&nbsp;<a href="https://www.logicbig.com/tutorials/core-java-tutorial/java-multi-threading/java-memory-model.html" rel="nofollow">Java Memory Model</a>, we must either establish some sort of happen-before relation between read and write threads or use synchronized blocks.</p> &nbsp; <h2>Example</h2> <p>In this example one thread increases a counter of type int and other thread attempts to read it:</p> <pre>public class ReaderWriterShareDataProblem {
    static int c;

public static void main (String[] args) {

Thread thread1 = new Thread(() -&gt; {
            int temp = 0;
            while (true) {
                if (temp != c) {
                    temp = c;
                    System.out.println("reader: value of c = " + c);
                }
            }
        });

Thread thread2 = new Thread(() -&gt; {
            for (int i = 0; i &lt; 5; i++) {
                c++;
                System.out.println("writer: changed value to = " + c);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

// sleep enough time to allow reader thread to read pending changes (if it can!).
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //exit the program otherwise other threads will be keep waiting on c to change.
            System.exit(0);
        });

thread1.start();
        thread2.start();
    }
}</pre> &nbsp; <p>Output:</p> <pre>    writer: changed value to = 1
    reader: value of c = 1
    writer: changed value to = 2
    writer: changed value to = 3
    writer: changed value to = 4
    writer: changed value to = 5

Process finished with exit code 0</pre> &nbsp; <p>As seen in the output the reader thread is not able to read the changes made with c at all, except for change in the default value, from 0 to 1.</p> <p>According to JSR-133:</p> 
    <blockquote>
      &nbsp;The write of the default value (zero, false or null) to each variable synchronizes-with to the first action in every thread. 
     <br> 
     <br> Although it may seem a little strange to write a default value to a variable before the object containing the variable is allocated, conceptually every object is created at the start of the program with its default initialized values. Consequently, the default initialization of any object happens-before any other actions (other than default writes) of a program. 
    </blockquote> &nbsp; <p>Note that output might vary for different kind of processor.</p> The machine I'm using: <pre>    OS Name	Microsoft Windows 10 Home
    Version	10.0.10586 Build 10586
    System Model	GP72 2QE
    System Type	x64-based PC
    Processor	Intel(R) Core(TM) i7-5700HQ CPU @ 2.70GHz, 2701 Mhz, 4 Core(s), 8 Logical Processor(s)
    Installed Physical Memory (RAM)	16.0 GB</pre> &nbsp; <h2>Fixing visibility problem with volatile variable</h2> <p>Using volatile forces all accesses (read or write) to occur to the main memory, effectively not caching volatile in CPU. This can be useful for the actions where visibility of the variable is important and order of accesses is not important.</p> <p>In above example just replace</p> <pre>static int c;</pre> with <pre>static int volatile c;</pre> &nbsp; <p>New class:</p> <pre>public class ReaderWriterShareDataProblemVolatileFix {
    static volatile int c ;
 // same code as before
    .......
}</pre> <p>Output:</p> <pre>    writer: changed value to = 1
    reader: value of c = 1
    writer: changed value to = 2
    reader: value of c = 2
    writer: changed value to = 3
    reader: value of c = 3
    reader: value of c = 4
    writer: changed value to = 4
    reader: value of c = 5
    writer: changed value to = 5

Process finished with exit code 0</pre> &nbsp; <p>As we can see in the output now, the changes in the value of c is visible to the reader thread immediately.</p> <p></p> <h2>Using volatile vs synchronized blocks</h2> <p>Above scenario is related to read and write threads where threads don't overlap same piece of code but still cause data-race (please see&nbsp;<a href="https://www.logicbig.com/tutorials/core-java-tutorial/java-multi-threading/java-memory-model.html" rel="nofollow">last tutorial</a>&nbsp;for a formal definition of data-race). In scenarios where threads interleave/overlap and try to read/write shared variables on the 'same method/piece of code' where atomicity of multiple actions is required, or perform some composite actions like ++, using 'volatile' will not be appropriate choice.<br> In those kind of cases we should use intrinsic locks on the shared code instead of volatile variables (in next tutorial we will see an example on that).</p> &nbsp; <h2>Why shouldn't we always use locks?</h2> <p>It's a common question that why bother about deciding in what scenarios we should use volatile or use intrinsic lock, why shouldn't we always use intrinsic locks. Using volatile (at appropriate scenarios) is important because the programmer is able to write cleaner and less error prone code as compare to writing synchronized blocks. It's kind of giving the synchronization responsibility to the JVM rather than doing it ourselves. Also depending on the runtime JVM implementation, volatile can have better throughput and better latency. However, if volatile fields are accessed frequently inside a single method, their use is likely to lead to slower performance than would locking the entire method.</p> &nbsp; <h2>Swing example</h2> <p>It's better to visualize the effect of using volatile in a Swing GUI. Let's modify our above example:</p> <pre>import javax.swing.*;
import java.awt.*;

public class ReaderWriterSwingWithVolatileExample {
    static volatile int c;

public static void main (String[] args) {
        JFrame frame = createFrame();
        frame.setLayout(new FlowLayout(FlowLayout.LEFT, 30, 5));

final ProgressUi writerProgressUi = new ProgressUi("Writer Thread");
        final ProgressUi readerProgressUi = new ProgressUi("Reader Thread");

frame.add(writerProgressUi.getProgressComponent());
        frame.add(readerProgressUi.getProgressComponent());

frame.setLocationRelativeTo(null);
        frame.setVisible(true);

Thread thread1 = new Thread(() -&gt; {
            int temp = 0;
            while (true) {
                if (temp != c) {
                    temp = c;
                    readerProgressUi.update(temp);
                }
            }
        });

Thread thread2 = new Thread(() -&gt; {
            for (int i = 1; i &lt;= 100; i++) {
                c++;
                writerProgressUi.update(c);
                try {
                    Thread.sleep(20);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

if (i == 100) {
                    i = 1;
                    c = 0;
                }
            }
        });

thread1.start();
        thread2.start();
    }

private static class ProgressUi {
        private JProgressBar progressBar = new JProgressBar();

ProgressUi (String name) {
            progressBar.setString(name);
            progressBar.setStringPainted(true);
        }

JComponent getProgressComponent () {
            return progressBar;
        }

void update (int c) {
            progressBar.setValue(c);
        }
    }

private static JFrame createFrame () {
        JFrame frame = new JFrame("Visibility Demo with Volatile");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setSize(new Dimension(400, 80));
        return frame;
    }
}</pre> &nbsp; <p>Using variable c with volatile keyword or without it, will give this output:</p> <p style="text-align:center;"><img alt="" src="https://img-blog.csdnimg.cn/img_convert/c26f5bcd480635d1f9cdf2dc0f358473.gif"></p> &nbsp; <p></p> <h2>Example Project</h2> <p>Dependencies and Technologies Used:</p> 
    <ul> 
     <li>JDK 1.8</li> 
     <li>Maven 3.0.4</li> 
    </ul></td> 
   <td> <p></p> <p></p> <p></p> <p></p> <p></p> <p style="text-align:center;"><img alt="" src="https://img-blog.csdnimg.cn/img_convert/8238c17d89540ac1f39445b75da927a2.png"></p> <p><a href="https://aax-us-east.amazon-adsystem.com/x/c/Qq-eeExlzbcM8gSbly3ER_IAAAF7UchyrAEAAAFKAZq6gKI/https://www.amazon.com/dp/0596007825/ref=sm_n_se_dkp_CN_pr_sea_0_0?adId=0596007825&amp;creativeASIN=0596007825&amp;linkId=ec98fbe3322cb32dce01764a9c07c107&amp;tag=logicbig-20&amp;linkCode=w42&amp;ref-refURL=https%3A%2F%2Fwww.logicbig.com%2Ftutorials%2Fcore-java-tutorial%2Fjava-multi-threading%2Fvisibility-volatile.html&amp;slotNum=0&amp;imprToken=6d88edc3a25653d91e7f1b1f0f616226&amp;adType=smart&amp;adMode=search&amp;adFormat=grid&amp;impressionTimestamp=1629164757272" rel="nofollow">Java Threads: Understanding and Ma…</a></p> <p>$21.08$39.95</p> <p>&nbsp;(34)</p> <p style="text-align:center;"><img alt="" src="https://img-blog.csdnimg.cn/img_convert/da871dd0ab08a5aa0fc7c9e8d8038458.png"></p> <p><a href="https://aax-us-east.amazon-adsystem.com/x/c/Qq-eeExlzbcM8gSbly3ER_IAAAF7UchyrAEAAAFKAZq6gKI/https://www.amazon.com/dp/1537130978/ref=sm_n_se_dkp_CN_pr_sea_0_1?adId=1537130978&amp;creativeASIN=1537130978&amp;linkId=ec98fbe3322cb32dce01764a9c07c107&amp;tag=logicbig-20&amp;linkCode=w42&amp;ref-refURL=https%3A%2F%2Fwww.logicbig.com%2Ftutorials%2Fcore-java-tutorial%2Fjava-multi-threading%2Fvisibility-volatile.html&amp;slotNum=0&amp;imprToken=6d88edc3a25653d91e7f1b1f0f616226&amp;adType=smart&amp;adMode=search&amp;adFormat=grid&amp;impressionTimestamp=1629164757274" rel="nofollow">Advanced Do-It-Yourself Java Games: An Introduc…</a></p> <p>$35.00</p> <p>&nbsp;(13)</p> <p style="text-align:center;"><img alt="" src="https://img-blog.csdnimg.cn/img_convert/e49a5ddcea85724f3a9cc49aacef182c.png"></p> <p><a href="https://aax-us-east.amazon-adsystem.com/x/c/Qq-eeExlzbcM8gSbly3ER_IAAAF7UchyrAEAAAFKAZq6gKI/https://www.amazon.com/dp/1484233476/ref=sm_n_se_dkp_CN_pr_sea_1_0?adId=1484233476&amp;creativeASIN=1484233476&amp;linkId=ec98fbe3322cb32dce01764a9c07c107&amp;tag=logicbig-20&amp;linkCode=w42&amp;ref-refURL=https%3A%2F%2Fwww.logicbig.com%2Ftutorials%2Fcore-java-tutorial%2Fjava-multi-threading%2Fvisibility-volatile.html&amp;slotNum=0&amp;imprToken=6d88edc3a25653d91e7f1b1f0f616226&amp;adType=smart&amp;adMode=search&amp;adFormat=grid&amp;impressionTimestamp=1629164757275" rel="nofollow">Java Language Features: With Modules, Strea…</a></p> <p>$48.86$59.99</p> <p>&nbsp;(3)</p> <p style="text-align:center;"><img alt="" src="https://img-blog.csdnimg.cn/img_convert/c1e14df65bf36408193fef2005df3c65.png"></p> <p><a href="https://aax-us-east.amazon-adsystem.com/x/c/Qq-eeExlzbcM8gSbly3ER_IAAAF7UchyrAEAAAFKAZq6gKI/https://www.amazon.com/dp/1484216997/ref=sm_n_se_dkp_CN_pr_sea_1_1?adId=1484216997&amp;creativeASIN=1484216997&amp;linkId=ec98fbe3322cb32dce01764a9c07c107&amp;tag=logicbig-20&amp;linkCode=w42&amp;ref-refURL=https%3A%2F%2Fwww.logicbig.com%2Ftutorials%2Fcore-java-tutorial%2Fjava-multi-threading%2Fvisibility-volatile.html&amp;slotNum=0&amp;imprToken=6d88edc3a25653d91e7f1b1f0f616226&amp;adType=smart&amp;adMode=search&amp;adFormat=grid&amp;impressionTimestamp=1629164757277" rel="nofollow">Java Threads and the Concurrency Utilities</a></p> <p>$29.99</p> <p>&nbsp;(3)</p> <p><a href="https://aax-us-east.amazon-adsystem.com/x/c/Qq-eeExlzbcM8gSbly3ER_IAAAF7UchyrAEAAAFKAZq6gKI/https://affiliate-program.amazon.com/home/ads/ref=sm_n_se_dkp_CN_logo?adId=logo&amp;creativeASIN=logo&amp;linkId=ec98fbe3322cb32dce01764a9c07c107&amp;tag=logicbig-20&amp;linkCode=w42&amp;ref-refURL=https%3A%2F%2Fwww.logicbig.com%2Ftutorials%2Fcore-java-tutorial%2Fjava-multi-threading%2Fvisibility-volatile.html&amp;slotNum=0&amp;imprToken=6d88edc3a25653d91e7f1b1f0f616226&amp;adType=smart&amp;adMode=search&amp;adFormat=grid&amp;impressionTimestamp=1629164757283&amp;ac-ms-src=nsa-ads&amp;cid=nsa-ads" rel="nofollow">Ads by Amazon</a>&nbsp;</p> <h3>Core Java Tutorials</h3> 
    <ul> 
     <li><a href="https://www.logicbig.com/tutorials/core-java-tutorial/java-16-changes.html" rel="nofollow">Java 16 Features</a></li> 
     <li><a href="https://www.logicbig.com/tutorials/core-java-tutorial/java-15-changes.html" rel="nofollow">Java 15 Features</a></li> 
     <li><a href="https://www.logicbig.com/tutorials/core-java-tutorial/java-14-changes.html" rel="nofollow">Java 14 Features</a></li> 
     <li><a href="https://www.logicbig.com/tutorials/core-java-tutorial/java-13-changes.html" rel="nofollow">Java 13 Features</a></li> 
     <li><a href="https://www.logicbig.com/tutorials/core-java-tutorial/java-12-changes.html" rel="nofollow">Java 12 Features</a></li> 
     <li><a href="https://www.logicbig.com/tutorials/core-java-tutorial/java-11-changes.html" rel="nofollow">Java 11 Features</a></li> 
     <li><a href="https://www.logicbig.com/tutorials/core-java-tutorial/java-10-changes.html" rel="nofollow">Java 10 Features</a></li> 
     <li><a href="https://www.logicbig.com/tutorials/core-java-tutorial/modules.html" rel="nofollow">Java 9 Module System</a></li> 
     <li><a href="https://www.logicbig.com/tutorials/core-java-tutorial/java-9-changes.html" rel="nofollow">Java 9 Misc Features</a></li> 
     <li><a href="https://www.logicbig.com/tutorials/core-java-tutorial/jshell.html" rel="nofollow">Java 9 JShell</a></li> 
    </ul><h3>Recent Tutorials</h3> 
    <ul> 
     <li><a href="https://www.logicbig.com/tutorials/spring-framework/spring-core/use-of-property-editors-with-value-annotation.html" rel="nofollow">Spring - The Use Of PropertyEditors With @Value Annotation</a></li> 
     <li><a href="https://www.logicbig.com/tutorials/spring-framework/spring-core/property-editors-used-with-xml-config.html" rel="nofollow">Spring - The Use Of PropertyEditors With XML Configuration</a></li> 
     <li><a href="https://www.logicbig.com/tutorials/spring-framework/spring-core/property-editors-used-by-stand-alone-bean-wrapper.html" rel="nofollow">Spring - Use of PropertyEditors via BeanWrapper</a></li> 
     <li><a href="https://www.logicbig.com/tutorials/spring-framework/spring-core/bean-utils-resolving-method-signature-as-string-representation.html" rel="nofollow">Spring - Using BeanUtils for resolving string based method signatures</a></li> 
     <li><a href="https://www.logicbig.com/tutorials/spring-framework/spring-core/bean-utils-copy-properties.html" rel="nofollow">Spring - Copying properties using BeanUtils</a></li> 
     <li><a href="https://www.logicbig.com/tutorials/spring-framework/spring-core/obtaining-bean-info-and-property-descriptors.html" rel="nofollow">Spring - Obtaining BeanInfo And PropertyDescriptors</a></li> 
     <li><a href="https://www.logicbig.com/tutorials/spring-framework/spring-core/direct-field-access.html" rel="nofollow">Spring - Directly setting fields via DirectFieldAccess</a></li> 
     <li><a href="https://www.logicbig.com/tutorials/spring-framework/spring-core/using-bean-wrapper-to-set-nested-beans.html" rel="nofollow">Spring - BeanWrapper, setting nested beans</a></li> 
     <li><a href="https://www.logicbig.com/tutorials/spring-framework/spring-core/using-bean-wrapper.html" rel="nofollow">Spring - Using BeanWrapper</a></li> 
     <li><a href="https://www.logicbig.com/tutorials/spring-framework/spring-core/spring-events-transforming-to-other-events.html" rel="nofollow">Spring - Transforming events</a></li> 
     <li><a href="https://www.logicbig.com/tutorials/spring-framework/spring-core/conditional-event-handling-via-event-listener-annotation.html" rel="nofollow">Spring - Conditional Event Handling via @EventListener annotation</a></li> 
     <li><a href="https://www.logicbig.com/tutorials/spring-framework/spring-core/event-listener-annotation-with-multiple-events.html" rel="nofollow">Spring - Using @EventListener annotation with multiple event types</a></li> 
     <li><a href="https://www.logicbig.com/tutorials/spring-framework/spring-core/creating-and-publishing-custom-events.html" rel="nofollow">Spring - Publishing and Consuming Custom Events</a></li> 
     <li><a href="https://www.logicbig.com/tutorials/core-java-tutorial/internationalization/resource-bundle-example.html" rel="nofollow">Java - Introduction to ResourceBundle</a></li> 
     <li><a href="https://www.logicbig.com/tutorials/spring-framework/spring-core/injecting-resources.html" rel="nofollow">Spring - Injecting Resource using @Value annotation</a></li> 
     <li><a href="https://www.logicbig.com/tutorials/spring-framework/spring-core/injecting-resource-loader.html" rel="nofollow">Spring - Injecting ResourceLoader</a></li> 
     <li><a href="https://www.logicbig.com/tutorials/spring-framework/spring-core/resource-loading.html" rel="nofollow">Spring - Resource Loading</a></li> 
     <li><a href="https://www.logicbig.com/tutorials/spring-framework/spring-core/value-annotation-with-expression-language.html" rel="nofollow">Spring - Using Spring Expression Language with @Value Annotation</a></li> 
     <li><a href="https://www.logicbig.com/tutorials/spring-framework/spring-core/using-value-annotation.html" rel="nofollow">Spring - Using @Value Annotation</a></li> 
     <li><a href="https://www.logicbig.com/tutorials/spring-framework/spring-core/injecting-environment.html" rel="nofollow">Spring - Injecting Environment to access properties in beans</a></li> 
     <li><a href="https://www.logicbig.com/tutorials/spring-framework/spring-core/adding-new-property-source.html" rel="nofollow">Spring - Adding New Property Source to Environment</a></li> 
     <li><a href="https://www.logicbig.com/tutorials/spring-framework/spring-core/accessing-environmental-properties-by-using-property-source.html" rel="nofollow">Spring - Adding user properties by using @PropertySource</a></li> 
     <li><a href="https://www.logicbig.com/tutorials/spring-framework/spring-core/spring-env-properties.html" rel="nofollow">Spring - Accessing Environment Properties</a></li> 
     <li><a href="https://www.logicbig.com/tutorials/spring-framework/spring-core/spring-profiles.html" rel="nofollow">Spring - Profiles</a></li> 
     <li><a href="https://www.logicbig.com/tutorials/spring-framework/spring-core/avoid-circular-dependencies-exception-with-lazy-annotation.html" rel="nofollow">Spring - Successfully injecting circular dependencies using @Lazy Annotation</a></li> 
     <li><a href="https://www.logicbig.com/tutorials/spring-framework/spring-core/avoid-circular-dependencies-with-setter.html" rel="nofollow">Spring - Successfully injecting circular dependencies using setter injection</a></li> 
     <li><a href="https://www.logicbig.com/tutorials/core-java-tutorial/java-16-changes/java-records-features-quick-walk-through.html" rel="nofollow">Java 16 - Records Features, Quick Walk-through</a></li> 
     <li><a href="https://www.logicbig.com/tutorials/core-java-tutorial/java-16-changes/intro-to-java-records.html" rel="nofollow">Java 16 - Introduction to Records</a></li> 
     <li><a href="https://www.logicbig.com/tutorials/spring-framework/spring-core/using-qualifiers-and-specifying-the-ordering.html" rel="nofollow">Spring - Injecting beans into Arrays/Collections, Using @Qualifiers And Specifying the Ordering</a></li> 
     <li><a href="https://www.logicbig.com/tutorials/spring-framework/spring-core/injecting-beans-into-arrays-and-collections-with-ordered-interface.html" rel="nofollow">Injecting Collections - Injecting Beans Into Arrays And Collections, ordering with Ordered Interface</a></li> 
     <li><a href="https://www.logicbig.com/tutorials/spring-framework/spring-core/injecting-beans-into-arrays-and-collections-with-ordered-annotation.html" rel="nofollow">Spring - Injecting beans Into Arrays and Lists, ordering with @Ordered annotation</a></li> 
     <li><a href="https://www.logicbig.com/tutorials/spring-framework/spring-core/injecting-arrays-and-collection-selecting-elements-with-qualifier-annotation.html" rel="nofollow">Spring - Injecting beans into Arrays and Collections, selecting elements with @Qualifier annotation</a></li> 
     <li><a href="https://www.logicbig.com/tutorials/spring-framework/spring-core/injecting-multiple-beans-into-arrays-and-collections.html" rel="nofollow">Spring - Injecting multiple Beans Into Arrays and Collections</a></li> 
     <li><a href="https://www.logicbig.com/tutorials/spring-framework/spring-core/arrays-and-collections-as-beans.html" rel="nofollow">Spring - Arrays and Collections As Beans</a></li> 
     <li><a href="https://www.logicbig.com/tutorials/spring-framework/spring-core/component-scan-exclude-filter-with-filter-type-annotation.html" rel="nofollow">Spring - Using @ComponentScan#excludeFilters to exclude classes from scanning based on annotations</a></li> 
     <li><a href="https://www.logicbig.com/tutorials/spring-framework/spring-core/component-scan-include-filter-with-filter-type-annotation.html" rel="nofollow">Spring - Using @ComponentScan#includeFilters to scan non component classes based on annotations</a></li> 
     <li><a href="https://www.logicbig.com/tutorials/spring-framework/spring-core/implementing-application-context-aware-interface.html" rel="nofollow">Spring - Implementing ApplicationContextAware Interface</a></li> 
     <li><a href="https://www.logicbig.com/tutorials/spring-framework/spring-core/component-scan-using-exclude-filter-for-component-classes.html" rel="nofollow">Spring - Using excludeFilters attribute of @ComponentScan to exclude component classes</a></li> 
     <li><a href="https://www.logicbig.com/tutorials/spring-framework/spring-core/component-scan-include-filter-for-non-component-classes.html" rel="nofollow">Spring - Using @ComponentScan to scan non component classes via includeFilters attribute</a></li> 
     <li><a href="https://www.logicbig.com/tutorials/spring-framework/spring-core/component-scan-using-filters-to-customize-scanning.html" rel="nofollow">Spring - Using Filters To Customize Scanning with @ComponentScan</a></li> 
     <li><a href="https://www.logicbig.com/tutorials/spring-framework/spring-core/component-scan-base-package-classes-attribute.html" rel="nofollow">Spring - Using basePackageClasses Attribute of @ComponentScan</a></li> 
     <li><a href="https://www.logicbig.com/tutorials/spring-framework/spring-core/component-scan-base-packages-attribute.html" rel="nofollow">Spring - Specifying packages to be scanned with basePackages attribute of @ComponentScan</a></li> 
     <li><a href="https://www.logicbig.com/how-to/junit/java-test-user-command-line-input.html" rel="nofollow">JUnit - How to test user command line Input in Java?</a></li> 
     <li><a href="https://www.logicbig.com/tutorials/spring-framework/spring-core/spring-session-based-prototype-bean-example.html" rel="nofollow">Spring - Session based Prototype Bean Example</a></li> 
     <li><a href="https://www.logicbig.com/tutorials/spring-framework/spring-core/spring-prototype-bean-example.html" rel="nofollow">Spring - Prototype Bean Example</a></li> 
     <li><a href="https://www.logicbig.com/tutorials/spring-framework/spring-core/spring-singleton-bean-example.html" rel="nofollow">Spring - Singleton Bean Example</a></li> 
     <li><a href="https://www.logicbig.com/tutorials/spring-framework/spring-core/lifecycle-callbacks-by-implementing-spring-interfaces.html" rel="nofollow">Spring - Receiving lifecycle callbacks by implementing InitializingBean and DisposableBean</a></li> 
     <li><a href="https://www.logicbig.com/tutorials/spring-framework/spring-core/lifecycle-callbacks-using-bean-annotation.html" rel="nofollow">Spring - Receiving lifecycle callbacks by using 'initMethod' and 'destroyMethod' of @Bean annotation</a></li> 
     <li><a href="https://www.logicbig.com/tutorials/spring-framework/spring-core/implicit-constructor-injection-in-config-class.html" rel="nofollow">Spring - Implicit Constructor Injection In @Configuration Class</a></li> 
     <li><a href="https://www.logicbig.com/tutorials/spring-framework/spring-core/using-autowired-annotation-on-arbitrary-methods.html" rel="nofollow">Spring - Using @Autowired annotation on arbitrary methods</a></li> 
     <li><a href="https://www.logicbig.com/examples/spring/spring-defining-injection-point/spring-inject-annotation-on-setter-example.html" rel="nofollow">Spring - Using @Inject annotation on setter methods</a></li> 
     <li><a href="https://www.logicbig.com/examples/spring/spring-defining-injection-point/spring-autowire-annotation-on-setter-example.html" rel="nofollow">Spring Core - Using @Autowire annotation On a setter method</a></li> 
     <li><a href="https://www.logicbig.com/tutorials/spring-framework/spring-core/defining-injection-point-by-using-inject-annotation.html" rel="nofollow">Spring - Defining Injection point by using @Inject annotation</a></li> 
     <li><a href="https://www.logicbig.com/tutorials/spring-framework/spring-core/defining-injection-point-by-using-autowire-annotation.html" rel="nofollow">Spring - Defining injection point by using @Autowire annotation</a></li> 
     <li><a href="https://www.logicbig.com/tutorials/spring-framework/spring-core/resolving-ambiguity-by-inject-and-named-annotations.html" rel="nofollow">Spring - Resolving ambiguity by using @Inject and @Named annotations</a></li> 
     <li><a href="https://www.logicbig.com/tutorials/spring-framework/spring-core/spring-inject-by-name-using-inject-annotation.html" rel="nofollow">Spring - Resolving ambiguity by using @Inject and @Qualifier Annotations</a></li> 
    </ul></td> 
  </tr> 
  <tr> 
   <td colspan="2"> 
    <table> 
     <tbody> 
      <tr> 
       <td>ui-buttonui-button&nbsp;Java - volatile Example</td> 
       <td>&nbsp;Select All&nbsp; <p style="text-align:center;"><img alt="" src="https://img-blog.csdnimg.cn/img_convert/029b0e92c376a2f410ecb9453a1687f7.png"></p> &nbsp;<a href="https://www.logicbig.com/tutorials/core-java-tutorial/java-multi-threading/visibility-volatile/java-memory-model-visibility-problem.zip" rel="nofollow">Download&nbsp;<img alt="" src="https://www.logicbig.com/images/download.png"></a></td> 
      </tr> 
     </tbody> 
    </table> 
    <ul> 
     <li>shared-data-visibility-example 
      <ul> 
       <li>src 
        <ul> 
         <li>main 
          <ul> 
           <li>java 
            <ul> 
             <li>com 
              <ul> 
               <li>logicbig 
                <ul> 
                 <li>example 
                  <ul> 
                   <li> <p>ReaderWriterShareDataProblem.java</p> </li> 
                   <li> <p>ReaderWriterShareDataProblemVolatileFix.java</p> </li> 
                   <li> <p>ReaderWriterSwingExample.java</p> </li> 
                   <li> <p>ReaderWriterSwingWithVolatileExample.java</p> </li> 
                  </ul></li> 
                </ul></li> 
              </ul></li> 
            </ul></li> 
          </ul></li> 
        </ul></li> 
       <li> <p>pom.xml</p> </li> 
      </ul></li> 
    </ul><pre>package com.logicbig.example;

public class ReaderWriterShareDataProblem {
    static int c;

public static void main (String[] args) {

}

// sleep some time to allow reader thread to read changes (if it can!).
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //exit the program
            System.exit(0);
        });

thread1.start();
        thread2.start();
    }
}</pre> </td> 
  </tr> 
  <tr> 
   <td colspan="2"> <p></p> </td> 
  </tr> 
 </tbody> 
</table>