不可变对象要满足的条件：
- 1.对象创建以后其状态不能修改(话外音：final数据可以是编译时不改变值的常量，在对这个常量进行定义的时候，必须对其赋值。变量的值一旦初始化，就不能改变。如果final变量是引用类型的变量，那么代表你不能去改变它的引用，一旦引用指向被初始化指向一个对象，就无法再把它改为指向另一个对象，但是可以改变这个变量所引用的对象的属性)
- 2.对象所有域都是final类型。
- 3.对象是正确创建的(在对象创建期间，this引用没有逸出)。
Collections.unmodifiableXXX:Collection、List、Set、Map...
Guava: ImmutabeXXX:Collection、List、Set、Map...
这些方法都能将指定对象设置为不可变，只读。
newHashMap已经是不可变，不能再添加新元素了。如果再进行put操作，会抛出java.lang.UnsupportedOperationException异常。
public class C {
public static void main(String[] args) {
Map<String, String> hashMap = Maps.newHashMap();
hashMap.put("boy", "cmazxiaoma");
Map<String, String> newHashMap = Collections.unmodifiableMap(hashMap);
newHashMap.put("girl", "doudou");
}
}
这里提一个概念"线程封闭"：就是将对象封装到一个线程里，只有一个线程能看到这个对象，就算这个对象就算不是线程安全的，也不会出现线程安全方面的问题。SpringMVC、Shiro框架都用到了线程封闭的思想。
堆栈封闭：就是方法中定义局部变量，不存在并发问题，因为是线程私有的。多个线程访问一个方法时，方法中的布局变量都会被拷贝一份到线程的栈中，所以局部变量时不会被多个线程所共享的。
ThreadLocal线程封闭：这就不多说了(之前文章提到过)。ThreadLocal为每个线程提供了一个变量副本，从而解决了多线程访问变量的冲突。话外音：如果系统CPU资源有空闲，但是内存使用紧张，可以考虑使用时间换空间的策略(synchronized就是采取该策略)。反之，CPU资源紧张，内存资源空闲，则可以使用空间换时间策略(ThreadLocal就是采取该策略)，提高整体性能。
SimpleDateFormat是线程不安全的，可以通过ThreadLocal或者JDK1.8的LocalDateTime和DateTimeFormatter。
public class MyThreadLocal {
public static final ThreadLocal<DateFormat> dateFormatThreadLocal = new ThreadLocal<DateFormat>(){
@Override
protected DateFormat initialValue() {
return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
}
};
public static String format(Date date) {
return dateFormatThreadLocal.get().format(date);
}
public static Date parse(String date) throws ParseException {
return dateFormatThreadLocal.get().parse(date);
}
public static void main(String[] args) {
String date = format(new Date());
System.out.println(date);
}
}
public class LocalTimeTest {
public static void main(String[] args) {
// jdk1.8 线程安全获取系统时间
System.out.println(LocalDateTime.now());
DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
// parse
LocalDateTime localDateTime = LocalDateTime.parse("2018-11-23 21:58:00", dateTimeFormatter);
System.out.println(localDateTime);
// format
System.out.println(LocalDateTime.now().format(dateTimeFormatter));
}
}
Java中是有提供了同步容器的，不过性能很差。
ArrayList ===>Vector, Stack
image.png
image.png
HashMap(key和value都能为空) ===> Hashtable(key，value不能为空)
写到这里，就来讲讲HashMap和Hashtable之间的区别把：
1.Hashtable中key和value都不允许出现null值，但是在HashMap中null是可以作为key的，这样的key只有一个。可以有一个key或者多个key所对应的值为null。当get()方法返回null时，即可以表示HashMap中没有该key，也可以表示该key所对应的值为null。因此在HashMap中不能由get()方法来判断HashMap是否存在某个key，而应该用containsKey()来判断。
2.两个在遍历方式的内部实现上有所不同。两者都使用了Iterator，而Hashtable由于历史原因，还使用了Enumeration。
3.哈希值的使用不同。Hashtable直接使用了对象的hashcode，而HashMap需要重新计算hash值。
4.两者内部实现的数组的初始化大小和扩容方式不同。Hashtable中hash数组默认大小是11，扩容方式是2*old+1。而HashMap中hash数组默认大小是16，扩容后大小一定是2的指数。
5.HashSet依靠hashCode()和equals()方法来区分重复元素。HashSet内部使用Map来保存数据。HashSet的数据作为Map中的key值保存，这也是HashSet中元素不能重复的原因。而Map保存key值时，会去判断当前Map中是否会有该key。先通过key的hashcode，如果有相同的hashcode(hash冲突)，再用equals()方法判断是否相同。
Collections.synchronizedXXX(List、Set、Map)
虽然说Vector是同步容器，但是也无法保证多线程读写数据情况下的线程安全(不支持边遍历边修改)。
public class VectorTest {
private static Vector<Long> vector = new Vector<>();
public static void main(String[] args) {
for (;;) {
for (int i = 0; i < 10; i++) {
vector.add(i + 1L);
}
Thread getThread = new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < vector.size(); i++) {
vector.get(i);
}
}
});
Thread removeThread = new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0 ; i < vector.size(); i++) {
vector.remove(i);
}
}
});
getThread.start();
removeThread.start();
}
}
}
来看看并发容器把。
ArrayList对应着CopyOnWriteArrayList
HashSet、TreeSet对应着CopyOnWriteArraySet、ConCurrentSkipListSet
HashMap、TreeMap对应着ConcurrentHashMap、ConcurrentSkipListMap
CopyOnWriteArrayList当有新元素的时候添加时，它会将原来数组拷贝一份。然后在新的数组上面做写操作，写完之后，将原来的数组指向新的数组。当元素的内容过多的时候，会造成YGC或者FGC。因为拷贝数据是需要时间的，我们读的可能不是最新的数据，所以无法满足实时读。也就是说不是强一致性，而是追求最终一致性。CopyOnWriteArrayList用到了读写分离思想，适合读多写少的场景。CopyOnWriteArray读是不需要加锁的，是在原来的数组上面读。而写却是要加锁，避免多线程并发修改拷贝出多个副本。
