CountDownLatch的使用（注：转载于http://www.blogjava.net/fanjs2000/archive/2012/10/31/390521.html）

小一败涂地 — Wed, 31 Oct 2012 09:19:00 GMT

CountDownLatch如其所写，是一个倒计数的锁存器，当计数减至0时触发特定的事件。利用这种特性，可以让主线程等待子线程的结束。下面以一个模拟运动员比赛的例子加以说明。

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Test {
    private static final int PLAYER_AMOUNT = 5;

    public static void main(String[] args) {
        //对于每位运动员，CountDownLatch减1后即结束比赛
        CountDownLatch begin = new CountDownLatch(1);
        //对于整个比赛，所有运动员结束后才算结束
        CountDownLatch end = new CountDownLatch(PLAYER_AMOUNT);
        Player[] plays = new Player[PLAYER_AMOUNT];

        for (int i = 0; i < PLAYER_AMOUNT; i++)
            plays[i] = new Player(i + 1, begin, end);

        //设置特定的线程池，大小为5
        ExecutorService exe = Executors.newFixedThreadPool(PLAYER_AMOUNT);
        for (Player p : plays)
            exe.execute(p); //分配线程
        begin.countDown();
        System.out.println("Race begins!");
        try {
            end.await(); //等待end状态变为0，即为比赛结束
        } catch (InterruptedException e) {
            // TODO: handle exception
            e.printStackTrace();
        } finally {
            System.out.println("Race ends!");
        }
        exe.shutdown();
    }
}

class Player implements Runnable {

    private int id;
    private CountDownLatch begin;
    private CountDownLatch end;

    public Player(int i, CountDownLatch begin, CountDownLatch end) {
        // TODO Auto-generated constructor stub
        super();
        this.id = i;
        this.begin = begin;
        this.end = end;
    }

    public void run() {
        // TODO Auto-generated method stub
        try {
            begin.await(); //等待begin的状态为0
            Thread.sleep((long) (Math.random() * 100)); //随机分配时间，即运动员完成时间
            System.out.println("Play" + id + " arrived.");
        } catch (InterruptedException e) {
            // TODO: handle exception
            e.printStackTrace();
        } finally {
            end.countDown(); //使end状态减1，最终减至0
        }
    }
}

小一败涂地 2012-10-31 17:19 发表评论

synchronized(this) 解释

小一败涂地 — Thu, 27 Sep 2012 08:03:00 GMT

public class DemoThread implements Runnable {
    public void run() {
        synchronized(this) {            //请问这里的this怎样理解，t1和t2的地址不是不一样嘛，怎么会只有一个线程运行？？？
            for (int i = 0; i < 5; i++) {
                System.out.println(Thread.currentThread().getName() + " synchronized loop " + i);
            }
         }
    }

    public static void main(String[] args) {
        DemoThread t1 = new DemoThread();
        Thread ta = new Thread(t1, "A");
        Thread tb = new Thread(t1, "B");
        ta.start();
        tb.start();
    }
}

    解释：
    这里的this是指当前对象,也就是说不管ta还是tb,刚开始运行这段代码的时候会给这段代码加个锁,这样即使运行到中间被替换了,
另一个线程也不会执行这段代码,因为这段代码加锁了,而钥匙在给代码加锁的那个线程手里,只有加锁的线程运行完这段代码,才会给代码解锁.
然后其他线程才能执行这段代码..  加个synchronized(this)以后运行结果是这样: 
A synchronized loop 0 
A synchronized loop 1 
A synchronized loop 2 
A synchronized loop 3 
A synchronized loop 4 
B synchronized loop 0 
B synchronized loop 1 
B synchronized loop 2 
B synchronized loop 3 
B synchronized loop 4  

不加的话是这样:(顺序乱了,有好多种结果,这里只是其中一种).. 
A synchronized loop 0 
B synchronized loop 0 
A synchronized loop 1 
B synchronized loop 1 
A synchronized loop 2 
B synchronized loop 2 
A synchronized loop 3 
B synchronized loop 3 
B synchronized loop 4 
A synchronized loop 4

小一败涂地 2012-09-27 16:03 发表评论

BlogJava-anchor110-文章分类-并发、多线程

CountDownLatch的使用（注：转载于http://www.blogjava.net/fanjs2000/archive/2012/10/31/390521.html）

synchronized(this) 解释