面試刷題19:併發工具包有哪些工具？

時間 2020-03-31

原文原文鏈接

java.util.concurrent包提供了大量的併發工具。

你們好，我是李福春，今天的題目是：

java提供的併發工具備哪些？

答：java.util.concurrent工具包中提供的工具分4大類。

一，同步工具，CountDownLatch, CyclicBarrier , Semaphore ;
二，併發安全容器， ConcurrentHashMap,ConcurrentSkipListMap,
CopyOnWriteArrayList,CopyOnWriteArraySet;
三，併發安全隊列，主要用在線程池上，ArrayBlockingQueue,SynchronousQueue,PriorityBlockingQueue；
四，併發線程池executor框架；

java

同步工具

semaphore

信號量，設置併發訪問的線程數量。

通常要結對使用： try{s.acquire();}finally{s.release()}
數組

package org.example.mianshi.synctool;

import java.util.concurrent.Semaphore;

/**
 * 建立日期:  2020/3/30 14:24
 * 描述:     信號量應用
 *
 * @author lifuchun
 */

public class SemaphoreApp {


    public static void main(String[] args) {

        Semaphore semaphore = new Semaphore(0);

        for (int i = 1; i <= 10; i++) {
            new MyThread(semaphore).start();
        }

        System.out.println("go ```");
        semaphore.release(5);


    }

    public static class MyThread extends Thread {

        private Semaphore semaphore;

        public MyThread(Semaphore semaphore) {
            this.semaphore = semaphore;
        }

        @Override
        public void run() {

            try {

                semaphore.acquire();

                System.out.println(System.currentTimeMillis() + " :" + Thread.currentThread().getName() + " -execute ```");

            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                semaphore.release();
            }


        }
    }


}

CountDownLatch

設置線程等待某些操做完成；

其它線程完成了，調用 c.countDown（）

當c的value=0，即執行其它線程在 await（）方法後面邏輯。

安全

package org.example.mianshi.synctool;

import java.util.concurrent.CountDownLatch;
import java.util.stream.IntStream;

/**
 * 建立日期:  2020/3/30 14:38
 * 描述:     countDownLatch的例子
 * @author lifuchun
 */

public class CountDownLatchApp {

    public static void main(String[] args) {

        CountDownLatch countDownLatch = new CountDownLatch(5);

        new Thread(() -> {

            try {
                countDownLatch.await();

                System.out.println("後置任務");


            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();


        IntStream.rangeClosed(1, 10)
                .forEach(i -> new MyThread(countDownLatch).start());


    }

    public static class MyThread extends Thread {

        private CountDownLatch countDownLatch;

        public MyThread(CountDownLatch countDownLatch) {
            this.countDownLatch = countDownLatch;
        }

        @Override
        public void run() {

            countDownLatch.countDown();

            System.out.println("前置任務");


        }
    }

}

CyclicBarrier

容許多個線程同時到達某個屏障。設置併發執行的線程數量。

通常調用await()方法，當數量達到預設的數量N,則統一執行await（）方法後面的邏輯，會自動重置。

併發

package org.example.mianshi.synctool;

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
import java.util.stream.IntStream;

/**
 * 建立日期:  2020/3/30 14:49
 * 描述:     cyclicBarrier的應用
 *
 * @author lifuchun
 */

public class CyclicBarrierApp {

    public static void main(String[] args) {

        CyclicBarrier cyclicBarrier = new CyclicBarrier(3, CyclicBarrierApp::run);

        IntStream.rangeClosed(1, 30)
                .forEach(i -> new MyThread(cyclicBarrier).start());

    }

    private static void run() {
        System.out.println("reset , start again !");
    }

    public static class MyThread extends Thread {

        private CyclicBarrier cyclicBarrier;

        public MyThread(CyclicBarrier cyclicBarrier) {
            this.cyclicBarrier = cyclicBarrier;
        }

        @Override
        public void run() {

            try {
                cyclicBarrier.await();
            } catch (InterruptedException | BrokenBarrierException e) {
                e.printStackTrace();
            }

            System.out.println("do my work!");

        }
    }

}

同步安全容器

類層級以下圖：

場景選擇：

1，若是注重的是併發放入和獲取的速度，使用ConcurrentHashMap ;

2, 若是注重順序，而且頻繁併發修改大量的數據，使用ConcurrentSkipListMap

CopyOnWrite*防護複製：

add,set,remote操做都會copy原數組，修改完成以後替換原來的數組，代價比較大，適合讀多寫少的場景；

框架