当前位置:首页 > 开发 > 编程语言 > 多线程 > 正文

Java 多线程之闭锁-CountDownLatch

发表于: 2015-07-03   作者:zhangwei_david   来源:转载   浏览:
摘要:     实现并发的最直接方式是在操作系统级别使用进程。进程是运行在自己的地址空间内的自包容程序。多任务操作系统可以通过周期性地将CPU从一个进程切换到另一个进程,来实现同时运行多个进程的。操作系统将进程相互隔离开,因此他们不会相互干扰,这使得通过进程实现并发编程相对容易一些。而JAVA的并发时通过多线程机制实现的。    一个

    实现并发的最直接方式是在操作系统级别使用进程。进程是运行在自己的地址空间内的自包容程序。多任务操作系统可以通过周期性地将CPU从一个进程切换到另一个进程,来实现同时运行多个进程的。操作系统将进程相互隔离开,因此他们不会相互干扰,这使得通过进程实现并发编程相对容易一些。而JAVA的并发时通过多线程机制实现的。

   一个线程就是在进程中的一个单一的顺序控制流,因此,单个进程可以拥有多个并发执行的任务,使得程序看起来好像都有其自己的CPU一样。其底层的机制是切分CPU的时间片。

    java.util.concurrency包提供了很多并发编程的工具类,可以极大提高并发编程的效率。

 

   闭锁是一种同步工具类,可以延迟线程的进度直到闭锁到达终止状态。Latch在英语中就是门栓的意思,所以形象地说闭锁就相当于一扇门,在日常生 活中我们都遇到过类似的场景,进入一个场馆前,必须达到一定的条件,比如活动开始前半小时可以入场;如果来早了的话,对不起,以便等着。 CountDownLatch 在多线程中也是这样的作用,在闭锁到达结束状态前,这扇门是一直关闭的,不允许任何线程通过,当到达结束状态时,这扇门就 保持打开,并且是永久的处于打开状态;也就是说这个门是一次性的。 如同柏林墙一样,推到了就建不起来了。

     闭锁可以用来确保某些活动直到其他活动都完成后才继续执行。CountDownLatch是一种灵活的闭锁实现,它可以使一个或多个线程 等待一组事件的发生。闭锁包括一个计数器,该计数器被初始化为一个正整数,表示等待的事件数量。有一等待时间发生时,使用countDown方法递减计数 器,而await方法就是等待所有事件的发生,也就是计数器的值为0.如果计数器的值不为0 那么await 方法需要一直等待。

 

public class CountDownLatch {
    /**
     * 闭锁的同步控制类
     */
    private static final class Sync extends AbstractQueuedSynchronizer {
        private static final long serialVersionUID = 4982264981922014374L;
		// 
        Sync(int count) {
            setState(count);
        }

        int getCount() {
            return getState();
        }
		//获取共享锁,如果当前线程数量为0则表示获取到锁,否则无法获取
        protected int tryAcquireShared(int acquires) {
            return (getState() == 0) ? 1 : -1;
        }
		//释放共享锁
        protected boolean tryReleaseShared(int releases) {
            for (;;) {
                int c = getState();
                if (c == 0)
                    return false;
                int nextc = c-1;
                if (compareAndSetState(c, nextc))
                    return nextc == 0;
            }
        }
    }

    private final Sync sync;

    /**
     * 构造器
     */
    public CountDownLatch(int count) {
        if (count < 0) throw new IllegalArgumentException("count < 0");
        this.sync = new Sync(count);
    }

    /**
     *  当前线程一直等到闭锁的数量为0才可以执行
     */
    public void await() throws InterruptedException {
        sync.acquireSharedInterruptibly(1);
    }

