java.util.concurrent.atomic

一個小型工具包，支持單個變量上的無鎖線程安全編程.
包含的類:

這些類的相關操作都是原子性的

java.util.concurrent

線程池

//線程池的創建 //創建一個線程池，該線程池重用固定數量的從共享無界隊列中運行的線程。 //在任何時候，最多nThreads個線程同時處理任務。 //如果所有線程處于活動狀態時又提交其他任務，則它們將在等待隊列中直到有一個線程空閑可用。 //如果任何線程由于在關閉之前的執行期間發生故障而終止，如果需要執行后續任務，則新線程將占用它。 //池中的線程將一直存在，直到調用shutdown方法 。 //public static ExecutorService newFixedThreadPool(int nThreads) ExecutorService es = Executors.newFixedThreadPool(3);//向線程池中添加任務 es.execute(new Runnable(){});//可以添加多個任務 //但是最多有三個線程去執行這些任務,即最多只有三個任務同時執行//線程池的關閉 es.shutdown();//所有任務執行完后關閉 es.shutdownNow(); //立即關閉，不管任務有沒有執行完//創建緩存的線程池 //創建一個根據需要創建新線程的線程池，但在可用時將重新使用以前構造的線程。 //這些池通常會提高執行許多短暫異步任務的程序的性能。 //調用execute將重用以前構造的線程（如果可用）。 //如果沒有可用的線程，將創建一個新的線程并將其添加到該池中。 //未使達六十秒的線程將被終止并從緩存中刪除。 //因此，長時間保持閑置的池將不會消耗任何資源 public static ExecutorService newCachedThreadPool()//創建只有單個線程的線程池public static ExecutorService newSingleThreadExecutor() //如何實現線程死掉后重新啟動，通過單一線程池，這樣這個線程死掉后，線程池會自動重新創建一個線程來替代//調度線程池 ScheduledExecutorService se = Executors.newScheduledThreadPool(3); se.schedule(new Runnable() //3秒后執行 { @Overridepublic void run(){System.out.println("bombing");} }, 3, TimeUnit.SECONDS);se.scheduleAtFixedRate(new Runnable()//6秒后第一次執行，以后每隔兩秒執行一次 {@Overridepublic void run(){System.out.println("bombing");} }, 6, 2, TimeUnit.SECONDS);se.scheduleWithFixedDelay(new Runnable() {@Overridepublic void run(){System.out.println("bombing");} }, 3, 2, TimeUnit.SECONDS);

Callable 與 Future 類似 dot net 的async與await

使用Callable來執行任務，Future獲取結果，在使用到結果的時候如果Callable還沒結束，程序會暫停并等待結果，就跟await一樣

public class CallableAndFuture { /*** @param args*/ public static void main(String[] args) {ExecutorService es = Executors.newSingleThreadExecutor();Future<String> future = es.submit(new Callable<String>(){@Overridepublic String call() throws Exception{Thread.sleep(2000);return "Hello";}});System.out.println("等待結果");try{System.out.println("返回結果:"+future.get());}catch (InterruptedException e){e.printStackTrace();}catch (ExecutionException e){e.printStackTrace();}es.shutdown();ExecutorService es1 = Executors.newFixedThreadPool(10);CompletionService<Integer> completionService = new ExecutorCompletionService<>(es1);for(int i=1;i<=10;i++){final int sequence=i;completionService.submit(new Callable<Integer>(){@Overridepublic Integer call() throws Exception{Thread.sleep(new Random().nextInt(5000));return sequence;}});}for(int i=0;i<10;i++){try{System.out.println(completionService.take().get());}catch (InterruptedException | ExecutionException e){e.printStackTrace();}}es1.shutdown(); } }

java.util.concurrent.locks

主要的類與接口

