Changes for page Concurrency

Summary

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

Details

Page properties

Content

...	...	@@ -46,6 +46,7 @@
46	46	* Livelock
47	47	* Thread Pools
48	48	* Future
	49	+ * Also these??
49	49	* Synchronization: General term for techniques that control the access of multiple threads to shared resources.
50	50	* Race Condition: A situation where the system's behavior depends on the relative timing of events, often leading to bugs.
51	51	* Semaphore: An abstract data type used to control access to a common resource by multiple threads.
...	...	@@ -52,10 +52,62 @@
52	52	* Locks: Mechanisms to ensure that only one thread can access a resource at a time.
53	53	* Atomic Operations: Operations that are completed in a single step relative to other threads.
54	54	* Thread Safety
	56	+ * Race Conditions
	57	+ * Statelessness, Statefulness
	58	+ * Functional Programming
	59	+ * Cloning Data to avoid side effects
	60	+ * Side effects
55	55	* Producer-consumer
56	56	* Reader-recorder vs Reader Writer??
57	57	* Philosopher problem → Study algorithms and their application in solutions.
58	58
	65	+A few more suggestions from ChatGPT:
	66	+
	67	+ Learning about concurrency algorithms and common concurrency problems is a great way to deepen your understanding of concurrent programming. Here's a list of key algorithms and problems, along with their typical solutions:
	68	+ Concurrency Algorithms:
	69	+
	70	+ Producer-Consumer:
	71	+ Problem: How to handle scenarios where one or more threads (producers) are producing data and one or more threads (consumers) are consuming it.
	72	+ Solution: Use buffers, queues, semaphores, or condition variables to synchronize producers and consumers.
	73	+
	74	+ Readers-Writers:
	75	+ Problem: How to manage access to a shared resource where some threads (readers) only read data, and others (writers) write data.
	76	+ Solution: Implement mechanisms to ensure that multiple readers can access the resource simultaneously, but writers have exclusive access.
	77	+
	78	+ Dining Philosophers:
	79	+ Problem: A classic synchronization problem dealing with resource allocation and avoiding deadlocks.
	80	+ Solution: Strategies include resource hierarchy, arbitrator, or limiting the number of philosophers.
	81	+
	82	+ Barriers:
	83	+ Problem: Synchronizing a group of threads to wait until they have all reached a certain point in their execution.
	84	+ Solution: Use barrier constructs that block threads until all have reached the barrier.
	85	+
	86	+ Concurrency Problems and Solutions:
	87	+
	88	+ Deadlocks:
	89	+ Problem: Occurs when multiple threads or processes are waiting on each other to release resources, and none of them can proceed.
	90	+ Solution: Deadlock prevention techniques (like resource ordering), deadlock avoidance (like Banker’s algorithm), and deadlock detection and recovery.
	91	+
	92	+ Race Conditions:
	93	+ Problem: Occurs when the outcome of a program depends on the relative timing of threads or processes.
	94	+ Solution: Use mutual exclusion (mutexes), atomic operations, or transactional memory to ensure that only one thread can access the shared resource at a time.
	95	+
	96	+ Livelocks:
	97	+ Problem: Threads or processes are actively performing concurrent operations, but these operations do not progress the state of the program.
	98	+ Solution: Careful algorithm design to ensure progress and avoid situations where processes continuously yield to each other.
	99	+
	100	+ Starvation:
	101	+ Problem: A thread or process does not get the necessary resources to proceed, while others continue to be serviced.
	102	+ Solution: Implement fair locking mechanisms, priority scheduling, or resource allocation strategies that ensure all processes get a chance to proceed.
	103	+
	104	+ Priority Inversion:
	105	+ Problem: A lower-priority thread holds a resource needed by a higher-priority thread, leading to the higher-priority thread waiting unexpectedly.
	106	+ Solution: Priority inheritance protocols where the lower-priority thread temporarily inherits the higher priority.
	107	+
	108	+ Thread Interference:
	109	+ Problem: When multiple threads are accessing and modifying shared data, causing unexpected results.
	110	+ Solution: Ensure that critical sections of code that access shared resources are protected using synchronization mechanisms like locks.
	111	+
59	59	### Watch out for dependencies between synchronized methods
60	60
61	61	* Dependencies between synchronized methods in concurrent code cause subtle bugs.