一、ThreadPoolExecutor 執行緒池執行者

• 初始化執行緒池的引數

• 執行緒池內部執行機制

1、當有任務委託給執行緒池，若池中執行緒數量 < 核心執行緒數量,則建立新的執行緒，即使有空閒執行緒。

2、若核心執行緒數量已滿，且沒有空閒，則把任務放入阻塞佇列。

3、若核心執行緒和阻塞佇列都沒有空閒，此時再來任務，則判斷當前池內執行緒數量是否 < 最大執行緒數量

4、若核心執行緒，阻塞佇列，臨時執行緒都已經到達上限，且被佔用。此時再來任務，則由拒絕助手去處理。

• 程式碼示例

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class ThreadPoolExecutorDemo {

	public static void main(String[] args) throws InterruptedException {
		
		//阻塞佇列
		ArrayBlockingQueue<Runnable> workQueue = new ArrayBlockingQueue<Runnable>(2);
		//拒絕助手
		RejectedExecutionHandler handler = new RejectedExecutionHandler() {
			@Override
			public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
				System.out.println("執行緒池已滿  ##### 任務被拒絕 ");
			}
		};
		//建立執行緒池
		ThreadPoolExecutor  pool =  new ThreadPoolExecutor(2, 4, 60L, TimeUnit.SECONDS, workQueue, handler);
										
		//1,2被核心執行緒處理
		pool.execute(new RunnableDemo(1,5000L));
		pool.execute(new RunnableDemo(2,5000L));
		Thread.sleep(100);
		//3,4放入阻塞佇列，等核心執行緒或臨時執行緒有空閒了再處理
		pool.execute(new RunnableDemo(3,2000L));
		pool.execute(new RunnableDemo(4,2000L));
		Thread.sleep(100);
		//5,6被臨時執行緒處理
		pool.execute(new RunnableDemo(5,2000L));
		pool.execute(new RunnableDemo(6,2000L));
		Thread.sleep(100);
		//7,8被拒接助手處理了
		pool.execute(new RunnableDemo(7,2000L));
		pool.execute(new RunnableDemo(8,2000L));
		
		//執行緒池關閉
		pool.shutdown();
		
	}

}

class RunnableDemo implements Runnable {
	
	private int id;
	private long time;
	
	public RunnableDemo(int id, long time) {
		this.id = id;
		this.time = time;
	}
	
	@Override
	public void run() {
		try {
			
			System.out.println("id=" + id + " 開始執行！時間：" + System.currentTimeMillis());
			Thread.sleep(time);
			System.out.println("id=" + id + " 執行完成！時間：" + System.currentTimeMillis());
			
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		
	}
	
}
 

二、ExecutorService 執行器服務

• 獲取執行緒池

通過Executors類的各個靜態方法，可以直接獲取常用配置的執行緒池。

例如：

ExecutorService executorService = Executors.newFixedThreadPool(5);

其實內部也是用ThreadPoolExecutor來實現：

public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }
 

• 執行

• 關閉執行緒池

• 程式碼示例

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class ExecutorServiceDemo {
	
	public static void main(String[] args) throws Exception {
		ExecutorService executorService = Executors.newFixedThreadPool(5);
		Future<String> future = executorService.submit(new CallableDemo());
		
		//阻塞直到任務結束
		System.out.println(future.get());
		
		executorService.shutdown();
		
	}
}

class CallableDemo implements Callable<String> {

	public String call() throws Exception {
		System.out.println("開始執行！");
		Thread.sleep(3000);
		System.out.println("執行結束！");
		
		return "[email protected]!";
	}
	
}

三、Lock鎖

作用類似synchronized，但是更靈活，通過lock(),unlock()兩個方法配合使用，保證執行緒安全。

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class LockDemo {
	public static void main(String[] args) throws InterruptedException {
		Lock lock = new ReentrantLock();
		
		Thread t1 = new Thread(new T1(lock));
		Thread t3 = new Thread(new T1(lock));
			t1.start();
			Thread.sleep(100);
			t3.start();
			t3.interrupt();
		
	}
}

class T1 implements Runnable {
	
	Lock lock = null;
	
	public T1(Lock lock) {
		this.lock = lock;
	}
	public void run() {
		
		try {
			//噹噹前執行執行緒被打斷時，當前執行緒會退出這個方法呼叫
			lock.lockInterruptibly();
			System.out.println("任務開始執行！");
			Thread.sleep(2000);
			System.out.println("任務執行結束！");
			
		} catch (Exception e) {
			System.out.println("執行緒被打斷");
		}finally {
			lock.unlock();
		}
		
	}
	
}

四、ReadWriteLock讀寫鎖

讀是可以併發處理的，但是讀和寫，或者多個寫是不可以併發處理的。

import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReadWriteLockDemo {
	
	public static String name = "lisi";
	public static void main(String[] args) {
		ReadWriteLock lock = new ReentrantReadWriteLock();
		//read可以併發
		new Thread(new TRead(lock)).start();
		new Thread(new TRead(lock)).start();
		new Thread(new TRead(lock)).start();
		//read+write 或者 多個write不能併發
		new Thread(new TWrite(lock)).start();
		new Thread(new TWrite(lock)).start();
		new Thread(new TRead(lock)).start();
		
	}
}

class TWrite implements Runnable {
	private ReadWriteLock lock = null;
	
	public TWrite(ReadWriteLock lock) {
		this.lock = lock;
	}
	
	public void run() {
		
		try {
			lock.writeLock().lock();
			System.out.println(Thread.currentThread().getId() + "  # 開始寫資料");
			Thread.sleep(2000);
			ReadWriteLockDemo.name ="wangwu";
			System.out.println(Thread.currentThread().getId() + "  # 資料寫入成功" + ReadWriteLockDemo.name);
			lock.writeLock().unlock();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		
	}
}

class TRead implements Runnable {
	private ReadWriteLock lock = null;
	
	public TRead(ReadWriteLock lock) {
		this.lock = lock;
	}
	
	public void run() {
		
		try {
			lock.readLock().lock();
			System.out.println(Thread.currentThread().getId() + "  # 開始讀資料");
			Thread.sleep(2000);
			ReadWriteLockDemo.name ="wangwu";
			System.out.println(Thread.currentThread().getId() + "  # 讀取到資料" + ReadWriteLockDemo.name);
			lock.readLock().unlock();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		
	}
}