使用java闭锁实现并发

闭锁：一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。即，一组线程等待某一事件发生，事件没有发生前，所有线程将阻塞等待；而事件发生后，所有线程将开始执行；闭锁最初处于封闭状态，当事件发生后闭锁将被打开，一旦打开，闭锁将永远处于打开状态。

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.URL;
import java.net.URLConnection;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CountDownLatch;

public class ThreadTest {
    public static void main(String[] args) {
        final int num = 10;
        //CountDownLatch是一种灵活的闭锁实现，闭锁状态包括一个计数器，该计数器被初始化一个正数，表示需要等待的事件数量。
        final CountDownLatch begin = new CountDownLatch(1);
        final CountDownLatch end = new CountDownLatch(num);
        for (int i = 0; i < num; i++) {
            new Thread(new MyWorker(i, begin, end)).start();
        }
        // 睡眠十秒,等所有线程都准备好之后再启动并发测试
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e1) {
            e1.printStackTrace();
        }
        System.out.println("开始进行并发测试");
        //调用countDown 方法递减计算器，表示有一个事件已经发生了
        begin.countDown();
        long startTime = System.currentTimeMillis();
        try {
            //await方法要一直阻塞直到计数器为零，或者等待的线程中断、超时
            end.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            long endTime = System.currentTimeMillis();
            System.out.println("结束并发测试 !");
            System.out.println("花费时间: " + (endTime - startTime));
        }
    }
}

class MyWorker implements Runnable {
    final CountDownLatch begin;
    final CountDownLatch end;
    final int id;

    public MyWorker(final int id, final CountDownLatch begin,
            final CountDownLatch end) {
        this.id = id;
        this.begin = begin;
        this.end = end;
    }

    @Override
    public void run() {
        try {
            System.out.println(this.id + " ready !");
            //await方法要一直阻塞直到计数器为零，或者等待的线程中断、超时
            begin.await();
            // execute your logic
            URLConnection webUrlRequest = request("http://the090303.com");
            List<String> readline = readLine(webUrlRequest.getInputStream());
//            System.out.println(readline);
            Thread.sleep((long) (Math.random() * 10000));
        } catch (Throwable e) {
            e.printStackTrace();
        } finally {
            System.out.println(this.id + " 完成测试 !");
            //调用countDown 方法递减计算器，表示有一个事件已经发生了
            end.countDown();
        }
    }

    public static URLConnection request(String requestUrl) throws IOException {
        return new URL(requestUrl).openConnection();
    }

    public static List<String> readLine(InputStream inputStream)
            throws IOException {
        List<String> list = new ArrayList<String>();
        BufferedReader bufferReader = null;
        try {
            bufferReader = new BufferedReader(
                    new InputStreamReader(inputStream));
            String readline;
            while ((readline = bufferReader.readLine()) != null) {
                list.add(readline);
            }
        } finally {
            bufferReader.close();
        }
        return list;
    }
}

上面CountDownLatch是一种灵活的闭锁实现，闭锁状态包括一个计数器，该计数器被初始化一个正数，表示需要等待的事件数量。调用countDown 方法递减计算器，表示有一个事件已经发生了，而await方法要一直阻塞直到计数器为零，或者等待的线程中断、超时.所以上面用两个闭锁来实现一个起始门（begin）跟结束门（end），起始门计数器初始值为1，结束门计算器初始值为线程数量，每个线程就是在起始门等待，所以这样确保实现真正并发，而每个线程在最后做的一件事情是调用结束门（end）的countDown方法减1，使得当所有的线程都执行完毕后，我们可以统计出所有线程对笔者网站进行访问所消耗的时间.