liam8 / gitalk-data

gitalk-data

gitalk-data's Issues

[leetcode] 141. 环形链表 | Liam's Blog

https://liam-blog.ml/2019/02/05/leetcode-141/

QES给定一个链表，判断链表中是否有环。

Hive添加自定义UDF函数 | Liam's Blog

https://liam-blog.ml/2016/04/11/add-udf-to-hive/

1 编写UDF类以简单的处理单个字段的UDF函数为例,开发自定义UDF函数需要继承’org.apache.hadoop.hive.ql.exec.UDF’类.可以通过Maven添加,pom文件中加入(版本号跟Hive版本一致即可):<dependency> <groupId>org.apache.hive</groupId> <artifactId&g

一条通往服务器所有端口的隧道 | Liam's Blog

https://liam-blog.ml/2017/06/13/ssh-tunnel-with-windows/

应用场景通常为了安全,服务器需要通过跳板机访问，服务器对外网暴露的端口也严格限制。这种情况下若要在本地访问服务器上的服务或系统就会比较蛋疼。有一个简单的解决方案，就是在本地和跳板机之间建立SSH隧道。SSH隧道提供了一个网络代理服务，通过该代理服务可以直接访问跳板机所在的局域网，即服务器上的任意端口，服务都可以直接访问。 本文介绍的方法比一般的端口映射更方便，不需要为每个端口配置一条SSH隧道，

基于Redis实现分布式锁和分布式限流器 | Liam's Blog

https://liam-blog.ml/2020/03/29/redis-lock-rate-limiter/

分布式锁和分布式限流器应该是算是比较常见的需求了，而Redis现在几乎是应用的标配了，于是很多人会倾向于选择基于Redis来实现，因为不需要引入额外的依赖。分布式锁和分布式限流器在Java领域比较成熟和常用的开源实现是Redisson(中文官方介绍)，下面从它的极小部分源码，分析下分布式锁和分布式限流器的实现逻辑。

Maven用户都应该知道的一些事：关于依赖的常见问题 | Liam's Blog

https://liam-blog.ml/2019/06/20/maven-details-about-dependency/

依赖范围(scope)不同选项的区别依赖范围参数的作用是控制依赖在不同阶段与classpath的关系，具体区别如下图所示。 表中没有列出的值是import，这个选项是用于引入dependencyManagement，下文会有介绍。 依赖调解，调解同一依赖的不同版本假设你的项目有如下的依赖树POM|-- A| -- B 1.0|-- C| -- D| -- B 2.0-

Spark Core 解析 3：Shuffle | Liam's Blog

https://liam-blog.ml/2019/12/29/spark-core-shuffle/

Overview所谓shuffle就是将数据按新的规则进行分区的过程，将数据分区从旧分区转变成新分区。这个过程分为两个阶段，第一个阶段称为shuffle write，每个计算节点需要对自己持有的那部分数据按新分区规则进行重新分区，并按新分区写入文件。shuffle write完成后，同一个新分区的数据会分散在不同的节点上，这样是不利于接下来的计算的，必须把同一个新分区的数据汇集到一个节点才行，所以

How to solve dependency conflicts with Maven | Liam's Blog

https://liam-blog.ml/2021/09/24/How-to-solve-dependency-conflicts-with-Maven/

What are dependency conflicts?Here is an example, this project has 2 dependencies, and both of them depend on the Guava library with different versions. <dependencies> <dependency>

tags | Liam's Blog

https://liam-blog.ml/tags/

Scala并发编程实战：Monitor与synchronized | Liam's Blog

https://liam-blog.ml/2019/07/14/Scala-Concurrency-in-Practice-1/

Java并发编程最常用和易用的技术莫过于synchronized关键字，而Scala的并发编程之旅也可以从synchronized开始。而synchronized的背后其实是monitor技术。 什么是MonitorMonitor是解决并发编程问题的一种常用技术，可以有效解决互斥和同步两大常见问题，通常翻译为‘监视器’或‘管程’。个人认为‘管程‘更能表达monitor的含义，指的是管理共享变量以及

《黑客与画家》读书笔记 | Liam's Blog

