高并发、多线程探索-4-不可变对象 -final -Immutable{google guava} -unmodifiable

Posted on | In |   本文总阅读量 次

概念

1、不可变对象

有一种对象只要它发布了就是安全的，它就是不可变对象。一个不可变对象需要满足的条件：

对象创建一个其状态不能修改
对象所有域都是final类型
对象是正确创建的(在对象创建期间，this引用没有逸出)

2、创建一个不可变对象的方法

（1）自己定义
这里可以采用的方式包括：
1、将类声明为final，这样它就不能被继承。
2、将所有的成员声明为私有的，这样就不允许直接访问这些成员。
3、对变量不提供set方法，将所有可变的成员声明为final，这样就只能赋值一次。通过构造器初始化所有成员进行深度拷贝。
4、在get方法中不直接返回对象的本身，而是克隆对象，返回对象的拷贝。

（2）使用Java中提供的Collection类中的各种unmodifiable开头的方法
（3）使用Guava中的Immutable开头的类

3、final关键字

final关键字可以修饰类、修饰方法、修饰变量

修饰类：类不能被集成。
基础类型的包装类都是final类型的类。final类中的成员变量可以根据需要设置为final，但是要注意的是，final类中的所有成员方法都会被隐式的指定为final方法
修饰方法：
(1)把方法锁定，以防任何继承类修改它的含义
(2)效率：在早期的java实现版本中，会将final方法转为内嵌调用。但是如果方法过于庞大，可能看不见效果。一个private方法会被隐式的指定为final方法
修饰变量：
基本数据类型变量，在初始化之后，它的值就不能被修改了。如果是引用类型变量，在它初始化之后便不能再指向另外的对象。 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
package cn.northpark.concurrency.immutable;

import java.util.Map;

import com.google.common.collect.Maps;

import cn.northpark.concurrency.annotaion.NotThreadSafe;
import lombok.extern.slf4j.Slf4j;

@Slf4j
@NotThreadSafe
public class ImmutableExample1 {

    private final static Integer a = 1;
    private final static String b = "2";
    private final static Map<Integer, Integer> map = Maps.newHashMap();

    static {
        map.put(1, 2);
        map.put(3, 4);
        map.put(5, 6);
    }

    public static void main(String[] args) {
        //a = 2;//报错
        //b = "3";//报错
        //map = Maps.newHashMap();//报错
        map.put(1, 3);
        log.info("{}", map.get(1));
    }

    private void test(final int a) {
//        a = 1;
    }
}

（1）对一个被final修饰的变量（Integer a、String b）被赋值时在编译过程中就出现了错误。
（2）（map）在重新被指向一个新的map对象的时候也出现了错误。
那么对被定义为final的map进行赋值呢？我们单独运行map.put(1,3)语句，结果是可以的。被final修饰的引用类型变量，虽然不能重新指向，但是可以修改,这一点尤为要注意。

18:05:19.163 [main] INFO cn.northpark.concurrency.immutable.ImmutableExample1 - 3

（3）当final修饰方法的参数时：同样也是不允许在方法内部对其修改的。 

1
2
3
private void test(final int a) {
//        a = 1;	//报错
    }

4、Java:unmodifiable相关方法

使用Java的Collection类的unmodifiable相关方法，可以创建不可变对象。unmodifiable相关方法包含：Collection、List、Map、Set….

2

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
package cn.northpark.concurrency.immutable;

import java.util.Collections;
import java.util.Map;

import com.google.common.collect.Maps;

import cn.northpark.concurrency.annotaion.ThreadSafe;
import lombok.extern.slf4j.Slf4j;

@Slf4j
@ThreadSafe
public class ImmutableExample2 {

    private static Map<Integer, Integer> map = Maps.newHashMap();

    static {
        map.put(1, 2);
        map.put(3, 4);
        map.put(5, 6);
        map = Collections.unmodifiableMap(map);
    }

    public static void main(String[] args) {
        map.put(1, 3);
        log.info("{}", map.get(1));
    }

}