//Lock接口 void lock() //獲得鎖。 void lockInterruptibly() //獲取鎖定，除非當前線程是 interrupted 。 Condition newCondition() //返回一個新Condition綁定到該實例Lock實例。 boolean tryLock() //只有在調用時才可以獲得鎖。 boolean tryLock(long time, TimeUnit unit) //如果在給定的等待時間內是空閑的，并且當前的線程尚未得到 interrupted，則獲取該鎖。 void unlock() //釋放鎖。 //使用規范 //當在不同范圍內發生鎖定和解鎖時， //必須注意確保在鎖定時執行的所有代碼由try-finally或try-catch保護，以確保在必要時釋放鎖定。 Lock l = ...; l.lock(); try { } finally { l.unlock(); } //ReentrantLock static class Outputer {Lock lock = new ReentrantLock();public void output(String name){lock.lock();try{int len=name.length();for(int i=0;i<len;i++){System.out.print(name.charAt(i));}System.out.println();}finally{// TODO: handle finally clauselock.unlock();}}} //基于讀寫鎖的緩存 public class CacheDemo {private Map<String, Object> cache = new HashMap<>();private ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();public static void main(String[] args){}//這種思路不能很好的處理獲取數據//因為所有的獲取數據都是互斥的，效率低public synchronized Object getData1(String key){Object value = cache.get(key);if(value==null){value=new Random().nextInt(100);cache.put(key, value);}return value;}//鎖降級：從寫鎖變成讀鎖；//鎖升級：從讀鎖變成寫鎖。//讀鎖是可以被多線程共享的，寫鎖是單線程獨占的。//也就是說寫鎖的并發限制比讀鎖高。/*** 這種方法使用讀寫鎖來處理緩存，同時讀的時候不互斥，*當有一個去修改的時候，轉換為寫鎖* @param key* @return value*/public Object getData2(String key){rwl.readLock().lock();Object value = null;try{value=cache.get(key);if(value==null)//緩存中沒有數據，去獲取{rwl.readLock().unlock();//釋放讀鎖rwl.writeLock().lock(); //加寫鎖try{value=cache.get(key);//為了防止多次寫入if(value==null)//為了防止多次寫入{value=new Random().nextInt(100);cache.put(key, value);}rwl.readLock().lock();}finally{// TODO: handle finally clauserwl.writeLock().unlock();}}}finally {rwl.readLock().unlock();}return value;} }/*關于讀寫鎖升級和降級的限制1.因為同一個線程中，在沒有釋放讀鎖的情況下，就去申請寫鎖，這屬于鎖升級，ReentrantReadWriteLock是不支持的。2.從寫鎖降級成讀鎖，并不會自動釋放當前線程獲取的寫鎖，仍然需要顯示的釋放，否則別的線程永遠也獲取不到寫鎖。 */

Condition 線程通信

//利用condition進行線程間的通信static class Business{private ReentrantLock lock = new ReentrantLock();private Condition condition1 = lock.newCondition();private Condition condition2 = lock.newCondition();private Condition condition3 = lock.newCondition();private int flag=1;public void sub(int i){lock.lock();try{while(flag!=1){try{//this.wait();condition1.await();}catch (InterruptedException e){e.printStackTrace();}}for (int j = 1; j <= 10; j++){System.out.println("sub thread sequence of " + j+",loop of "+i);}flag=2;condition2.signal();}finally{// TODO: handle finally clauselock.unlock();}}public void sub2(int i){lock.lock();try{while(flag!=2){try{//this.wait();condition2.await();}catch (InterruptedException e){e.printStackTrace();}}for (int j = 1; j <= 20; j++){System.out.println("sub2 thread sequence of " + j+",loop of "+i);}flag=3;condition3.signal();}finally{// TODO: handle finally clauselock.unlock();}}public void main(int i){lock.lock();try{while(flag!=3){try{//this.wait();condition3.await();}catch (InterruptedException e){e.printStackTrace();}}for (int j = 1; j <= 100; j++){System.out.println("main thread sequence of " + j+",loop of "+i);}flag=1;//this.notify();condition1.signal();}finally{// TODO: handle finally clauselock.unlock();}}}

轉載于:https://www.cnblogs.com/phasd/p/9245019.html

總結

以上是生活随笔為你收集整理的Java5的 线程并发库的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。