在这篇文章中，我们将为您详细介绍JavaConcurrency/Threads的内容，并且讨论关于1——join详解的相关问题。此外，我们还会涉及一些关于hivejoin,outerjoin,semi

在这篇文章中，我们将为您详细介绍Java Concurrency/Threads的内容，并且讨论关于1——join详解的相关问题。此外，我们还会涉及一些关于hive join,outer join, semi join详解、Hive 中Join的专题---Join详解、Java 21 新特性：虚拟线程（Virtual Threads）、Java 8 Concurrency Tutorial--转的知识，以帮助您更全面地了解这个主题。

• Java Concurrency/Threads（1）——join详解（java thread.join）
• hive join,outer join, semi join详解
• Hive 中Join的专题---Join详解
• Java 21 新特性：虚拟线程（Virtual Threads）
• Java 8 Concurrency Tutorial--转

Java Concurrency/Threads（1）——join详解（java thread.join）

public final void join()；//此方法会把当前线程变为wait，直到执行join操作的线程结束，如果该线程在执行中被中断，则会抛出InterruptedException
public final synchronized void join(long milis); //此方法会把当前线程变为wait，直到执行join操作的线程结束或者在执行join后等待millis的时间。因为线程调度依赖于操作系统的实现，因为这并不能保证当前线程一定会在millis时间变为RUnnable。
public final synchronized void join(long milis,int nanos); //此方法会把当前线程变为wait，直到执行join操作的线程结束或者在join后等待millis+nanos的时间。

package com.guoqiang;

import static com.guoqiang.ThreadColor.*;


public class Main {

    public static void main(String[] args) {
        Thread t1 = new Thread(new MyRunnable(),"t1");
        Thread t2 = new Thread(new MyRunnable(),"t2");
        Thread t3 = new Thread(new MyRunnable(),"t3");

        t1.start();

        //start second thread after waiting for 2 seconds or if it's dead
        try {
            t1.join(2000);
        } catch (InterruptedException e) {
            e.printstacktrace();
        }

        t2.start();

        //start third thread only when first thread is dead
        try {
            t1.join();
        } catch (InterruptedException e) {
            e.printstacktrace();
        }

        t3.start();

        //let all threads finish execution before finishing main thread
        try {
            t1.join();
            t2.join();
            t3.join();
        } catch (InterruptedException e) {
            // Todo Auto-generated catch block
            e.printstacktrace();
        }

        System.out.println("All threads are dead,exiting main thread");
    }
}
class MyRunnable implements Runnable{

    @Override
    public void run() {
        System.out.println("Thread started:::"+Thread.currentThread().getName());
        try {
            Thread.sleep(4000);
        } catch (InterruptedException e) {
            e.printstacktrace();
        }
        System.out.println("Thread ended:::"+Thread.currentThread().getName());
    }
}

hive join,outer join, semi join详解

hive join,outer join, semi join详解

• join 最简单 两个表取交集
• left outer join是以左表驱动，右表不存在的key均赋值为null
• right outer join是以右表驱动，左表不存在的key均赋值为null

此外hive sql不支持 in函数 比如

• SELECT a.key, a.value

  FROM a

  WHERE a.key in (SELECT b.key FROM B);

这个可以用 left outer join替换

• SELECT a.key, a.value

  FROM a LEFT OUTER JOIN b ON (a.key = b.key)

  WHERE b.key <> NULL;

更高端的写法是  用 semi join

• SELECT a.key, a.value

  FROM a LEFT SEMI JOIN b on (a.key = b.key);

Hive 中Join的专题---Join详解

1.什么是等值连接？
2.hive转换多表join时，如果每个表在join字句中，使用的都是同一个列，该如何处理？
3.LEFT，RIGHT，FULL OUTER连接的作用是什么？
4.LEFT或RIGHT join是连接从左边还有右边？




Hive表连接的语法支持如下：
Sql代码  :

join_table:  
    table_reference JOIN table_factor [join_condition]  
  | table_reference {LEFT|RIGHT|FULL} [OUTER] JOIN table_reference join_condition  
  | table_reference LEFT SEMI JOIN table_reference join_condition  
  | table_reference CROSS JOIN table_reference [join_condition] (as of Hive 0.10)  
  
table_reference:  
    table_factor  
  | join_table  
  
table_factor:  
    tbl_name [alias]  
  | table_subquery alias  
  | ( table_references )  
  
join_condition:  
    ON equality_expression ( AND equality_expression )*

