day1 java concurrent包一些知識點

hgs19921112發表於2018-10-16
Java

Concurrent:

1.  BlockingQueue( 阻塞佇列 )

ArrayBlockingQueue( 指定容量，不可變 ),LinkeBlocingQueue （指定容量不可變，也可以不指定容量，預設 Integer.Max_value ）

PriorityBlockingQueue ( 根據實現的介面自定義排序，只有在逐個拿取的時候才有序 )

SynchronousQueue （長度以 1 只能為 1 ）  

 

 

2.  ConcurrentMap

ConcurrentHashMap  

   1.5 分桶加鎖，1.8 CAS+紅黑樹來保證執行緒安全

ConcurrentNavigableMap （針對有序列表，有 map.headMap map.subMap map.tailMap ,   返回有序的在取出範圍的 map ）

3.  CountDownLatch   閉鎖

CountDownLatch 以一個給定的數量初始化。 countDown() 每被呼叫一次，這一數 量就減一。透過呼叫 await() 方法之一，執行緒可以阻塞等待這一數量到達零。

等待一定數量的執行緒完成。來執行其後的程式

4.  CyclicBarrier   柵欄

它能夠對處理一些演算法的執行緒實現同
步。換句話講，它就是一個所有執行緒必須等待的一個柵欄，直到所有執行緒都到達這 裡，然後所有執行緒才可以繼續做其他事情  

5.  Exchanger 交換機  

類表示一種兩個執行緒可以進行互相交換物件的會和點   ，只能兩個執行緒之間交換資料

 

 

 

6.  Semaphore   訊號量

l acquire()
l release()
計數訊號量由一個指定數量的 " 許可 " 初始化。每呼叫一次 acquire() ，一個許可會 被呼叫執行緒取走。每呼叫一次 release() ，一個許可會被返還給訊號量。因此，在沒 有任何 release() 呼叫時，最多有 N 個執行緒能夠透過 acquire() 方法， N 是該信 號量初始化時的許可的指定數量。

執行緒池

7.  ExecutorService

(executors.newFixedThreadPool ，長任務場景，只有核心執行緒，沒有臨時執行緒，容納無限多

,newCachedThreadPool （高併發短任務場景，沒有核心執行緒，全部都是臨時執行緒，處理任意多的執行緒）

,newSingleThreadPool

,newSchedulerThreadPool （有核心執行緒，有臨時執行緒）

)

提交執行緒的方法

execute() 提交執行緒 沒有返回值submit(Runnable) 提交執行緒，返Future 可以透過Future.get()得到該執行緒的狀態但是如果該執行緒未執行完成，那麼該方法阻塞

submit(Callable) 同上面類似，但是執行緒可以帶有返回值

invokeAny(.....)，隨機選擇執行緒執行一個

invokeAll(),自動執行所有的執行緒

關閉執行緒池： ExecutorService.shutdown();該方法不再接受執行緒池，等待所有執行緒執行完畢後，執行緒池結束。

ExecutorService.shutdown();立即關閉，退出任務，正在執行的執行緒可能會出錯。

##Callable只能用執行緒池提交

Callable runnable :

1.  返回值

2.  異常， runnabel沒有容錯機制，callable有容錯機制，可以將 異常拋給上層處理

3.  Callable只能透過submit方法提交，runnable可以new 也可 以透過執行緒池提交

8.  ReadWriteLock 讀寫鎖 ，可以是公平，也可以是非公平的。該鎖可以跨方法

    讀鎖可以共享，寫鎖互斥

    讀鎖 readLock().lock();

    寫鎖 writeLock().lock();   




