Unsafe concurrency of collection classes

There are many concurrent unsafe objects in collection classes , Has caused unsafe problems ！

Such as ：ArrayList、ArraySet、HashMap（ Began in jdk1.2） It's not thread safe , It's possible to report java.util.ConcurrentModificationException Concurrent modification exception

We can do it in jdk1.8 See in help document , Since this release, it has provided many safe Thread objects for us to use ！

ArrayList It's not safe

The solution is as follows ：
Method 1 ：Vector Replace ArrayList
List<String> list = new Vector<>();
Method 2 ：Collections（ Collection tool class ） Provides methods for converting unsafe classes to safe classes
List<String> list = Collections.synchronizedList(new ArrayList<>());
Method 3 ：JUC The provided read-write security collection class ：CopyOnWriteArrayList
List<String> list = new CopyOnWriteArrayList<>();

The code is as follows ：

package com.unsafe;

import java.util.*;
import java.util.concurrent.CopyOnWriteArrayList;

public class ListTest {
    
    public static void main(String[] args) {
    
        // And send it  ArrayList  unsafe 
        /** *  Solution  * 1、List<String> list = new Vector<>(); * 2、List<String> list = Collections.synchronizedList(new ArrayList<>()); * 3、List<String> list = new CopyOnWriteArrayList<>(); */
        //List<String> list = new Vector<>();
        //List<String> list = Collections.synchronizedList(new ArrayList<>());
        List<String> list = new CopyOnWriteArrayList<>();
        for (int i = 0; i < 10; i++) {
    
            new Thread(()->{
    
                list.add(UUID.randomUUID().toString().substring(0,5));
                System.out.println(list);
            },String.valueOf(i)).start();
        }
    }
}

ArraySet It's not safe

The solution is as follows ：
Method 1 ：Collections（ Collection tool class ） Provides methods for converting unsafe classes to safe classes
Set<String> set = Collections.synchronizedSet(new HashSet<>());
Method 2 ：JUC The provided read-write security collection class ：CopyOnWriteArraySet
Set<String> set = new CopyOnWriteArraySet<>();

The code is as follows ：

package com.unsafe;
import java.util.*;
import java.util.concurrent.CopyOnWriteArraySet;

/** *  The same is true  ：ConcurrentModificationException  Concurrent modification exception ！ *  Solution ： * 1、 Set<String> set = Collections.synchronizedSet(new HashSet<>()); * 2、Set<String> set = new CopyOnWriteArraySet<>(); */
public class SetTest {
    
    public static void main(String[] args) {
    
       //Set<String> set = Collections.synchronizedSet(new HashSet<>());
       
       Set<String> set = new CopyOnWriteArraySet<>();

        for (int i = 0; i <= 10; i++) {
    
            new Thread(() -> {
    
                set.add(UUID.randomUUID().toString().substring(0,5));
                System.out.println(set);
            }, String.valueOf(i)).start();
        }
    }
}

HashMap It's not safe

The solution is as follows ：
Method 1 ：Collections（ Collection tool class ） Provides methods for converting unsafe classes to safe classes
Map<String, String> map = Collections.synchronizedMap(new HashMap<String, String>());
Method 2 ：JUC The provided read-write security collection class ：ConcurrentHashMap
Map<String,String> map = new ConcurrentHashMap<>();

The code is as follows ：

package com.unsafe;

import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;
import static java.util.Collections.synchronizedMap;

/** * ConcurrentModificationException  Concurrent modification exception ！ *  resolvent ： * 1、Map<String, String> map = Collections.synchronizedMap(new HashMap<String, String>()); * 2、Map<String,String> map = new ConcurrentHashMap<>(); */
public class MapTest {
    
    public static void main(String[] args) {
    
      	//Map<String, String> map = Collections.synchronizedMap(new HashMap<String, String>());
      	
        Map<String,String> map = new ConcurrentHashMap<>();
        for (int i = 1; i < 30; i++) {
    
            new Thread(()->{
    
                map.put(Thread.currentThread().getName(), UUID.randomUUID().toString().substring(0,5));
                System.out.println(map);
            },String.valueOf(i)).start();
        }

    }
}

Summarized below ：

1、 CopyOnWrite

Due to the use of “ When writing copy ” Thought , Apply to “ Read more and write less ” Scene ;
Because the original array will be copied when writing , It will occupy a large amount of memory , It is not applicable to scenarios with large amount of data ;
Only the final data consistency can be guaranteed , Real time data consistency cannot be guaranteed —— Read operations can only read data from old arrays , At this point, a new array may have been copied , And is modifying the data of the new array .
Iterations are performed on snapshots , Don't throw ConcurrentModificationException, And modification is not supported in the iteration process .

2、ConcurrentHashMap Principle analysis

One 、 Background

1、 Thread unsafe HashMap

Because in multithreaded environment , Use Hashmap Conduct put Operation can cause a dead cycle , Lead to CPU The utilization rate is close to 100%, So you can't use HashMap.

2、 Inefficient HashTable Containers

ConcurrentHashMap Lock segmentation technology used , First of all, the data is divided into pieces of storage , Then each piece of data is equipped with a lock , When a thread occupies a lock to access one of the segment data , Other segments of data can also be accessed by other threads .

3、ConcurrentHashMap Lock segment technology based on

ConcurrentHashMap Lock segmentation technology used , First of all, the data is divided into pieces of storage , Then each piece of data is equipped with a lock , When a thread occupies a lock to access one of the segment data , Other segments of data can also be accessed by other threads .
ConcurrentHashMap By Segment Array structure and HashEntry Array structure composition .
Segment The structure and HashMap similar , Is an array and linked list structure , One Segment It contains a HashEntry Array , Every HashEntry Is an element of a linked list structure , Every Segment Guarding a HashEntry The elements in the array , When the HashEntry When the data of the array is modified , Must first obtain its corresponding Segment lock .

Two 、 Principle analysis ：

1、HashMap Right and wrong synchronized, Thread unsafe ,
2、 and Hashtable It's thread safe , Yes table Lock ;
3、conCurrentHashmap: Lock the barrel , Thread safe .