多线程-CountDownLatch

CountDownLatch是一个同步工具类，它允许一个或多个线程一直等待，直到其他线程的操作执行完后再执行。

CountDownLatch是在java1.5被引入的，跟它一起被引入的并发工具类还有CyclicBarrier、Semaphore、ConcurrentHashMap和BlockingQueue，它们都存在于java.util.concurrent包下。CountDownLatch这个类能够使一个线程等待其他线程完成各自的工作后再执行。例如，应用程序的主线程希望在负责启动框架服务的线程已经启动所有的框架服务之后再执行。
CountDownLatch是通过一个计数器来实现的，计数器的初始值为线程的数量。每当一个线程完成了自己的任务后，计数器的值就会减1。当计数器值到达0时，它表示所有的线程已经完成了任务，然后在闭锁上等待的线程就可以恢复执行任务。

主要方法
 public CountDownLatch(int count);
 public void countDown();
 public void await() throws InterruptedException

构造方法参数指定了计数的次数

countDown方法，当前线程调用此方法，则计数减一

awaint方法，调用此方法会一直阻塞当前线程，直到计时器的值为0

public class CountDownLatchDemo {final static SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");    public static void main(String[] args) throws InterruptedException {    CountDownLatch latch=new CountDownLatch(2);//两个工人的协作    Worker worker1=new Worker("zhang san", 5000, latch);    Worker worker2=new Worker("li si", 8000, latch);    worker1.start();//    worker2.start();//    latch.await();//等待所有工人完成工作        System.out.println("all work done at "+sdf.format(new Date()));}            static class Worker extends Thread{    String workerName;     int workTime;    CountDownLatch latch;    public Worker(String workerName ,int workTime ,CountDownLatch latch){     this.workerName=workerName;     this.workTime=workTime;     this.latch=latch;    }    public void run(){    System.out.println("Worker "+workerName+" do work begin at "+sdf.format(new Date()));    doWork();//工作了    System.out.println("Worker "+workerName+" do work complete at "+sdf.format(new Date()));    latch.countDown();//工人完成工作，计数器减一    }        private void doWork(){    try {Thread.sleep(workTime);} catch (InterruptedException e) {e.printStackTrace();}    }    }         }

利用多线程来实现sql数据库批量插入，CountDownLatch用于同步计数

public class ThreadImport {    private String url="jdbc:oracle:thin:@localhost:1521:orcl";    private String user="cmis";    private String password="cmis";    public Connection getConnect(){        Connection con = null;         try {            Class.forName("oracle.jdbc.driver.OracleDriver");            con=DriverManager.getConnection(url, user, password);        } catch (Exception e) {            e.printStackTrace();        }         return con;    }    public void multiThreadImport( final int ThreadNum){        final CountDownLatch cdl= new CountDownLatch(ThreadNum);        long starttime=System.currentTimeMillis();        for(int k=1;k<=ThreadNum;k++){            new Thread(new Runnable() {                @Override                public void run() {                    Connection con=getConnect();                    try {                        Statement st=con.createStatement();                        for(int i=1;i<=80000/ThreadNum;i++){                            String uuid=UUID.randomUUID().toString();                            st.addBatch("insert into demo_table(a,b) values('"+uuid+"','"+uuid+"')");                            if(i%500==0){                                st.executeBatch();                            }                        }                        cdl.countDown();                    } catch (Exception e) {                    }finally{                        try {                            con.close();                        } catch (SQLException e) {                            e.printStackTrace();                        }                    }                }            }).start();        }        try {            cdl.await();            long spendtime=System.currentTimeMillis()-starttime;            System.out.println( ThreadNum+"个线程花费时间:"+spendtime);        } catch (InterruptedException e) {            e.printStackTrace();        }    }    public static void main(String[] args) throws Exception {        ThreadImport ti=new ThreadImport();        ti.multiThreadImport(1);        ti.multiThreadImport(5);        ti.multiThreadImport(8);        ti.multiThreadImport(10);        ti.multiThreadImport(20);        ti.multiThreadImport(40);        System.out.println("笔记本CPU数:"+Runtime.getRuntime().availableProcessors());    }}

运行结果：
1个线程花费时间:56707
5个线程花费时间:21688
8个线程花费时间:16625
10个线程花费时间:16098
20个线程花费时间:19882
40个线程花费时间:23536
笔记本CPU数:8
下面关于PreparedStatement和Statement一些总结

    选择PreparedStatement还是Statement取决于你要怎么使用它们。对于只执行一次的SQL语句选择Statement是最好的. 相反, 
如果SQL语句被多次执行选用PreparedStatement是最好的。

    PreparedStatement: 数据库会对sql语句进行预编译，下次执行相同的sql语句时，数据库端不会再进行预编译了，而直接用数据库的缓冲区，提高数据访问的效率（但尽量采用使用？号的方式传递参数），如果sql语句只执行一次，以后不再复用。    从安全性上来看，PreparedStatement是通过?来传递参数的，避免了拼sql而出现sql注入的问题，所以安全性较好。在开发中，推荐使用 PreparedStatement。

　　PreparedStatement的第一次执行消耗是很高的。它的性能体现在后面的重复执行。例如, 假设我使用Employee ID, 
使用prepared的方式来执行一个针对Employee表的查询。JDBC驱动会发送一个网络请求到数据解析和优化这个查询，而执行时会产生另一个网络请求。在JDBC驱动中，减少网络通讯是最终的目的。如果我的程序在运行期间只需要一次请求, 
那么就使用Statement. 对于Statement, 同一个查询只会产生一次网络到数据库的通讯。

　　对于使用PreparedStatement池的情况下, 本指导原则有点复杂。当使用PreparedStatement池时, 如果一个查询很特殊, 
并且不太会再次执行到, 那么可以使用Statement。如果一个查询很少会被执行,但连接池中的Statement池可能被再次执行, 
那么请使用PreparedStatement。在不是Statement池的同样情况下, 请使用Statement。

　　使用PreparedStatement的Batch功能

　　Update大量的数据时, 先Prepare一个INSERT语句再多次的执行, 会导致很多次的网络连接。要减少JDBC的调用次数改善性能, 
你可以使用PreparedStatement的AddBatch()方法一次性发送多个查询给数据库.