Java并发之同步工具类

同步工具类

• 同步工具类可以是任何一个对象,只要他根据自身的状态来协调线程的控制流.阻塞队列可以作为同步工具类,其他类型的同步工具类有: 信号量(semaphore),栅栏(Barrier),闭锁(Latch).
• 所有的同步工具类都有一些特定的结构化属性,封装了一些状态,这些状态决定执行同步工具类的线程是继续还是等待.

闭锁(CountDownLatch)

CountDownLatch 方法解析

CountDownLatch可以使一个或者多个线程等待一组事件的发生.闭锁状态包括一个计数器,该计数器初始化为一个正数,表示需要等待的事件数量.countDown()表示递减计数器,表示有个一个事件发生,而await()等待计数器达到零,这表示所有等待的事件都已经发生.如果计数器值非0,那么await()则会阻塞直到计数器为0,或者线程中断,或者等待超时.

• public CountDownLatch(int count)

  用一个给定的数值初始化CountDownLatch，之后计数器就从这个值开始倒计数，直到计数值达到零。

• public void countDown()

  这个函数用来将CountDownLatch的计数值减一

• public void await() throws InterruptedException
public boolean await(long timeout, TimeUnit unit) throws InterruptedException

  这两个函数的作用都是让线程阻塞等待其他线程，直到CountDownLatch的计数值变为0才继续执行之后的操作。区别在于第一个函数没有等待时间限制,第二个函数给定一个等待超时时间，超过该时间就直接放弃了，并且第二个函数具有返回值，超时时间之内CountDownLatch的值达到0就返回true,等待时间结束计数值都还没达到0就返回false。这两个操作在等待过程中如果等待的线程被中断，则会抛出InterruptedException异常。

测试例子

