前言

在日常开发过程中，我们经常会遇到一些资源初始化的情况，往往有些资源就是那种我初始化以后我们就不希望被改动，但是我们又担心别人使用的时候不小心改动了，这时候我就在想，要是我们的JDK能提供一种不能被修改的容器改有多好，好死不死，jdk中还真有这样的容器，map和list都有，这里以map为例子给大家讲解一下！

一般用法

在项目中一些不被改变的资源，通常采用静态代码块的形式去初始化，如下：

  private static Map<Integer, String> readOnlyMap;

  static {
        Map<Integer, String> callTimesMap = new HashMap<>();
        callTimesMap.put(1, "一呼");
        callTimesMap.put(2, "二呼");
        callTimesMap.put(3, "三呼");
        callTimesMap.put(4, "四呼");
        callTimesMap.put(5, "五呼");
        callTimesMap.put(6, "六呼");
        callTimesMap.put(7, "七呼");
        callTimesMap.put(8, "八呼");
        callTimesMap.put(9, "九呼");
        callTimesMap.put(10, "十呼");

        readOnlyMap = Collections.unmodifiableMap(callTimesMap);
    }

练习时长两年半左右的Java练习生应该知道，这样做的好处是由静态代码块在Java虚拟机中的执行时机所决定的，下面给大伙呱唧一下！

静态代码块在Java中如何执行？

在Java中，静态代码块由类加载器在加载类的过程中执行。当类被第一次加载时，类加载器会执行其中的静态代码块，并且只会执行一次。

创建只读的容器

要创建只读的容器其实也很简单：

Collections.unmodifiableMap(callTimesMap);

这样就可以实现了！

测试证明

      public static void main(String[] args) {
       //模拟并发环境
        new Thread(()->{
            readOnlyMap.put(11,"s");
        }).start();
        
         readOnlyMap.put(11,"s");
    }

测试结果：

Exception in thread "Thread-0" java.lang.UnsupportedOperationException
	at java.util.Collections$UnmodifiableMap.put(Collections.java:1459)
	at com.zhuiyi.yicall.callout.statistic.impl.SessionStatisticServiceImpl.lambda$main$0(SessionStatisticServiceImpl.java:94)
	at java.lang.Thread.run(Thread.java:748)
    
Exception in thread "main" java.lang.UnsupportedOperationException
	at java.util.Collections$UnmodifiableMap.put(Collections.java:1459)
	at com.zhuiyi.yicall.callout.statistic.impl.SessionStatisticServiceImpl.main(SessionStatisticServiceImpl.java:96)

我们可以看到“Thread-0”和"main"线程都抛出了异常！这说明在并发条件下确实不允许写，只允许读！

只读容器的底层实现原理

直接上源码：

      private static class UnmodifiableMap<K,V> implements Map<K,V>, Serializable {
        private static final long serialVersionUID = -1034234728574286014L;

        private final Map<? extends K, ? extends V> m;

        UnmodifiableMap(Map<? extends K, ? extends V> m) {
            if (m==null)
                throw new NullPointerException();
            this.m = m;
        }

        public int size()                        {return m.size();}
        public boolean isEmpty()                 {return m.isEmpty();}
        public boolean containsKey(Object key)   {return m.containsKey(key);}
        public boolean containsValue(Object val) {return m.containsValue(val);}
        public V get(Object key)                 {return m.get(key);}

        public V put(K key, V value) {
            throw new UnsupportedOperationException();
        }
        public V remove(Object key) {
            throw new UnsupportedOperationException();
        }
        public void putAll(Map<? extends K, ? extends V> m) {
            throw new UnsupportedOperationException();
        }
        public void clear() {
            throw new UnsupportedOperationException();
        }
        //.....此处省略很多代码
      }

从源码中我们可以看出，UnmodifiableMap实现了map接口，所以它具有map的所有功能，同时最最重要的是他将所有会动到容器中的数据的方法都抛出异常了！

如下：

        public V put(K key, V value) {
            throw new UnsupportedOperationException();
        }
        public V remove(Object key) {
            throw new UnsupportedOperationException();
        }
        public void putAll(Map<? extends K, ? extends V> m) {
            throw new UnsupportedOperationException();
        }
        public void clear() {
            throw new UnsupportedOperationException();
        }

这样就从源头上控制了容器不支持写，只支持读！

思考:针对这样的场景，是否还有别的实现方式？

答案肯定是有的，我们可以使用一个全局锁，或者分布式锁都能实现！

全局读锁：

    ReadWriteLock lock = new ReentrantReadWriteLock();
    
    public void readData() {
        lock.readLock().lock();
        try {
            // 执行读取操作callTimesMap
            
        } finally {
            lock.readLock().unlock();
        }
    }

如果使用分布式锁或者全局锁的话性能会变差，所以最好的解决方案就是直接创建一个不能被修改的容器，这样效率是最高，也是最安全的！