java concurrency course

The concept of first contact deadlock is the "Philosopher's meal" as described in the principle of operating system in a university course. In the operating system, a deadlock problem may occur because each process shares system resources. In the same Java multithreaded environment, there are also deadlock problems caused by resource sharing. When a set of Java t

Java course practice log (Thursday) and java practice log Import java. awt. eventQueue; import javax. imageio. imageIO; import javax. swing. JFrame; import javax. swing. JPanel; import javax. swing. border. emptyBorder; import javax. swing. abstractButton; import javax. swing. imageIcon; import javax. swing. JButton; i

depending on the memory recycling policy), the allocation of space is only the pointer like the free memory side of the object to move the size of the distance.2. Idle list: This applies to memory irregularities, in which case the JVM maintains a memory list that records which memory areas are idle and how large. When assigning space to an object, go to the free list to find the appropriate area and assign it.But the JVM can't always run in a single-threaded state, so inefficient. Because it is

In concurrent programming, there are two basic units: processes and threads. Concurrent programming is primarily for threading, and of course, the process is also very important.The operating system contains many processes and threads. Even in a single-core system (systems, which has a single execution core), the monolithic system actually has only one thread running, which implements thread concurrency thr

course, to respond to reader and writer changes Public classReader extends Thread {Privatebufferinterruptibly Buff; PublicReader (bufferinterruptibly buff) { This. Buff =Buff; } @Override Public voidrun () {Try{buff.read ();//can receive an interrupt exception to effectively exit}Catch(interruptedexception e) {System. out. println ("I'm not reading."); } System. out. println ("Read End"); } } Public classWriter extends Thread {P

task, then the calling task will be suspended (blocked) until the lock is available.Summary: We were able to interrupt the call to sleep (or any call that would throw interruptexception). However, you cannot interrupt a thread that is attempting to acquire a synchronized lock or attempt to perform an IO operation. At any given moment, as long as the task is blocked in a non-disruptive manner, there is a potential for locking the program.Workaround:For non-interruptible io, you can close the und

be flushed to main memory2 notification that other related thread variables have been invalidated3 Other threads will re-read from main memory when they use the variable again This solves the problem of visibility in Java concurrency programming.Visibility: When multiple threads access the same shared variable, a thread's modification of that shared variable can be known in real time by other threads acces

formal definition of immutability in both the Java specification and the Java memory model, immutability does not mean that all fields in the object are declared as final, even if all the fields in the object are of the final type, the object is still mutable because the final A reference to a Mutable object can be saved in a field of type.An object is immutable when the following conditions are true:

Illegalmonitorstateexception (); Setexclusiveownerthread (null); Tstate (0);//release of resources, abandonment of possessionStatus true;27 return}28}29 30//The implementation of the true synchronization class relies on a custom synchronizer that inherits from Aqs! Private final Sync sync = new sync ();//lockWhen implemented, a synchronization class typically defines a custom Synchronizer (sync) as an internal class for its own use, while the synchronization class itself (the Mutex) implements

can continue to execute, so that the entire program can continue to go forward. In summary, from a performance point of view, if there is no task blocking, concurrency on a single processor is not mission-meaningful.3, concurrency on a single processor common use is event-driven programming4, concurrency in the embodiment of