5.10（java学习笔记）容器的同步控制与只读设置

来源：cnblogs　　作者：gcmh　　时间：2018/10/23 9:28:40　　对本文有异议

1、容器的同步控制

像我们平常使用的容器有些是不同步的即线程不安全，例如HashMap等，在多线程时可能出现并发问题。

而有些容器又是同步的，例如Hashtable。

有些时候我们需要将这些不同步的容器包装成同步的，就需要使用到Collections中提供的一些方法。

static <T> List<T> synchronizedList(List<T> list);

static <T> Set<T> synchronizedSet(Set<T> s);

static <K,V> Map<K,V> synchronizedMap(Map<K,V> m);

传递进去的是线程不同步的容器，返回一个线程同步的集合。

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
public class Test {
    public static void main(String[] args) {
        Map<String,String> map = new HashMap<>();
        map.put("1", "1");
        map.put("2", "2");
        map.put("3", "3");
        //返回同步的容器
        Map<String,String> synMap = Collections.synchronizedMap(map);
    
        List<String> list = new ArrayList<>();
        list.add("1");
        list.add("2");
        list.add("3");
        //返回同步的容器
        List<String> synList = Collections.synchronizedList(list);
        
        Set<String> set = new HashSet<>();
        set.add("1");
        set.add("2");
        set.add("3");
        //返回同步的容器
        Set<String> synSet = Collections.synchronizedSet(set);
    }
}

返回的syn...就是同步的容器，是线程安全的。

2、容器的只读控制

static <T> List<T> unmodifiableList(List<? extends T> list)
static <K,V> Map<K,V>unmodifiableMap(Map<? extends K,? extends V> m)
static <T> Set<T> unmodifiableSet(Set<? extends T> s)

返回一个只读属性的容器。

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
public class Test{
    public static void main(String[] args) {
        Map<String,String> map = new HashMap<>();
        map.put("1", "1");
        map.put("2", "2");
        map.put("3", "3");
        //返回只读的容器
        Map<String,String> unmoMap = Collections.unmodifiableMap(map);
        //unmMap为只读，这时往里面放入元素会出现错误。
        List<String> list = new ArrayList<>();
        list.add("1");
        list.add("2");
        list.add("3");
        //返回同步的容器
        List<String> unmoList = Collections.unmodifiableList(list);
        //unmoList为只读，这时往里面放入元素会出现错误。
        Set<String> set = new HashSet<>();
        set.add("1");
        set.add("2");
        set.add("3");
        //返回同步的容器
        Set<String> synSet = Collections.unmodifiableSet(set);
        //unmoSet为只读，这时往里面放入元素会出现错误。
    }
}

3.单元素不可变容器

放置一个元素的不可变容器，创建时添加第一个元素后再次添加会报错。

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
public class Test{
    public static void main(String[] args) {
        //返回了只能放一个元素的集合
        Map<String,String> singMap = Collections.singletonMap("1","1");//创建时已放入第一个元素
        //如果再往singMap中添加元素会出错。
        //返回了只能有一个元素的集合
        List<String> singList = Collections.singletonList("1");
        //如果再往singList中添加元素会出错。
    }
}

4.不可变空集合

static <T> List<T> emptyList()
static <K,V> Map<K,V> emptyMap()
static <T> Set<T> emptySet()

返回一个空的不可变的集合。

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
public class Test{
    public static void main(String[] args) {
        Map<String,String> map = new HashMap<>();
        map = null;
        if(reMap(map) == Collections.EMPTY_MAP)
            System.out.println("true");
        
    }
    public static Map<String, String> reMap(Map<String, String> map){
        if(map == null)
            return Collections.emptyMap();
        return map;
    }
}