java并发编程--线程池初步 - Chinaunix

1.public class ExecutorsDemo {
2.
3. public static void main(String[] args) throws Exception {
4. System.out.println("----------------FixedThreadPool---------------------");
5. ExecutorService fixedPool = getFixedThreadPool();
6. executeThread(fixedPool);
7.
8. // 为了避免混淆, 需要等待executeThread(fixedPool)执行完成
9. Thread.sleep(3000);
10.
11. System.out.println("----------------CashedThreadPool---------------------");
12. ExecutorService cashedPool = getCashedThreadPool();
13. executeThread(cashedPool);
14.
15. // 为了避免混淆, 需要等待executeThread(cashedPool)执行完成
16. Thread.sleep(3000);
17.
18. System.out.println("----------------SingleThreadExecutor---------------------");
19. ExecutorService singleExecutor = getSingleThreadExecutor();
20. executeThread(singleExecutor);
21.
22. }
23.
24. // 只存在一个线程的线程池
25. private static ExecutorService getSingleThreadExecutor() {
26. return Executors.newSingleThreadExecutor();
27. }
28.
29. // 创建一个根据需要自动调整大小的线程池
30. private static ExecutorService getCashedThreadPool() {
31. return Executors.newCachedThreadPool();
32. }
33.
34. // 创建一个可重用的固定线程数的线程池
35. private static ExecutorService getFixedThreadPool() {
36. return Executors.newFixedThreadPool(2);
37. }
38.
39. private static void executeThread(ExecutorService pool) {
40. Thread t1 = new MyThread();
41. Thread t2 = new MyThread();
42. Thread t3 = new MyThread();
43. Thread t4 = new MyThread();
44. // 将Tread放入线程池中执行
45. // MyThread类继承自Thread, 而Thread类实现了Runnable接口
46. pool.execute(t1);
47. pool.execute(t2);
48. pool.execute(t3);
49. pool.execute(t4);
50. // 关闭线程池
51. pool.shutdown();
52. }
53.
54. private static final class MyThread extends Thread {
55. @Override
56. public void run() {
57. super.run();
58. System.out.println(Thread.currentThread().getName() + ": is running!");
59. }
60. }
61.}
public class ExecutorsDemo {
public static void main(String[] args) throws Exception {
System.out.println("----------------FixedThreadPool---------------------");
ExecutorService fixedPool = getFixedThreadPool();
executeThread(fixedPool);
// 为了避免混淆, 需要等待executeThread(fixedPool)执行完成
Thread.sleep(3000);
System.out.println("----------------CashedThreadPool---------------------");
ExecutorService cashedPool = getCashedThreadPool();
executeThread(cashedPool);
// 为了避免混淆, 需要等待executeThread(cashedPool)执行完成
Thread.sleep(3000);
System.out.println("----------------SingleThreadExecutor---------------------");
ExecutorService singleExecutor = getSingleThreadExecutor();
executeThread(singleExecutor);
}
// 只存在一个线程的线程池
private static ExecutorService getSingleThreadExecutor() {
return Executors.newSingleThreadExecutor();
}
// 创建一个根据需要自动调整大小的线程池
private static ExecutorService getCashedThreadPool() {
return Executors.newCachedThreadPool();
}
// 创建一个可重用的固定线程数的线程池
private static ExecutorService getFixedThreadPool() {
return Executors.newFixedThreadPool(2);
}
private static void executeThread(ExecutorService pool) {
Thread t1 = new MyThread();
Thread t2 = new MyThread();
Thread t3 = new MyThread();
Thread t4 = new MyThread();
// 将Tread放入线程池中执行
// MyThread类继承自Thread, 而Thread类实现了Runnable接口
pool.execute(t1);
pool.execute(t2);
pool.execute(t3);
pool.execute(t4);
// 关闭线程池
pool.shutdown();
}
private static final class MyThread extends Thread {
@Override
public void run() {
super.run();
System.out.println(Thread.currentThread().getName() + ": is running!");
}
}
}

复制代码

----------------FixedThreadPool---------------------
pool-1-thread-1: is running!
pool-1-thread-2: is running!
pool-1-thread-2: is running!
pool-1-thread-1: is running!
----------------CashedThreadPool---------------------
pool-2-thread-1: is running!
pool-2-thread-2: is running!
pool-2-thread-4: is running!
pool-2-thread-3: is running!
----------------SingleThreadExecutor---------------------
pool-3-thread-1: is running!
pool-3-thread-1: is running!
pool-3-thread-1: is running!
pool-3-thread-1: is running!

复制代码

1.public class FutureDemo {
2. public static void main(String[] args) throws Exception {
3. ExecutorService pool = Executors.newFixedThreadPool(2);
4.
5. Future<Integer> intFuture = pool.submit(new IntegerCallable());
6. // get()方法将阻塞主线程, 直到IntegerCallable线程的call()运行结束并返回结果时为止.
7. Integer returnInt = intFuture.get();
8. System.out.println("返回值为" + returnInt);
9.
10. Future<Boolean> boolFuture = pool.submit(new BooleanCallable());
11. Boolean returnBool = boolFuture.get();
12. System.out.println("返回值为" + returnBool);
13.
14. pool.shutdown();
15. }
16.
17. private final static class IntegerCallable implements Callable<Integer> {
18. // call()方法的返回值类型由泛型决定
19. @Override
20. public Integer call() throws Exception {
21. return 2;
22. }
23. }
24.
25. private final static class BooleanCallable implements Callable<Boolean> {
26. @Override
27. public Boolean call() throws Exception {
28. return true;
29. }
30. }
31.}
public class FutureDemo {
public static void main(String[] args) throws Exception {
ExecutorService pool = Executors.newFixedThreadPool(2);
Future<Integer> intFuture = pool.submit(new IntegerCallable());
// get()方法将阻塞主线程, 直到IntegerCallable线程的call()运行结束并返回结果时为止.
Integer returnInt = intFuture.get();
System.out.println("返回值为" + returnInt);
Future<Boolean> boolFuture = pool.submit(new BooleanCallable());
Boolean returnBool = boolFuture.get();
System.out.println("返回值为" + returnBool);
pool.shutdown();
}
private final static class IntegerCallable implements Callable<Integer> {
// call()方法的返回值类型由泛型决定
@Override
public Integer call() throws Exception {
return 2;
}
}
private final static class BooleanCallable implements Callable<Boolean> {
@Override
public Boolean call() throws Exception {
return true;
}
}
}

复制代码