public class VectorDemo implements Runnable{
    public static ConcurrentHashMap<String,Integer> concurrentHashMap = new ConcurrentHashMap<>(5);
    public static void main(String[] args) throws InterruptedException {
        concurrentHashMap.put("表哥",0);
        VectorDemo demo = new VectorDemo();
        Thread thread1 = new Thread(demo);
        Thread thread2 = new Thread(demo);
        thread1.start();
        thread2.start();
        thread1.join();
        thread2.join();
        System.out.println(concurrentHashMap.get("表哥"));
    }

    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            /*代码意思：
            因为在自增操作时非线程安全的，假设这两个线程同时读取到的 oldscord 的值都为0，然后为其加1，之后调用 replace，
            那么只有一个线程会替换成功，而下一个线程就让他重新循环一次
            */
            while (true){
                Integer oldscord = concurrentHashMap.get("表哥");
                //非线程安全
                Integer newScord = oldscord + 1;
                //线程安全,判断旧的值是否与新的值一样，一样则返回false，不一样则更新值
                boolean b = concurrentHashMap.replace("表哥", oldscord, newScord);
                if (b){
                    break;
                }
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

//如果不存在这个 key
if(!map.containsKey(key))
    //则添加这个 key 和对应的 value
    return map.put(key,value);
else
    //否则返回容器中这个 key 所对应的值
    return map.get(key);

/**
 * 演示 CopyOnWriteArrayList 可以在迭代的过程中修改数组内容，但是，迭代时不会把修改的数据迭代出来，而是打印出迭代前的数据 ArrayList 不行，会报错
 */
public class CopyOnWriteArrayListDemo {
    public static void main(String[] args) {
        //ArrayList<String> list = new ArrayList<>();
        CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
        list.add("1");
        list.add("2");
        list.add("3");
        list.add("4");
        list.add("5");
        Iterator<String> iterator = list.iterator();
        while(iterator.hasNext()){
            System.out.println("list is" + list);
            String next = iterator.next();
            System.out.println(next);

            if(next.equals("2")){
                list.remove("5");
            }
            if (next.equals("3")){
                list.add("3 found");
            }
        }
    }
}

public class ArrayBlockingQueueDemo {
    public static ArrayBlockingQueue<String> queue = new ArrayBlockingQueue<String>(3);

    public static void main(String[] args) {
        Interviewer r1 = new Interviewer(queue);
        Consumer r2 = new Consumer(queue);
        new Thread(r1).start();
        new Thread(r2).start();

    }
}

class Interviewer implements Runnable{
    BlockingQueue<String> queue;

    public Interviewer(BlockingQueue queue) {
        this.queue = queue;
    }

    @Override
    public void run() {
        System.out.println("10个候选人都来啦");
        for (int i = 0; i < 10; i++) {
            String candidate = "candidate" + i;
            try {
                queue.put(candidate);
                System.out.println("安排好了" + candidate);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        try {
            queue.put("stop");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

class Consumer implements Runnable{
    BlockingQueue<String> queue;

    public Consumer(BlockingQueue queue) {
        this.queue = queue;
    }

    @Override
    public void run() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        String msg;
        try {
            while(!(msg = queue.take()).equals("stop")){
                System.out.println(msg + "到了");
            }
            System.out.println("所有候选人都结束了");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}