线程方法 join

你的名字 2024-03-16 10:54 30阅读 0赞

### 线程加入：join方法 ###

<table> 
 <thead> 
  <tr> 
   <th align="left">与sleep一样它也是一个可中断的方法，也就是说，如果有其他线程执行了对当前线程的interrupt操作，它也会捕获到中断信号，并且擦除线程的interrupt标识</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left"></td> 
  </tr> 
  <tr> 
   <td align="left">Thread的API为我们提供了三个不同的join方法，具体如下。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>·public final void join（）throws InterruptedException</code></td> 
  </tr> 
  <tr> 
   <td align="left"><code>·public final synchronized void join（long millis，int nanos）throws InterruptedException</code></td> 
  </tr> 
  <tr> 
   <td align="left"><code>·public final synchronized void join（long millis）</code></td> 
  </tr> 
  <tr> 
   <td align="left"></td> 
  </tr> 
  <tr> 
   <td align="left">join某个线程A，会使当前线程B进入等待，直到线程A结束生命周期，或者到达给定的时间，那么在此期间B线程是处于BLOCKED的</td> 
  </tr> 
 </tbody> 
</table>

public class ThreadJoin {
        
        public static void main(String[] args) throws InterruptedException {
        
            //① 定义两个线程，并保存在threads中
            List<Thread> threads = IntStream.range(1, 3).mapToObj(ThreadJoin::create).toList();
            //② 启动这两个线程
            threads.forEach(Thread::start);
    
            //③ 执行这两个线程的join方法
            for (Thread thread : threads) {
        
                thread.join();
            }
    
            //④ main线程循环输出
            for (int i = 0; i < 10; i++) {
        
                System.out.println(Thread.currentThread().getName() + "#" + i);
                shortSleep();
            }
        }
    
        //构造一个简单的线程，每个线程只是简单的循环输出
        private static Thread create(int seq) {
        
            return new Thread(() -> {
        
                for (int i = 0; i < 10; i++) {
        
                    System.out.println(Thread.currentThread().getName() + "#" + i);
                    shortSleep();
                }
            }, String.valueOf(seq));
        }
    
        private static void shortSleep() {
        
            try {
        
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
        
                e.printStackTrace();
            }
        }
    }

1#0
    2#0
    2#1
    1#1
    1#2
    2#2
    2#3
    1#3
    2#4
    1#4
    2#5
    1#5
    2#6
    1#6
    2#7
    1#7
    2#8
    1#8
    2#9
    1#9
    main#0
    main#1
    main#2
    main#3
    main#4
    main#5
    main#6
    main#7
    main#8
    main#9

### join方法结合实战 ###

<table> 
 <thead> 
  <tr> 
   <th align="left">典型的串行任务局部并行化处理</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left"><strong>实际案例：多任务并发获取航班信息</strong></td> 
  </tr> 
  <tr> 
   <td align="left">假设你有一个APP，主要用于查询航班信息，你的APP是没有这些实时数据的，当用户发起查询请求时，你需要到各大航空公司的接口获取信息，最后统一整理加工返回到APP客户端。当然JDK自带了很多高级工具，比如CountDownLatch和CyclicBarrier等都可以完成类似的功能，但是仅就我们目前所学的知识，使用join方法即可完成下面的功能。</td> 
  </tr> 
  <tr> 
   <td align="left"></td> 
  </tr> 
  <tr> 
   <td align="left">该例子是典型的串行任务局部并行化处理，用户在APP客户端输入出发地“北京”和目的地“上海”，服务器接收到这个请求之后，先来验证用户的信息，然后到各大航空公司的接口查询信息，最后经过整理加工返回给客户端，每一个航空公司的接口不会都一样，获取的数据格式也不一样，查询的速度也存在着差异，如果再跟航空公司进行串行化交互（逐个地查询），很明显客户端需要等待很长的时间，这样的话，用户体验就会非常差。如果我们将每一个航空公司的查询都交给一个线程去工作，然后在它们结束工作之后统一对数据进行整理，这样就可以极大地节约时间，从而提高用户体验效果。</td> 
  </tr> 
 </tbody> 
</table>

// 查询接口FightQuery
    public interface FightQuery {
        
        List<String> get();
    }

// 查询Fight的task，其实就是一个线程的子类，主要用于到各大航空公司获取数据
    public class FightQueryTask extends Thread implements FightQuery {
        
        private final String origin;
        private final String destination;
        private final List<String> flightList = new ArrayList<>();
    
        public FightQueryTask(String airline, String origin, String destination) {
        
            super("[" + airline + "]");
            this.origin = origin;
            this.destination = destination;
        }
    
        @Override
        public void run() {
        
            System.out.printf("%s-query from %s to %s \n", getName(), origin, destination);
            int randomVal = ThreadLocalRandom.current().nextInt(10);
            try {
        
                TimeUnit.SECONDS.sleep(randomVal);
                this.flightList.add(getName() + "-" + randomVal);
                System.out.printf("The Fight：%s list query successful\n", getName());
            } catch (InterruptedException e) {
        
            }
        }
    
        @Override
        public List<String> get() {
        
            return this.flightList;
        }
    }

// 实现一下从SH（上海）到北京（BJ）的航班查询
    public class FightQueryExample {
        
        //①合作的各大航空公司
        private static List<String> fightCompany = Arrays.asList("CSA", "CEA", "HNA");
    
        public static void main(String[] args) {
        
            List<String> results = search("SH", "BJ");
            System.out.println("===========result===========");
            results.forEach(System.out::println);
        }
    
        private static List<String> search(String original, String dest) {
        
            final List<String> result = new ArrayList<>();
            
            //②创建查询航班信息的线程列表
            List<FightQueryTask> tasks = fightCompany.stream().map(f -> createSearchTask(f, original, dest)).toList();
            //③分别启动这几个线程
            tasks.forEach(Thread::start);
    
            //④分别调用每一个线程的join方法，阻塞当前线程
            tasks.forEach(t -> {
        
                try {
        
                    t.join();
                } catch (InterruptedException e) {
        
                }
            });
    
            //⑤在此之前，当前线程会阻塞住，获取每一个查询线程的结果，并且加入到result中
            tasks.stream().map(FightQuery::get).forEach(result::addAll);
    
            return result;
        }
    
        private static FightQueryTask createSearchTask(String fight, String original, String dest) {
        
            return new FightQueryTask(fight, original, dest);
        }
    }

[CSA]-query from SH to BJ 
    [HNA]-query from SH to BJ 
    [CEA]-query from SH to BJ 
    The Fight：[CSA] list query successful
    The Fight：[CEA] list query successful
    The Fight：[HNA] list query successful
    ===========result===========
    [CSA]-8
    [CEA]-9
    [HNA]-9

\-----------------------------------------------------------------------------读书笔记摘自书名：Java高并发编程详解：多线程与架构设计 作者：汪文君

### [多线程 如何设置2个线程执行顺序][_2] ###

### [多线程 一个关于Join和synchronized的小例子][_Join_synchronized] ###

[_2]: https://blog.csdn.net/weixin_37646636/article/details/130815313
[_Join_synchronized]: https://blog.csdn.net/weixin_37646636/article/details/130816789