上面程序的执行结果为：在map.put（1，3）操作的位置抛出了异常。由此可见map对象已经成为不可变对象。

Exception in thread “main” java.lang.UnsupportedOperationException
at java.util.Collections$UnmodifiableMap.put(Unknown Source)
at cn.northpark.concurrency.immutable.ImmutableExample2.main(ImmutableExample2.java:25)

那么unmodifiable相关类的实现原理是什么呢？我们查看一下Collections.unmodifiableMap的源码：（以下源码只筛选出表达观点的部分，非全部）

1
2
3
4
5
6
7
8
9
10
public static <K,V> Map<K,V> unmodifiableMap(Map<? extends K, ? extends V> m) {
        return new UnmodifiableMap<>(m);
}
private static class UnmodifiableMap<K,V> implements Map<K,V>, Serializable {
    ...
    public V put(K key, V value) {
        throw new UnsupportedOperationException();
    }
    ...
}

Collections.unmodifiableMap在执行时，将参数中的map对象进行了转换，转换为Collection类中的内部类 UnmodifiableMap对象。而 UnmodifiableMap对map的更新方法（比如put、remove等）进行了重写，均返回UnsupportedOperationException异常，这样就做到了map对象的不可变。

5、Guava:Immutable相关类

使用Guava的Immutable相关类也可以创建不可变对象。同样包含很多类型：Collection、List、Map、Set….

3

例如：

（1）ImmutableList

1
2
3
private final static ImmutableList<Integer> list = ImmutableList.of(1, 2, 3);

list.add(4);//这一句在书写完就会被IDE提示该add方法为过时方法，实际为不可用方法

对于ImmutableList.of方法，如果传多个参数，需要这样一直写下去，以逗号分隔每个参数。其源码中是这样实现的：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
//单个或少于12个参数时
   public static <E> ImmutableList<E> of() {
       return RegularImmutableList.EMPTY;
   }

   public static <E> ImmutableList<E> of(E element) {
       return new SingletonImmutableList(element);
   }

   public static <E> ImmutableList<E> of(E e1, E e2) {
       return construct(e1, e2);
   }

   public static <E> ImmutableList<E> of(E e1, E e2, E e3) {
       return construct(e1, e2, e3);
   }
   ....

   //多于12个参数时，参数列表中最后的E...other会以数组形式接收参数
   @SafeVarargs
   public static <E> ImmutableList<E> of(E e1, E e2, E e3, E e4, E e5,
    E e6, E e7, E e8, E e9, E e10, E e11, E e12, E... others) {
       Object[] array = new Object[12 + others.length];
       array[0] = e1;
       array[1] = e2;
       array[2] = e3;
       array[3] = e4;
       array[4] = e5;
       array[5] = e6;
       array[6] = e7;
       array[7] = e8;
       array[8] = e9;
       array[9] = e10;
       array[10] = e11;
       array[11] = e12;
       System.arraycopy(others, 0, array, 12, others.length);
       return construct(array);
   }

运行结果仍然为抛出UnsupportedOperationException异常。
分析源码：Immutable相关类使用了跟Java的unmodifiable相关类相似的实现方法。

1
2
3
4
5
6
/** @deprecated */
    @Deprecated
    @CanIgnoreReturnValue
    public final boolean add(E e) {
        throw new UnsupportedOperationException();
    }

（2）ImmutableSet

ImmutableSet除了使用of的方法进行初始化，还可以使用copyof方法，将Collection类型、Iterator类型作为参数。

1
2
3
private final static ImmutableSet set = ImmutableSet.copyOf(list);

private final static ImmutableSet set = ImmutableSet.copyOf(list.iterator());

（3）ImmutableMap

ImmutableMap有特殊的builder写法：

1
2
3
4
private final static ImmutableMap<Integer, Integer> map = ImmutableMap.of(1, 2, 3, 4);

private final static ImmutableMap<Integer, Integer> map2 = ImmutableMap.<Integer, Integer>builder()
           .put(1, 2).put(3, 4).put(5, 6).build();
生活不止苟且,还有我喜爱的海岸.