You signed in with another tab or window. Reload to refresh your session.You signed out in another tab or window. Reload to refresh your session.You switched accounts on another tab or window. Reload to refresh your session.Dismiss alert
Copy file name to clipboardExpand all lines: dirty-flag/README.md
+121-8Lines changed: 121 additions & 8 deletions
Original file line number
Diff line number
Diff line change
@@ -3,26 +3,139 @@ title: Dirty Flag
3
3
category: Behavioral
4
4
language: en
5
5
tag:
6
-
- Game programming
7
-
- Performance
6
+
- Game programming
7
+
- Performance
8
+
- Resource management
9
+
- State tracking
8
10
---
9
11
10
12
## Also known as
11
-
* IsDirty pattern
13
+
14
+
* Change Tracking
15
+
* Is-Modified Flag
12
16
13
17
## Intent
14
-
To avoid expensive re-acquisition of resources. The resources retain their identity, are kept in some
15
-
fast-access storage, and are re-used to avoid having to acquire them again.
18
+
19
+
The Dirty Flag design pattern is employed to avoid unnecessary computations or resource-heavy operations by maintaining a boolean flag that tracks whether the state of an object has changed ('dirty') or remains unchanged ('clean'). This flag, when set, indicates that a particular operation, such as recalculating or refreshing data, needs to be performed again to reflect the updated state.
20
+
21
+
## Explanation
22
+
23
+
Real world example
24
+
25
+
> Imagine a library with an electronic catalog system that tracks which books are checked out and returned. Each book record has a "dirty flag" that gets marked whenever a book is checked out or returned. At the end of each day, the library staff reviews only those records marked as "dirty" to update the physical inventory, instead of checking every single book in the library. This system significantly reduces the effort and time required for daily inventory checks by focusing only on the items that have changed status, analogous to how the Dirty Flag design pattern minimizes resource-intensive operations by performing them only when necessary.
26
+
27
+
In plain words
28
+
29
+
> The Dirty Flag design pattern minimizes unnecessary operations by using a flag to track when an object's state has changed and an update is needed.
30
+
31
+
Wikipedia says
32
+
33
+
> A dirty bit or modified bit is a bit that is associated with a block of computer memory and indicates whether the corresponding block of memory has been modified. The dirty bit is set when the processor writes to (modifies) this memory. The bit indicates that its associated block of memory has been modified and has not been saved to storage yet. When a block of memory is to be replaced, its corresponding dirty bit is checked to see if the block needs to be written back to secondary memory before being replaced or if it can simply be removed. Dirty bits are used by the CPU cache and in the page replacement algorithms of an operating system.
34
+
35
+
**Programmatic Example**
36
+
37
+
The DataFetcher class is responsible for fetching data from a file. It has a dirty flag that indicates whether the data in the file has changed since the last fetch.
38
+
39
+
```java
40
+
publicclassDataFetcher {
41
+
privatelong lastFetched;
42
+
privateboolean isDirty =true;
43
+
// ...
44
+
}
45
+
```
46
+
47
+
The DataFetcher class has a fetch method that checks the dirty flag before fetching data. If the flag is true, it fetches the data from the file and sets the flag to false. If the flag is false, it returns the previously fetched data.
48
+
49
+
```java
50
+
publicList<String> fetch() {
51
+
if (!isDirty) {
52
+
return data;
53
+
}
54
+
data = fetchFromDatabase();
55
+
isDirty =false;
56
+
return data;
57
+
}
58
+
```
59
+
60
+
The World class uses the DataFetcher to fetch data. It has a fetch method that calls the fetch method of the DataFetcher.
The App class contains the main method that demonstrates the use of the Dirty Flag pattern. It creates a World object and fetches data from it in a loop. The World object uses the DataFetcher to fetch data, and the DataFetcher only fetches data from the file if the dirty flag is true.
}, 0, 15, TimeUnit.SECONDS); // Run at every 15 seconds.
87
+
}
88
+
}
89
+
```
90
+
91
+
The program output is as follows:
92
+
93
+
```
94
+
20:51:42.490 [pool-1-thread-1] INFO com.iluwatar.dirtyflag.DataFetcher -- world.txt is dirty! Re-fetching file content...
95
+
20:51:42.494 [pool-1-thread-1] INFO com.iluwatar.dirtyflag.App -- Our world currently has the following countries:-
96
+
20:51:42.494 [pool-1-thread-1] INFO com.iluwatar.dirtyflag.App -- UNITED_KINGDOM
97
+
20:51:42.494 [pool-1-thread-1] INFO com.iluwatar.dirtyflag.App -- MALAYSIA
98
+
20:51:42.494 [pool-1-thread-1] INFO com.iluwatar.dirtyflag.App -- UNITED_STATES
99
+
```
16
100
17
101
## Class diagram
18
-
![alt text](./etc/dirty-flag.png"Dirty Flag")
102
+
103
+
![Dirty Flag](./etc/dirty-flag.png"Dirty Flag")
19
104
20
105
## Applicability
21
-
Use the Dirty Flag pattern when
22
106
23
-
* Repetitious acquisition, initialization, and release of the same resource causes unnecessary performance overhead.
107
+
* When an operation is resource-intensive and only necessary after certain changes have occurred.
108
+
* In scenarios where checking for changes is significantly cheaper than performing the operation itself.
109
+
* Within systems where objects maintain state that is expensive to update and the updates are infrequent.
110
+
111
+
## Known Uses
112
+
113
+
* Graphic rendering engines to update only parts of the scene that have changed.
114
+
* Web applications for partial page rendering or caching strategies.
115
+
* Database applications for tracking changes in datasets to minimize write operations.
116
+
117
+
## Consequences
118
+
119
+
Benefits:
120
+
121
+
* Reduces computational and resource overhead by avoiding unnecessary operations.
122
+
* Can significantly improve performance in systems where operations are costly and changes are infrequent.
123
+
* Simplifies the decision-making process about when to perform certain operations.
124
+
125
+
Trade-offs:
126
+
127
+
* Introduces complexity by adding state management responsibility to the system.
128
+
* Requires diligent management of the flag to ensure it accurately reflects the state changes, avoiding stale or incorrect data.
129
+
* Potentially increases the risk of bugs related to improper flag resetting.
130
+
131
+
## Related Patterns
132
+
133
+
*[Observer](https://java-design-patterns.com/patterns/observer/): Can be used in conjunction to notify interested parties when the dirty flag is set or cleared.
134
+
*[Memento](https://java-design-patterns.com/patterns/memento/): Useful for storing the previous state of an object, which can work hand in hand with dirty flag logic to revert to clean states.
135
+
*[Command](https://java-design-patterns.com/patterns/command/): Commands can set the dirty flag when executed, indicating a change in state that requires attention.
0 commit comments