java多線程中如何實現線程并發庫

本篇文章給大家分享的是有關java多線程中如何實現線程并發庫，小編覺得挺實用的，因此分享給大家學習，希望大家閱讀完這篇文章后可以有所收獲，話不多說，跟著小編一起來看看吧。

多線程之線程并發庫

原子性操作類

java.util.concurrent.atomic包下的類:

Package java.util.concurrent.atomic

線程池

java.util.concurrent:Class Executors

常用線程池

幾種常用的的生成線程池的方法：

• newCachedThreadPool

• newFixedThreadPool

• newScheduledThreadPool

• newSingleThreadExecutor

• newSingleThreadScheduledExecutor

例子：newFixedThreadPool

ExecutorService threadPool = Executors.newFixedThreadPool(3);
for(int i=0;i<10;i++){
    threadPool.execute(new Runnable() {
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName());
        }
    });
}

單線程newSingleThreadExecutor可用于重啟

用線程池啟動定時器

例子：類似Timer的定時執行

Executors.newScheduledThreadPool(3).scheduleAtFixedRate(
            new Runnable() {
                @Override
                public void run() {
                    System.out.println("ScheduledThreadPool "+Thread.currentThread().getName());
                }
            },3,1, TimeUnit.SECONDS
    );

Callable&Future

ExecutorService在Executor的基礎上增加了一些方法，其中有兩個核心的方法：

• Future<?> submit(Runnable task)

• <T> Future<T> submit(Callable<T> task)

這兩個方法都是向線程池中提交任務，它們的區別在于Runnable在執行完畢后沒有結果，Callable執行完畢后有一個結果。這在多個線程中傳遞狀態和結果是非常有用的。另外他們的相同點在于都返回一個Future對象。Future對象可以阻塞線程直到運行完畢（獲取結果，如果有的話），也可以取消任務執行，當然也能夠檢測任務是否被取消或者是否執行完畢。

Lock&Condition

Lock

Lock功能類似傳統多線程技術里的synchronized，實現線程互斥，但更加面向對象。將需要互斥的代碼片段放到lock.lock();和lock.unlock();之間。

例子

class A{
    private Lock lock = new ReentrantLock();
    
    public void function(){
        lock.lock();
        try{
            //功能代碼
        }finally{
            lock.unlock();
        }
    }
}

• 讀寫鎖

java.util.concurrent.locks:Class ReentrantReadWriteLock

javaDoc文檔讀寫鎖例子,緩存:

class CachedData {
   Object data;
   volatile boolean cacheValid;
   final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();

   void processCachedData() {
     rwl.readLock().lock();
     if (!cacheValid) {
       // Must release read lock before acquiring write lock
       rwl.readLock().unlock();
       rwl.writeLock().lock();
       try {
         // Recheck state because another thread might have
         // acquired write lock and changed state before we did.
         if (!cacheValid) {
           data = ...
           cacheValid = true;
         }
         // Downgrade by acquiring read lock before releasing write lock
         rwl.readLock().lock();
       } finally {
         rwl.writeLock().unlock(); // Unlock write, still hold read
       }
     }

     try {
       use(data);
     } finally {
       rwl.readLock().unlock();
     }
   }
 }

重點注意在釋放寫鎖前加讀鎖那部分代碼，注釋為 // Downgrade by acquiring read lock before releasing write lock。自己掛了寫鎖，再掛讀鎖是可以的，這面涉及的技巧以后再研究。

Condition

Condition類似于傳統多線程技術中的Object.wait和Object.notify,實現線程間同步。

javaDoc文檔例子，可阻塞隊列

class BoundedBuffer例子

class BoundedBuffer {
   final Lock lock = new ReentrantLock();
   final Condition notFull  = lock.newCondition(); 
   final Condition notEmpty = lock.newCondition(); 

   final Object[] items = new Object[100];
   int putptr, takeptr, count;

   public void put(Object x) throws InterruptedException {
     lock.lock();
     try {
       while (count == items.length)
         notFull.await();
       items[putptr] = x;
       if (++putptr == items.length) putptr = 0;
       ++count;
       notEmpty.signal();
     } finally {
       lock.unlock();
     }
   }

   public Object take() throws InterruptedException {
     lock.lock();
     try {
       while (count == 0)
         notEmpty.await();
       Object x = items[takeptr];
       if (++takeptr == items.length) takeptr = 0;
       --count;
       notFull.signal();
       return x;
     } finally {
       lock.unlock();
     }
   }
 }

使用了兩個condition

同步工具

• Semaphore

類似占坑

• CyclicBarrier

階段性使進度一致

• CountDownLatch

一人通知多人/多人通知一人

• Exchanger

線程間數據交換，都到達則自然交換

以上就是java多線程中如何實現線程并發庫，小編相信有部分知識點可能是我們日常工作會見到或用到的。希望你能通過這篇文章學到更多知識。更多詳情敬請關注億速云行業資訊頻道。