en-o · en-o · Nov 7, 2020 · Nov 6, 2020 · Nov 6, 2020 · Nov 6, 2020
diff --git a/03concurrency/0301/src/main/java/java0/conc0302/atomic/AtomicCount.java b/03concurrency/0301/src/main/java/java0/conc0302/atomic/AtomicCount.java
@@ -7,7 +7,7 @@ public class AtomicCount {
 
     private AtomicInteger num = new AtomicInteger();
 
-    public synchronized int add() {
+    public int add() {
         return num.getAndIncrement();
     }
 

diff --git a/03concurrency/0301/src/main/java/java0/conc0302/lock/ReentrantReadWriteLockDemo2.java b/03concurrency/0301/src/main/java/java0/conc0302/lock/ReentrantReadWriteLockDemo2.java
@@ -41,7 +41,7 @@ public Object readWrite(String key) {
 
     public static void main(String[] args) {
         ReentrantReadWriteLockDemo2 demo2 = new ReentrantReadWriteLockDemo2();
-        demo2.readWrite("wangwei");
+        demo2.readWrite("bingfabiancheng");
     }
 
 }
diff --git a/03concurrency/0301/src/main/java/java0/conc0303/Homework03.java b/03concurrency/0301/src/main/java/java0/conc0303/Homework03.java
@@ -0,0 +1,37 @@
+package java0.conc0303;
+
+/**
+ * 本周作业：（必做）思考有多少种方式，在main函数启动一个新线程或线程池，
+ * 异步运行一个方法，拿到这个方法的返回值后，退出主线程？
+ * 写出你的方法，越多越好，提交到github。
+ *
+ * 一个简单的代码参考：
+ */
+public class Homework03 {
+
+    public static void main(String[] args) {
+
+        long start=System.currentTimeMillis();
+        // 在这里创建一个线程或线程池，
+        // 异步执行 下面方法
+
+        int result = sum(); //这是得到的返回值
+
+        // 确保  拿到result 并输出
+        System.out.println("异步计算结果为："+result);
+
+        System.out.println("使用时间："+ (System.currentTimeMillis()-start) + " ms");
+
+        // 然后退出main线程
+    }
+
+    private static int sum() {
+        return fibo(36);
+    }
+
+    private static int fibo(int a) {
+        if ( a < 2) 
+            return 1;
+        return fibo(a-1) + fibo(a-2);
+    }
+}
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()));
+    }
+
+}