Home PC Games Linux Windows Database Network Programming Server Mobile  
           
  Home \ Programming \ Java Concurrency -volatile keywords     - Java Virtual Machine Basics (Programming)

- awk pattern matching (Programming)

- Installation and deployment of MariaDB under CentOS (Database)

- Select helps secure the system network management tools (Linux)

- Linux basic articles of the boot process (Linux)

- Use ARChon runtime environment to run Android apps on Ubuntu (Linux)

- Cool Android realization SVG animation (Programming)

- Through Oracle to help restore MySQL data problems (Database)

- The FreeBSD zfs: failed with error 6 Error Resolution (Linux)

- Caffe + Ubuntu 14.04 64bit + CUDA 6.5 configuration instructions (Linux)

- Linux Bash share tips for getting started (Linux)

- Android Scroller call mechanism and the relationship of computeScroll (Programming)

- Copy U disk files to the Linux system on a virtual machine (Linux)

- Linux remote connectivity tools -OpenSSH (Linux)

- How to choose the correct HTTP status code (Server)

- Linux use chattr and lsattr commands to manage file and directory attributes (Linux)

- Ubuntu 14.04 / 13.10 users how to install Ubuntu Touch core applications (Linux)

- Linux in order to make NMAP hide and seek with the firewall (Linux)

- How to ensure that the Internet will not be attacked (Linux)

- Android Activity launchMode (Programming)

 
         
  Java Concurrency -volatile keywords
     
  Add Date : 2018-11-21      
         
         
         
  Java language provides a weaker synchronization mechanism, namely volatile variable used to ensure that the notification of the update operation variables to other threads.

When the variable type is declared as volatile, the compiler and runtime will be noted that this variable is shared, and therefore the action is not on the variable memory operations together with other reordering, volatile variables are not cached in registers or on processor invisible place, so when reading the volatile variable always returns the latest value written. Access volatile variable does not perform locking operation and, therefore, does not make the execution thread is blocked, so volatile variable is a more lightweight synchronization mechanism than sychronized keywords.

One kind of volatile variables typical usage: checking a status flag to determine whether to exit loop

volatile boolean asleep;

while (! asleep)
      countSomeSheep ();

volatile variables are usually used with an operation is complete, interrupt, or state identification. Despite the volatile variables it can be used to represent other status information, but should be used with caution. For example, volatile enough to guarantee semantic increment operation (count ++) atomicity, unless you can ensure that only one thread of the variable write operation.

Locking mechanism to ensure both visibility and can guarantee atomicity, while volatile variable visibility only guarantee.

Use volatile should meet a number of conditions

First. Variable write operation does not depend on the current value of the variable, or you can ensure that only a single thread to update the values of variables

The variables are not included in the invariance conditions in conjunction with other state variables

Accessing locked variables are not required

Variable write operation does not depend on the current value of the variable, or you can ensure that only a single thread to update the values of variables

Common operations such as: i ++ operation, i write i need to rely on their own values, when there are multiple execution threads simultaneously i ++, A, B read the value of i, then ++ operator, the value may actually get ++ only once

The following code:

public class Volatiletest extends Thread {

        static volatile int a = 0;


      public void run ()
      {

        for (int i = 0; i < 10; i ++)
              try
        {
                a = a + 1;
                sleep (300);

            }
              catch (Exception e)
            {
            }
      }

      public static void main (String [] args) throws InterruptedException
      {
        Thread thread [] = new Thread [100];

        for (int i = 0; i < 100; i ++)
                thread [i] = new Volatiletest ();

        for (int i = 0; i < 100; i ++)
                thread [i] .start ();

        for (int i = 0; i < 100; i ++)
                thread [i] .join ();

        . System out.println ( "a:" + a);

      }
}

Run, you can learn a result is not necessarily equal to 1000, a lot of time to be less than 1000

Second. This variable is not included in the invariance conditions in conjunction with other state variables

Look at an example: There is a range of values is always less than or equal upper lower This is an invariant

  public class NumberRange {
          private volatile int lower, upper;
          public int getLower () {
              return lower;
          }
          public int getUpper () {
              return upper;
          }
          public void setLower (int value) {
              if (value> upper) throw new IllegalArgumentException (...);
              lower = value;
          }
          public void setUpper (int value) {
              if (value < lower) throw new IllegalArgumentException (...);
              upper = value;
          }
      }

In this way limit the scope of the state variables, the lower and upper fields are defined as volatile types can not be fully realized thread-safe class; thus still need to use synchronization. Otherwise, if you happen to execute two threads setLower and setUpper inconsistent values at the same time, then the range will be in an inconsistent state. For example, if the initial state is (0,5), the same time, the thread A calls setLower(4) Because using a volatile variable, the upper reading is 5, and the thread B calls setUpper(3) Similarly, since the variable is volatile, lower reading is 0, it is clear that the value of the cross into the two operations are not eligible, then by two threads are used to protect the invariant checks, making the final range value is (4,3) - - an invalid value. As for the other operations on the field, we need to make setLower () and setUpper () atomic operation - and the field is defined as a volatile type is impossible to achieve this purpose.

Third.from the previous know - locking mechanism to ensure both visibility and can guarantee atomicity, while volatile variable visibility only guarantee.

So volatile variable does not guarantee atomic lock operations.
     
         
         
         
  More:      
 
- Notebook computer forget password solution (Linux)
- Android annotation support (Support Annotations) (Programming)
- Syncthing: Private Security Synchronization tool to synchronize files between computers / folder (Linux)
- How to modify the Emacs Major Mode Shortcuts (Linux)
- How Datadog monitor Nginx (Server)
- Linux kernel source tree to establish load module hello (Linux)
- Linux iptables: combat scenes (Linux)
- CentOS 6.6 source compiler GCC upgrade to 4.8.2 (Linux)
- Memcached and Redis (Linux)
- Stunning exclamation point at the Linux command line (Linux)
- Steps to build MPICH2 development environment on CentOS 6.4 (Linux)
- To install Gitolite in Ubuntu / Fedora / CentOS (Linux)
- Linux --- file descriptors and redirection (Linux)
- Analyzing Linux server architecture is 32-bit / 64-bit (Server)
- Linux stand-alone OGG synchronous Oracle 11g DB test (Database)
- Spacewalk remove packages install the update (Linux)
- Django how to generate content in non-HTML formats (Programming)
- Ubuntu batch scp to copy files without password (Linux)
- Killall five options you might not know (Linux)
- Linux signal and orphans, and zombie process (Programming)
     
           
     
  CopyRight 2002-2022 newfreesoft.com, All Rights Reserved.