1 What is thread safety

Suppose our website needs to count the number of users , We need to achieve this through the self increment of variables ：count++; This operation has thread safety problems ：

The number of people counted at last is small ;

2 Problem analysis

count++ The operation of is divided into three steps ：

 Read count Value 
 Calculation count+1 Value 
 Save the new value into count
 hypothesis count The value is 100, Two threads A and B All operations have been performed 1,
 Then perform the operation at the same time 2,A Do it first 3, At this time count The value is 101,
B Perform the operation again 3, Before B The value read is 100, Finish the operation 3 after B
 The result is still 101, So there is a problem with the data . Because of the above operation 
 It's not atomic , Can be executed separately .

3 solve

AtomicInteger The problem above has been solved , Use it to perform statistics ：

	static AtomicInteger at = new AtomicInteger(0);
	
	public static void main(String[] args) {
    
		for(int i = 0;i < 10000;i++){
    
			new Thread(()->{
    at.incrementAndGet();}).start();
		}
		try {
    
			Thread.sleep(1000);
		} catch (InterruptedException e) {
    
			e.printStackTrace();
		}
		System.out.println("count = " + at.get());
	}

AtomicInteger There are keywords in the source code volatile;
It ensures that volatile Field updates inform other threads in a predictable way . In short volatile When a thread modifies a variable , Another thread can read the modified value .

4 summary

AtomicInteger It can realize the atomic operation of integer data , It can ensure data security in the environment of multithreading concurrency , And the optimistic lock is used internally , Higher concurrency performance than using lock mechanism ;

volatile It ensures that when a thread modifies data , Other threads can also see the modification of data
CAS Operation ensures the security of data modification

5 Thread count failed

Multiple threads execute a piece of logic , Count how many threads failed

      ConcurrentMap<Integer, AtomicInteger> jobTimeoutCountMap = new ConcurrentHashMap<>();

        // branch 10 Threads , Each thread is self increasing 2000 Time 
        for (int i = 0; i < 10; i++) {
    
            new Thread(new Runnable() {
    
                public void run() {
    
                    for (int i = 0; i < 2000; i++) {
    

                        AtomicInteger timeoutCount = jobTimeoutCountMap.putIfAbsent(22, new AtomicInteger(1));
                        if (timeoutCount != null) {
    
                            //  Record the number of slow tasks 
                            timeoutCount.incrementAndGet();
                        }
                    }
                }
            }).start();
        }
        try {
    
            Thread.sleep(1000);
        } catch (InterruptedException e) {
    
            e.printStackTrace();
        }
        System.out.println(jobTimeoutCountMap.get(22));