Changes for page Concurrency

Summary

• Page properties (1 modified, 0 added, 0 removed)

Details

Page properties

Content

...	...	@@ -1,5 +1,7 @@
1		-Objects are abstractions of processing, threads are abstractions of timing.
	1	+## Concurrency
2	2
	3	+* Objects are abstractions of processing, threads are abstractions of timing.
	4	+
3	3	### Why concurrency?
4	4
5	5	* Concurrency is a decoupling strategy. The what is decoupled from the when. Concurrency is important and can improve the throughput and structure of an application. On the other hand, it is hard to write clean concurrent code and it is harder to debug.
...	...	@@ -9,54 +9,34 @@
9	9
10	10	### Principles of defensive concurrency programming
11	11
12		-*
13		-
14		-SRP
	14	+* SRP
15	15	* Changes to concurrent code should not be mixed with changes to the rest of the code. So you should separate the two cleanly.
16	16	* Concurrency has its own life cycle with development, modification, and polish.
17	17	* Concurrent code is associated with special problems that have a different form and often a higher degree of difficulty than non-concurrent code.
18		-*
19		-
20		-Constrain the range of validity of data
	18	+* Constrain the range of validity of data
21	21	* Take data encapsulation to heart; restrict access to all shared resources.
22	22	* So you should keep the mass of shared code low, and shared resources should only be claimed by threads that need them. That means one should divide the blocks and resources into smaller blocks if necessary.
23		-*
24		-
25		-Work with copies of the data
26		- *
27		-
28		-One can sometimes get around data sharing by:
29		- *
	21	+* Work with copies of the data
	22	+ * One can sometimes get around data sharing by:
30	30	* working with copies of objects and treating them as read-only objects.
31	31	* making multiple copies of an object, having multiple threads compute results on it, and merging those results into a single thread.
32	32	* It is often worth creating multiple objects to avoid concurrency issues.
33		-*
34		-
35		-Threads should be as independent of each other as possible.
	26	+* Threads should be as independent of each other as possible.
36	36	* Threads should not share data or know anything about each other. Instead, they should prefer to work with their own local variables.
37	37	* Try to decompose data into independent subsets that can be processed by independent threads, possibly in different processes.
38	38
39	39	### Things to learn before working with concurrency
40	40
41		-*
42		-
43		-Get to know your library
	32	+* Get to know your library
44	44	* Use the thread-safe collections provided.
45	45	* Use the executor framework to execute disjointed tasks.
46	46	* Use non-blocking solutions if possible.
47	47	* Multiple library classes are not thread-safe.
48		-*
49		-
50		-Thread-safe collections
	37	+* Thread-safe collections
51	51	* So you should use ConcurrentHashMap instead of HashMap.
52	52	* Author's recommendations: java.util.concurrent, java.util.concurrent.atomic, java.util.concurrent.locks.
53		-*
54		-
55		-Get to know execution models
56		- *
57		-
58		-Basic definitions
59		- *
	40	+* Get to know execution models
	41	+ * Basic definitions
60	60	* Bound Resources
61	61	* Mutual Exclusion
62	62	* Starvation
...	...	@@ -74,15 +74,11 @@
74	74	### Watch out for dependencies between synchronized methods
75	75
76	76	* Dependencies between synchronized methods in concurrent code cause subtle bugs.
77		-*
78		-
79		-Avoid applying more than one method to a shared object. If this is not possible, you have three options:
	59	+* Avoid applying more than one method to a shared object. If this is not possible, you have three options:
80	80	* Client-based locking: the client should lock the server before the first method is called and ensure that the lock includes the code that calls the last method.
81	81	* Server-based locking: Create a method in the server that locks the server, calls all methods, and then unlocks the server. Have the client call the new method.
82	82	* Adapted Server: Create an intermediate component that performs the lock. This is a variant of server-based locking if the original server cannot be changed.
83		-*
84		-
85		-Keep synchronized sections small.
	63	+* Keep synchronized sections small.
86	86	* Locks are expensive because they add administrative overhead to delays. On the other hand, critical sections must be protected.
87	87	* Critical sections, are parts of the code that are only executed correctly if several threads do not access it at the same time.
88	88	* Keep synchronized sections as small as possible.
...	...	@@ -89,9 +89,7 @@
89	89
90	90	### Writing correct shutdown code is difficult
91	91
92		-*
93		-
94		-You should think about a shutdown as early as possible and get it running as soon as possible. If you wait, it will always take longer. Study the available algorithms because this task is probably harder than you think.
	70	+* You should think about a shutdown as early as possible and get it running as soon as possible. If you wait, it will always take longer. Study the available algorithms because this task is probably harder than you think.
95	95	* TODO: Why do I need shutdown code?
96	96
97	97	Some Notes: