java 并发编程实战书籍学习 第五章，CountDownLatch，FutureTask，CyclicBarrier，Semaphore学习

CountDownLatch

public class CountLanuth implements Runnable {

	static CountDownLatch countDownLatch = new CountDownLatch(4);//初始化
	public static void main(String[] args) throws InterruptedException {
		for (int i = 0; i <4; i++) {
			Thread t =new Thread( new CountLanuth());
			t.start();
		}
		countDownLatch.await();//在countDownLatch里的值减到0之前 一直挂起。
		System.out.println("wanchen");//这句话会最后输出
		
	}

	@Override
	public void run() {
		try {
			TimeUnit.SECONDS.sleep(1);
		} catch (InterruptedException e) {
		}finally{
			countDownLatch.countDown();//务必放到finally语句块中，
		}
		System.out.println("执行线程"+Thread.currentThread().getName());
	}
}

FutureTask

public class Future {
	//FutureTask实现RunnableFuture，RunnableFuture实现Future和Runnable
	//执行thread.run方法，启动线程的时候会执行到实现了Callable实现类的call方法，同时有返回值
	public static void main(String[] args) throws InterruptedException, ExecutionException, TimeoutException {
		
		FutureTask<String>  futureTask = new FutureTask<String>(new Callable<String>() {

			@Override
			public String call() throws Exception {
				int i =0;
				for ( i = 0; i < 3; i++) {
					TimeUnit.SECONDS.sleep(1);
				}
				return i+"";
			}
		});
		
		Thread thread = new Thread(futureTask);
		thread.run();
		String string = futureTask.get();//获取线程执行的结果，如果获取不到则一直阻塞，也有超时的方法
		System.out.println(string);
		}
}

CyclicBarrier

public class CyclicBarry extends Thread{


	static CyclicBarrier barrier = new CyclicBarrier(3, new Runnable() {
		@Override
		public void run() {
			System.err.println(1010);
		}
	});//有个runable的构造函数，如果传入这个值则在 barrier.await()之前执行,即再线程一起都执行到await的时候 再先执行runable
	public static void main(String[] args) {
		
		for (int i = 0; i < 6; i++) {
			new CyclicBarry().start();
		}
	}
	
	@Override
	public void run() {
		try {
			 System.out.println("线程"+Thread.currentThread().getName()+"正在写");
            Thread.sleep(100);     
            System.out.println("线程"+Thread.currentThread().getName()+"等待其他线程");
			barrier.await();//当执行的线程到达这里的时候，数量为你初始化的数量的时候，则这初始化的线程 看是向下执行自己的任务
		} catch (InterruptedException | BrokenBarrierException e) {
		}
		try {
			Thread.sleep(100);
		} catch (InterruptedException e) {
		} 
		System.out.println("我们一起执行"+Thread.currentThread().getName());
	}
}//如果打印 的结果 和你预想的不一样 ，eclipse，打印顺序问题。

Semaphore

public class Semaphore extends Thread {

	static java.util.concurrent.Semaphore semaphore = new java.util.concurrent.Semaphore(3);
	
	
	public static void main(String[] args) {
		
		for (int i = 0; i < 10; i++) {
			Runnable thread = new Runnable() {
				
				@Override
				public void run() {
					run1();
				}
			};
			Thread thread2 = new Thread(thread);
			thread2.start();
		}
	}
	
	
	public static void run1() {
		try {
			System.out.println(Thread.currentThread().getName()+" store");
			semaphore.acquire();//只有三个可以获取到，其他的则阻塞
			Thread.sleep(2000);
			System.out.println(Thread.currentThread().getName()+ " release");
		

		} catch (InterruptedException e) {
			
		}finally{

			semaphore.release();没当释放掉以后，其他线程则可以acquire，有点类似固定长度的线程池

		}
	}