Skip to main content

Avoid Writing to static Fields from Instance Methods

High
reliabilitydata integritymultithreading

What is it?​

This practice is triggered when a static field is updated from a non-static method in Java, potentially causing issues in environments with multiple instances or threads.

Why apply it?​

Updating a static field from instance methods can lead to race conditions and inconsistent states if not managed correctly, especially in multithreaded environments.

How to fix it?​

Access and modify static fields within synchronized static methods to ensure consistent updates and avoid unexpected behaviors caused by concurrent modifications.

Examples​

Example 1:​

Negative​

The negative example directly modifies a static field from an instance method, risking race conditions and inconsistent states.

public class MyClass {

  private static int count = 0;

  public void doSomething() {
    //...
    count++;  // Noncompliant: Direct modification of static field
  }
}

Example 2:​

Positive​

The positive example updates the static field using a synchronized static method, ensuring thread-safe operations.

public class MyClass {

  private static int count = 0;

  public static synchronized void incrementCount() {
    count++;  // Compliant: Updates are synchronized
  }

  public void doSomething() {
    //...
    MyClass.incrementCount();
  }
}

Negative​

The negative example directly alters a static field from within an instance method, creating potential thread-safety and data consistency problems.

public class Counter {

  private static int counterValue = 0;

  public void process() {
    // Perform tasks
    counterValue += 1;  // Noncompliant: Direct modification of static field
  }
}

Example 3:​

Positive​

The positive example groups static field updates in a dedicated synchronized static method, allowing safe access and modifications.

public class Counter {

  private static int counterValue = 0;

  public static synchronized void updateCounter() {
    counterValue += 1;  // Compliant: Uses synchronized static method
  }

  public void process() {
    // Perform tasks
    Counter.updateCounter();
  }
}