浪費了“黃金五年”的Java程式設計師，還有救嗎？ >>>   

Semaphore:訊號燈

特點：控制每次執行的執行緒數，達到控制執行緒併發的效果

• 測試程式碼

package com.zhiwei.thread;

import java.util.Random;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;

/**
 * 訊號燈：當執行緒空閒時自動去執行阻塞的執行緒，實現執行最優化
 */
public class SemaphoreTest {

public static void main(String[] args) {

    ExecutorService threadPool = Executors.newCachedThreadPool();

    // 定義訊號燈，一次最多能處理3個執行緒
    Semaphore sp = new Semaphore(3); 

    for (int i = 0; i < 20; i++) {
        threadPool.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    
                    // 獲取訊號，訊號燈處理阻塞執行緒，最多允許3個執行緒訪問
                    sp.acquire(); 
                    
                    System.out.println(Thread.currentThread().getName() + ":進入訊號燈，還有" +  sp.availablePermits() + "個訊號");
                    
                    Thread.sleep(new Random().nextInt(2000));
                    
                    // 回收訊號燈訊號，供別的執行緒使用
                    sp.release();
                    System.out.println(Thread.currentThread().getName() + ":離開訊號燈，還有" +  sp.availablePermits() + "個訊號");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
    }
    threadPool.shutdown();
}
}

 

效果:

---

CyclicBarrier

作用：控制執行緒執行的任務總量同步，例如等待所有人完成工作才可以下班

測試程式碼

package com.zhiwei.thread;
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 threadPool = Executors.newCachedThreadPool();
    
    // 規定總的任務量：只有全部完成才會進行下一步處理
    CyclicBarrier cb = new CyclicBarrier(3); 

    for (int i = 0; i < 3; i++) {
        threadPool.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep((long) (Math.random() * 10000));
                    System.out.println(Thread.currentThread().getName() + ":完成分任務,剩餘任務：" + (2 - cb.getNumberWaiting()));
                    
                    //如果前面2個執行緒阻塞 + 正在執行的執行緒 = 3，表明總任務完成
                    if (cb.getNumberWaiting() == 2) {
                        System.out.println("恭喜，總任務已完成！");
                    }

                    //分任務完成則等待,直到搜尋的任務都完成,才執行await後面的程式碼
                    cb.await(); 
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
    }
    threadPool.shutdown();
}
}
 

效果：

---

CountDownLatch 發令槍

CountDownLatch：可理解為所有執行緒都就緒之後就一起執行，類似旅遊跟團，只有所有人都到了才可以觸發

測試程式碼：

package com.zhiwei.thread;

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

public class CountDownLatchTest {

	public static void main(String[] args) {

    // 快取執行緒池：自動建立執行緒執行任務，如果執行緒執行完成任務則儲存，供下次使用，如果執行緒不夠則動態建立
    ExecutorService threadPool = Executors.newCachedThreadPool();

    // 表示將完成3個任務量：任務計數器：多執行緒完成一些列操作
    CountDownLatch ct = new CountDownLatch(3);

    for (int i = 0; i < 3; i++) {

        threadPool.execute(new Runnable() {
            @Override
            public void run() {
                try {

                    Thread.sleep((long) (Math.random() * 10000));
                    ct.countDown(); // 減1
 					System.out.println(Thread.currentThread().getName() + "準備分任務,剩餘任務：" + ct.getCount());
                   

                    // 如果ct計數器不為0則阻塞，為0 則一起執行
                    ct.await(); 
                     System.out.println(Thread.currentThread().getName() + "完成分任務");
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
    }
	if (ct.getCount() == 0) {
                        System.out.println("恭喜，總任務已完成！");
                    }
    threadPool.shutdown();
}
}

 

效果：

---

ArrayBlockingQueue

ArrayBlockingQueue： JDK內部提供的阻塞佇列，能夠保證執行緒安全

主要同步方法：

put方法

 public void put(E e) throws InterruptedException {
        checkNotNull(e);
        final ReentrantLock lock = this.lock;
        lock.lockInterruptibly();
        try {
            while (count == items.length)
                notFull.await();
            enqueue(e);
        } finally {
            lock.unlock();
        }
    }

take方法

 public E take() throws InterruptedException {
        final ReentrantLock lock = this.lock;
        lock.lockInterruptibly();
        try {
            while (count == 0)
                notEmpty.await();
            return dequeue();
        } finally {
            lock.unlock();
        }
    }

測試程式碼：

package com.zhiwei.thread;
import java.util.concurrent.ArrayBlockingQueue;

/**
 * 阻塞佇列：可用於處理生產消費的問題
 * 
 * 實現機制：put/take利用重入鎖ReentrantLock實現同步效果
 */
public class ArrayBlockingQueueTest {

	public static void main(String[] args) {
		
        ArrayBlockingQueue<String> abq = new ArrayBlockingQueue<String>(3);

        new Thread(new Runnable() {
	
			@Override
			public void run() {
				while(true){
					try {
						Thread.sleep(1000);
						abq.put("Hello Java World");
						System.out.println(Thread.currentThread().getName()+":放入資料，剩餘資料："+abq.size());
					} catch (Exception e) {
						e.printStackTrace();
					}	
				}
			}
		}).start();
        
        new Thread(new Runnable() {
			@Override
			public void run() {
				while(true){
					try {
						Thread.sleep(10000);
						abq.take();
						System.out.println(Thread.currentThread().getName()+":取出資料，剩餘資料："+abq.size());
					} catch (Exception e) {
						e.printStackTrace();
					}	
				}
			}
		}).start();
	}
}

效果：

相關推薦