update 0303

kimmking · kimmking · commit 436102c8e5a1 · 2020-11-07T18:17:35.000+08:00
diff --git a/03concurrency/0301/src/main/java/java0/conc0303/collection/ConcurrentHashMapDemo.java b/03concurrency/0301/src/main/java/java0/conc0303/collection/ConcurrentHashMapDemo.java
@@ -0,0 +1,46 @@
+package java0.conc0303.collection;
+
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.atomic.AtomicInteger;
+
+public class ConcurrentHashMapDemo {
+    
+    public static void main(String[] args) {
+        demo1();
+    }
+    
+    public static void demo1() {
+        final Map<String, AtomicInteger> count = new ConcurrentHashMap<>();
+        final CountDownLatch endLatch = new CountDownLatch(2);
+        Runnable task = new Runnable() {
+            @Override
+            public void run() {
+                AtomicInteger oldValue;
+                for (int i = 0; i < 5; i++) {
+                    oldValue = count.get("a");
+                    if (null == oldValue) {
+                        AtomicInteger zeroValue = new AtomicInteger(0);
+                        oldValue = count.putIfAbsent("a", zeroValue);
+                        if (null == oldValue) {
+                            oldValue = zeroValue;
+                        }
+                    }
+                    oldValue.incrementAndGet();
+                }
+                endLatch.countDown();
+            }
+        };
+        new Thread(task).start();
+        new Thread(task).start();
+        
+        try {
+            endLatch.await();
+            System.out.println(count);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+    
+}
diff --git a/03concurrency/0301/src/main/java/java0/conc0303/collection/CopyOnWriteArrayListDemo.java b/03concurrency/0301/src/main/java/java0/conc0303/collection/CopyOnWriteArrayListDemo.java
@@ -0,0 +1,69 @@
+package java0.conc0303.collection;
+
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Vector;
+import java.util.concurrent.CopyOnWriteArrayList;
+
+public class CopyOnWriteArrayListDemo {
+    
+    public static void main(String[] args) {
+    
+        // ArrayList，LinkedList，Vector不安全，运行报错
+        // why Vector 也不安全
+//        List<Integer> list = new ArrayList<Integer>();
+//        List<Integer> list = new LinkedList<>();
+//        List<Integer> list = new Vector<>();
+    
+        // 只有CopyOnWriteArrayList 安全，不报错
+        List<Integer> list = new CopyOnWriteArrayList();
+        
+        for (int i = 0; i < 10000; i++)
+        {
+            list.add(i);
+        }
+    
+        T1 t1 = new T1(list);
+        T2 t2 = new T2(list);
+        t1.start();
+        t2.start();
+        
+    }
+    
+    public static class T1 extends Thread
+    {
+        private List<Integer> list;
+        
+        public T1(List<Integer> list)
+        {
+            this.list = list;
+        }
+        
+        public void run()
+        {
+            for (Integer i : list)
+            {
+            }
+        }
+    }
+    
+    public static class T2 extends Thread
+    {
+        private List<Integer> list;
+        
+        public T2(List<Integer> list)
+        {
+            this.list = list;
+        }
+        
+        public void run()
+        {
+            for (int i = 0; i < list.size(); i++)
+            {
+                list.remove(i);
+            }
+        }
+    }
+    
+}
diff --git a/03concurrency/0301/src/main/java/java0/conc0303/collection/CopyOnWriteArrayListDemo1.java b/03concurrency/0301/src/main/java/java0/conc0303/collection/CopyOnWriteArrayListDemo1.java
@@ -0,0 +1,69 @@
+package java0.conc0303.collection;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+
+public class CopyOnWriteArrayListDemo1 {
+    private static final int THREAD_POOL_MAX_NUM = 10;
+    //private List<String> mList = new ArrayList<String>();  // ArrayList 无法运行
+    private List<String> mList = new CopyOnWriteArrayList<>();
+    
+    public static void main(String args[]) {
+        new CopyOnWriteArrayListDemo1().start();
+    }
+    
+    private void initData() {
+        for (int i = 0; i <= THREAD_POOL_MAX_NUM; i++) {
+            this.mList.add("...... Line " + (i + 1) + " ......");
+        }
+    }
+    
+    private void start() {
+        initData();
+        ExecutorService service = Executors.newFixedThreadPool(THREAD_POOL_MAX_NUM);
+        for (int i = 0; i < THREAD_POOL_MAX_NUM; i++) {
+            service.execute(new ListReader(this.mList));
+            service.execute(new ListWriter(this.mList, i));
+        }
+        service.shutdown();
+    }
+    
+    private class ListReader implements Runnable {
+        private List<String> mList;
+        
+        public ListReader(List<String> list) {
+            this.mList = list;
+        }
+        
+        @Override
+        public void run() {
+            if (this.mList != null) {
+                for (String str : this.mList) {
+                    System.out.println(Thread.currentThread().getName() + " : " + str);
+                }
+            }
+        }
+    }
+    
+    private class ListWriter implements Runnable {
+        private List<String> mList;
+        private int mIndex;
+        
+        public ListWriter(List<String> list, int index) {
+            this.mList = list;
+            this.mIndex = index;
+        }
+        
+        @Override
+        public void run() {
+            if (this.mList != null) {
+                //this.mList.remove(this.mIndex);
+                this.mList.add("...... add " + mIndex + " ......");
+            }
+        }
+    }
+}
diff --git a/03concurrency/0301/src/main/java/java0/conc0303/collection/CopyOnWriteArrayListDemo2.java b/03concurrency/0301/src/main/java/java0/conc0303/collection/CopyOnWriteArrayListDemo2.java
@@ -0,0 +1,51 @@
+package java0.conc0303.collection;
+
+import java.util.concurrent.CopyOnWriteArrayList;
+
+public class CopyOnWriteArrayListDemo2 {
+    
+    private final static CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList();
+    
+    public static void main(String[] args) {
+        // 这个例子再次证明，
+        // 多个步骤的操作，不能保证原子性
+        // list.size() 获取到的数，再继续用list时，可能已经变了
+        // 
+        test();
+    }
+    public static void test(){
+        for(int i = 0; i<10000; i++){
+            list.add("string" + i);
+        }
+        
+        new Thread(new Runnable() {
+            @Override
+            public void run() {
+                while (true) {
+                    if (list.size() > 0) {    // todo ： 下一个get操作执行时，size可能已经是0了
+                        String content = list.get(list.size() - 1);
+                    }else {
+                        break;
+                    }
+                }
+            }
+        }).start();
+        
+        new Thread(new Runnable() {
+            @Override
+            public void run() {
+                while (true) {
+                    if(list.size() <= 0){
+                        break;
+                    }
+                    list.remove(0);
+                    try {
+                        Thread.sleep(10);
+                    } catch (InterruptedException e) {
+                        e.printStackTrace();
+                    }
+                }
+            }
+        }).start();
+    }
+}
diff --git a/03concurrency/0301/src/main/java/java0/conc0303/collection/LinkedHashMapDemo.java b/03concurrency/0301/src/main/java/java0/conc0303/collection/LinkedHashMapDemo.java
@@ -0,0 +1,43 @@
+package java0.conc0303.collection;
+
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Set;
+
+public class LinkedHashMapDemo {
+    public static void main(String[] args) {
+        
+        // test hash map
+        System.out.println("=====>1. test hash map");
+        Map<String, String> hashMap = new HashMap<String, String>();
+        hashMap.put("name1", "josan1");
+        hashMap.put("name2", "josan2");
+        hashMap.put("name3", "josan3");
+        Set<Map.Entry<String, String>> set = hashMap.entrySet();
+        Iterator<Map.Entry<String, String>> iterator = set.iterator();
+        while(iterator.hasNext()) {
+            Map.Entry entry = iterator.next();
+            String key = (String) entry.getKey();
+            String value = (String) entry.getValue();
+            System.out.println("key:" + key + ",value:" + value);
+        }
+        
+        // test linked hash map
+        System.out.println("=====>2. test linked hash map");
+        Map<String, String> linkedHashMap = new LinkedHashMap<>();
+        linkedHashMap.put("name1", "josan1");
+        linkedHashMap.put("name2", "josan2");
+        linkedHashMap.put("name3", "josan3");
+        Set<Map.Entry<String, String>> set1 = linkedHashMap.entrySet();
+        Iterator<Map.Entry<String, String>> iterator1 = set1.iterator();
+        while(iterator1.hasNext()) {
+            Map.Entry entry = iterator1.next();
+            String key = (String) entry.getKey();
+            String value = (String) entry.getValue();
+            System.out.println("key:" + key + ",value:" + value);
+        }
+        
+    }
+}
diff --git a/03concurrency/0301/src/main/java/java0/conc0303/collection/SyncListDemo.java b/03concurrency/0301/src/main/java/java0/conc0303/collection/SyncListDemo.java
@@ -0,0 +1,47 @@
+package java0.conc0303.collection;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+public class SyncListDemo {
+    
+    public static void main(String[] args) {
+        List list0 = Arrays.asList(1,2,3,4,5,6,7,8,8);
+        list0.set(8,9);        // 可以修改内容，不能变动元素数量
+        // list0.add(10)  will throw an error
+        
+        List list = new ArrayList(); // 正常List，可以操作
+        list.addAll(list0);
+        
+        List list1 = Collections.synchronizedList(list);
+        
+        // 多线程操作
+        // to do something
+    
+        System.out.println(Arrays.toString(list1.toArray()));
+    
+        Collections.shuffle(list1);
+    
+        
+    
+        System.out.println(Arrays.toString(list1.toArray()));
+        
+        
+        // 假如不再修改
+        
+        List list2 = Collections.unmodifiableList(list1);
+    
+        System.out.println(list2.getClass());
+    
+        list2.set(8,10);
+    
+        System.out.println(Arrays.toString(list2.toArray()));
+        
+        list2.add(11);
+    
+        System.out.println(Arrays.toString(list2.toArray()));
+    }
+    
+}
diff --git a/03concurrency/0301/src/main/java/java0/conc0303/collection/TreeMapDemo.java b/03concurrency/0301/src/main/java/java0/conc0303/collection/TreeMapDemo.java
@@ -0,0 +1,25 @@
+package java0.conc0303.collection;
+
+import java.util.Comparator;
+import java.util.TreeMap;
+
+public class TreeMapDemo {
+    
+    public static void main(String[] args) {
+        
+        // 
+        TreeMap<Integer, String> map = new TreeMap<>(Comparator.reverseOrder());
+        map.put(3, "val");
+        map.put(2, "val");
+        map.put(1, "val");
+        map.put(5, "val");
+        map.put(4, "val");
+        // {5=val, 4=val, 3=val, 2=val, 1=val}
+        System.out.println(map);
+    
+        TreeMap<Integer, String> map1 = new TreeMap<>(Comparator.naturalOrder());
+        map1.putAll(map);
+        System.out.println(map1);
+    }
+    
+}
diff --git a/03concurrency/0301/src/main/java/java0/conc0303/stream/StreamParallelDemo.java b/03concurrency/0301/src/main/java/java0/conc0303/stream/StreamParallelDemo.java
@@ -0,0 +1,34 @@
+package java0.conc0303.stream;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+
+public class StreamParallelDemo {
+    public static void main(String[] args) {
+        List<Integer> list = new ArrayList<>();
+        IntStream.range(1, 10000).forEach(i -> list.add(i));
+        BlockingQueue<Long> blockingQueue = new LinkedBlockingQueue(10000);
+        List<Long> longList = list.stream().parallel()
+                .map(i -> i.longValue())
+                .sorted()
+                .collect(Collectors.toList());
+//      // 串行，单线程
+//      longList.stream().forEach(
+        // 并行，默认使用CPU * 2个线程
+        longList.stream().parallel().forEach(
+                i -> {
+            try {
+                blockingQueue.put(i);
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+        });
+        System.out.println("blockingQueue:" + blockingQueue.toString());
+    }
+    
+    
+}
diff --git a/03concurrency/0301/src/main/java/java0/conc0303/threadlocal/ThreadLocalDemo.java b/03concurrency/0301/src/main/java/java0/conc0303/threadlocal/ThreadLocalDemo.java