    /**
     * 当前线程等到闭锁的数量为0或者超时
     */
    public boolean await(long timeout, TimeUnit unit)
        throws InterruptedException {
        return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout));
    }

    /**
     * 闭锁减去1
     */
    public void countDown() {
        sync.releaseShared(1);
    }

    /**
     * 获取当前闭锁的数量
     */
    public long getCount() {
        return sync.getCount();
    }

   
    public String toString() {
        return super.toString() + "[Count = " + sync.getCount() + "]";
    }
}

 AbstractQueuedSynchronizer#acquireSharedInterruptibly()方法,首先调用子类的实现方法判断是否可以获取到锁,如果无法获取到锁,则调用doAcquireAsharedInterruptibly()方法

   public final void acquireSharedInterruptibly(int arg)
            throws InterruptedException {
        if (Thread.interrupted())
            throw new InterruptedException();
        if (tryAcquireShared(arg) < 0)
            doAcquireSharedInterruptibly(arg);
    }

 

 

 /**
     *.
     *在中断模式中获取共享锁
     */
    private void doAcquireSharedInterruptibly(int arg)
        throws InterruptedException {
		//将当前线程添加到等待队列中
        final Node node = addWaiter(Node.SHARED);
        boolean failed = true;
        try {
			//循环
            for (;;) {
			     //获取队列中的上一个节点
                final Node p = node.predecessor();
				//如果上一个节点是队列头
                if (p == head) {
					//视图获取共享锁
                    int r = tryAcquireShared(arg);
					//获取到锁
                    if (r >= 0) {
                        setHeadAndPropagate(node, r);
                        p.next = null; // help GC
                        failed = false;
                        return;
                    }
                }
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    throw new InterruptedException();
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

 

 

/**
 *
 * @author zhangwei_david
 * @version $Id: TestHarness.java, v 0.1 2014年11月10日 下午5:08:17 zhangwei_david Exp $
 */
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() {
                @Override
                public void run() {
                    try {
                        // 等待所有线程都准备好
                        startGate.await();
                        try {
                            task.run();
                        } finally {
                            // 线程执行结束,闭锁减一
                            endGate.countDown();
                        }
                    } catch (InterruptedException e1) {
                    }
                }
            };
            t.start();
        }
        long start = System.nanoTime();
        //// 所有的线程都准备好,可以执行
        startGate.countDown();
        // 等待所有线程执行结束
        endGate.await();

        long end = System.nanoTime();
        return end - start;
    }
}

 

/**
 *
 * @author zhangwei_david
 * @version $Id: Test.java, v 0.1 2014年11月10日 下午5:13:24 zhangwei_david Exp $
 */
public class Test {
    public static void main(String[] args) throws InterruptedException {

        System.out.println(new TestHarness().timeTasks(10, new Runnable() {

            public void run() {
                System.out.println(Thread.currentThread().getName() + "开始执行时间:"
                                   + System.currentTimeMillis());
            }
        }));
    }
}

 

   结果是:

Thread-2开始执行时间:1435904413836
Thread-9开始执行时间:1435904413836
Thread-5开始执行时间:1435904413836
Thread-7开始执行时间:1435904413836
Thread-6开始执行时间:1435904413836
Thread-3开始执行时间:1435904413836
Thread-8开始执行时间:1435904413836
Thread-1开始执行时间:1435904413836
Thread-0开始执行时间:1435904413836
Thread-4开始执行时间:1435904413836
1192112

 通过console控制台输出的结果可以看出:所有的线程几乎是在同一时刻开始执行的,这个就是闭锁的作用!

Java 多线程之闭锁-CountDownLatch

  • 0

    开心

    开心

  • 0

    板砖

    板砖

  • 0

    感动

    感动

  • 0

    有用

    有用

  • 0

    疑问

    疑问

  • 0

    难过

    难过

  • 0

    无聊

    无聊

  • 0

    震惊

    震惊

编辑推荐
线程间的竞争叫做Racing,正如这篇文章的图片一样,不同的线程好比在高速赛道上行驶的F1方程式赛车
线程间的竞争叫做Racing,正如这篇文章的图片一样,不同的线程好比在高速赛道上行驶的F1方程式赛车
前面写了两篇JDBC源码的文章,自己都觉得有点枯燥,先插一段JUC系列的文章来换换胃口,前面有文章大
现实场景下我们可以借助java.util.concurrent包下的以下几个类做到更好。 1.CountDownLatch(闭锁) 2
首先来看下一个场景,某电影院某个时间4个窗口同时在卖票,本场电影总共票只有100张,卖完为止。看
join是线程的一个方法,在API中,它的英文解释是Waits for this thread to die.等待此线程死亡。谁
一、线程的五种状态 1. 新建状态(New) : 线程对象被创建后,就进入了新建状态。例如,Thread thread
转载请注明出处 http://blog.csdn.net/pony_maggie/article/details/42587821 作者:小马 先看一个示
转载请注明出处 http://blog.csdn.net/pony_maggie/article/details/42364105 作者:小马 先看一个不
详细代码如下: public class CountdownLatchTest { public static void main(String[] args) { Exec
版权所有 IT知识库 CopyRight © 2009-2015 IT知识库 IT610.com , All Rights Reserved. 京ICP备09083238号