Home PC Games Linux Windows Database Network Programming Server Mobile  
           
  Home \ Programming \ Java Concurrency -volatile keywords     - ORA-01839 error caused by incorrect system date setting (Database)

- Linux dd command applies amplification SWAP partition (Linux)

- Node.js developers must know four JavaScript concepts (Programming)

- Redis 3.0.3 Cluster Setup (Database)

- To use iostat display I / O status under Linux (Linux)

- Solaris 11 forget the root password (Linux)

- C ++ in the elimination Wunused (Programming)

- How to display a dialog Bash Shell script (Programming)

- Ubuntu Server security risk checks (Linux)

- Use OpenSSL to generate a certificate (Linux)

- Echo Command Examples (Linux)

- C / C ++ various data types Conversion Summary (Programming)

- SELinux multi-level security (Linux)

- Learning the Linux powerful network management capabilities (Linux)

- JIRA 3.6.2 Upgrade from older version to the new version 6.0.8 (Linux)

- Log4j configuration file Explanation (Linux)

- Why learn Java EE (Programming)

- JQuery implements the same content merge cells (Programming)

- CentOS 6.6 command-line automatic completion (Linux)

- Story timestamp and time zones: daily programmer (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:      
 
- SendMail version of Java implementation with attachments (Programming)
- Installation GitLab appears ruby_block supervise_redis_sleep action run (Linux)
- VirtualBox virtual machine can not start to solve under Ubuntu (Linux)
- Linux System Getting Started Learning: The Linux logrotate (Linux)
- Oracle archive log full cause abnormal slow database performance (Database)
- OpenSUSE installation on CentOS6 (GUI) (Linux)
- Python Basics: Search Path (Programming)
- How to choose the first programming language based on the life you want (Programming)
- Linux Getting Started tutorial: Borrow Windows fonts in Ubuntu 14.10 (Linux)
- Install and configure GO 1.2.1 under CentOS 6.5 (Linux)
- HTML5 Application Cache (Programming)
- Configuring DNS process under CentOS 6.5 (Server)
- Iptables small summary (Linux)
- C ++ Supplements - Virtual Function Principle (Programming)
- Oracle Linux 5.9 configuration Xmanager (Linux)
- Compare Several MySQL environmental issues (Database)
- Eclipse distributed management using GitHub project development (Linux)
- Windows 8.1 and Ubuntu 14.04 dual system uninstall Ubuntu Tutorial (Linux)
- Ubuntu 15.04 installation MATE 1.10 (Linux)
- When should I use Angular 2 (Programming)
     
           
     
  CopyRight 2002-2020 newfreesoft.com, All Rights Reserved.