创建一定数量的线程,利用他们并发执行指定的任务,计算出总共花了多少时间.

    public class TestHarness {        public long timeTasks(int nThreads, final Runnable task)                throws InterruptedException {            final CountDownLatch startGate = new CountDownLatch(1);            final CountDownLatch endGate = new CountDownLatch(nThreads);            for (int i = 0; i < nThreads; i++) {                Thread t = new Thread() {                    public void run() {                        try {                            startGate.await(); //等待直到所有线程准备就绪,实现真正的并发执行任务                            try {                                task.run();                            } finally {                                endGate.countDown();//任务执行完毕,计数器减1;                            }                        } catch (InterruptedException ignored) {                        }                    }                };                t.start();            }            long start = System.nanoTime();            startGate.countDown(); //到此处,说明所有线程准备就绪,可以开始执行任务            endGate.await();// 阻塞等待所有线程执行完毕.            long end = System.nanoTime();            return end - start;        }    }

栅栏(Barrier)

栅栏类似闭锁,能阻塞一组线程直到某个事件发生.栅栏与闭锁的区别关键在于:闭锁用于等待事件,而栅栏用于等待其他线程.

CyclicBarrier可以使得一定数量的参与反复在栅栏位置汇聚,在并行迭代算法中非常有用:将一个问题拆分成一系列相互独立的子问题.当线程达到栅栏位置时调用await()阻塞直到所有线程到达栅栏位置,如果所有线程到达,栅栏打开,线程唤醒,而栅栏被重置下次使用.如果await()调用超时,或者阻塞的线程被中断,那么栅栏就算是被打破,所有await()调用会抛出BrokenBrrierException.

CyclicBarrier还可以在构造函数中传入一个Runnable,当成功通过栅栏时会(在一个子线程中)执行他,但是阻塞线程被释放之前是不能执行的.

构造函数

循环栅栏函数解析

• public CyclicBarrier(int parties, Runnable barrierAction)
public CyclicBarrier(int parties)

  参数parties表示一共有多少线程参与这次“活动”，参数barrierAction是可选的，用来指定当所有线程都完成这些必须的“神秘任务”之后需要干的事情，所以barrierAction这里的动作在一个相互等待的循环内只会执行一次。

• blic int getParties()

  用来获取当前的CyclicBarrier一共有多少线程参数与.

• public int await() throws InterruptedException, BrokenBarrierException
public int await(long timeout, TimeUnit unit)throws InterruptedException, BrokenBarrierException, TimeoutException

  await函数用来执行等待操作，一个函数是一个无参函数，第二个函数可以指定等待的超时时间。它们的作用是：一直等待知道所有参与“活动”的线程都调用过await函数，如果当前线程不是即将调用await函数的的最后一个线程，当前线程将会被挂起，直到下列某一种情况发生：

  • 最后一个线程调用了await函数；
  • 某个线程打断了当前线程；
  • 某个线程打断了其他某个正在等待的线程；
  • 其他某个线程等待时间超过给定的超时时间；
  • 其他某个线程调用了reset函数。

  如果等待过程中线程被打断了，则会抛出InterruptedException异常；
  如果等待过程中出现下列情况中的某一种情况，则会抛出BrokenBarrierException异常：

  • 其他线程被打断了；
  • 当前线程等待超时了；
  • 当前CyclicBarrier被reset了；
  • 等待过程中CyclicBarrier损坏了；
  • 构造函数中指定的barrierAction在执行过程中发生了异常。

  如果等待时间超过给定的最大等待时间，则会抛出TimeoutException异常，并且这个时候其他已经嗲用过await函数的线程将会继续后续的动作。

  返回值：返回当前线程在调用过await函数的所以线程中的编号，编号为parties-1的表示第一个调用await函数，编号为0表示是最后一个调用await函数。

• public boolean isBroken()

  用来判断barrier是否已经损坏,如果因为任何原因被损坏返回true，否则返回false。

• public void reset()

  这个函数用来重置barrier,如果调用了该函数，则在等待的线程将会抛出BrokenBarrierException异常。

• public int getNumberWaiting()

  该函数用来获取当前正在等待该barrier的线程数

实例展示:

    public class CellularAutomata {        private final Board mainBoard;        private final CyclicBarrier barrier;        private final Worker[] workers;        public CellularAutomata(Board board) {            this.mainBoard = board;            int count = Runtime.getRuntime().availableProcessors();            this.barrier = new CyclicBarrier(count,                    new Runnable() {                        public void run() {                            mainBoard.commitNewValues();//栅栏打开,计算值                        }});            this.workers = new Worker[count];            for (int i = 0; i < count; i++)                workers[i] = new Worker(mainBoard.getSubBoard(count, i));        }        private class Worker implements Runnable {            private final Board board;            public Worker(Board board) { this.board = board; }            public void run() {                while (!board.hasConverged()) {                    for (int x = 0; x < board.getMaxX(); x++)                        for (int y = 0; y < board.getMaxY(); y++)                            board.setNewValue(x, y, computeValue(x, y));                    try {                        barrier.await();//线程计算完毕等待其他线程                    } catch (InterruptedException ex) {                        return;                    } catch (BrokenBarrierException ex) {                        return;                    }                }            }            private int computeValue(int x, int y) {                // Compute the new value that goes in (x,y)                return 0;            }        }        public void start() {            for (int i = 0; i < workers.length; i++)                new Thread(workers[i]).start();            mainBoard.waitForConvergence();        }        interface Board {            int getMaxX();            int getMaxY();            int getValue(int x, int y);            int setNewValue(int x, int y, int value);            void commitNewValues();            boolean hasConverged();            void waitForConvergence();            Board getSubBoard(int numPartitions, int index);        }    }

信号量(Semaphore)

计数信号量(Counting Semaphore)用来控制同时访问某个特定资源的操作数量,或者执行某个指定操作的数量.还可以用来实现某种连接池,或者对容器加边界.

Semaphore管理着一组虚拟的许可(permit),许可的初始数量可通过构造函数指定,在执行操作时先要获得许可,并在使用后释放许可.如果没有许可,accquire将阻塞到有许可为止(或者被中断,或者操作超时),release()将返回一个许可信号量.

Semaphore类只是一个资源数量的抽象表示,并不负责管理资源对象本身,可能有多个线程同时获取到资源使用许可,因此需要使用同步机制避免数据竞争.

Semaphore函数解析

• public Semaphore(int permits)
public Semaphore(int permits, boolean fair)

  其中permits参数表示初始的可用资源数量，fair参数表示是否使用公平策略选择正在等候的使用者，fair为true表示公平策略，采用先来先用的算法，为false表示非公平策略，完全随机，默认使用非公平策略。

• public void acquire() throws InterruptedException
public void acquire(int permits) throws InterruptedException

  acquire函数用来申请资源,第一个函数用来申请一个资源，第二个函数用来申请permits个资源，当没有需要申请的数量这么多个资源时，申请线程会被阻塞，直到有可用资源或者申请线程被打断，如果申请线程被打断，则抛出InterruptedException异常。

• public void acquireUninterruptibly()
public void acquireUninterruptibly(int permits)

  该函数用来申请可用资源，并且不会被打断，第一个函数用来申请一个资源，第二个函数用来申请permits个资源。就算线程在申请资源过程中被打断，依然会继续申请，只不过获取资源的时间可能会有所变化。

• public boolean tryAcquire()
public boolean tryAcquire(long timeout, TimeUnit unit)throws InterruptedException
public boolean tryAcquire(int permits)
public boolean tryAcquire(int permits, long timeout, TimeUnit unit)throws InterruptedException

  tryAcquire函数用来获取可用资源，但是这类函数能够有时间的限制，如果超时，立即返回，

  第一个函数用来申请一个资源，如果当前有可用资源，立即返回true，否则立即返回false；
  第二个函数用来申请一个资源，指定一个超时时间，如果当前可以资源数量足够，立即返回true，否则最多等待给定的时间，如果时间到还是未能获取资源，则返回false；如果等待过程中线程被打断，抛出InterruptedException异常；
  和1一样，只是申请permits个资源；
  和2一样，只是申请permits个资源。

• public void release()
public void release(int permits)

  第一个函数释放一个资源，第二个函数释放permits个资源。

• public int availablePermits()

• availablePermits函数用来获取当前可用的资源数量

• public int drainPermits()
  drainPermits函数用来申请当前所有
  可用的资源，

• protected void reducePermits(int reduction)

  用来禁止某些资源不可用
  reduction表示禁止的数量，比如由于厕所马桶坏了，有一个坑位不能用，此时就可以调用该函数禁止一个资源不可用。如果reduction小于零，则抛出IllegalArgumentException异常。

• public boolean isFair()

  函数返回true表示采用的是公平策略，返回false表示采用非公平策略。

• public final boolean hasQueuedThreads()

  用来判断是否有现成正在等待申请资源，返回true表示有现成正在等待申请资源，false表示没有，需要注意的是：因为申请过程是可以取消的，函数返回true并不表示肯定会申请资源，该函数设计的初衷是用来做系统监控的。

• public final int getQueueLength()

  返回当前正在等待申请资源的线程数。

• protected Collection<Thread> getQueuedThreads()

  返回当前正在等待申请资源的线程集合

多线程同时操作特定资源例子

    public class SemaphoreDemo {        private final ReentrantLock lock = new ReentrantLock();        private final Semaphore semaphore;        private final LinkedList<Object> resourceList = new LinkedList<Object>();        private static CountDownLatch mCountDownLatch = new CountDownLatch(9);        public SemaphoreDemo(Collection<Object> resourceList) {            this.resourceList.addAll(resourceList);            //公平模式            this.semaphore = new Semaphore(resourceList.size(), true);        }        public Object acquire() throws InterruptedException {            semaphore.acquire();            lock.lock();            try {                return resourceList.pollFirst();            } finally {                lock.unlock();            }        }        public void release(Object resource) {            lock.lock();            try {                resourceList.addLast(resource);            } finally {                lock.unlock();            }            semaphore.release();        }        public static void main(String[] args) {            //准备2个可用资源            List<Object> resourceList = new ArrayList<>();            resourceList.add("Resource1");            resourceList.add("Resource2");            //准备工作任务            final SemaphoreDemo demo = new SemaphoreDemo(resourceList);            Runnable worker = new Runnable() {                @Override                public void run() {                    Object resource = null;                    try {                        //获取资源                        resource = demo.acquire();                        System.out.println(Thread.currentThread().getName() + "\twork   on\t" + resource);                        //用resource做工作                        Thread.sleep(1000);                        System.out.println(Thread.currentThread().getName() + "\tfinish on\t" + resource);                    } catch (InterruptedException e) {                        e.printStackTrace();                    } finally {                        //归还资源                        if (resource != null) {                            demo.release(resource);                            mCountDownLatch.countDown();                        }                    }                }            };            //启动9个任务            ExecutorService service = Executors.newCachedThreadPool();            for (int i = 0; i < 9; i++) {                service.submit(worker);            }            try {                mCountDownLatch.await();            } catch (InterruptedException e) {                e.printStackTrace();            }            service.shutdown();        }    }

将任何一种容器变成有界阻塞容器

    public class BoundedHashSet <T> {        private final Set<T> set;        private final Semaphore sem;        public BoundedHashSet(int bound) {            this.set = Collections.synchronizedSet(new HashSet<T>());            sem = new Semaphore(bound);        }        public boolean add(T o) throws InterruptedException {            sem.acquire();            boolean wasAdded = false;            try {                wasAdded = set.add(o);                return wasAdded;            } finally {                if (!wasAdded)                    sem.release();            }        }        public boolean remove(Object o) {            boolean wasRemoved = set.remove(o);            if (wasRemoved)                sem.release();            return wasRemoved;        }    }