https://liam-blog.ml/2019/01/19/Hackers-and-Painters-note/

简介《黑客与画家》是硅谷创业之父Paul Graham的文集，这里的黑客指的是优秀的软件工程师，作者将黑客与画家作比较，认为与黑客最接近的职业是画家，这便是这本书书名的由来了。Paul Graham在1995年创办了Viaweb，帮助个人用户方便的开设网上商店，1998年以5千万美元的价格卖给Yahoo公司。2005年他创建了风投公司YC，被称为全世界最牛的创业孵化器，YC帮助了大量的创业公司（到

Scala implicit（隐式转换）驾驶手册 | Liam's Blog

https://liam-blog.ml/2019/09/28/scala-implicit/

这篇短文将结合实例对隐式转换的各种场景进行解释和总结，希望看完的人能够充分掌握隐式转换这个大坑。 隐式转换函数隐式转换函数有两种作用场景。 1 转换为期望类型：就是指一旦编译器看到X，但需要Y，就会检查从X到Y的隐式转换函数。 2 转换方法的调用者：简单来说，如obj.f()，如果obj对象没有f方法，则尝试将obj转换为拥有f方法的类型。 object ImpFunction extends

Scala并发编程实战：Semaphore 信号量模型 | Liam's Blog

https://liam-blog.ml/2019/08/26/Scala-Concurrency-Semaphore/

Semaphore信号量模型，是一种通过维护计数器数值来控制并发数量的模型，Lock实现的互斥锁只允许一个线程访问临界区，而Semaphore允许有限多个线程访问临界区。 什么情况需要允许多个线程同时访问？最常见的需求就是池化资源，连接池、线程池、对象池等等。 java.util.concurren.Semaphore 是JDK中的实现类，常用方法有这些： public Semaphore(int

Spark Core 解析：Scheduler 调度系统 | Liam's Blog

https://liam-blog.ml/2019/11/07/spark-core-scheduler/

Overview调度系统，是贯穿整个Spark应用的主心骨，从调度系统开始入手了解Spark Core，比较容易理清头绪。Spark的资源调度采用的是常见的两层调度，底层资源的管理和分配是第一层调度，交给YARN、Mesos或者Spark的Standalone集群处理，Application从第一层调度拿到资源后，还要进行内部的任务和资源调度，将任务和资源进行匹配，这是第二层调度，本文讲的就是这第

ARTS-5 | Liam's Blog

https://liam-blog.ml/2019/08/04/ARTS-5/

Algorithm/** * 231. Power of Two * https://leetcode.com/problems/power-of-two/submissions/ * Runtime: 1 ms, faster than 100.00% of Java online submissions for Power of Two. * Memory Usage: 33.3 MB, le

Spark API 全集(3):Spark RDD API全集 | Liam's Blog

https://liam-blog.ml/2018/03/26/spark-rdd-RDD-api/

RDD是啥Resilient Distributed Dataset (RDD)，弹性分布式数据集，是对不可修改，分区的数据集合的抽象。 RDD is characterized by five main properties: A list of partitions A function for computing each split A list of dependencies on o

[leetcode] 206.反转链表 | Liam's Blog

https://liam-blog.ml/2019/02/02/leetcode-206/

QES反转一个单链表。 示例: 输入: 1->2->3->4->5->NULL输出: 5->4->3->2->1->NULL进阶:你可以迭代或递归地反转链表。你能否用两种方法解决这道题？

Spark work with MySQL | Liam's Blog

https://liam-blog.ml/2016/12/27/spark-work-with-mysql/

With spark 2.0.x,we can use DataFrameReader and DataFrameWriter.Use SparkSession.read to access DataFrameReader and use Dataset.write to access DataFrameWriter. Suppose using spark-shell. read example

ARTS-Week 3 | Liam's Blog

https://liam-blog.ml/2019/06/30/ARTS-3/

Algorithm212. Word Search II step 1 put all words into a Trie 2 use DFS to search in the board public class Solution { private Set<String> found = new HashSet<>(); private in

Hive窗口函数实战 | Liam's Blog

https://liam-blog.ml/2019/02/20/hive-window-sql/

本文将介绍使用Hive强大的窗口函数，解决实际问题的方法，仅供参考。 连续登陆/活跃/访问问题假设有一张登陆日志表：CREATE TABLE user_login ( uid int comment '用户ID', dt int comment '日期yyyymmdd') STORED AS PARQUET PS：如果用户在某天多次登陆，也只会有一条记录。 计算距离上次登录天数先来个最

Scala并发编程实战：Executor线程池 | Liam's Blog

https://liam-blog.ml/2019/09/22/Scala-Concurrency-Executor/

创建线程是一个重量级操作，因为需要调用操作系统内核的API，所以最好不要频繁的创建和销毁线程，为了能够复用创建的线程，常用的办法的就是创建线程池。 Executorjava.util.concurren包中提供了若干接口和类来实现线程池，最常用的有Executor，ExecutorService，ThreadPoolExecutor。 Executor接口很简单定义如下：public interf

Spark API 全集(1):Spark SQL Dataset & DataFrame API | Liam's Blog

https://liam-blog.ml/2018/03/22/spark-sql-dataset-api/

简介org.apache.spark.sql.Dataset是Spark SQL中核心的类，定义如下：class Dataset[T] extends Serializable DataFrame是Dataset[Row]的别名。 本文基于spark2.3.0. 下面是类方法简介。 类方法Actionscollect(): Array[T]返回一个数组，包含Dataset所有行的数据。注意：所有数

Hello World, Hello Blog | Liam's Blog

https://liam-blog.ml/2016/12/25/hello-blog/

Hello!Today is this blog’s first day ! Merry Christmas !

Maven用户必须知道的一些事：构建生命周期和插件 | Liam's Blog

https://liam-blog.ml/2019/06/16/maven-lifecycle-and-plugin-goal/

Maven的所有实际操作都是由插件完成的，如果没有插件，Maven什么都不会干。（即时你没有在POM中配置<plugin>元素，Super POM中也已经帮你引入了若干核心插件） 那么问题来了，项目构建过程中，Maven是怎么知道应该在什么时候调用哪个插件的呢？ 插件的调用时机，跟’生命周期’和’插件目标’有很大关系。 插件目标(Plugin Goal)是个什么鬼首先需要知道的是，Ma

Spark Core 解析：RDD | Liam's Blog

https://liam-blog.ml/2019/10/23/spark-core-rdd/

引言Spark Core是Spark的核心部分，是Spark SQL，Spark Streaming，Spark MLlib等等其他模块的基础, Spark Core提供了开发分布式应用的脚手架，使得其他模块或应用的开发者不必关心复杂的分布式计算如何实现，只需使用Spark Core提供的分布式数据结构RDD及丰富的算子API，以类似开发单机应用的方式来进行开发。 图中最下面那个就是Spark

Spark on YARN 部署 | Liam's Blog

https://liam-blog.ml/2016/03/29/spark-on-yarn/

1.说明: 首先要部署好Hadoop集群包括HDFS和YARN,这里不再赘述. Spark on YARN模式,不需要启动spark的master和worker,master的工作由YARN完成. 相关路径根据实际情况修改. 1.4和1.6版本部署过程类似. 2.部署下载从官网(http://spark.apache.org/)下载对应Hadoop版本的包,如spark-1.6.1-bin-ha

tags | Liam's Blog

https://liam-blog.ml/tags/

ARTS-Week 2 | Liam's Blog

https://liam-blog.ml/2019/06/23/ARTS-2/

Algorithm208. Implement Trie (Prefix Tree) Implement a trie with insert, search, and startsWith methods. Example: Trie trie = new Trie(); trie.insert(“apple”);trie.search(“apple”); // returns truetr

[leetcode] 122.买卖股票的最佳时机 II | Liam's Blog

https://liam-blog.ml/2019/01/27/leetcode-122/

买卖股票的最佳时机 II给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。 设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易（多次买卖一支股票）。

Scala并发编程实战：Condition 条件变量 | Liam's Blog

https://liam-blog.ml/2019/08/03/Scala-Concurrency-in-Practice-3/

在Scala并发编程实战：Lock 锁中我们了解到如何通过Lock来实现互斥操作，但是获取锁之后，如果发现条件不满足（如消费一个队列中的数据时，发现队列为空），线程要如何等待条件满足（如队列不为空）并让出锁呢？这需要用到Condition条件变量，又称作条件队列。 Condition与JDK内置的管程的等待队列功能类似，主要功能都是让线程在队列上等待被唤醒，但是内置管程的锁只能有一个对应的队列，而

Spark 2.x读写MySQL | Liam's Blog

https://liam-blog.ml/2018/12/25/spark-work-with-mysql-cn/

简介从 spark 2.0 开始，我们可以使用DataFrameReader 和 DataFrameWriter来读写MySQL。 SparkSession.read 返回 DataFrameReader.Dataset.write 返回 DataFrameWriter. 煮几个栗子其中spark是SparkSession read exampleval prop=new java.util.Pr

基于Spark实现推荐算法-4:基于物品的协同过滤(实现篇) | Liam's Blog

https://liam-blog.ml/2018/05/04/spark-recommendation-item-based-cf/

算法设计与实现基于物品的协同过滤又称Item-Based CF.基于Spark的Item-Based CF算法其实现原理和步骤与经典方法基本一致，不同的地方主要在于具体步骤内的并行化计算。 相似度算法在Spark MLlib中提供了余弦相似度的分布式实现，org.apache.spark.mllib.linalg.distributed包中的IndexedRowMatrix是一个分布式矩阵类，其中

ARTS-Week 4 | Liam's Blog

https://liam-blog.ml/2019/07/14/ARTS-4/

Algorithm191. Number of 1 Bits stepUse n & (n - 1) to change the last 1 to 0. /** * 191. Number of 1 Bits * https://leetcode-cn.com/problems/number-of-1-bits/ * 执行用时 :4 ms, 在所有 Java 提交中击败了68.36%的

Spark API 全集(2):Spark SQL 函数全集 | Liam's Blog

https://liam-blog.ml/2018/03/23/spark-sql-functions-api/

Summaryorg.apache.spark.sql.functions是一个Object，提供了约两百多个函数。 大部分函数与Hive的差不多。 除UDF函数，均可在spark-sql中直接使用。 经过import org.apache.spark.sql.functions._ ，也可以用于Dataframe，Dataset。 version2.3.0 大部分支持Column的函数也支持St

Spark Core 解析 4：内存模型 | Liam's Blog

https://liam-blog.ml/2020/02/29/spark-core-memory/

Spark内存模型Spark之所以快，很大程度上是因为它善于利用内存，大量利用内存进行存储和计算，从而减少磁盘IO，提升执行效率。从1.6版本开始，Spark引入了统一内存管理模型（之前版本只有静态内存管理，这里不细说），找到两张图能够表达的很清晰：为什么有两张图呢，因为Spark既能使用JVM堆内存(on-heap)，也能使用堆外内存(off-heap)，两张图分别描述的是这两块内存的情况。图中

Details you need to know about Apache Parquet | Liam's Blog

https://liam-blog.ml/2020/05/31/details-you-need-to-know-about-Apache-Parquet/

Parquet is a columnar file format that supports nested data. Lots of data systems support this data format because of it’s great advantage of performance.

Scala并发编程实战：Lock 锁 | Liam's Blog

https://liam-blog.ml/2019/07/21/Scala-Concurrency-in-Practice-2/

synchronized作为内置锁，使用简单，不易出错，然鹅确有相当的局限性，例如，无法从等待获取锁的阻塞中中断，无法设置获取锁的超时。所以JUC提供了另一种更灵活的加锁方式，即Lock和Condition接口。 LockLock接口定义如下 public interface Lock { void lock(); void lockInterruptibly()

ARTS-Week 1 | Liam's Blog

https://liam-blog.ml/2019/06/08/ARTS-1/

ARTS: Algorithm + Review + Tip + Share1.Algorithm：每周至少做一个 leetcode 的算法题2.Review：阅读并点评至少一篇英文技术文章3.Tip：学习至少一个技术技巧4.Share：分享一篇有观点和思考的技术文章 Algorithm69. Sqrt(x) Implement int sqrt(int x). Compute and ret