java.util.concurrent.atomic 包含了不用加鎖情況下就能改變值的原子變量。
java.util.concurrent.locks 包包含鎖定的工具
Executor 是 java5 下的一個多任務併發執行框架(Doug
Lea),可以建立一個類似數據庫連接池的線程池來執行任務。這個框架主要由三個接口和其相應的具體類組成。Executor、
ExecutorService 和 ScheduledExecutorService 。
1
、 Executor 接口：是用來執行 Runnable 任務的；它只定義一個方法- execute(Runnable command)；執行 Ruannable 類型的任務。
2
、 ExecutorService 接口： 繼承Executor接口，提供了執行Callable任務和中止任務執行的服務。
3
、 ScheduledExecutorService 接口：繼承 ExecutorService 接口，提供了按排程執行任務的服務。
4
、 Executors 類：爲了方便使用, 建議使用 Executors的工具類來得到 Executor 接口的具體對象。
Executors 類有幾個重要的方法，在這裏簡明一下：
1
、 callable(Runnable task)： 將 Runnable 的任務轉化成 Callable 的任務
2
、 newSingleThreadExecutor()： 產生一個 ExecutorService 對象，這個對象只有一個線程可用來執行任務，若任務多於一個，任務將按先後順序執行。
3
、 newCachedThreadPool()： 產生一個 ExecutorService 對象，這個對象帶有一個線程池，線程池的大小會根據需要調整，線程執行完任務後返回線程池，供執行下一次任務使用。
4
、 newFixedThreadPool(int poolSize)： 產生一個 ExecutorService 對象，這個對象帶有一個大小爲 poolSize 的線程池，若任務數量大於 poolSize ，任務會被放在一個 queue 裏順序執行。
5
、 newSingleThreadScheduledExecutor()： 產生一個 ScheduledExecutorService 對象，這個對象的線程池大小爲 1 ，若任務多於一個，任務將按先後順序執行。
6
、 newScheduledThreadPool(int poolSize)： 產生一個 ScheduledExecutorService 對象，這個對象的線程池大小爲 poolSize ，若任務數量大於 poolSize ，任務會在一個 queue 裏等待執行 。
有關Executor框架其它類的說明請參看JAVA 5 的 API文檔
下面是幾個簡單的例子，用以示例Executors中幾個主要方法的使用。
1、 Task.java 任務
2、 SingleThreadExecutorTest.java 單線程執行程序的測試
3、 CachedThreadPoolTest.java 線程池線程執行程序的測試
4、 FixedThreadPoolTest.java 線程池線程執行程序的測試(線程數固定)
5、 DaemonThreadFactory.java 守護線程生成工廠
6、 MaxPriorityThreadFactory.java 大優先級線程生成工廠
7、 MinPriorityThreadFactory.java 小優先級線程生成工廠
8、 ThreadFactoryExecutorTest.java 在自定義線程生成工廠下的測試
=============== 1、 Task.java
package Executor;
//可執行任務
public class Task implements Runnable {
// 中斷信號
volatile boolean stop = false;
// 該任務執行的次數
private int runCount = 0;
// 任務標識
private int taskId;
public Task(int taskId) {
this.taskId = taskId;
System.out.println("Create Task-" + taskId);
}
// 執行任務
public void run() {
while (!stop) {
try {
Thread.sleep(10);
} catch (InterruptedException e) {
System.out.println("Task interrupted...");
}
// 線程運行3次後,中斷信號置爲true
if (++runCount == 3)
stop = true;
// 輸出一些語句
System.out.println("" + Thread.currentThread().toString() + "/t/t/t/t execute Task-" + taskId + "'s " + runCount
+ "th run. ");
}
}
}
=============== 1 end
=============== 2、 SingleThreadExecutorTest.java
package Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class SingleThreadExecutorTest {
public static void main(String[] args) {
try {
// 創建一個單線程執行程序
ExecutorService executorService = Executors.newSingleThreadExecutor();
for (int i =1; i <= 3; i++) {
executorService.execute(new Task(i));
}
executorService.shutdown();
} catch (Exception e) {}
}
}
=============== 2 end
=============== 3、 CachedThreadPoolTest.java
package Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class CachedThreadPoolTest {
public static void main(String[] args) {
try {
// 建新線程的線程池，如果之前構造的線程可用則重用它們
ExecutorService executorService = Executors.newCachedThreadPool();
for (int i =1; i <= 4; i++) {
executorService.execute(new Task(i));
}
executorService.shutdown();
} catch (Exception e) {}
}
}
=============== 3 end
=============== 4、 FixedThreadPoolTest.java
package Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class FixedThreadPoolTest {
public static void main(String[] args) {
try {
// 創建固定線程數的線程池，以共享的無界隊列方式來運行這些線程
ExecutorService executorService = Executors.newFixedThreadPool(2);
for (int i =1; i <= 5; i++) {
executorService.execute(new Task(i));
}
executorService.shutdown();
} catch (Exception e) {}
}
}
=============== 4 end
=============== 5、 DaemonThreadFactory.java
package Executor;
import java.util.concurrent.ThreadFactory;
public class DaemonThreadFactory implements ThreadFactory {
//創建一個守護線程
public Thread newThread(Runnable r) {
Thread t = new Thread(r);
t.setDaemon(true);
return t;
}
}
=============== 5 end
=============== 6、 MaxPriorityThreadFactory.java
package Executor;
import java.util.concurrent.ThreadFactory;
public class MaxPriorityThreadFactory implements ThreadFactory {
//創建一個最大優先級的線程
public Thread newThread(Runnable r) {
Thread t = new Thread(r);
//優先級最大、意思是切換到這個線程的概率比其它的低一些
t.setPriority(Thread.MAX_PRIORITY);
return t;
}
}
=============== 6 end
=============== 7、 MinPriorityThreadFactory.java
package Executor;
import java.util.concurrent.ThreadFactory;
public class MinPriorityThreadFactory implements ThreadFactory {
//創建一個最小優先級的線程
public Thread newThread(Runnable r) {
Thread t = new Thread(r);
//優先級最小、意思是切換到這個線程的概率比其它的低一些
t.setPriority(Thread.MIN_PRIORITY);
return t;
}
}
=============== 7 end
=============== 8、 ThreadFactoryExecutorTest.java
package Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadFactoryExecutorTest {
public static void main(String[] args) {
try {
// 創建一個單線程執行程序
ExecutorService defaultExecutor = Executors.newCachedThreadPool();
ExecutorService daemonExec = Executors
.newCachedThreadPool(new DaemonThreadFactory());
ExecutorService maxPriorityExecutor = Executors
.newCachedThreadPool(new MaxPriorityThreadFactory());
ExecutorService minPriorityExecutor = Executors
.newCachedThreadPool(new MinPriorityThreadFactory());
//用守護線程執行任務
for (int i = 1; i < 10; i++){
daemonExec.execute(new Task(i));
}
//用其它線程執行任務
for (int j = 10; j <= 20; j++){
if (j == 10)
maxPriorityExecutor.execute(new Task(j));
else if (j == 11)
minPriorityExecutor.execute(new Task(j));
else
defaultExecutor.execute(new Task(j));
}
} catch (Exception e) {}
}
}
=============== 8 end