hive只支持等连接，外连接，左半连接。hive不支持非相等的join条件（通过其他方式实现，如left outer join），因为它很难在map/reducejob实现这样的条件。而且，hive可以join两个以上的表。


例子
写join查询时，有几个典型的点要考虑，如下：

等连接
只有等连接才允许
Sql代码  :

SELECT a.* FROM a JOIN b ON (a.id = b.id)  
SELECT a.* FROM a JOIN b ON (a.id = b.id AND a.department = b.department)

这两个是合法的连接
Sql代码  :

SELECT a.* FROM a JOIN b ON (a.id <> b.id)

这个是不允许的。

多表连接
同个查询，可以join两个以上的表
Sql代码  :

SELECT a.val, b.val, c.val FROM a JOIN b ON (a.key = b.key1) JOIN c ON (c.key = b.key2)

join的缓存和任务转换
hive转换多表join时，如果每个表在join字句中，使用的都是同一个列，只会转换为一个单独的map/reduce。
Sql代码  :

SELECT a.val, b.val, c.val FROM a JOIN b ON (a.key = b.key1) JOIN c ON (c.key = b.key1)

这个会转换为单独的map/reduce任务，只有b表的key1列在join被调用。
另一方面
Sql代码  :

SELECT a.val, b.val, c.val FROM a JOIN b ON (a.key = b.key1) JOIN c ON (c.key = b.key2)

被转换为两个map/reduce任务，因为b的key1列在第一个join条件使用，而b表的key2列在第二个join条件使用。第一个map/reduce任务join a和b。第二个任务是第一个任务的结果join c。
在join的每个map/reduce阶段，序列中的最后一个表，当其他被缓存时，它会流到reducers。所以，reducers需要缓存join关键字的特定值组成的行，通过组织最大的表出现在序列的最后，有助于减少reducers的内存。
Sql代码  :

SELECT a.val, b.val, c.val FROM a JOIN b ON (a.key = b.key1) JOIN c ON (c.key = b.key1)

三个表，在同一个独立的map/reduce任务做join。a和b的key对应的特定值组成的行，会缓存在reducers的内存。然后reducers接受c的每一行，和缓存的每一行做join计算。
类似
Sql代码  :

SELECT a.val, b.val, c.val FROM a JOIN b ON (a.key = b.key1) JOIN c ON (c.key = b.key2)

这里有两个map/reduce任务在join计算被调用。第一个是a和b做join，然后reducers缓存a的值，另一边，从流接收b的值。第二个阶段，reducers缓存第一个join的结果，另一边从流接收c的值。
在join的每个map/reduce阶段，通过关键字，可以指定哪个表从流接收。
Sql代码  :

SELECT /*+ STREAMTABLE(a) */ a.val, b.val, c.val FROM a JOIN b ON (a.key = b.key1) JOIN c ON (c.key = b.key1)

三个表的连接，会转换为一个map/reduce任务，reducer会把b和c的key的特定值缓存在内存里，然后从流接收a的每一行，和缓存的行做join。


join的结果
LEFT，RIGHT，FULL OUTER连接存在是为了提供ON语句在没有匹配时的更多控制。例如，这个查询：
Sql代码  :

SELECT a.val, b.val FROM a LEFT OUTER JOIN b ON (a.key=b.key)

将会返回a的每一行。如果b.key等于a.key,输出将是a.val,b.val,如果a没有和 b.key匹配，输出的行将是a.val,NULL。如果b的行没有和a.key匹配上，将被抛弃。语法"FROM a LEFT OUTER JOIN b"必须写在一行，为了理解它如何工作——这个查询，a是b的左边，a的所有行会被保持；RIGHT OUTER JOIN将保持b的所有行， FULLOUTER JOIN将会保存a和b的所有行。OUTER JOIN语义应该符合标准的SQL规范。


join的过滤
Joins发生在where字句前，所以，如果要限制join的输出，需要写在where字句，否则写在JOIN字句。现在讨论的一个混乱的大点，就是分区表
Sql代码  :

SELECT a.val, b.val FROM a LEFT OUTER JOIN b ON (a.key=b.key)  
WHERE a.ds=''2009-07-07'' AND b.ds=''2009-07-07''

将会连接a和b，产生a.val和b.val的列表。WHERE字句，也可以引用join的输出列，然后过滤他们。
但是，无论何时JOIN的行找到a的key，但是找不到b的key时，b的所有列会置成NULL，包括ds列。这就是说，将过滤join输出的所有行，包括没有合法的b.key的行。然后你会在LEFT OUTER的要求扑空。
也就是说，如果你在WHERE字句引用b的任何列，LEFTOUTER的部分join结果是不相关的。所以，当外连接时，使用这个语句
Sql代码  : 

