多线程(四) ：同步工具类 和 集合工具类

1: 同步工具之：CountDownLatch 计数器

import java.util.concurrent.CountDownLatch;


public class CountdownLatchTest {


	public static void main(String[] args) {
	
		//线程同步工具之：计数器
		//构造表示计数器的初始值，当这个值为0的时候就会向下执行，否则不为0时调用await即可阻塞。
		//countDown（）表示把当前计数器减一。
		new CountdownLatchTest().test();
	}
	
	CountDownLatch task1 = new CountDownLatch(1);	
	CountDownLatch task2 = new CountDownLatch(1);	
	//同时启动三个线程，当第三个线程执行完后 唤醒第二个和第一个。
	public void test(){
		Task1 t1 = new Task1(task1);
		Task2 t2 = new Task2(task2);
		Task3 t3 = new Task3();
		new Thread(t1).start();
		new Thread(t2).start();
		new Thread(t3).start();
	}
	
	class Task1 implements Runnable{
		CountDownLatch c ;
		public Task1(CountDownLatch c){
			this.c = c;
		}
		@Override
		public void run() {
			try {
				System.out.println("task1启动..");
				//阻塞
				c.await();
				//任务执行5秒
				Thread.sleep(5000);
				System.out.println("task1完毕");
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			
		}
		
	}
	class Task2 implements Runnable{
		CountDownLatch c ;
		public Task2(CountDownLatch c){
			this.c = c;
		}
		
		@Override
		public void run() {
			try {
				System.out.println("task2启动..");
				c.await();
				Thread.sleep(5000);
				System.out.println("task2完毕");
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			
		}
		
	}
	class Task3 implements Runnable{
		
		@Override
		public void run() {
			try {
				System.out.println("task3启动..");
				Thread.sleep(5000);
				System.out.println("task3完毕");
				//唤醒task1和task2线程
				task1.countDown();
				task2.countDown();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

2: 同步工具之：Semaphore : 可以控制访问资源的线程的个数.

3. 同步工具之：Exchanger：可以交互线程之间的数据，经过测试，线程数量必须是偶数，也就是成对儿出现

                          ，否则 将会有一个线程不能交换数据，至于交换规则经过测试没有规律。随机的。

4:同步工具之：CyclicBarrier：可以控制一组线程到达某个点。

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

public class CyclicBarrierTest {

	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()*500));	
						System.out.println("当前已有" + (cb.getNumberWaiting()+1) + "个已经到达，" 
								+ (cb.getNumberWaiting()==2?"都到齐了，继续走啊":"正在等候"));						
						cb.await();
						
						Thread.sleep((long)(Math.random()*500));	
						System.out.println("当前已有" + (cb.getNumberWaiting()+1) + "个已经到达，" 
								+ (cb.getNumberWaiting()==2?"都到齐了，继续走啊":"正在等候"));
						cb.await();	
						Thread.sleep((long)(Math.random()*500));	
						System.out.println("当前已有" + (cb.getNumberWaiting() + 1) + "个已经到达，"
								+ (cb.getNumberWaiting()==2?"都到齐了，继续走啊":"正在等候"));						
						cb.await();						
					} catch (Exception e) {
						e.printStackTrace();
					}				
				}
			};
			service.execute(runnable);
		}
		service.shutdown();
	}
}

集合工具类：

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.Queue;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentSkipListMap;
import java.util.concurrent.ConcurrentSkipListSet;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.CopyOnWriteArraySet;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Phaser;
import java.util.concurrent.locks.Lock;
import java.util.function.BiFunction;
import java.util.function.Function;

public class Test9 {

	public static void main(String[] args) throws Exception {
		//java 5中线程并发库 :
		//线程池..
		ExecutorService executorService = Executors.newCachedThreadPool();
		
		//java.util.concurrent.atomic 
		//对于多线程操作基本数据类型的情况下。可以考虑用此包下的类。
		
		//同步工具类..
		//CountDownLatch: 计数器
		//阻塞队列...
		BlockingQueue<String> queue = new ArrayBlockingQueue<String>(5);
		//添加失败报异常
		queue.add("1");
		queue.add("2");
		queue.add("3");
		queue.add("4");
		//阻塞方法:队列慢了就等待
		queue.put("5");
		
		//添加失败有返回值
		System.out.println(queue.offer("6"));
		//检索获取值，但是不删除.
		queue.element();
		
		int size = queue.size();
		for(int i=0;i<size;i++){
			//获取就是删除一个元素
			//System.out.println(queue.remove());
			//System.out.println(queue.poll());
			try {
				System.out.println(queue.take());
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		
		LinkedList<String> linkedList = new LinkedList<String>();
		
		//线程安全的hashmap
		ConcurrentHashMap<String, String> cHashMap = new ConcurrentHashMap<String, String>();
		HashMap<String, String> hashMap = new HashMap<String, String>();
		hashMap.put("a", "b");
		hashMap.compute("a", new BiFunction<String, String, String>() {
			@Override
			public String apply(String t, String u) {
				if(t!=null&&u!=null){
					System.out.println(t);
					System.out.println(u);
				}
				return "value replaced";
			}
		});
		System.out.println(hashMap.get("a"));
		
		
		ConcurrentSkipListMap<String, String> ListMap = new ConcurrentSkipListMap<String, String>();
		ConcurrentSkipListSet<String> listSet = new ConcurrentSkipListSet<String>();
		//线程安全的ArrayList
		CopyOnWriteArrayList<String> copyWriteList = new CopyOnWriteArrayList<String>();
		ArrayList<String> arrayList = new ArrayList<String>();
		//线程安全的hashset
		CopyOnWriteArraySet<String> copyWriteSet = new CopyOnWriteArraySet<String>();
		HashSet<String> set = new HashSet<String>();
		copyWriteSet.add("a");
		copyWriteSet.add("a");
		System.out.println(copyWriteSet.size());
		
	}

}