【併發編程】-併發容器

在上一篇文章簡單瞭解了一下線程池。自定義線程池有5個參數，其中第五個就是選擇併發容器。而Java幫我們封裝好的幾個線程池，也都用了相應的併發容器，接下來看一下Java中有哪些併發容器呢？

ConcurrentMap、CopyOnWriteArrayList、SynchronizedList、ConcurrentLinkedQueue、LinkedBlockingQueue、ArrayBlockingQueue、DelayQueue、TransferQueue、SynchronousQueue

ConcurrentMap

它是一個接口，實現類有兩個：ConcurrentHashMap、ConcurrentSkipListMap

· ConcurrentHashMap

線程安全且高效的HashMap，內容無序。
併發量不是很高的情況，更高效。

· ConcurrentSkipListMap

線程安全且高效的HashMap，內容有序。
對於併發量特表高的程序，使用ConcurrentSkipListMap更高效。

public static void main(String[] args) {
//        ConcurrentMap
        Map<String,String> map=new ConcurrentHashMap<>();//運行時間：1162 高併發不排序
//        Map<String,String> map=new ConcurrentSkipListMap<>();//運行時間：2094  高併發並且排序

        Random r=new Random();
        Thread[] ths=new Thread[100];
        CountDownLatch latch=new CountDownLatch(ths.length);//門閂
        long start=System.currentTimeMillis();
        for(int i=0;i<ths.length;i++) {
            ths[i] = new Thread(() -> {
                for (int j = 0; j < 10000; j++) map.put("a" + r.nextInt(100), "a" + r.nextInt(100));
                latch.countDown();//門閂值減1
            });
        }

        Arrays.asList(ths).forEach(t->t.start());
        try {
            latch.await();//阻塞等待門閂值爲0
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        long end=System.currentTimeMillis();
        System.out.println(end-start);
    }

對此程序來說，並法量爲10000，則ConcurrentHashMap執行的時間更短一些。

CopyOnWriteArrayList

使用了“寫時複製”的思想。
只在增刪改上加了鎖，查沒有加鎖，但是它在高併發下不會出問題。因爲它在增刪改都是將隊列複製一份，修改完之後再將地址指向修改完成的那個隊列。
故它的特點是：讀的快，寫的慢。

public static void main(String[] args) {
        List<String> lists=
//                new ArrayList<>();//沒有鎖，會出併發問題，效率高
//                new Vector<>();//有鎖
            new CopyOnWriteArrayList<>();//有鎖，寫的慢，讀的快
        Random r=new Random();
        Thread[] ths =new Thread[100];
        for(int i=0;i<ths.length;i++){
            Runnable task=new Runnable() {
                @Override
                public void run() {
                    for(int i=0;i<1000;i++)lists.add("a"+r.nextInt(10000));
                }
            };
            ths[i]=new Thread(task);
        }
        runAndComputeTime(ths);
        System.out.println(lists.size());
    }
    static void runAndComputeTime(Thread[] ths){
        long s1=System.currentTimeMillis();
        Arrays.asList(ths).forEach(t->t.start());
        Arrays.asList(ths).forEach(t->{
            try {
                t.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        long s2=System.currentTimeMillis();
        System.out.println(s2-s1);
    }

這種併發容器的使用場景是：讀多寫少的業務。

SynchronizedList

加了鎖的list。
該對象的每個方法是原子的，但是該對象的兩個方法可不是原子的。

public static void main(String[] args) {
        List<String> strs=new ArrayList<>();//沒有加鎖
        List<String> strsSync= Collections.synchronizedList(strs);//加了鎖的list
        
        /*以下兩個方法線程不安全*/
        strsSync.add("aaa");//線程安全
        strsSync.remove("aaa");//線程安全
    }

比如以下程序

public class T03_SynchronizedList {
    public static void main(String[] args) {
        List<String> strs = new ArrayList<>();//沒有加鎖
        List<String> strsSync = Collections.synchronizedList(strs);//加了鎖的list

            new Thread(() -> {
                if (strsSync.isEmpty()) {
                    try {
                        TimeUnit.MILLISECONDS.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    strsSync.add("aaa");
                }
            }).start();
        try {
            TimeUnit.MILLISECONDS.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        if (strsSync.isEmpty()) {
            strsSync.add("bbb");
        }
        try {
            TimeUnit.MILLISECONDS.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(strsSync);
}

當strsSync不爲空的時候，添加“aaa”。
輸出結果：

顯然不是線程安全的。這時候還是需要自己同步的。使用synchronized

public static void main(String[] args) {
        List<String> strs = new ArrayList<>();//沒有加鎖
        List<String> strsSync = Collections.synchronizedList(strs);//加了鎖的list

            System.out.println(strsSync.isEmpty());
            new Thread(() -> {
                synchronized (strsSync) {
                    if (strsSync.isEmpty()) {
                        try {
                            TimeUnit.MILLISECONDS.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        strsSync.add("aaa");
                    }
                }
            }).start();
        try {
            TimeUnit.MILLISECONDS.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        if (strsSync.isEmpty()) {
            strsSync.add("bbb");
        }
        try {
            TimeUnit.MILLISECONDS.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(strsSync);
}

輸出結果：

ConcurrentLinkedQueue

無界線程安全隊列。
常用的方法介紹：
pool：取出第一個元素，隊列中也刪除。如果隊列爲空，返回null
peek：讀第一個元素，但隊列中仍然存在。
offer：將指定元素插入隊列的尾部。如果隊列爲空，返回null

public static void main(String[] args) {
        Queue<String> strs =new ConcurrentLinkedQueue<>();
        for(int i=0;i<10;i++){
            strs.offer("a"+i);
        }
        System.out.println(strs);

        System.out.println(strs.size());

        System.out.println(strs.poll());
        System.out.println(strs.size());

        System.out.println(strs.peek());
        System.out.println(strs.size());
    }

輸出結果：

LinkedBlockingQueue

無界隊列。不指定容量，默認爲Integer.MAX_VALUE。
讀寫操作可並行，採用可重入鎖保證併發情況下的線程安全。
常用方法：
取元素
take()：隊列爲空時阻塞
pool()：返回隊頂元素，且從隊列清除。隊列爲空時，返回空。
peek()：返回隊頂元素，隊列保留。隊列爲空時返回null。
remove()：移除元素。隊列爲空時拋出異常。成功移除返回true。
添加數據
put()：隊列滿時阻塞
offer()：隊列滿時添加失敗，返回false。還可以指定等待多長時間之內插入成功返回true
eg：strs.offer(“aaa”,1, TimeUnit.SECONDS);

ArrayBlockingQueue

有界隊列。必須指定隊列長度。
常用方法參考上邊那個，LinkedBlockingQueue。

DelayQueue

延遲隊列，執行定時任務。任務按等待時間長短排序

static BlockingQueue<MyTask> tasks=new DelayQueue<>();//等待時間最長的在最前面，裏面的任務等待多長時間可以被拿
    static class MyTask implements Delayed{
        long runningTime;

        MyTask(long rt){
            this.runningTime=rt;
        }
        @Override
        public long getDelay(TimeUnit unit) {
            return unit.convert(runningTime=System.currentTimeMillis(),TimeUnit.MILLISECONDS);
        }

        @Override
        public int compareTo(Delayed o) {
            if(this.getDelay(TimeUnit.MILLISECONDS)<o.getDelay(TimeUnit.MILLISECONDS))
                return -1;
            else if(this.getDelay(TimeUnit.MILLISECONDS)>o.getDelay(TimeUnit.MILLISECONDS))
                return 1;
            return 0;
        }
        @Override
        public String toString(){
            return ""+runningTime;
        }

        public static void main(String[] args) throws InterruptedException {
            long now=System.currentTimeMillis();
            MyTask t1=new MyTask(now+1000);
            MyTask t2=new MyTask(now+2000);
            MyTask t3=new MyTask(now+1500);
            MyTask t4=new MyTask(now+2000);
            MyTask t5=new MyTask(now+500);

            tasks.put(t1);
            tasks.put(t2);
            tasks.put(t3);
            tasks.put(t4);
            tasks.put(t5);

            System.out.println(tasks);
            for(int i=0;i<5;i++){
                System.out.println(tasks.take());
            }
        }
    }

TransferQueue

生產的消息直接給消費者，如果沒有消費者，會阻塞。

public static void main(String[] args) throws InterruptedException {
        LinkedTransferQueue<String> strs=new LinkedTransferQueue<>();
        new Thread(()->{
            try {
                System.out.println(strs.take());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();//這個線程註釋，程序會阻塞
        strs.transfer("aaa");
        new Thread(()->{
            try {
                System.out.println(strs.take());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
    }

將第一個線程註釋掉，也就是先transfer在取元素，則會阻塞。因爲transfer生產的消息必須直接給消費者。

SynchronousQueue

容量爲0的隊列。
使用put()方法，沒有消費者的時候會阻塞等待消費者。
有add()方法，但是使用會報錯。

public static void main(String[] args) throws InterruptedException {
        BlockingQueue<String> strs=new SynchronousQueue<>();
        new Thread(()->{
            try {
                System.out.println(strs.take());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
        strs.put("aaa");//阻塞等待消費者
//        strs.add("aaa");//不可以
        System.out.println(strs.size());
    }

運行結果：

上一篇文章介紹了Java中的線程池分別使用的併發容器
FixedThreadPool（固定個數線程池）：LinkedBlockingQueue
CachedThreadPool（彈性線程池）：SynchronousQueue
SingleThreadExecutor（單線程線程池）：LinkedBlockingQueue
ScheduleThreadPool（定時器線程池）：DelayedWorkQueue

【併發編程】-併發容器

ConcurrentMap

· ConcurrentHashMap

· ConcurrentSkipListMap

CopyOnWriteArrayList

SynchronizedList

ConcurrentLinkedQueue

LinkedBlockingQueue

ArrayBlockingQueue

DelayQueue

TransferQueue

SynchronousQueue

【分佈式】-分佈式事務

【Docker】-三要素

【設計模式】--原型深拷貝方式之序列化對象

【Maven-問題】No implementation for org.apache.maven.model.path.PathTranslator was bound

【maven】解決jar包衝突

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結