java 并发编程学习笔记（五）之 不可变对象、同步容器、juc并发容器
不可变对象、同步容器、juc并发容器
(1)不可变对象：
- 不可变对象需要满足的条件
- 对象创建以后其状态就不能修改
- 对象所有域都是final类型
- 对象时正确创建（在对象创建期间，this引用没有溢出）
final 关键字：类、方法、变量
修饰类：不能被继承
修饰方法：锁定方法不能被继承类修改 ，效率
修饰变量：基本数据类型变量，引用类型变量
@Slf4j
public class ImmutableExample1 {
private final static Integer a = 1;
private final static String b = "2";
private final static Map map1 = Maps.newHashMap();
static {
map1.put(1, 2);
map1.put(3, 4);
map1.put(5, 6);
}
private static Map map2 = Maps.newHashMap();
private static List list2 = new ArrayList<>();
static {
map2.put(1, 2);
map2.put(3, 4);
map2.put(5, 6);
//通过Collections获取一个不可被修改的map
map2 = Collections.unmodifiableMap(map2);
list2.add(1);
list2.add(2);
//通过Collections获取一个不可被修改的list
list2 = Collections.unmodifiableList(list2);
}
//通过guava 也可以获取不可变list，set ，map
private static final ImmutableList list3 = ImmutableList.of(11, 2, 3, 6);
private static final List list4 = new ArrayList();
private static final ImmutableMap unMap = ImmutableMap.of(1, 2, 3, 4);
private static final ImmutableMap unMap1 = ImmutableMap.builder().put(1, 6).build();
static {
list4.add(1);
list4.add(2);
}
public static void main(String[] args) {
// a = 2 ;
// b ="3";
// map =Maps.newHashMap();
map1.put(1, 3);
log.info("{}", map1.get(1));
map2.put(1, 3);
list2.add(4);
log.info("{}", map2.get(1));
list3.add(56);
ImmutableSet list2 = ImmutableSet.copyOf(list4);
list2.add(7);
unMap.put(1, 6);
unMap1.put(1, 8);
}
} (2) 线程 封闭
public class RequestHolder {
private final static ThreadLocal requestHolder = new ThreadLocal();
public static void add(Long id) {
requestHolder.set(id);
}
public static Long getId() {
return requestHolder.get();
}
public static void remove() {
requestHolder.remove();
}
} (3)常见的线程不安全的类
public class StringExample1 {
//请求次数
private static int clientTotal = 5000;
//允许同时运行的线程数
private static int threadTotal = 200;
/**
* stringBuilder 线程不安全
* stringBuffer 线程安全
*/
//public static StringBuilder stringBuilder=new StringBuilder();
public static StringBuffer stringBuffer = new StringBuffer();
/**
* simpleDateFormat 不是线程安全的
* joda-time 的dateTimeFormatter 是线程安全的
*/
public static SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy/MM/dd");
public static DateTimeFormatter dateTimeFormatter = DateTimeFormat.forPattern("yyyy/MM/dd");
public static void main(String[] args) {
ExecutorService executorService = Executors.newCachedThreadPool();
final Semaphore semaphore = new Semaphore(threadTotal);
final CountDownLatch countDownLatch = new CountDownLatch(clientTotal);
for (int i = 0; i < clientTotal; i++) {
executorService.execute(() -> {
try {
semaphore.acquire();
append();
semaphore.release();
} catch (InterruptedException e) {
log.error("exception", e);
}
countDownLatch.countDown();
});
}
try {
countDownLatch.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
executorService.shutdown();
log.info("count:{}", stringBuffer.length());
}
private static void append() {
DateTime dateTime = DateTime.parse("2018/06/07", dateTimeFormatter);
log.info(dateTime.toDate().toString());
}
}（4）同步容器
@Slf4j
public class ContainExample {
//请求次数
private static int clientTotal = 5000;
//允许同时运行的线程数
private static int threadTotal = 200;
private static List list = new ArrayList();
private static Vector vector =new Vector<>();
static {
vector.add(1);
vector.add(2);
vector.add(3);
}
private static List safeList = Collections.synchronizedList(new ArrayList());
private static Set set =new HashSet();
private static Set safeSet = Collections.synchronizedSet(new HashSet());
private static Map map = new HashMap();
private static Map safeMap = new Hashtable<>();
private static Map safeMap1 = Collections.synchronizedMap(new HashMap());
public static void main(String[] args) {
ExecutorService executorService = Executors.newCachedThreadPool();
final Semaphore semaphore = new Semaphore(threadTotal);
final CountDownLatch countDownLatch = new CountDownLatch(clientTotal);
for (int i = 0; i < clientTotal; i++) {
final int index = i;
executorService.execute(() -> {
try {
semaphore.acquire();
putValue(index);
semaphore.release();
} catch (InterruptedException e) {
log.error("exception", e);
}
countDownLatch.countDown();
});
}
try {
countDownLatch.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
executorService.shutdown();
log.info("count:{}", safeMap.size());
// testVector();
testVector1();
}
private static void putValue(int i) {
safeMap.put(i,i);
}
public static void testVector(){
//ExecutorService executorService = Executors.newCachedThreadPool();
//在这种情况下 线程的 vector 也会变得线程不安全
while(true) {
new Thread(() -> {
for (int i = 0, l = vector.size(); i < l; i++) {
vector.remove(i);
}
}).start();
new Thread(() -> {
for (int i = 0, l = vector.size(); i < l; i++) {
vector.get(i);
}
}).start();
}
}
public static void testVector1(){
try {
for (Integer i : vector) { //不推荐
if(i == 3){
vector.remove(i);
}
}
}catch (Exception e){
log.error("foreach循环删除时报错",e);
}
try {
Iterator iterator = vector.iterator();
while(iterator.hasNext()){ //推荐
if(iterator.next() == 3){
iterator.remove();
}
}
}catch (Exception e){
log.error("iterator循环删除时报错",e);
}
try {
for (int i =0; i< vector.size();i++) { //推荐
if(i == 3){
vector.remove(i);
}
}
}catch (Exception e){
log.error("for循环删除时报错",e);
}
}
} （5）并发容器
- CopyOnWriteArrayList
CopyOnWriteArrayList是ArrayList的一个线程安全的变体,其中所有可变操作(add、set等等)都是通过对底层数组进行一次新的复制来实现的。与ArrayList不同处就在于是否会拷贝数组和加锁.
CopyOnWriteArrayList顾名思义就是写时复制的ArrayList,其意思就是在修改容器的元素时,并不是直接在原数组上修改,而是先拷贝了一份数组,然后在拷贝的数组上进行修改,修改完后将其引用赋值给原数组的引用。这样体现了读写分离,这样无论在任何时候我们都可以对容器进行读取。
所谓动态数组操作机制:即通过volatile修饰的Object类型数组来进行数组的CRUD操作。在进行add,set,remove等可变操作的时候,都会先新建一个数组把更新的值赋给该数组,然后再传递给上面的array数组来保持该次操作的可见性。这也是CopyOnWriteArrayList命名的由来。这一般需要很大的开销,但是当遍历操作的数量大大超过可变操作的数量时,即在进行读操作时的效率要远远高于写或是修改操作,这种方法可能比其他替代方法更 有效。
- CopyOnWriteArraySet
它是线程安全的无序的集合,可以将它理解成线程安全的HashSet。有意思的是,CopyOnWriteArraySet和HashSet虽然都继承于共同的父类AbstractSet;但是,HashSet是通过“散列表(HashMap)”实现的,而CopyOnWriteArraySet则是通过“动态数组(CopyOnWriteArrayList)”实现的,并不是散列表。
和CopyOnWriteArrayList类似,CopyOnWriteArraySet具有以下特性:
1. 它最适合于具有以下特征的应用程序:Set 大小通常保持很小,只读操作远多于可变操作,需要在遍历期间防止线程间的冲突。
2. 它是线程安全的。
3. 因为通常需要复制整个基础数组,所以可变操作(add()、set() 和 remove() 等等)的开销很大。
4. 迭代器支持hasNext(), next()等不可变操作,但不支持可变 remove()等 操作。
5. 使用迭代器进行遍历的速度很快,并且不会与其他线程发生冲突。在构造迭代器时,迭代器依赖于不变的数组快照。
- ConcurrentSkipListSet
ConcurrentSkipListSet是线程安全的有序的集合,适用于高并发的场景。
ConcurrentSkipListSet和TreeSet,它们虽然都是有序的集合。但是,第一,它们的线程安全机制不同,TreeSet是非线程安全的,而ConcurrentSkipListSet是线程安全的。第二,ConcurrentSkipListSet是通过ConcurrentSkipListMap实现的,而TreeSet是通过TreeMap实现的。
- ConcurrentHashMap
ConcurrentHashMap是线程安全且高效的HashMap。正常业务场景中,我们会经常会用到HashMap,而在多线程环境下,java.util.Hashmap进行put操作时会导致死循环,是因为多线程会导致HashMap的Entry链表形成环形数据结构,一旦形成环形数据结构,Entry的next节点永远不为空,就会死循环获取Entry。HashMap put时,发生死循环的原因是因为rehash时导致
而线程安全的HashTable 使用synchronized来保证线程安全,在线程锁竞争激烈的情况下 HashTable的效率非常低下。在Hashtable里,同一把锁连get都会使用synchronized来保证线程安全,Hashtable会竞争同一把锁,所以效率低下。若是能够变成多把锁,就能有效提升并发的效率。ConcurrentHashMap采用了锁分段技术,并且设计与实现非常精巧,大量的利用了volatile,final,CAS等lock-free技术来减少锁竞争对于性能的影响
- ConcurrentSkipListMap
ConcurrentSkipListMap提供了一种线程安全的并发访问的排序映射表。内部是SkipList（跳表）结构实现，在理论上能够在O(log(n))时间内完成查找、插入、删除操作。
SkipList是一种红黑树的替代方案，由于SkipList与红黑树相比无论从理论和实现都简单许多，所以得到了很好的推广。SkipList是基于一种统计学原理实现的，有可能出现最坏情况，即查找和更新操作都是O(n)时间复杂度，但从统计学角度分析这种概率极小。
使用SkipList类型的数据结构更容易控制多线程对集合访问的处理，因为链表的局部处理性比较好，当多个线程对SkipList进行更新操作（指插入和删除）时，SkipList具有较好的局部性，每个单独的操作，对整体数据结构影响较小。而如果使用红黑树，很可能一个更新操作，将会波及整个树的结构，其局部性较差。因此使用SkipList更适合实现多个线程的并发处理。
在非多线程的情况下，应当尽量使用TreeMap。此外对于并发性相对较低的并行程序可以使用Collections.synchronizedSortedMap将TreeMap进行包装，也可以提供较好的效率。对于高并发程序，应当使用ConcurrentSkipListMap，能够提供更高的并发度。
所以在多线程程序中，如果需要对Map的键值进行排序时，请尽量使用ConcurrentSkipListMap，可能得到更好的并发度。
注意，调用ConcurrentSkipListMap的size时，由于多个线程可以同时对映射表进行操作，所以映射表需要遍历整个链表才能返回元素个数，这个操作是个O(log(n))的操作。
在JDK1.8中，ConcurrentHashMap的性能和存储空间要优于ConcurrentSkipListMap，但是ConcurrentSkipListMap有一个功能： 它会按照键的自然顺序进行排序。
总结：
线程限制 ： 一个被线程限制的对象，由线程独占，并且只能被占有它的线程修改
共享只读：一个共享只读的对象，在没有额外同步的情况下，可以被多个线程并发访问，但是
任何线程都不能修改它
线程安全对象： 一个线程安全的对象或者容器，在内部通过同步机制保证线程安全，所以其他线程
无需额外的同步就可以通过公共接口随意访问它
被守护对象：被守护对象只能通过获取特定的锁来访问