Is there a way to avoid overwriting new data without using statics or singletons?

Question

3.00/5 (2 votes)

See more:

Couple of scenarios.
If 2 separate classes receive the same data from the same file at about the same time, then change the data.

Scenario 1:
Class 1 is passed the data from an invoking class.
Class 2 is passed the same data from the same invoking class.
Both classes change the data and return it to the invoking class.

Scenario 2:
Classes 1 and 2 load the data at about the same time.
Class 1 saves, then class 2 saves.

What is the best way to avoid these situations?

What I have tried:

Created a god class to handle all the data loading, changing and saving. Not the best method and trying to find a better way.

Posted 3-Jun-16 23:22pm

Michael Hurt

Updated 4-Jun-16 4:31am

v2

Add a Solution

2 solutions

Add a Solution

Add your solution here

Treat my content as plain text, not as HTML

Preview 0

…

Existing Members

Sign in to your account

...or Join us

Download, Vote, Comment, Publish.

Your Email
Password
Forgot your password?

Your Email
This email is in use. Do you need your password?
Optional Password

I have read and agree to the Terms of Service and Privacy Policy
Please subscribe me to the CodeProject newsletters

When answering a question please:

Read the question carefully.
Understand that English isn't everyone's first language so be lenient of bad spelling and grammar.
If a question is poorly phrased then either ask for clarification, ignore it, or edit the question and fix the problem. Insults are not welcome.
Don't tell someone to read the manual. Chances are they have and don't get it. Provide an answer or move on to the next question.

Let's work to help developers, not make them feel stupid.

This content, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Afzaal Ahmad Zeeshan · Answer 1 · 2016-06-04T01:28:00

The first thing that I came to think of was a mutex. Since you are talking about Java programming I will restrict myself to Java environment only.

Mutex are used in multithreading environments where multiple threads are going to perform actions on the same topic. This way, a simpler solution may be like this,

Java

// Save a flag
public static boolean writing = false;
public void write(BufferedWriter bw) {
   if(!writing) { // Or you may want to use a loop to wait for that thread.
      synchronized(bw) {
         writing = true;
         // Write the data to the file
      }
      writing = false;
   }
}

This way, you will have just one single object writing the data out to the file at the time. However, this would cause later threads to wait. An example program that I wrote just to clarify how you will be doing this is like this,

Java

// User object
public class User {
    public String name;
    public int age;
    
    public void write(int name) {
        System.out.println(String.valueOf(name) + " thread entered.");
        new Writer().write(this.name + ", " + String.valueOf(age), name);
        System.out.println(String.valueOf(name) + " thread leaving.");
    }
}

// Writer object; you can create a function that holds the thread
// I paused the thread instead of performing the task of writing. 
public class Writer extends OutputStream {
    
    public void write(String data, int number) {
        try {
            write(number);
        } catch (IOException ex) {
            Logger.getLogger(Writer.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

    @Override
    public void write(int b) throws IOException {
        synchronized(this) {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException ex) {
                Logger.getLogger(Writer.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
    }
}

// Calling the functions, 
public static void main(String[] args) {
        User u1 = new User();
        User u2 = new User();
        
        u1.name = "Afzaal Ahmad Zeeshan";
        u2.name = "Afzaal Ahmad Zeeshan";
        u1.age = 20;
        u1.age = 20;
        
        u1.write(1);
        u2.write(2);
    }

Once this program generates the output it is like this,

1 thread entered.
1 thread leaving.
2 thread entered.
2 thread leaving.
// BUILD SUCCESSFUL (total time: 4 seconds)

It took 4 seconds because each thread took 2 seconds and until that was happening other threads were not allowed to perform anything on that object. Have a look at that, "synchronized (this)" which hold the object reference to itself.

multithreading - What is a mutex? - Stack Overflow[^]
https://docs.oracle.com/javase/tutorial/essential/concurrency/sync.html[^]
Lesson: Concurrency (The Java™ Tutorials > Essential Classes)[^]

Sergey Alexandrovich Kryukov · Answer 2 · 2016-06-04T04:31:00

The problem is unrelated to the concept of static member or singleton pattern. The problem is the problem of multithreading, the shared data, more exactly, access to the shared objects, and is solved via the mutual exclusion. You have to understand the essence of thread synchronization:
Mutual exclusion — Wikipedia, the free encyclopedia[^],
Critical section — Wikipedia, the free encyclopedia[^],
Synchronization (computer science) — Wikipedia, the free encyclopedia[^],
Race condition — Wikipedia, the free encyclopedia[^].

Solution 1 gives you an example of mutex use.

But your confusion stems from the lack of clear understanding what you are doing. First of all, you always talk about one or another class performing one or another action on the data. Classes are essentially irrelevant here; you should think of instances of classes, objects. If two instances work on the same (shared) objects concurrently, it does not matter if they are of the same class or different classes. However, you didn't mention the threads at all, so it's not clear if you even face the thread synchronization issues at all or not. It's not really clear what "about the same" may possibly mean, but it would be safer to assume you really do something in parallel.

Another problem is: you confuse static members and singletons with shared data.

If the object is shared, it does not matter if it is static member of some class or not. Likewise, it does not matter if singleton pattern is implemented or not. You simply share the reference to the same object in different parts of the code; this is all that matters. Actually, it's important to avoid static data by all means; and singleton, which is better, is also best avoided.

Even without static and without singleton, sharing of objects can be implemented, it this is needed, including the cases when it should be only one in the application runtime; you reach all the same goals related to the use of this object and face the same synchronization problems in case of concurrent use of it. Imagine the scenario: somewhere on the upper place of the execution stack, you create both objects accessing the data, the data class and pass the reference of the data class to both objects. As you need the mutex, you also create it in this code and pass the reference to the same objects. That's all.

And finally, let me note that "god object" is not even a pattern. It's a bad thing, a well-known anti-pattern of object-oriented programming. Please see:
God object — Wikipedia, the free encyclopedia[^],
Anti-pattern — Wikipedia, the free encyclopedia[^].

—SA