进程与线程：
一个进程可以包含多个线程。多个线程可以并行，但是一个时间点只能有一个线程是运行状态。
线程的状态：
查看API可以，线程的状态分为五种：
(JVM里面的状态：These states are virtual machine states which do not reflect any operating system thread states)
1. NEW: 当新建一个Thread的时候，当前线程的处于新建状态，线程还未开始。
2. RUNNABLE: 调用Thread的start方法，线程进入可运行状态，在这个状态下，线程开始处理工作，还有一种情况是未真正处理，还正在等待操作系统的调用。
3. BLOCKED: 线程的阻塞状态。一种情况下当调用wait方法时，当前线程释放锁，其他线程获取锁，开始处理，当前线程进入阻塞状态。
4. WAITING: 不定期等待状态。等待其他线程的notify.
5. TIMED_WAITING：有一定期限的等待状态，与WAITING最明显的区别是Thread.sleep(). 可以指定sleep时间。
6. TERMINATED: 终止状态。线程处理完成。
两个JDK自带的同步工具类：CountDownLatch 和CyclicBarrier
先上代码：
package com.my.thread; import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors; public class CountDownLatchTest { static CountDownLatch latch = new CountDownLatch(1); static CountDownLatch downLatch = new CountDownLatch(10); static ExecutorService service = Executors.newCachedThreadPool(); public static void main(String[] args) {
final long start = System.currentTimeMillis(); for (int i = 0; i < 10; i++) {
final int index = i+1;
Runnable runnable = new Runnable() { @Override
public void run() { try {
latch.await();
long end = System.currentTimeMillis();
System.out.println(Thread.currentThread().getName()+"===已鸣枪，第"+index+"位运动员出发,反应时间："+(end-start)+"ms");
Thread.sleep((long) (Math.random() * 10000));
end = System.currentTimeMillis();
System.out.println(Thread.currentThread().getName()+"===第"+index+"位运动员完成,用时"+(end-start)+"ms");
downLatch.countDown();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} }
};
service.execute(runnable);
}
try {
System.out.println("鸣枪开始！");
latch.countDown(); downLatch.await();
System.out.println("比赛结束"); } catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
service.shutdown();
} }
CountDownLatchTest .java
构造器中的计数值（count）实际上就是闭锁需要等待的线程数量。这个值只能被设置一次，而且CountDownLatch没有提供任何机制去重新设置这个计数值。
与CountDownLatch的第一次交互是主线程等待其他线程。主线程必须在启动其他线程后立即调用CountDownLatch.await()方法。
这样主线程的操作就会在这个方法上阻塞，直到其他线程完成各自的任务。
package com.my.thread; import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors; public class ThreadCycleBarrire {
public static void main(String[] args) {
ExecutorService service = Executors.newCachedThreadPool();
final CyclicBarrier cb = new CyclicBarrier(3); // 三个线程同时到达
for (int i = 0; i < 3; i++) {
Runnable runnable = new Runnable() {
public void run() {
try {
// Thread.sleep((long) (Math.random() * 10000));
System.out.println(
"线程" + Thread.currentThread().getName() + "即将到达集合地点1，当前已有" + (cb.getNumberWaiting() + 1)
+ "个已到达" + (cb.getNumberWaiting() == 2 ? "都到齐了，继续走啊" : "正在等候"));
try {
cb.await();
} catch (BrokenBarrierException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
Thread.sleep((long) (Math.random() * 10000));
System.out.println(
"线程" + Thread.currentThread().getName() + "即将到达集合地点2，当前已有" + (cb.getNumberWaiting() + 1)
+ "个已到达" + (cb.getNumberWaiting() == 2 ? "都到齐了，继续走啊" : "正在等候"));
try {
cb.await();
} catch (BrokenBarrierException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
Thread.sleep((long) (Math.random() * 10000));
System.out.println(
"线程" + Thread.currentThread().getName() + "即将到达集合地点3，当前已有" + (cb.getNumberWaiting() + 1)
+ "个已到达" + (cb.getNumberWaiting() == 2 ? "都到齐了，继续走啊" : "正在等候"));
try {
cb.await();
} catch (BrokenBarrierException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
};
service.execute(runnable);
}
service.shutdown();
}
}
ThreadCycleBarrire.java
CyclicBarrier 的字面意思是可循环使用（Cyclic）的屏障（Barrier）。它要做的事情是，让一组线程到达一个屏障（也可以叫同步点）时被阻塞，直到最后一个线程到达屏障时，屏障才会开门，所有被屏障拦截的线程才会继续干活。
CyclicBarrier 可用于综合统计，用CyclicBarrier(int num,Runable run),最后运行run里面的方法。