package hgs.test;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.ConcurrentNavigableMap;
import java.util.concurrent.ConcurrentSkipListMap;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.Exchanger;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.PriorityBlockingQueue;
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.Semaphore;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantReadWriteLock;
public class Test {
	public static void main(String[] args) throws InterruptedException, BrokenBarrierException {
		//ConcurrentMap
		//BlockingQueue<String> bq = new ArrayBlockingQueue<String>(4);
		
		//add(超過長度會報錯) remove(沒有元素會報錯)
		/*
		bq.add("1");
		bq.add("1");
		bq.add("1");
		bq.add("1");
		bq.remove();
		bq.remove();
		bq.remove();
		bq.remove();
		*/
		
		//offer(如果可以插入返回true 否則 false) poll(如果沒有元素返回null)
		
		//bq.offer("1");
		//bq.offer("1");
		//bq.offer("1");
		//bq.offer("1");
		//bq.offer("1");
		//String flag = bq.poll();
		//System.out.println(flag);
		
		//put take 阻塞式
		//bq.put("1");
		//bq.put("1");
		//bq.put("1");
		//bq.put("1");
		//bq.put("1");
		//bq.put("1");
		//bq.take();
		
		//offer(o,timeout,timeunit),poll(timeout,tameunit)  等待timeout時間,然後跳過
		
		//bq.poll(10, TimeUnit.SECONDS);
		
		
		
		//bq.element();//檢查是否為空，是的話跑出異常
		//bq.peek();//阻塞
		
/*		ConcurrentNavigableMap<Integer ,String> m = new ConcurrentSkipListMap<Integer, String>() ;
		m.put(1, "1");
		m.put(2, "2");
		m.put(5, "5");
		m.put(4, "4");
		m.put(6, "6");
		m.put(5, "5");
		
		System.out.println("head(\"5\")"+m.headMap(4));
		System.out.println();
		System.out.println();*/
		/*Boy b1 = new Boy("b1",24);
		Boy b2 = new Boy("b2",23);
		Boy b3 = new Boy("b3",26);
		Boy b4 = new Boy("b4",19);
		PriorityBlockingQueue< Boy> pbq = new PriorityBlockingQueue<Boy>(100);
		pbq.add(b1);
		pbq.add(b2);
		pbq.add(b3);
		pbq.add(b4);
		for(int i =0 ;i<4;i++) {
			System.out.println(pbq.take().toString());
		}		*/
		
		//閉鎖
		/*CountDownLatch cdl = new CountDownLatch(4);
		for(int i = 0; i<4; i++) {
			new Thread(new BoyRun(cdl)).start();
		}
		cdl.await();
		System.out.println("全部到達。。。");*/
		
		//柵欄
		/*CyclicBarrier cb = new CyclicBarrier(4);
		for(int i = 0; i<4; i++) {
			new Thread(new GirlRan(cb)).start();
		}
		cb.await();
		System.out.println("all comming.");*/
		
		//exchanger交換器
		
		/*Exchanger<String> ex = new Exchanger<String>();
		ExchangerTest e1 = new ExchangerTest(ex);
		ExchangerTest e2 = new ExchangerTest(ex);
		new Thread(e1).start();
		new Thread(e2).start();	*/
		
		//6.Semaphore 訊號量
		
/*		Semaphore s = new Semaphore(5);
		for(int i = 0 ;i<9;i++) {
			new SemaphoreTest(s).start();
		}*/
		
		
		//原始建立執行緒池，executors.newCacheThreadPool 的底層呼叫該方法
/*		ExecutorService es =  new 
				ThreadPoolExecutor(5, 10, 10, TimeUnit.SECONDS, new ArrayBlockingQueue<>(10),
						new RejectedExecutionHandler() {
							
							@Override
							public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
							System.out.println("full......");
								
							}
						});
		for(int i = 0 ;i<24;i++) {
			es.execute(new ThreadPoolTest());
		}
		es.shutdown();*/
		
		
		
		//可重入鎖 ReentrantLock  可重入讀寫鎖ReentrantReadWriteLock
/*		
		ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
		for (int i = 0 ;i<3;i++) {
			new ReadLockTest( rwLock ).start();
		}*/
		
		
		ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
		for (int i = 0 ;i<3;i++) {
			new WriteLockTest( rwLock ).start();
		}
		 
		
	}
		
		
		
	}
class WriteLockTest extends Thread{
	ReentrantReadWriteLock rwLock ;
	public WriteLockTest(ReentrantReadWriteLock rwLock ) {
		this.rwLock = rwLock;
	}
	@Override
	public void run() {
		rwLock.writeLock().lock();
		System.out.println("reading......");
		try {
			Thread.sleep((long)(Math.random()*2000));
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		System.out.println("done......");
		rwLock.writeLock().unlock();
	}
	
}
class ReadLockTest extends Thread{
	ReentrantReadWriteLock rwLock ;
	public ReadLockTest(ReentrantReadWriteLock rwLock ) {
		this.rwLock = rwLock;
	}
	@Override
	public void run() {
		rwLock.readLock().lock();
		System.out.println("reading......");
		try {
			Thread.sleep((long)(Math.random()*2000));
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		System.out.println("done......");
		rwLock.readLock().unlock();
	}
	
}
	class ThreadPoolTest implements Runnable{
		ThreadPoolTest (){
			
		}
		@Override
		public void run() {
		 System.out.println(Thread.currentThread().getName());
		 
			try {
				Thread.sleep((long)(Math.random()*2000));
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			
		}
		
	}
class SemaphoreTest extends Thread{
	Semaphore s = null;
	public SemaphoreTest(Semaphore s) {
		this.s = s;
	}
	@Override
	public void run() {
		try {
			s.acquire();
			System.out.println("aquire......");
			Thread.sleep((long)(Math.random()*3000));
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println("release......");
		s.release();
		
		
	}
	
}
class ExchangerTest implements Runnable{
	Exchanger<String> ex = null;
	
	public ExchangerTest(Exchanger<String> ex) {
		this.ex = ex;
	}
	@Override
	public void run() {
		String my = Thread.currentThread().getName();
		String exstr = null;
		try {
			exstr = ex.exchange(my);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println(my+"   "+exstr);
		
	}
	
}
class BoyRun implements Runnable{
	CountDownLatch cdl ;
	public BoyRun(CountDownLatch cdl ) {
		this.cdl = cdl;
	}
	@Override
	public void run() {
		System.out.println("cdl"+" +1");
		cdl.countDown();
		System.out.println("cdl"+" +1--");
	}
	
}
class GirlRan implements Runnable {
	CyclicBarrier  cb ;
	public GirlRan(CyclicBarrier  cb ) {
		this.cb = cb;
	}
	@Override
	public void run() {
		System.out.println("cdl"+" +1");
		try {
			Thread.sleep((long)(Math.random()*5000));
			cb.await();
			
		} catch (InterruptedException | BrokenBarrierException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println("cdl"+" +1--");
		
	}
	
}
class Boy implements Comparable<Boy>{
	String name;
	int age;
	public Boy(String name ,int age) {
		this.name = name;
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public int compareTo(Boy o) {
		
		return this.age - o.age;
	}
	@Override
	public String toString() {
		return "Boy [name=" + name + ", age=" + age + "]";
	}
	
	
	
}



來自 “ ITPUB部落格 ” ，連結：http://blog.itpub.net/31506529/viewspace-2216629/，如需轉載，請註明出處，否則將追究法律責任。

相關文章