java不可变对象讲解

1.使用基本的final创建：数据类型变量不可被修改，但是引用类型变量仍然可以被修改，线程不安全

package com.zr.concurrency.test.notsafe.immutable;

import com.zr.concurrency.annotation.ThreadNotSafe;
import lombok.extern.slf4j.Slf4j;

import java.util.HashMap;
import java.util.Map;

/**
 * @description: 使用final创建不可变对象，线程不安全，因为引用类型变量仍然可以被修改
 * @author: liangrui
 * @create: 2020-01-01 13:13
 **/
@Slf4j
@ThreadNotSafe
public class ImmutableExample1 {

    //创建不可变对象map
    private final static Map<Integer,Integer> map=new HashMap<>();

    //初始值
    static {
        map.put(1,2);
        map.put(3,4);
        map.put(4,6);
    }

    public static void main(String[] args) {
        //修改不可变对象
        map.put(1,3);
        //输出结果为：3，由此可见final修饰的引用类型变量仍然可以被修改，不安全
        log.info("{}",map.get(1));
    }


}

2.使用Collections.unmodifiableMap()让引用类型变量不可变，线程安全

package com.zr.concurrency.test.safe.immutable;

import com.zr.concurrency.annotation.ThreadSafe;
import lombok.extern.slf4j.Slf4j;

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

/**
 * @description: 使用Collections.unmodifiableMap()让引用类型变量不可变，线程安全
 * @author: liangrui
 * @create: 2020-01-01 13:13
 **/
@Slf4j
@ThreadSafe
public class ImmutableExample2 {

    //创建不可变对象map
    private static Map<Integer,Integer> map=new HashMap<>();

    //初始值
    static {
        map.put(1,2);
        map.put(3,4);
        map.put(4,6);
        map= Collections.unmodifiableMap(map);
    }

    public static void main(String[] args) {
        //修改不可变对象
        map.put(1,3);
        //输出结果为：
        //Exception in thread "main" java.lang.UnsupportedOperationException
        //	at java.util.Collections$UnmodifiableMap.put(Collections.java:1457)
        //	at com.zr.concurrency.test.safe.immutable.ImmutableExample2.main(ImmutableExample2.java:33)
        //由此可见Collections.unmodifiable()修饰的引用类型变量不可以被修改，安全
        log.info("{}",map.get(1));
    }


}

3.使用谷歌的Immutable和final让引用类型变量不可变，线程安全

package com.zr.concurrency.test.safe.immutable;

import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
import com.zr.concurrency.annotation.ThreadSafe;
import lombok.extern.slf4j.Slf4j;

/**
 * @description: 使用谷歌的Immutable和final让引用类型变量不可变，线程安全
 * @author: liangrui
 * @create: 2020-01-01 13:13
 **/
@Slf4j
@ThreadSafe
public class ImmutableExample3 {

    //创建不可变对象list,包含三个元素：1，2，3
    private final static ImmutableList<Integer> list=ImmutableList.of(1,2,3);

    //创建不可变对象set,复制list中的元素
    private final static ImmutableSet<Integer> set=ImmutableSet.copyOf(list);

    //创建不可变对象map
    private final static ImmutableMap<Integer,Integer> map=ImmutableMap.of(1,2,3,4);

    public static void main(String[] args) {
        //修改不可变对象,结果出异常
        map.put(1,3);
        //输出结果为：
        //Exception in thread "main" java.lang.UnsupportedOperationException
        //	at com.google.common.collect.ImmutableMap.put(ImmutableMap.java:495)
        //	at com.zr.concurrency.test.safe.immutable.ImmutableExample3.main(ImmutableExample3.java:33)
        //由此可见Immutable创建的对象不可以被修改，安全
        log.info("{}",map.get(1));
    }


}

总结：

只使用final创建的不可变引用类型变量仍然可以被修改，线程不安全。

使用java自带的Collections.unmodifiable…()可以让变量不可变，线程安全。

使用谷歌的Immutable创建的对象为不可变对象，不可被修改，线程安全。