1、FutureTask
1 package com.ietree.basicskill.mutilthread.OtherClass;
2
3 import java.util.concurrent.*;
4
5 /**
6 * Created by Administrator on 2017/5/17.
7 */
8 public class UseFuture implements Callable<String> {
9
10 private String para;
11
12 public UseFuture(String para){
13 this.para = para;
14 }
15
16 /**
17 * 这里是真实的业务逻辑，其执行可能很慢
18 */
19 @Override
20 public String call() throws Exception {
21 //模拟执行耗时
22 Thread.sleep(5000);
23 String result = this.para + "处理完成";
24 return result;
25 }
26
27 //主控制函数
28 public static void main(String[] args) throws Exception {
29 String queryStr = "query";
30 //构造FutureTask，并且传入需要真正进行业务逻辑处理的类,该类一定是实现了Callable接口的类
31 FutureTask<String> future = new FutureTask<String>(new UseFuture(queryStr));
32
33 FutureTask<String> future2 = new FutureTask<String>(new UseFuture(queryStr));
34 //创建一个固定线程的线程池且线程数为1,
35 ExecutorService executor = Executors.newFixedThreadPool(2);
36 //这里提交任务future,则开启线程执行RealData的call()方法执行
37 //submit和execute的区别： 第一点是submit可以传入实现Callable接口的实例对象， 第二点是submit方法有返回值
38
39 Future f1 = executor.submit(future); //单独启动一个线程去执行的
40 Future f2 = executor.submit(future2);
41 System.out.println("请求完毕");
42
43 try {
44 //这里可以做额外的数据操作，也就是主程序执行其他业务逻辑
45 System.out.println("处理实际的业务逻辑...");
46 Thread.sleep(1000);
47 } catch (Exception e) {
48 e.printStackTrace();
49 }
50 //调用获取数据方法,如果call()方法没有执行完成,则依然会进行等待
51 System.out.println("数据：" + future.get());
52 System.out.println("数据：" + future2.get());
53
54 executor.shutdown();
55 }
56
57
58 }
2、CyclicBarrier
1 package com.ietree.basicskill.mutilthread.OtherClass;
2
3 import java.io.IOException;
4 import java.util.Random;
5 import java.util.concurrent.BrokenBarrierException;
6 import java.util.concurrent.CyclicBarrier;
7 import java.util.concurrent.ExecutorService;
8 import java.util.concurrent.Executors;
9
10 /**
11 * Created by Administrator on 2017/5/17.
12 */
13 public class UseCyclicBarrier {
14
15 static class Runner implements Runnable {
16 private CyclicBarrier barrier;
17 private String name;
18
19 public Runner(CyclicBarrier barrier, String name) {
20 this.barrier = barrier;
21 this.name = name;
22 }
23 @Override
24 public void run() {
25 try {
26 Thread.sleep(1000 * (new Random()).nextInt(5));
27 System.out.println(name + " 准备OK.");
28 barrier.await();
29 } catch (InterruptedException e) {
30 e.printStackTrace();
31 } catch (BrokenBarrierException e) {
32 e.printStackTrace();
33 }
34 System.out.println(name + " Go!!");
35 }
36 }
37
38 public static void main(String[] args) throws IOException, InterruptedException {
39 CyclicBarrier barrier = new CyclicBarrier(3); // 3
40 ExecutorService executor = Executors.newFixedThreadPool(3);
41
42 executor.submit(new Thread(new Runner(barrier, "zhangsan")));
43 executor.submit(new Thread(new Runner(barrier, "lisi")));
44 executor.submit(new Thread(new Runner(barrier, "wangwu")));
45
46 executor.shutdown();
47 }
48
49 }
3、CountDownLatch
1 package com.ietree.basicskill.mutilthread.OtherClass;
2
3 import java.util.concurrent.CountDownLatch;
4
5 /**
6 * Created by Administrator on 2017/5/17.
7 */
8 public class UseCountDownLatch {
9
10 public static void main(String[] args) {
11
12 final CountDownLatch countDown = new CountDownLatch(2);
13
14 Thread t1 = new Thread(new Runnable() {
15 @Override
16 public void run() {
17 try {
18 System.out.println("进入线程t1" + "等待其他线程处理完成...");
19 countDown.await();
20 System.out.println("t1线程继续执行...");
21 } catch (InterruptedException e) {
22 e.printStackTrace();
23 }
24 }
25 },"t1");
26
27 Thread t2 = new Thread(new Runnable() {
28 @Override
29 public void run() {
30 try {
31 System.out.println("t2线程进行初始化操作...");
32 Thread.sleep(3000);
33 System.out.println("t2线程初始化完毕，通知t1线程继续...");
34 countDown.countDown();
35 } catch (InterruptedException e) {
36 e.printStackTrace();
37 }
38 }
39 });
40 Thread t3 = new Thread(new Runnable() {
41 @Override
42 public void run() {
43 try {
44 System.out.println("t3线程进行初始化操作...");
45 Thread.sleep(4000);
46 System.out.println("t3线程初始化完毕，通知t1线程继续...");
47 countDown.countDown();
48 } catch (InterruptedException e) {
49 e.printStackTrace();
50 }
51 }
52 });
53
54 t1.start();
55 t2.start();
56 t3.start();
57 }
58 }
4、Semaphore
1 package com.ietree.basicskill.mutilthread.OtherClass;
2
3 import java.util.concurrent.ExecutorService;
4 import java.util.concurrent.Executors;
5 import java.util.concurrent.Semaphore;
6
7 /**
8 * Created by Administrator on 2017/5/17.
9 */
10 public class UseSemaphore {
11
12 public static void main(String[] args) {
13 // 线程池
14 ExecutorService exec = Executors.newCachedThreadPool();
15 // 只能5个线程同时访问
16 final Semaphore semp = new Semaphore(5);
17 // 模拟20个客户端访问
18 for (int index = 0; index < 20; index++) {
19 final int NO = index;
20 Runnable run = new Runnable() {
21 public void run() {
22 try {
23 // 获取许可
24 semp.acquire();
25 System.out.println("Accessing: " + NO);
26 //模拟实际业务逻辑
27 Thread.sleep((long) (Math.random() * 10000));
28 // 访问完后，释放
29 semp.release();
30 } catch (InterruptedException e) {
31 }
32 }
33 };
34 exec.execute(run);
35 }
36
37 try {
38 Thread.sleep(10);
39 } catch (InterruptedException e) {
40 e.printStackTrace();
41 }
42 //System.out.println(semp.getQueueLength());
43 // 退出线程池
44 exec.shutdown();
45 }
46 }
时间： 2024-08-07 17:22:27