[concurrent programming] concurrent security

Thread safety definition of class  

If you use this class under multithreading , But how do multithreading use and schedule this class , This class always shows the right behavior , This class is thread safe .

The thread safety performance of class is ：

1. Atomicity of operation
2. Memory visibility

Don't do the right synchronization , When sharing state among multiple threads , There will be thread insecurity .

How to achieve thread safety of class ？

Stack closure

All variables are declared inside the method , These variables are all stack closed .

No state

A class without any member variables , It's called stateless class

Make classes immutable

Make the state immutable , Two ways ：

1, Add final keyword , For a class , All member variables should be private , The same as long as possible , All member variables should be added with final keyword , But add final, Note that if the member variable is another object , If the class corresponding to this object is immutable , To ensure that the entire class is immutable .

2、 There is no place to modify member variables at all , At the same time, the member variable is not the return value of the method

volatile

Ensure class visibility , most Suitable for one thread to write , Multiple threads reading Scenario ,

Lock and CAS

Safe release （ return ）

Member variables held in class , In particular, references to objects , If this member object is not thread safe , adopt get Wait for the method to be released , This will result in incorrect modification of the data held by the member object itself under multithreading , Thus, the whole class thread is unsafe .

TheadLocal

synchronize （Spring To load a bean Time use synchronize）

HashMap  Space for time

ConcurrentHashMap Concurrent

Volatile

Servlet

Not a thread safe class , Why don't we usually feel ,：1、Tomcat Handle ;2、 On demand , There is little need for sharing , second , Request received , When returning the answer , It is the responsibility of one thread .

Deadlock

Two or more processes in execution , A blocking phenomenon caused by competition for resources or communication with each other , If there is no external force , They will not be able to move forward . These processes that have been waiting for each other are called deadlock processes .

Resources must be more than 1 individual , At the same time, it is less than or equal to the number of competing threads , There is only one resource , There will only be fierce competition .

The fundamental cause of deadlock ： The inconsistent order in which locks are acquired results in .

ordinary

Suspected sending deadlock ：

adopt jps Query applied id,

Re pass jstack id Check the lock holding of the application

terms of settlement ： Ensure the sequence of locking

Dynamic

Dynamic sequence deadlock , It is locked in a certain order during implementation , But because of the problem of external calls , Resulting in no guarantee of lock sequence .

solve ：

1. By internal ordering , Ensure the sequence of locking
2. By trying to get the lock , It's fine too .

Other safety issues

Live lock

Try to take the lock mechanism , There are multiple threads giving way to each other , It's going to happen all the time , The process of releasing the lock .

terms of settlement ： Sleep random number per thread , Stagger the lock time .

Thread starvation

stay CPU In a busy situation , Low priority threads have little chance of execution , It's possible that threads “ hunger ”; Thread holding lock , If the execution time is too long , May also lead to “ hunger ” problem .

solve “ hunger ” The solution to the problem is simple , There are three options ： First, ensure sufficient resources , The second is to allocate resources fairly , The third is to avoid long-time execution of the thread holding the lock . Of the three options , The applicable scenarios of scheme 1 and scheme 3 are relatively limited , Because in many scenes , There is no way to solve the scarcity of resources , It is also difficult to shorten the execution time of the thread holding the lock . However, the applicable scenarios of scheme 2 are relatively more .