SELECT a.val, b.val FROM a LEFT OUTER JOIN b ON (a.key=b.key AND b.ds=''2009-07-07'' AND a.ds=''2009-07-07''

join的输出会预先过滤，然后你不用对有a.key而没有b.key的行做过滤。RIGHT和FULL join也是一样的逻辑。


join的顺序
join是不可替换的，连接是从左到右，不管是LEFT或RIGHT join。
Sql代码  : 

SELECT a.val1, a.val2, b.val, c.val  
FROM a  
JOIN b ON (a.key = b.key)  
LEFT OUTER JOIN c ON (a.key = c.key)

首先，连接a和b，扔掉a和b中没有匹配的key的行。结果表再连接c。这提供了直观的结果，如果有一个键 都存在于A和C，但不是B：完整行(包括 a.val1,a.val2,a.key)会在"a jOINb"步骤，被丢弃，因为它不在b中。结果没有a.key，所以当它和c做LEFT OUTER JOIN,c.val也无法做到，因为没有c.key匹配a.key(因为a的行都被移除了)。类似的，RIGHTOUTER JOIN(替换为LEFT),我们最终会更怪的效果,NULL, NULL, NULL, c.val。因为尽管指定了join key是a.key=c.key，我们已经在第一个JOIN丢弃了不匹配的a的所有行。
为了达到更直观的效果，相反，我们应该从
Sql代码  : 

FROM c LEFT OUTER JOIN a ON (c.key = a.key) LEFT OUTER JOIN b ON (c.key = b.key).

LEFT SEMI JOIN实现了相关的IN / EXISTS的子查询语义的有效途径。由于Hive目前不支持IN / EXISTS的子查询，所以你可以用 LEFT SEMI JOIN 重写你的子查询语句。LEFT SEMIJOIN 的限制是， JOIN 子句中右边的表只能在 ON 子句中设置过滤条件，在 WHERE 子句、SELECT 子句或其他地方过滤都不行。
Sql代码  : 

SELECT a.key, a.value FROM a WHERE a.key in (SELECT b.key FROM B);

可以重写为
Sql代码  : 

SELECT a.key, a.val FROM a LEFT SEMI JOIN b on (a.key = b.key)

mapjoin
但如果所有被连接的表是小表，join可以被转换为只有一个map任务。查询是

SELECT /*+ MAPJOIN(b) */ a.key, a.value
FROM a join b ona.key = b.key

不需要reducer。对于每一个mapper,A和B已经被完全读出。限制是a FULL/RIGHTOUTER JOIN b不能使用。
如果表在join的列已经分桶了，其中一张表的桶的数量，是另一个表的桶的数量的整倍，那么两者可以做桶的连接。如果A有4个桶，表B有4个桶，下面的连接：
Sql代码  : 

SELECT /*+ MAPJOIN(b) */ a.key, a.value FROM a join b on a.key = b.key

只能在mapper工作。为了为A的每个mapper完整抽取B。对于上面的查询，mapper处理A的桶1，只会抽取B的桶1，这不是默认行为，要使用以下参数：
Sql代码  : 

set hive.optimize.bucketmapjoin = true;

如果表在join的列经过排序，分桶，而且他们有相同数量的桶，可以使用排序-合并 join。每个mapper，相关的桶会做连接。如果A和B有4个桶，
Sql代码  : 

SELECT /*+ MAPJOIN(b) */ a.key, a.value FROM A a join B b on a.key = b.key

只能在mapper使用。使用A的桶的mapper，也会遍历B相关的桶。这个不是默认行为，需要配置以下参数：
Sql代码  : 

set hive.input.format=org.apache.hadoop.hive.ql.io.BucketizedHiveInputFormat;  
set hive.optimize.bucketmapjoin = true;  

set hive.optimize.bucketmapjoin.sortedmerge = true;

Java 21 新特性：虚拟线程（Virtual Threads）

在 Java 21 中，引入了虚拟线程（Virtual Threads）来简化和增强并发性，这使得在 Java 中编程并发程序更容易、更高效。

虚拟线程，也称为 “用户模式线程（user-mode threads）” 或 “纤程（fibers）”。该功能旨在简化并发编程并提供更好的可扩展性。虚拟线程是轻量级的，这意味着它们可以比传统线程创建更多数量，并且开销要少得多。这使得在自己的线程中运行单独任务或请求变得更加实用，即使在高吞吐量的程序中也是如此。

创建和使用虚拟线程

在 Java 21 中创建和使用虚拟线程有多种方法：

1. 使用静态构建器方法

Thread.startVirtualThread 方法将可运行对象作为参数来创建，并立即启动虚拟线程，具体如下代码：

Runnable runnable = () -> {
    System.out.println("Hello, www.didispace.com");
};

// 使用静态构建器方法
Thread virtualThread = Thread.startVirtualThread(runnable);

也可以使用 Thread.ofVirtual() 来创建，这里还可以设置一些属性，比如：线程名称。具体如下代码：

Thread.ofVirtual()
        .name("didispace-virtual-thread")
        .start(runnable);

2. 与 ExecutorService 结合使用

从 Java 5 开始，就推荐开发人员使用 ExecutorServices 而不是直接使用 Thread 类了。现在，Java 21 中引入了使用虚拟线程，所以也有了新的 ExecutorService 来适配，看看下面的例子：

Runnable runnable = () -> {
    System.out.println("Hello, www.didispace.com");
};

try (ExecutorService executorService = Executors.newVirtualThreadPerTaskExecutor()) {
    for (int i = 0; i < 100; i++) {
        executorService.submit(runnable);
    }
}

上述代码在 try 代码块中创建了一个 ExecutorServices，用来为每个提交的任务创建虚拟线程。

3. 使用虚拟线程工厂

开发者还可以创建一个生成虚拟线程的工厂来管理，具体看下面的例子例子：

Runnable runnable = () -> {
    System.out.println("Hello, www.didispace.com");
};

ThreadFactory virtualThreadFactory = Thread.ofVirtual()
        .name("didispace", 0)
        .factory();

Thread factoryThread = virtualThreadFactory.newThread(runnable);
factoryThread.start;

这段代码创建了一个虚拟线程工厂，每个虚拟线程都会以 didispace 为前缀、以数字结尾（从 0 开始累加）的名称。

小结

上面我们介绍了虚拟线程的创建和使用，而我们大多数 Java 开发者都基于 Spring 来开发具体业务应用，所以很多场景下可能都不太涉及手工创建的操作。所以，对于虚拟线程的概念，你只需要有一个基本的认识。所以，在文章的最后，做一个小结，以方便大家理解和记忆：

• 虚拟线程是由 JVM 管理的轻量级线程。
• 虚拟线程不需要任何显式分配或调度。
• 虚拟线程非常适合 I/O 密集型任务或需要大量并行性的任务。
• 虚拟线程也可以用来实现异步操作。

另外，值得注意的是，虽然虚拟线程可以在并发性和可扩展性方面提供显着的帮助，但它们并不总是适合所有场景。有些需要大量计算的任务，并不一定在虚拟线程中运行更好，因为虚拟线程也有上下文切换的开。具体情况还是需要通过测试评测，以找到最优解。

如果您学习过程中如遇困难？可以加入我们超高质量的技术交流群，参与交流与讨论，更好的学习与进步！另外，不要走开，关注我！持续更新 Java 新特性专栏！

参考资料

• Java 21：JEP444-Virtual-Threads
• Spring Boot 虚拟线程与 Webflux 在 JWT 验证和 MySQL 查询上的性能比较

欢迎关注我的公众号：程序猿 DD。第一时间了解前沿行业消息、分享深度技术干货、获取优质学习资源

Java 8 Concurrency Tutorial--转

<h1>Threads and Executors

Welcome to the first part of my Java 8 Concurrency tutorial. This guide teaches you  in Java 8 with easily understood code examples. It's the first part out of a series of tutorials covering the Java Concurrency API. In the next 15 min you learn how to execute code in parallel via threads,tasks and executor services.

• Part 1: Threads and Executors
• Part 2: 
• Part 3: 

The  was first introduced with the release of Java 5 and then progressively enhanced with every new Java release. The majority of concepts shown in this article also work in older versions of Java. However my code samples focus on Java 8 and make heavy use of lambda expressions and other new features. If you're not yet familiar with lambdas I recommend reading my  first.

All modern operating systems support concurrency both via  and . Processes are instances of programs which typically run independent to each other,e.g. if you start a java program the operating system spawns a new process which runs in parallel to other programs. Inside those processes we can utilize threads to execute code concurrently,so we can make the most out of the available cores of the CPU.

Java supports  since JDK 1.0. Before starting a new thread you have to specify the code to be executed by this thread,often called the task. This is done by implementing Runnable - a functional interface defining a single void no-args method run() as demonstrated in the following example: