系统学习Java新特性-Stream API使用

发表于 2021-11-04

这是我参与11月更文挑战的第3天，活动详情查看：2021最后一次更文挑战

阅读《Java实战》，本文为第5章总结，主要系统全面的介绍Steam的API，包含筛选、切片和映射，查找与匹配、归约操作、数值流、以及流的各种构建方法。

1、筛选

从流中筛选出目标对象，主要分为两个:

filter(Predicate)：基于谓词（返回boolean的函数式接口）筛选过滤
distinct() : 筛选去重
limit(n) ：截断流，即返回一个不超过指定长度n的流
skip(n)：跳过前面n个元素，和limit互补，实现类似分页功能

使用示例：

java复制代码    // filter示例：过滤出素食的选项
    List<Dish> vegetarianMenu =
            menu.stream()
                    .filter((m) -> m.isVegetarian())// lambda实现
                    //.filter(Dish::isVegetarian) // 方法引用
                    .collect(Collectors.toList());
    
    vegetarianMenu.forEach(
           // (Dish d) -> System.out.println(d) //lambda实现
            System.out::println
    );
    
    // distinct示例：筛选出偶数并去重复
    List<Integer> intArr = Arrays.asList(1,5,4,2,3,3,2,4,6);
    //输出：426
    intArr.stream()
            .filter(i -> i%2==0)
            .distinct()
            .forEach(System.out::print);
    // limit示例：
    // 输出：42
    intArr.stream()
            .filter(integer -> integer%2==0)
            .limit(2)
            .forEach(System.out::print);
    // skip示例：
    // 输出：26
    intArr.stream()
            .filter(integer -> integer%2==0)
            .distinct()
            .skip(1)
            .forEach(System.out::print);

2、映射

将每个元素映射处理成一个新的元素，主要实现有：

map(Function<T,R> f)：将函数应用到每个元素上，并将其转换成一个新的元素。
mapToInt(ToIntFunction f)：接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的IntSteam。
flatMap(Function f)：接收一个函数作为参数，将流中的每个值都转换成另外一个流，然后把所有流连接成一个流。

java复制代码    //map示例：Dish对象映射成dishName
    List<String> dishNames =
            Dish.menu.stream()
                    .map(
                        //(Dish dish) -> dish.getName() //基于Lambda
                        Dish::getName // 基于方法引用
                    ).collect(Collectors.toList());
    // [pork, beef, chicken, french fries, rice, season fruit, pizza, prawns, salmon]
    System.out.println(dishNames);

    //map的复合示例：除了映射成dishName的字符长度
    List<Integer> dishNameLengths =
            Dish.menu.stream()
                    .map(Dish::getName)
                    .map(String::length)
                    .collect(Collectors.toList());
    // [4, 4, 7, 12, 4, 12, 5, 6, 6]
    System.out.println(dishNameLengths);

    //flatMap示例：将单词数组，按字母整体去重处理
    String[] helloWorld = {"Hello","World"};
    List<String> uniqueCharacters =
            Arrays.stream(helloWorld)
                    .map(word -> word.split(""))//Stream<String[]> 拆分成一个个字符的数组流
                    .flatMap(Arrays::stream)//将所有数组流汇聚成一个新流
                    .distinct()
                    .collect(Collectors.toList());
    // [H, e, l, o, W, r, d]
    System.out.println(uniqueCharacters);

3、查找与匹配

查找或判断数据流中某些元素是否匹配一个给定的属性，常见API如下:

anyMatch(Predicate p)：至少有一个元素匹配给定的谓词
allMatch(Predicate p)：检查是否匹配所有元素
noneMatch(Predicate p)：检查是否没有匹配的元素
findAny()：返回当前流中的任意元素（注意，返回是Optional对象）
findFirst()：返回第一个匹配的元素(和findAny区别是并发流上)

java复制代码    //anyMatch: 是否存在素食
    System.out.println(
            Dish.menu.stream()
                    .anyMatch(Dish::isVegetarian)
    );//true

    //allMatch：所有菜热量是否<1000
    System.out.println(
        Dish.menu.stream().allMatch(dish -> dish.getCalories()<1000)
    );//true

    // findAny : 返回一道素食
    Optional<Dish> dish =
            Dish.menu.stream()
                    .filter(Dish::isVegetarian)
                    .findAny();

    //french fries#true
    dish.ifPresent(dish1 ->
            System.out.println(dish1.getName()+"#"+dish1.isVegetarian()));

4、归约操作

将流中的元素反复结合起来，从而得到一个值，比如最大值、热量总和，这样的操作统称为归约操作。

java复制代码    List<Integer> intList = Arrays.asList(1,3,5,2,4,6);
    // 求和计算
    Integer sum = intList.stream().reduce(0,(a,b) -> a+b);
    Integer sum1 = intList.stream().reduce(0,Integer::sum);
    System.out.println(sum+"#"+sum1);//21#21
    //无初始值，返回Optional<T>
    Optional<Integer> sum2 = intList.stream().reduce(Integer::sum);
    sum2.ifPresent(System.out::println);//21

    // 求最值示例：
    Optional<Integer> maxOpt = intList.stream().reduce((x,y) -> x>y?x:y);
    Optional<Integer> maxOpt1 = intList.stream().reduce(Integer::max);
    System.out.println(maxOpt.get()+"#"+maxOpt1.get());//6#6

    intList.stream().reduce(Integer::min).ifPresent(System.out::println);//1

5、数值流

这块主要基于数值特点，有两个特殊场景，规避数值类型的装箱问题的基础类型流特化、数值范围两个。

5.1 基础类型流特化

使用reduce对Integer类似对象进行数值计算暗含装拆箱成本，因此StreamAPI提供了IntStream、DoubleStream、LongStream三个基础类型流特化接口来处理，避免了潜在的装箱成本。

java复制代码    // 映射成数值流
    IntStream intStream = Dish.menu.stream()
            .mapToInt(Dish::getCalories);
    // 结果返回的是OptionalInt
    OptionalInt optionalInt = intStream.max();
    //orElse值不存在时默认值
    System.out.println(optionalInt.orElse(-999));
    System.out.println("----------");
    // 装箱转换成Stream
    intStream = Dish.menu.stream()
            .mapToInt(Dish::getCalories);
    Stream<Integer> integerStream = intStream.boxed();
    integerStream.forEach(System.out::println);

5.2 数值范围

数值流针对生产指定范围数字的需求，提供了range和rangeClosed两个方法，有两个参数，指定范围，后面方法为闭区间。

java复制代码    // 数值范围方法
    IntStream evenNumbers = IntStream.rangeClosed(1, 10)
            .filter(n -> n % 2 == 0);
    evenNumbers.forEach(i -> System.out.print(i+","));//2,4,6,8,10,

6、构建流

数据元素源时Stream数据处理操作的基石，本小节主要系统介绍除了Collection外所有可能的流生成方式。

由值创建流：利用Stream.of()可以直接将值对象封装成Stream
数组创建：使用Arrays.stream()静态方法，将数组直接转换成流
文件生成流：主要利用java.nio.file.Files工具类来实现，比如lines()方法
由函数生成流：主要时使用Stream.iterate(final T seed, final UnaryOperator<T> f)和Stream.generate()方法来循环调用函数生成无限流。

java复制代码    // 基于值序列创建
    Stream<String> stream = Stream.of("Java","In","Action");
    stream.map(String::toUpperCase).forEach(System.out::println);

    // 基于数组创建
    int[] intArr = {1,3,5,2,4,6};
    int sum = Arrays.stream(intArr).sum();
    System.out.println(sum);

    // 基于文件创建
    Path path = Paths.get(BuildingStreams.class.
            getClassLoader().getResource("data.txt").toURI());
    try(Stream<String> lineStream = Files.lines(path)){
        lineStream.forEach(System.out::println);
    }

    // 基于函数生成:因为无限流，所以配合limit使用
    Stream.iterate(0,n -> n+2)
            .limit(5)
            .forEach(e -> System.out.print(e+","));//0,2,4,6,8,

    Stream.generate(Math::random)
            .limit(5)
            .forEach(e -> System.out.print(e+","));//随机生成5个随机数

本文涉及的代码示例地址

本文转载自: 掘金

开发者博客 – 和开发相关的这里全都有

02flink实时数据管理-cdc捕获ETL作业进度 +

发表于 2021-11-04

引言

需求背景： ETL离线作业，需要实时监控运行状况，由于调度工具是Azkaban，故同步获取其后台配置库Mysql；本文为第二步：flink-cdc监控execution_jobs表，实时获取作业运行状况，关联第一步处理的projects广播变量，组装信息—— projectName、flowName、jobName、status、startTime、endTime

功能部件

flink-cdc-connector + Mysql + flink Table Api

实现逻辑

利用flink-connector，实现cdc元数据库execution_jobs表，获取作业实时运行情况;
筛选指定的字段，将TableStream转化为DataStream，并封装样例类;
join广播变量，获取projectName;

前提准备

确保Mysql库，开启binlong并设置为ROW格式; (off:关闭; on:开启)

1	sql复制代码SHOW VARIABLES LIKE 'log_bin';

创建cdc对应的用户

sql复制代码-- create user
CREATE USER 'flink_cdc'@'localhost' IDENTIFIED BY 'password';
-- grant user
GRANT SELECT, RELOAD, SHOW DATABASES, REPLICATION SLAVE, REPLICATION CLIENT ON *.* TO 'flink_cdc' IDENTIFIED BY 'password';
-- flush
FLUSH PRIVILEGES;

实现Demo

创建结果样例类

scala复制代码object Domain {

case class ExecutionJobs(
                         project_node: String,
                         project_id: String,
                         flow_name: String,
                         job_name: String,
                         active_status: String,
                         create_time: String,
                         update_time: String,
                         event_time: String
                         )
  
case class ProjectsClass(
                          project_id: String,
                          project_name: String,
                          project_desc: String,
                          create_time: String,
                          update_time: String
                        )

case class UpsertNeo4j(
                        project_node: String,
                        project_name: String,
                        flow_name: String,
                        job_name: String,
                        active_status: String,
                        create_time: String,
                        update_time: String
                      )
                        
                
                         
}

flink-cdc实现 TableApi

scala复制代码
import com.haierubic.bigdata.dataflow.models.Domain.ExecutionJobs
import com.haierubic.bigdata.dataflow.models.Sentence
import com.haierubic.bigdata.dataflow.utils.ConfigParse
import org.apache.flink.table.api.bridge.scala.StreamTableEnvironment
import org.apache.flink.streaming.api.scala._

/**
 * flink-cdc azkaban-mysql 元数据库获取工程运行情况
 * created by moun
 *
 * @FAQ:
 *   1. 使用flink-cdc-mysql 1.1.0版本;
 *   2. flink-cdc-mysql: scan.startup.mode 参数不起作用;  --替换为：'debezium.snapshot.mode' = 'schema_only'
 */

object ChangeDataCapture extends Sentence {

  def genUpdateNeo4jInfo(tEnv: StreamTableEnvironment) = {
    val azkHost: String = ConfigParse.getString("db.azkaban.host")
    val azkPort: Int = ConfigParse.getInt("db.azkaban.port")
    val azkUserName: String = ConfigParse.getString("db.azkaban.username")
    val azkPassword: String = ConfigParse.getString("db.azkaban.password")
    val azkDBName: String = ConfigParse.getString("db.azkaban.dbname")
    val cdcTabExecutionJobs: String = ConfigParse.getString("cdc.azkaban_run_jobs.tablename")

//    val url = ConfigParse.getString("db.neo4j.commitUrl")
    val project_node = ConfigParse.getString("kg.neo4j.projectNode")


    // cdc execution_jobs 表，获取工程作业运行记录
    tEnv.executeSql(
      s"""
         |create table execution_jobs (
         |  exec_id int NOT NULL,
         |  project_id string NOT NULL,
         |  version int NOT NULL,
         |  flow_id string NOT NULL,
         |  job_id string NOT NULL,
         |  attempt int NOT NULL,
         |  start_time bigint NULL,
         |  end_time bigint NULL,
         |  status string NULL,
         |  input_params string,
         |  output_params string,
         |  attachments string
         |) with (
         |  'connector' = 'mysql-cdc',
         |  'hostname' = '${azkHost}',
         |  'port' = '${azkPort}',
         |  'username' = '${azkUserName}',
         |  'password' = '${azkPassword}',
         |  'database-name' = '${azkDBName}',
         |  'table-name' = '${cdcTabExecutionJobs}',
         |  'debezium.snapshot.mode' = 'schema_only'
         |)
         |""".stripMargin
    )


    val update_info = tEnv.sqlQuery(
      s"""
         |select
         |  '${project_node}' as project_node,
         |  project_id,
         |  flow_id,
         |  job_id,
         |  status as active_status,
         |  from_unixtime(start_time/1000,'yyyy-MM-dd HH:mm:ss') as create_time,
         |  from_unixtime(end_time/1000,'yyyy-MM-dd HH:mm:ss') as update_time,
         |  cast((case when end_time = -1 then start_time else end_time end) as varchar) as event_time
         |from execution_jobs
         |""".stripMargin)


    tEnv.toRetractStream[ExecutionJobs](update_info)
  }

  def main(args: Array[String]): Unit = {
    println("cdcMysql~~")
  }
}

join广播变量获取projectName

自定义BroadcastProcessFunction 实现join关联逻辑

scala复制代码
import com.haierubic.bigdata.dataflow.models.Domain.{ExecutionJobs, ProjectsClass, UpsertNeo4j}
import org.apache.flink.api.common.state.MapStateDescriptor
import org.apache.flink.api.common.typeinfo.BasicTypeInfo
import org.apache.flink.streaming.api.functions.co.BroadcastProcessFunction
import org.apache.flink.util.Collector

class CustomBroadcastProcessFunction extends BroadcastProcessFunction[ExecutionJobs, ProjectsClass, UpsertNeo4j] {

  // 建立MapStateDescriptor
  val projectsDimDesc = new MapStateDescriptor(
    "projects",
    BasicTypeInfo.STRING_TYPE_INFO,
    BasicTypeInfo.STRING_TYPE_INFO
  )

  override def processElement(
                               in1: ExecutionJobs,
                               readOnlyContext: BroadcastProcessFunction[ExecutionJobs, ProjectsClass, UpsertNeo4j]#ReadOnlyContext,
                               collector: Collector[UpsertNeo4j]): Unit = {
    // 1. 从value中获取 project_id
    val project_id = in1.project_id

    val project_name = readOnlyContext.getBroadcastState(projectsDimDesc).get(project_id)

    // 可以查询到对应的工程名称，则输出，未查到则跳过
    if (project_name != null) {
      // 2. 封装collector 类型
      val result = UpsertNeo4j(in1.project_node, project_name, in1.flow_name, in1.job_name, in1.active_status, in1.create_time, in1.update_time)

      collector.collect(result)
    }

  }

  override def processBroadcastElement(
                                        in2: ProjectsClass,
                                        context: BroadcastProcessFunction[ExecutionJobs, ProjectsClass, UpsertNeo4j]#Context,
                                        collector: Collector[UpsertNeo4j]): Unit = {
    // 获取广播状态
    val broadcastState = context.getBroadcastState(projectsDimDesc)

    // 清空广播状态
//    broadcastState.clear()

    // 更新广播状态
    broadcastState.put(in2.project_id, in2.project_name)
  }
}

将cdc结果与广播变量join组合新的DataStream

scala复制代码object DataFlowMonitor extends Sentence {
  def main(args: Array[String]): Unit = {


    // flink env
    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment

    // 设置时间语义为 事件时间Event Time
    env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime)

    env.setParallelism(1)

    // flink table settings
    val tSettings: EnvironmentSettings = EnvironmentSettings
      .newInstance()
      .useBlinkPlanner()
      .inStreamingMode()
      .build()

    // flink table env
    val tEnv: StreamTableEnvironment = StreamTableEnvironment.create(env, tSettings)

    // Step1: cdc-azkaban-execution_jobs, get project running status
    val updateNeo4jSteam = ChangeDataCapture.genUpdateNeo4jInfo(tEnv)
    // filter status = 'insert'
    val filterUpdateNeo4jStream = updateNeo4jSteam.filter(_._1).map(_._2)
    // Step2: broadcast azkaban-projects, get project_name
    val projectsDataStream = QueryProjects.getProjects(env)

    // Step3: join broadcast, replace project_name
    val result = filterUpdateNeo4jStream.connect(projectsDataStream).process(
      new CustomBroadcastProcessFunction()  // 自定义广播变量函数
    )
    
}

本文转载自: 掘金

开发者博客 – 和开发相关的这里全都有

Java集合 Java随笔记

发表于 2021-11-04

「这是我参与11月更文挑战的第3天，活动详情查看：2021最后一次更文挑战」

Java随笔记：随笔记

前言

刚跳槽换了工作，最近忙的焦头烂额，回想起来，还是老东家的日子才是天堂啊！
感觉自己停更蛮久了，but，2021的最后日更活动，咬着牙也要坚持下去啊！hahah
中间件的更新暂且停一停，最近特别想整理下先前面试的过程【痛苦又真实】。
接下来我会更新一些java基础的内容，有兴趣的可以看看，对我本人来说，这是回顾，这是记录。对各位看官来说，也是一个总结吧，希望对各位有帮助哦~
当然，也有水文的因素在里面，我怂我承认~

一、Java集合

集合类存放于 Java.util 包中，主要有 3 种：set(集）、list(列表包含 Queue）和 map(映射)。
- Collection：Collection 是集合 List、Set、Queue 的最基本的接口。
- Iterator：迭代器，可以通过迭代器遍历集合中的数据
- Map：是映射表的基础接口
大体关系如下图：

二、List

在实际工作中，可能我们用的最多的就是List了吧，无处不在！无所不能！
Java 的 List 是非常常用的数据类型。List 是有序的 Collection。Java List 一共三个实现类：分别是 ArrayList、Vector 和 LinkedList。
打开Idea瞅一瞅，

+ ![image-20211102225836179.png](https://gitee.com/songjianzaina/juejin_p17/raw/master/img/8524254c2aa881fcb033a088e52547255440d822535efa9972126a26888f2c4d)
+ ![image-20211102225901717.png](https://gitee.com/songjianzaina/juejin_p17/raw/master/img/42cb376205a00890a69b76d14044f050c224cb9357932c988c7662c05aaad627)
+ 和上面的图一直，继承了Collection，再往上就是迭代器Iterable。

那么，List的三种实现有什么区别呢？

三、ArrayList

ArrayList ：数组，这个也应该是用的最多的。最常见的。
ArrayList 是最常用的 List 实现类，内部是通过数组实现的，它允许对元素进行快速随机访问。数组的缺点是每个元素之间不能有间隔，当数组大小不满足时需要增加存储能力，就要将已经有数组的数据复制到新的存储空间中。当从 ArrayList 的中间位置插入或者删除元素时，需要对数组进行复制、移动、代价比较高。
还是看看idea中的继承链：

+ ![image-20211102230329285.png](https://gitee.com/songjianzaina/juejin_p17/raw/master/img/92cf5ed98508fdccb42b8fa7a689b8010760469d061d8d77da52caa3ee8fb090)
+ 蓝色实线条代表继承，绿色虚线条代表实现。
+ 可以很明显的看出，ArrayList 继承了AbstractList，实现了RandomAccess、Cloneable、java.io.Serializable。
+ 点到List源码中看一看：
+ ![image-20211102231012544.png](https://gitee.com/songjianzaina/juejin_p17/raw/master/img/df0737238fccb1ad03ef38288dba2c2a43f7cafc9b556eb28646fe9e01b55c31)
+ 既然实现了Cloneable接口，那么代表了它覆盖了函数clone(),证明他是可以被克隆的。
+ 既然实现了java.io.Serializable接口，意味着它支持序列化，能通过序列化进行传输。
+ 我们再看一看AbstractList的继承链和源码：
+ ![image-20211102231210709.png](https://gitee.com/songjianzaina/juejin_p17/raw/master/img/610a1a000f316b7e6d1337446e3f94cebf88b9a2716e67f648143d1fdcf422ae)
+ ![image-20211102231222779.png](https://gitee.com/songjianzaina/juejin_p17/raw/master/img/66151b992a84669b4929a92ad8b8701d0e59ffdffd208c180668306e5fb6c667)
+ 呀，这玩意怎么也实现了List，那为什么我们ArrayList已经继承了AbstractList还要继续实现List呢？


    - 我们自己模拟一个类似这种的实现来看看（此模拟过程参考了其他博主的文章，鉴于不是掘金的文章，这里不贴链接了。）
    - 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
java复制代码public class Test {

    public static interface MyInterface {
        void foo();
    }

    public static class BaseClass implements MyInterface, Cloneable, Serializable {

        @Override
        public void foo() {
            System.out.println("BaseClass.foo");
        }
    }

    public static class Class1 extends BaseClass {

        @Override
        public void foo() {
            super.foo();
            System.out.println("Class1.foo");
        }
    }

    static class Class2 extends BaseClass implements MyInterface, Cloneable,
            Serializable {

        @Override
        public void foo() {
            super.foo();
            System.out.println("Class2.foo");
        }
    }

    public static void main(String[] args) {

        showInterfacesFor(BaseClass.class);
        showInterfacesFor(Class1.class);
        showInterfacesFor(Class2.class);
    }

    private static void showInterfacesFor(Class<?> clazz) {
        System.out.printf("%s --> %s\n", clazz, Arrays.toString(clazz
                .getInterfaces()));
    }
}


    - 输出结果如下


        * ![image-20211102231527660.png](https://gitee.com/songjianzaina/juejin_p17/raw/master/img/b108887ba171221cdac6957f20dd21cf749cbb5b881bc6db8dd122b557028783)
    - 从结果可以看出虽然Class1类的父类实现了接口，但是本身并没有再次实现接口，因此通过java.lang.Class直接获取Class1类的接口为空数组。
    - 因此在实现代理的时候就会出现问题。所以可能是设计者就是特意这样设计的嘞？有特别深入了解者，可以解惑下！

唔，这里就点到为止吧，我不知道这个文章需要详细到什么地步？需要贴具体的add和remove的源码讲解嘛？
因此，它适合随机查找和遍历，不适合插入和删除。

四、Vector

Vector 与 ArrayList 一样，也是通过数组实现的，不同的是它支持线程的同步，即某一时刻只有一个线程能够写 Vector，避免多线程同时写而引起的不一致性，但实现同步需要很高的花费。因此，访问它比访问 ArrayList 慢。
点击去看一看源码

+ ![image-20211104194534818.png](https://gitee.com/songjianzaina/juejin_p17/raw/master/img/c2c82623bb8ba9f53a52da8b52bf1451063b237bb6ab09803ee788727a87d94c)
+ 继承了AbstractList，实现了List；所以，**它是一个队列，支持相关的添加、删除、修改、遍历等功能**。
+ 实现了RandmoAccess接口，即**提供了随机访问功能**。RandmoAccess是java中用来被List实现，为List提供快速访问功能的。在Vector中，我们即可以通过元素的序号快速获取元素对象；这就是快速随机访问。
+ 实现了Cloneable接口，即实现clone()函数。它能被克隆。

我们看下Vector的构造函数：

+ 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
java复制代码/**
     * Constructs an empty vector with the specified initial capacity and
     * capacity increment.
     *
     * @param   initialCapacity     the initial capacity of the vector
     * @param   capacityIncrement   the amount by which the capacity is
     *                              increased when the vector overflows
     * @throws IllegalArgumentException if the specified initial capacity
     *         is negative
     capacity是Vector的默认容量大小，capacityIncrement是每次Vector容量增加时的增量值。
     */
    public Vector(int initialCapacity, int capacityIncrement) {
        super();
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        this.elementData = new Object[initialCapacity];
        this.capacityIncrement = capacityIncrement;
    }

    /**
     * Constructs an empty vector with the specified initial capacity and
     * with its capacity increment equal to zero.
     *
     * @param   initialCapacity   the initial capacity of the vector
     * @throws IllegalArgumentException if the specified initial capacity
     *         is negative
     capacity是Vector的默认容量大小。当由于增加数据导致容量增加时，每次容量会增加一倍。
     */
    public Vector(int initialCapacity) {
        this(initialCapacity, 0);
    }

    /**
     * Constructs an empty vector so that its internal data array
     * has size {@code 10} and its standard capacity increment is
     * zero.
     默认构造函数
     */
    public Vector() {
        this(10);
    }

    /**
     * Constructs a vector containing the elements of the specified
     * collection, in the order they are returned by the collection's
     * iterator.
     *
     * @param c the collection whose elements are to be placed into this
     *       vector
     * @throws NullPointerException if the specified collection is null
     * @since   1.2
      创建一个包含collection的Vector
     */
    public Vector(Collection<? extends E> c) {
        elementData = c.toArray();
        elementCount = elementData.length;
        // c.toArray might (incorrectly) not return Object[] (see 6260652)
        if (elementData.getClass() != Object[].class)
            elementData = Arrays.copyOf(elementData, elementCount, Object[].class);
    }


+ Vector一共有四个构造函数。


    - public Vector(int initialCapacity, int capacityIncrement) ：capacity是Vector的默认容量大小，capacityIncrement是每次Vector容量增加时的增量值。
    - public Vector(int initialCapacity) ： capacity是Vector的默认容量大小。当由于增加数据导致容量增加时，每次容量会增加一倍。
    - public Vector() ： 默认构造函数。
    - public Vector(Collection<? extends E> c) ： 创建一个包含collection的Vector。

五、LinkedList

LinkedList 是用链表结构存储数据的，很适合数据的动态插入和删除，随机访问和遍历速度比较慢。另外，他还提供了 List 接口中没有定义的方法，专门用于操作表头和表尾元素，可以当作堆栈、队列和双向队列使用。
同样，进去看下源码：

+ ![image-20211104195104098.png](https://gitee.com/songjianzaina/juejin_p17/raw/master/img/f441d52aaf2eef0adc33c30371c2d76daecc6e37ed4af122203fa877921c6e24)
+ ![image-20211104195131635.png](https://gitee.com/songjianzaina/juejin_p17/raw/master/img/504ad6214bc03a0a8bff1056080ef047b93b85e72d9f51ae736197719c19a595)
+ 首先看下构造函数：


    - 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
java复制代码/**
     * Constructs an empty list.
     */
    public LinkedList() {
    }

    /**
     * Constructs a list containing the elements of the specified
     * collection, in the order they are returned by the collection's
     * iterator.
     *
     * @param  c the collection whose elements are to be placed into this list
     * @throws NullPointerException if the specified collection is null
     */
    public LinkedList(Collection<? extends E> c) {
        this();
        addAll(c);
    }


    - 第一个构造方法不接受参数，将header实例的previous和next全部指向header实例。
    - 第二个构造方法接收一个Collection参数c，调用第一个构造方法构造一个空的链表，之后通过addAll将c中的元素全部添加到链表中。

路漫漫其修远兮，吾必将上下求索~

如果你认为i博主写的不错！写作不易，请点赞、关注、评论给博主一个鼓励吧~hahah

本文转载自: 掘金

开发者博客 – 和开发相关的这里全都有

Java 中 Map 的常见用法都在这了

发表于 2021-11-04

这是我参与11月更文挑战的第4天，活动详情查看：2021最后一次更文挑战。

Map 是容器里非常重要的一块内容。

HashMap 是 Map 里经常用的实现类。一看到这里，B站的弹幕里就开始跑了：“LeetCode 必见 HashMap”，足以证明，掌握好 HashMap 有多重要。

关键的话记住：键不可重复。

硬要往里面加同一个键，技术上是可以的，但是含义上会把之前的键对应的值覆盖掉。就不过多解释了。

小白练习，花样出错

1 在新建了类以后，直接就开始：

Map<Integer, String> m1 = new HashMap<>(); // 实现类 m1.put(1,"One");

然后，这句话没有毛病，此刻 IDEA 的界面是这样的：

于是我那个信心满满，就开始跟着敲 put 的那一行语句，敲的时候，隐隐觉得不对劲：

为什么呢？

按了回车以后就变成了：

我不信邪，偏要跟着敲。
果然报错了：

而且为什么我明明有 m1，后面紧跟着就用了 m1，怎么上面被使用过的 m1 还是灰色的呢？

放上去以后提示：

Cannot resolve symbol ‘put’
我更郁闷了。我明明和老高一样。难道是前面 Map，后面是 HashMap？

不好意思，猜错了。

然后就开始百度 HashMap java，打开了菜鸟教程，发现人家也是差不多的：

后来，我老老实实百度了报错原因，第一个结果就告诉了我解决办法：
没有放在 main 方法里！

包进去以后，果然通通听话了：

低阶方法：

get(), size(), isEmpty(), containsKey(), containsValue()

Java复制代码public class TestMap {
    public static void main(String[] args) {
        Map<Integer, String> m1 = new HashMap<>(); // 实现类

        m1.put(1,"One");
        m1.put(2,"Two");
        m1.put(3,"Three");
        m1.put(4,"Four");

        System.out.println("m1.get(1): " + m1.get(1));
        System.out.println("m1.size(): " + m1.size());
        System.out.println("m1.isEmpty(): " + m1.isEmpty());
        System.out.println("m1.containsKey(3)" + m1.containsKey(3));
        System.out.println("m1.containsValue("Five")" + m1.containsValue("Five"));

        Map<Integer, String> m2 = new HashMap<>();
        m2.put(5,"Five");
        m2.put(6, "Six");
        m1.putAll(m2);
        System.out.println("m1.putAll(m2) 之后:\n" + m1);
    }
}

在 Python 里是一个字典走天下：

get(): dict[key]
size(): len(dict)
isEmpty(): len(dict)==0
containsKey(): x in dict.keys()
containsValue(): x in dict.values()

哪里不会装哪里

上面一大块练习的代码，value 的类型都是字符串，现在来装个类：

Java复制代码public class TestMap2 {
    public static void main(String[] args) {

        Employee e1 = new Employee(666, "Fang", 66666);
        Employee e2 = new Employee(667, "张三", 9999999); // 因为他狂
        Employee e3 = new Employee(668, "萌叔", 36888);

        Map<Integer, Employee> map = new HashMap<>();
        map.put(666, e1);
        map.put(667, e2);
        map.put(668, e3);
        Employee emp = map.get(666); // 返回的就是对象
        System.out.println(emp.getName());
    }
}

类的信息是：（id，姓名，工资）+ JavaBean方法的 get 和 set，还有构造器。
运行结果如下：

Python 表示不服：

Python复制代码e1 = [666, "Fang", 66666]
e2 = [667, "张三", 9999999]
e3 = [668, "萌叔", 36888]
employees = {}
employees[666] = e1
employees[667] = e2
employees[668] = e3

也完全可以实现类似的用法。列表+字典暂时无敌。

又是期待新知识的一天呢！

本文转载自: 掘金

开发者博客 – 和开发相关的这里全都有

Python 时间操作之calendar模块复习回顾 1

发表于 2021-11-04

这是我参与11月更文挑战的第4天，活动详情查看：2021最后一次更文挑战

复习回顾

Python 对于时间日期操作提供了很多方法，我们前面已经学习了2个模块：

基于Unix 时间戳范围限制在1970~2038年的时间处理的time模块
提供六个类对时间日期更加人性化处理的datetime模块

在日常生活工作中，除了每一天时间及日期Python都提供了具体的模块来进行处理，那么日期的集合要使用什么模块来处理呢？

Python 专门为了处理日历提供了calendar日历模块。

那么，本期我们来学习一下calender模块相关方法及属性，Let’s go~

calendar 模块概述

calendar 模块提供与日历相关的实用函数，帮助我们得到与日历相关的信息。

calendar 特点

+ calendar 模块是基于datetime.date.weekday()对计算每一周的周数
+ calendar 默认星期一是每一周的第一天，星期天是一周的最后一天
+ calendar 提供calendar.setfirstweeksday()来更改指定星期几为一周的第一天

calendar 类结构

+ 我们可以查看Python内置库-calendar.py文件
+ calendar 主要提供三大类：Calendar、TextCalendar、HTMLCalendar
+ 其中，calendar是TextCalendar和HTMLCalendar的基类![](https://gitee.com/songjianzaina/juejin_p18/raw/master/img/18c8dd7bdc6864915bb069cd2895671ac0f41b8946a261d72bac2611c9495c3f)

calendar 使用步骤

+ calendar是内置库，直接使用import导入

1	python复制代码import calendar

calendar 相关方法

calendar 模块相关方法

方法	说明
calendar.firstweekday()	设置每星期的第一天数值
calendar.isleap(year)	判断是闰年，则返回Ture
calendar.leapdays(y1,y2)	计算要y1与y2的闰年数
calendar.weekday(year,month,day)	返回某日是星期几
calendar.weekheader(n)	星期几的缩写名的头
calendar.mothrange(year,month)	计算出指定年份的某月第一天是星期几和天数
calendar.prmonth(theyear,themonth,w=0,l=0)	格式化打印指定年的某月的日历
calendar.month(theyear,themonth,w=0,l=0)	使用TextCalendar类formation()以多行字符串形式返回月份日历
calendar.prcal(year,w=1,l=0,c=6,m=3)	格式化打印出整年的日历
calendar.calendar(year,w=1,l=0,c=6,m=3)	以整年3列的日历多行字符串的形式的日历

calendar 模块属性

方法	说明
calendar.day_name	当前语言环境下星期几的数组
calendar.day_abbr	当前语言环境下星期几的缩写
calendar.month_name	当前语言下一年的月份数组
calendar.month_abbr	当前语言下一年的月份缩写

calendar 模块提供5个类

类方法	说明
calendar.Calendar(firstweekday=0)	创建Calendar对象，默认周一为第一天
calendar.TextCalendar(firstweekday=0)	生成纯文本日历对象
calendar.HTMLCalendar(firstweekday=0)	生成HTML日志对象
calendar.LocaleTextCalenda(firstweekday=0,locale=None)	语言环境名称
calendar.LocaleHTMLCalendar(firstweekday=0,locale=None)	语言环境名称

calendar.Calendar类实例相关方法

方法	说明
cal.itermonthdates(year,month)	返回一个year年month月的日期的迭代器
cal.iterweekdats()	返回为一星期的数字的迭代器
cal.itermonthdays(year,month)	返回的日期为当月每一天的日期对应的天数，对于不在当月的日期，会显示0
cal.itermonthdays2(year,month)	返回一个由日期和代表星期几的数字组成的元组
cal.itermonthdays3(year,month)	返回一个由年月日组成的元组
cal.itermonthdays4(year,month)	返回一个由年月日和星期几的数字组成的元组
cal.monthdatescalendar(year,month)	返回一个由datetime.date对象组成的年月的周列表
cal.monthdays2calendar(year,month)	返回一个由日期数字和周几的数字的二元元组
cal.monthdayscalendar(year,month)	返回一个由七个日期数字的组成周列表
cal.yeardatescalendar(year,width=3)	返回可以用来格式化的指定年月的数据列表
cal.yeardays2calendar(year,width=3)	返回用来模式化的指定年月的数据。在这个月的日期为0，周列表由日期和星期数组成的元组
cal.yeardayscalendar(year,width=3)	返回一个周列表是日期数字组成可以用来模式化的指定年月的数据

calendar.TextCalendar类实例相关方法

方法	说明
tc.formatmonth(theyear,themonth,w=0,1=0)	以多行字符串来表示指定年月的日历
tc.prmonth(theyear,themonth,w=0,1=0)	格式化打印一个月的日历
tc.formatyear(theyear,w=0,l=1,c=6,m=3)	返回一个m列的日历
tc.pryear(theyear,w=0,l=1,c=6,m=3)	格式化打印一整年的日历

calendar.HTMLCalendar类实例相关方法

方法	说明
htl.formatmonth(theyear,themonth,withyear=True)	返回一个HTML表格的指定的年月日历
htl.formatyear(theyear，width=3)	返回HTML指定年份的日历
htl.formatyearpage(theyear,width=3,css=’calendar.css’,encoding=None)	返回一个完整的HTML页面作为指定的年份日历

calendar.HTMLCalendar类实例相关属性

方法	说明
htl.cssclasses	星期一到星期天的CSS class 列表
htl.cssclass_noday	工作日的CSS类在上个月或下个月发生
htl.cssclasses_weekday_head	用于标题行中工作日名称的css列表
htl.cssclass_month_head	月份的CSS列表标题
htl.cssclass_month	某个月的月历CSS类
htl.cssclass_year	某个年的年历CSS类
htl.cssclasses_year_head	年历的CSS列表标题

小试牛刀

打印2021年年历

python复制代码import calendar

# 打印2021年历
print(calendar.calendar(2021))

打印指定某年的月历

1	python复制代码print(calendar.month(2021,11))

总结

本期，我们对calendar模块日历相关的方法的学习，calendar模块主要提供3个主要类Calendar、TextCalendar、HTMLCalendar。我们可以更好地以字符串或者HTML形式打印出指定的日历。

以上是本期内容，欢迎大佬们点赞评论，下期见~

本文转载自: 掘金

开发者博客 – 和开发相关的这里全都有

Juc并发编程详解

发表于 2021-11-04

「这是我参与11月更文挑战的第4天，活动详情查看：2021最后一次更文挑战」

线程和进程

线程和进程

进程：一个程序的集合

一个进程往往可以包含多个线程，至少包含一个；

线程：开了一个进程，之后多线程处理

java复制代码    public synchronized void start() {
        /**
         * This method is not invoked for the main method thread or "system"
         * group threads created/set up by the VM. Any new functionality added
         * to this method in the future may have to also be added to the VM.
         *
         * A zero status value corresponds to state "NEW".
         */
        if (threadStatus != 0)
            throw new IllegalThreadStateException();

        /* Notify the group that this thread is about to be started
         * so that it can be added to the group's list of threads
         * and the group's unstarted count can be decremented. */
        group.add(this);

        boolean started = false;
        try {
            start0();
            started = true;
        } finally {
            try {
                if (!started) {
                    group.threadStartFailed(this);
                }
            } catch (Throwable ignore) {
                /* do nothing. If start0 threw a Throwable then
                  it will be passed up the call stack */
            }
        }
    }
	// 调用本地的c++方法，开启线程，java不能直接开启，运行在虚拟机上
    private native void start0();

并发和并行

并发(多线程操作同一个资源)：

抢票
cpu一核，模拟出来多条线程，天下武功，唯快不破，快速交替

并行(多人个一起行走)：

cpu多核，多个线程一同执行

java复制代码package com.jxau.demo01;

public class Test01 {
    public static void main(String[] args) {
        /*new Thread().start();*/

        System.out.println(Runtime.getRuntime().availableProcessors());
    }
}

并发编程的本质：提高效率，充分利用CPU的资源

线程有几个状态

java复制代码public enum State {
       
        NEW,

        RUNNABLE,

        BLOCKED,
        
        WAITING,

        TIMED_WAITING,

        TERMINATED;
    }

wait/sleep的区别

Lock锁

synchronized

java复制代码package com.jxau.demo01;

public class SynchronizedTest {

    public static void main(String[] args) {
        Ticklet ticklet=new Ticklet();
        new Thread(()->{for(int i=0;i<50;i++) ticklet.saleTicklet();},"A").start();
        new Thread(()->{for(int i=0;i<50;i++) ticklet.saleTicklet();},"B").start();
        new Thread(()->{for(int i=0;i<50;i++) ticklet.saleTicklet();},"C").start();
    }
}

class Ticklet{

    private static int nums=50;

    public synchronized void saleTicklet(){
        if(nums>0) System.out.println(Thread.currentThread().getName()+"卖出了一张还剩"+(--nums)+"张票");
    }
}

lock

公平锁:十分公平:可以先来后到

非公平锁:十分不公平:可以插队

使用onglock的步骤：

Synchronized 和LOck 区别

1、Synchronized内置的Java关键字，Lock是一个Java类

2、Synchronized无法判断获取锁的状态，Lock可以判断是否获取到了锁

3、Synchronized 会自动释放锁，lock必须要手动释放锁!如果不释放锁，死锁

4、Synchronized线程1(获得锁，阻塞)、线线程2(等待，傻傻的等） ; Lock锁就不一定会等待下去;

5、Synchronized可重入锁，不可以中断的，非公平;Lock，可重入锁，可以判断锁，非公平(可以自己设置) ;

6、Synchronized适合锁少量的代码同步问题，Lock适合锁大量的同步代码!

生产者和消费者问题

判断等待、业务、通知唤醒

java复制代码package com.jxau.pc;

public class Test01 {

    public static void main(String[] args) {
        Data data=new Data();

        new Thread(()->{
            for(int i=0;i<10;i++){
                data.doProduct();
            }
        },"product").start();
        new Thread(()->{
            for(int i=0;i<10;i++){
                data.doConsumer();
            }
        },"consumer").start();
        new Thread(()->{
            for(int i=0;i<10;i++){
                data.doProduct();
            }
        },"c").start();
        new Thread(()->{
            for(int i=0;i<10;i++){
                data.doConsumer();
            }
        },"d").start();

    }
}

/*
* 生产者模式与消费者模式三部曲
* 1、判断等待
* 2、业务功能
* 3、通知唤醒
* */

class Data{
    private int num=0;
    public synchronized void doProduct(){
        while(num!=0){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        num++;
        System.out.println(Thread.currentThread().getName()+"生产之后为"+num);
        this.notifyAll();

    }
    public synchronized void doConsumer(){
        while(num==0){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        num--;
        System.out.println(Thread.currentThread().getName()+"消费之后为"+num);
        this.notifyAll();

    }

}

A、b、c、d四个线程可能出现的问题

==要使用while==

juc版的生产者与消费者问题

使用lock condition.await() condition.singal()

通过look找到condition

java复制代码package com.jxau.pc;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Test02 {

    public static void main(String[] args) {
        Data1 data=new Data1();

        new Thread(()->{
            for(int i=0;i<10;i++){
                data.doProduct();
            }
        },"product").start();
        new Thread(()->{
            for(int i=0;i<10;i++){
                data.doConsumer();
            }
        },"consumer").start();
        new Thread(()->{
            for(int i=0;i<10;i++){
                data.doProduct();
            }
        },"c").start();
        new Thread(()->{
            for(int i=0;i<10;i++){
                data.doConsumer();
            }
        },"d").start();

    }
}

/*
 * 生产者模式与消费者模式三部曲
 * 1、判断等待
 * 2、业务功能
 * 3、通知唤醒
 * */

class Data1{
    // 使用lock锁的版本
    Lock lock=new ReentrantLock();
    Condition condition = lock.newCondition();
    
    private int num=0;
    public  void doProduct(){


        try{
            lock.lock();
            while(num!=0){
                condition.await();
            }
            num++;
            System.out.println(Thread.currentThread().getName()+"生产之后为"+num);
            condition.signalAll();

        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }



    }
    public  void doConsumer(){


        try{
            lock.lock();
            while(num==0){
               condition.await();
            }
            num--;
            System.out.println(Thread.currentThread().getName()+"消费之后为"+num);
            condition.signalAll();

        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }





    }


}

**任何一个新的技术，绝对不仅仅只是覆盖了原来的技术，优势和补充！

Condition精准的通知和唤醒线程

java复制代码package com.jxau.pc;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Test03 {
    public static void main(String[] args) {
        Data3 data3=new Data3();
        new Thread(()->{
            for(int i=0;i<10;i++){
                data3.printfA();
            }
        },"A").start();
        new Thread(()->{
            for(int i=0;i<10;i++){
                data3.printfB();
            }
        },"B").start();
        new Thread(()->{
            for(int i=0;i<10;i++){
                data3.printfC();
            }
        },"C").start();
    }
}


/*
 * 生产者模式与消费者模式三部曲
 * 1、判断等待
 * 2、业务功能
 * 3、通知唤醒
 * */

class Data3{
    // 使用lock锁的版本
    Lock lock=new ReentrantLock();
    Condition condition1 = lock.newCondition();
    Condition condition2 = lock.newCondition();
    Condition condition3= lock.newCondition();
    int num=1;
   public void printfA(){
       // 判断何时等待、业务、唤醒通知
       lock.lock();
       try{
           while(num!=1){
               condition1.await();
           }
           System.out.println(Thread.currentThread().getName()+"->AAAAAAA");
           num=2;
           condition2.signal();
       }catch (Exception e){
           e.printStackTrace();
       }finally {
           lock.unlock();
       }

   }

    public void printfB(){
       lock.lock();
       try{
            while(num!=2){
                condition2.await();
            }
           System.out.println(Thread.currentThread().getName()+"->BBBBBBB");
            num=3;
            condition3.signal();
        }catch (Exception e){
            e.printStackTrace();}
        finally {
            lock.unlock();
        }
    }

    public void printfC(){
        lock.lock();
        try{
            while(num!=3){
                condition3.await();
            }
            System.out.println(Thread.currentThread().getName()+"->CCCCCC");
            num=1;
            condition1.signal();
        }catch (Exception e){
            e.printStackTrace();}
        finally {
            lock.unlock();
        }
    }


}

八锁问题

synchronized锁的对象时方法的调用者！

一个静态方法锁，一个普通方法锁

集合类不安全

hashset的底层

java复制代码  public HashSet() {
        map = new HashMap<>();
    }

// add
 public boolean add(E e) {
        return map.put(e, PRESENT)==null;
    }

Runnable

java复制代码package com.jxau.callable;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class Test01 {

    public static void main(String[] args) throws ExecutionException, InterruptedException {

        FutureTask futureTask=new FutureTask(new MyCallable());

        Thread thread = new Thread(futureTask);
        thread.start();
        Integer o =(Integer) futureTask.get();
        System.out.println(o);

    }

}

class MyCallable implements Callable<Integer>{
    @Override
    public Integer call() throws Exception {
        System.out.println("call()");
        return 1024;
    }
}

常见的辅助类（可以解决高并发限流）

CountDownLatch

java复制代码package com.jxau.count;

import java.util.concurrent.CountDownLatch;

public class CountDownLatchTest {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch countDownLatch=new CountDownLatch(6);
        for(int i=1;i<=8;i++){

            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"同学已经走了");
                countDownLatch.countDown();// -1
            },String.valueOf(i)).start();
        }
        countDownLatch.await();// 等待计数器归零，再往下执行
        System.out.println("同学已经走完了");
    }
}

原理：

countDownLatch.countDown(); 数量-1

countDownLatch.await();等待计数器归零，再往下执行

CyclicBarrier

java复制代码package com.jxau.count;

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

public class CyclicBarrierTest {
    public static void main(String[] args) {
        CyclicBarrier cyclicBarrier=new CyclicBarrier(7,()->{
            System.out.println("集齐七颗龙珠，召唤神龙！");
        });

        for(int i=0;i<7;i++){
            int finalI = i;
            new Thread(()->{
                System.out.println("收集了"+ finalI +"星龙珠");
                try {
                    cyclicBarrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

Semaphore

java复制代码package com.jxau.count;

import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;

public class SemaphoreTest {

    public static void main(String[] args) {
        Semaphore semaphore=new Semaphore(3); // 信号量，初始为3

        for(int i=1;i<=6;i++){

            new Thread(()->{
                try {
                    semaphore.acquire();
                    System.out.println(Thread.currentThread().getName()+"占用车位");
                    TimeUnit.SECONDS.sleep(2);
                    System.out.println(Thread.currentThread().getName()+"离开车位");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    semaphore.release();// 释放
                }
            },String.valueOf(i)).start();


        }
    }
}

原理：

semaphore.acquire();获得，假设如果已经满了，进行等待，等待到被释放为止

semaphore.release();释放，会将当前的信号量释放+1，然后唤醒等待的线程

区别与联系：

CyclicBarrier: 指定个数线程执行完毕后在执行操作

Semaphore: 同一时间只能有指定数量个得到线程

读写锁

ReadWriteLock

独占锁（写锁）’一次只能被一个线程占有

共享锁（读锁)多个线程可以同时占有

ReadwriteLock

读-读可以共存!

读-写不能共存!

写-写不能共存!

java复制代码package com.jxau.rw;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReadWriteTest {

    public static void main(String[] args) {

        Data data=new Data();

        for(int i=1;i<=5;i++){
            int finalI = i;
            new Thread(()->{
                Object o=new Object();
                data.write(String.valueOf(finalI),o);
            },String.valueOf(finalI)).start();
        }


        for(int i=1;i<=5;i++){
            int finalI = i;
            new Thread(()->{

                data.read(String.valueOf(finalI));
            },String.valueOf(finalI)).start();
        }

    }
}

class Data{
    // 加上volatile保证原子性
    private volatile Map<String ,Object> map=new HashMap<>();
    private ReadWriteLock readWriteLock=new ReentrantReadWriteLock();



    public void write(String key,Object o){
        readWriteLock.writeLock().lock();
        try{
            System.out.println(Thread.currentThread().getName()+"写入了"+key);
            map.put(key,o);
            System.out.println(Thread.currentThread().getName()+"写入完毕");

        }catch (Exception e){
            e.printStackTrace();
        }finally {
            readWriteLock.writeLock().unlock();
        }

    }

    public void read(String key){
        readWriteLock.readLock().lock();
        try{
            System.out.println(Thread.currentThread().getName()+"读取"+key);
            Object o = map.get(key);
            System.out.println(Thread.currentThread().getName()+"读取完毕");
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            readWriteLock.readLock().unlock();
        }
    }

}

阻塞队列

什么情况下我们会使用阻塞队列：多线程并发处理，线程池！

四组常用API

学会使用队列

添加、移除

1、抛出异常

2、不会抛出异常

3、阻塞等待

4、超时等待

方式	抛出异常	有返回值，不抛出异常	阻塞等待	超时等待
添加	add()	offer()	put()	offer(,,)
移除	remove()	poll()	take()	poll()
检测队首元素	element()	peek()	-	-

java复制代码 /*
    * 抛出异常
    * */
    public static void test01(){

        ArrayBlockingQueue<Integer> arrayBlockingQueue=new ArrayBlockingQueue<Integer>(3);
        System.out.println(arrayBlockingQueue.add(1));
        System.out.println(arrayBlockingQueue.add(2));
        System.out.println(arrayBlockingQueue.add(3));
        // System.out.println(arrayBlockingQueue.add(4));
        System.out.println(arrayBlockingQueue.element());

        System.out.println(arrayBlockingQueue.remove());
        System.out.println(arrayBlockingQueue.remove());
        System.out.println(arrayBlockingQueue.remove());
        System.out.println(arrayBlockingQueue.remove());

    }

java复制代码 /*
     * 有返回值，不抛出异常
     * */
    public static void test02(){

        ArrayBlockingQueue<Integer> arrayBlockingQueue=new ArrayBlockingQueue<Integer>(3);

        System.out.println(arrayBlockingQueue.offer(1));
        System.out.println(arrayBlockingQueue.offer(2));
        System.out.println(arrayBlockingQueue.offer(3));
        System.out.println(arrayBlockingQueue.offer(4));
        System.out.println("==============");
        System.out.println(arrayBlockingQueue.peek());
        System.out.println(arrayBlockingQueue.poll());
        System.out.println(arrayBlockingQueue.poll());
        System.out.println(arrayBlockingQueue.poll());
        System.out.println(arrayBlockingQueue.poll());



    }

java复制代码    /*
     * 堵塞 等待
     * */
    public static void test03(){

        ArrayBlockingQueue<Integer> arrayBlockingQueue=new ArrayBlockingQueue<Integer>(3);

        try {
            arrayBlockingQueue.put(1);
            arrayBlockingQueue.put(2);
            arrayBlockingQueue.put(3);
            //arrayBlockingQueue.put(1);
            System.out.println("===========");
            System.out.println(arrayBlockingQueue.take());
            System.out.println(arrayBlockingQueue.take());
            System.out.println(arrayBlockingQueue.take());
            System.out.println(arrayBlockingQueue.take());

        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
    }

java复制代码    /*
     * 超时等待
     * */
    public static void test04(){

        ArrayBlockingQueue<Integer> arrayBlockingQueue=new ArrayBlockingQueue<Integer>(3);

        try {
            System.out.println(arrayBlockingQueue.offer(1, 2, TimeUnit.SECONDS));
            System.out.println(arrayBlockingQueue.offer(2, 2, TimeUnit.SECONDS));
            System.out.println(arrayBlockingQueue.offer(3, 2, TimeUnit.SECONDS));
            System.out.println(arrayBlockingQueue.offer(4, 2, TimeUnit.SECONDS));
            System.out.println("================");
            System.out.println(arrayBlockingQueue.poll(2, TimeUnit.SECONDS));
            System.out.println(arrayBlockingQueue.poll(2, TimeUnit.SECONDS));
            System.out.println(arrayBlockingQueue.poll(2, TimeUnit.SECONDS));
            System.out.println(arrayBlockingQueue.poll(2, TimeUnit.SECONDS));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }

SynchronousQueue

同步队列和其他的BlockQueue不一样，SynchronousQueue 不存储元素put了一个元素，必须从里面先take取出来，否则不能在put进去值！

java复制代码package com.jxau.queue;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.TimeUnit;

/**
 * 同步队列 和其他的BlockQueue不一样，SynchronousQueue 不存储元素
 * put了一个元素，必须从里面先take取出来，否则不能在put进去值！
 */
public class SynchronousQueueTest {
    public static void main(String[] args) {

        BlockingQueue<String> synchronousQueue=new SynchronousQueue<>();



            new Thread(()->{

                try {
                    System.out.println(Thread.currentThread().getName()+"put "+ "t1");
                    synchronousQueue.put("t1");
                    System.out.println(Thread.currentThread().getName()+"put "+ "t2");
                    synchronousQueue.put("t2");
                    System.out.println(Thread.currentThread().getName()+"put "+ "t3");
                    synchronousQueue.put("t3");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            },"I").start();



            new Thread(()->{
                try {
                    TimeUnit.SECONDS.sleep(2);
                    String take = synchronousQueue.take();
                    System.out.println(Thread.currentThread().getName()+"get "+ take);
                    TimeUnit.SECONDS.sleep(2);
                     take = synchronousQueue.take();
                    System.out.println(Thread.currentThread().getName()+"get "+ take);
                    TimeUnit.SECONDS.sleep(2);
                     take = synchronousQueue.take();
                    System.out.println(Thread.currentThread().getName()+"get "+ take);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            },"You").start();

    }
}

线程池

线程池：三大方法、7大参数、四种拒绝策略

池化技术

程序的运行，本质：占用系统的资源！优化资源的使用！=》池化技术

线程池、连接池、内存池、对象池 ///….. 创建、销毁。十分浪费资源

池化技术：事先准备好一些资源，有人要用，就来我这里拿，用完之后还给我。

线程池的好处：

1、降低资源的消耗

2、提高响应的速度

3、方便管理

==线程复用、可以控制最大并发数、管理线程==

线程池：三大方法

java复制代码package com.jxau.ThreadPool;

import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

// Executors 工具类、3大方法
public class Test01 {
    public static void main(String[] args) {
        //ExecutorService executorService = Executors.newSingleThreadExecutor();// 创建单一线程池
        //ExecutorService executorService = Executors.newCachedThreadPool();// 遇强则强、遇弱则弱
ExecutorService executorService = Executors.newFixedThreadPool(5);// 创建合适的线程池
        try{
            for(int i=0;i<100;i++){
                executorService.execute(()->{
                    System.out.println(Thread.currentThread().getName());
                });
            }

        }catch (Exception e){
            e.printStackTrace();
        }finally {
            executorService.shutdown();// 关闭线程池
        }

    }
}

源码分析：

java复制代码public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
    }


 public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }

public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }

// 七大核心参数
public ThreadPoolExecutor(int corePoolSize,// 核心线程大小
                              int maximumPoolSize,// 最大核心线程池大小
                              long keepAliveTime,// 超时了没有人调用就会释放
                              TimeUnit unit,// 超时单位
                              BlockingQueue<Runnable> workQueue,// 阻塞队列
                              ThreadFactory threadFactory,// 线程工厂：创建线程，一般不用动
                              RejectedExecutionHandler handler// 拒绝策略) {
        if (corePoolSize < 0 ||
            maximumPoolSize <= 0 ||
            maximumPoolSize < corePoolSize ||
            keepAliveTime < 0)
            throw new IllegalArgumentException();
        if (workQueue == null || threadFactory == null || handler == null)
            throw new NullPointerException();
        this.acc = System.getSecurityManager() == null ?
                null :
                AccessController.getContext();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

手动创建线程池

java复制代码package com.jxau.ThreadPool;

import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;


public class Test02 {
    public static void main(String[] args) {
        // 手动创建一个线程池
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(2,
                                                                   5,
                                                                      3,
                                                                        TimeUnit.SECONDS,
                                                new LinkedBlockingDeque<>(3),
                                                new ThreadPoolExecutor.DiscardPolicy()// 队列满了，丢掉任务，不会抛出异常
                                                                        );
        try{
            for(int i=0;i<10;i++){
                threadPoolExecutor.execute(()->{
                    System.out.println(Thread.currentThread().getName());
                });
            }

        }catch (Exception e){
            e.printStackTrace();
        }finally {
            threadPoolExecutor.shutdown();// 关闭线程池
        }
    }
}

四种拒绝策略

java复制代码/*
*   new ThreadPoolExecutor.AbortPolicy() // 银行满了，还有人进来，不处理这个人的，抛出异常
*   new ThreadPoolExecutor.CallerRunsPolicy()// 哪来的去哪里
*   new ThreadPoolExecutor.DiscardOldestPolicy()// 队列满了，尝试去和最早的竞争，也不会抛出异常
*   new ThreadPoolExecutor.DiscardPolicy()// 队列满了，丢掉任务，不会抛出异常
*/

小结和扩展

池的最大的大小如何去设置

了解：IO密集型，CPU密集型：（调优）

java复制代码//最大线程该如何定义

//1、CPU 密集型 几核 就是几 保持CPU的效率最高

//2、IO 密集型 > 判断你程序中十分耗IO的线程

//3、程序 15个大型任务 io十分占用资源

package com.jxau.ThreadPool;

import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/*
*   new ThreadPoolExecutor.AbortPolicy() // 银行满了，还有人进来，不处理这个人的，抛出异常
*   new ThreadPoolExecutor.CallerRunsPolicy()// 哪来的去哪里
*   new ThreadPoolExecutor.DiscardOldestPolicy()// 队列满了，尝试去和最早的竞争，也不会抛出异常
*   new ThreadPoolExecutor.DiscardPolicy()// 队列满了，丢掉任务，不会抛出异常
*/

public class Test02 {
    public static void main(String[] args) {

        int i1 = Runtime.getRuntime().availableProcessors(); // 获得运行时的机子最大cpu核数
        /*System.out.println(i1);*/
        

        // 手动创建一个线程池
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(2,
                                                                      i1,
                                                                       3,
                                                         TimeUnit.SECONDS,
                                                new LinkedBlockingDeque<>(3),
                                                new ThreadPoolExecutor.DiscardPolicy()// 队列满了，丢掉任务，不会抛出异常
                                                                        );
        try{
            for(int i=0;i<10;i++){
                threadPoolExecutor.execute(()->{
                    System.out.println(Thread.currentThread().getName());
                });
            }

        }catch (Exception e){
            e.printStackTrace();
        }finally {
            threadPoolExecutor.shutdown();// 关闭线程池
        }
    }
}

函数式接口

lambda表达式、链式编程、函数式接口、stream流式计算

function函数式接口

java复制代码package com.jxau.function;

import java.util.function.Function;

public class Test01 {

    public static void main(String[] args) {
        Function<String, String> function = new Function<String, String>() {
            @Override
            public String apply(String s) {
                return s;
            }
        };
        Function<String, String> function1=(s)->{return s;}; // lamdand 表达式简化
        System.out.println(function.apply("123"));
    }
}

Predicate 断定型接口

java复制代码package com.jxau.function;

import java.util.function.Predicate;

public class Test02 {
    public static void main(String[] args) {
        Predicate <String> predicate=new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return s.isEmpty();
            }
        };
        System.out.println(predicate.test("123"));
    }
}

consumer 消费型接口

java复制代码package com.jxau.function;

import java.util.function.Consumer;

public class Test03 {


    public static void main(String[] args) {
        // 消费性接口
/*       Consumer<Object> c= new Consumer<Object>() {
           @Override
            public void accept(Object o) {
                System.out.println(o);
            }
        };*/

        Consumer<String> c=(res)->{ System.out.println(res);};
       c.accept("123");

    }
}

supply 供给型接口

java复制代码package com.jxau.function;

import java.util.function.Supplier;

public class Test04 {

    public static void main(String[] args) {
     /*   Supplier<String> ss= new Supplier<String>(){
            @Override
            public String get() {
                return "123";
            }
        };*/

        Supplier<String> ss=()->{return "123";};
        System.out.println(ss.get());
    }
}

流式计算

java复制代码package com.jxau.stream;

import java.util.Arrays;
import java.util.List;

public class Test01 {

    /*
    * stream流式计算
    *   只用一行代码完成下列要求：
    * 1、倒序输出名字
    * 3、名字字母大写
    * 4、id为偶数的
    * 5、年龄大于23的
    *
    * */
    public static void main(String[] args) {

        User u1=new User(1,"a",20);
        User u2=new User(2,"b",21);
        User u3=new User(3,"c",22);
        User u4=new User(4,"d",23);
        User u5=new User(5,"e",24);
        User u6=new User(6,"f",25);
        List<User> users = Arrays.asList(u1, u2, u3, u4, u5, u6);
        users.stream()
                .filter((u)->{ return u.getId()%2==0;})
                .filter((u)->{return u.getAge()>23;})
                .map((u)->{return u.getName().toUpperCase();})// 函数式接口，可输入可输出
                .sorted((uu1,uu2)->{return uu1.compareTo(uu2);})
                .limit(1)
                .forEach(System.out::println);


    }

}

ForkJoin

什么是ForkJoin

ForkJoin在JDK1.7，并行执行任务！提高效率。大数据量！

大数据：Map Reduce(把大任务拆分为小任务)

ForkJoin 特点：工作窃取

异步回调

没有返回值的异步回调

java复制代码package com.jxau.async;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;

public class Test01 {

    public static void main(String[] args) {

        CompletableFuture<Void> completableFuture= CompletableFuture.runAsync(()->{

            System.out.println(Thread.currentThread().getName()+"runAsync");
            System.out.println("123");

        });
        try {
            completableFuture.get();// 执行方法获得返回值
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

        System.out.println("1111");
    }
}

有返回值的异步回调

java复制代码package com.jxau.async;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

public class Test02 {
    public static void main(String[] args) {
        CompletableFuture<String> completableFuture=CompletableFuture.supplyAsync(()->{

            System.out.println(Thread.currentThread().getName()+"supplyAsync");
            //int i=10/0;
            return "123";
        });

        try {
            System.out.println(completableFuture.whenCompleteAsync((u1, u2) -> {

                System.out.println("u1=" + u1);// 输出正常的返回值
                System.out.println("u2=" + u2);// 输出错误信息 java.util.concurrent.CompletionException: java.lang.ArithmeticException: / by zero

            }).exceptionally((e)->{
                System.out.println(e);
                return e.getMessage();
            }).get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

JMM

谈谈你对Volatile的理解

volatile是java虚拟机提供轻量级的同步机制

1、保证可见性

2、不保证原子性

3、禁止指令重排

什么是JMM

JMM：java内存模型，不存在的东西，概念！约定！

关于JMM的一些同步的约定：

1、线程解锁前，必须把共享变量立刻刷回主存。

2、线程加锁前，必须读取主存中的最新值到工作内存中！

3、加锁和解锁是同一把锁

内存交互操作有8种，虚拟机实现必须保证每一个操作都是原子的，不可在分的（对于double和long类型的变量来说，load、store、read和write操作在某些平台上允许例外）

lock （锁定）：作用于主内存的变量，把一个变量标识为线程独占状态
unlock （解锁）：作用于主内存的变量，它把一个处于锁定状态的变量释放出来，释放后的变量才可以被其他线程锁定
read （读取）：作用于主内存变量，它把一个变量的值从主内存传输到线程的工作内存中，以便随后的load动作使用
load （载入）：作用于工作内存的变量，它把read操作从主存中变量放入工作内存中
use （使用）：作用于工作内存中的变量，它把工作内存中的变量传输给执行引擎，每当虚拟机遇到一个需要使用到变量的值，就会使用到这个指令
assign （赋值）：作用于工作内存中的变量，它把一个从执行引擎中接受到的值放入工作内存的变量副本中
store （存储）：作用于主内存中的变量，它把一个从工作内存中一个变量的值传送到主内存中，以便后续的write使用
write 　（写入）：作用于主内存中的变量，它把store操作从工作内存中得到的变量的值放入主内存的变量中

　　JMM对这八种指令的使用，制定了如下规则：

不允许read和load、store和write操作之一单独出现。即使用了read必须load，使用了store必须write
不允许线程丢弃他最近的assign操作，即工作变量的数据改变了之后，必须告知主存
不允许一个线程将没有assign的数据从工作内存同步回主内存
一个新的变量必须在主内存中诞生，不允许工作内存直接使用一个未被初始化的变量。就是怼变量实施use、store操作之前，必须经过assig22n和load操作
一个变量同一时间只有一个线程能对其进行lock。多次lock后，必须执行相同次数的unlock才能解锁
如果对一个变量进行lock操作，会清空所有工作内存中此变量的值，在执行引擎使用这个变量前，必须重新load或assign操作初始化变量的值
如果一个变量没有被lock，就不能对其进行unlock操作。也不能unlock一个被其他线程锁住的变量
对一个变量进行unlock操作之前，必须把此变量同步回主内存

Volatile

保证可见性

java复制代码package com.jxau.tvolatile;

import java.util.concurrent.TimeUnit;

public class tvolatile {
     public volatile static int num=0;
    public static void main(String[] args) {


        new Thread(()->{
            while(num==0){

            }
        }).start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        num=1;
        System.out.println(num);
    }
}

2、不保证原子性

原子性：不可分割

线程A在执行任务的时候，不能被打扰的，也不能被分割。要么同时成功，要么同时失败。

java复制代码package com.jxau.tvolatile;

public class Test01 {

    private  volatile   static  int num=0;
    public  static void add(){
        num++;
    }
    public  static void main(String[] args) {

        for(int i=0;i<20;i++){
            new Thread(()->{

                for(int j=0;j<1000;j++){

                    add();
                }

            }).start();
        }

        while(Thread.activeCount()>2){// main、gc线程
            Thread.yield();// 线程礼让

        }
        System.out.println(num);

    }
}

如果不加lock和synchronized，怎么样保证原子性

使用原子类解决原子性问题

这些类的底层和操作系统挂钩！

java复制代码package com.jxau.tvolatile;

import java.util.concurrent.atomic.AtomicInteger;

public class Test03 {
    private  static AtomicInteger num=new AtomicInteger();// 原子类
    public  static void add(){
        num.incrementAndGet();
    }
    public  static void main(String[] args) {

        for(int i=0;i<20;i++){
            new Thread(()->{

                for(int j=0;j<1000;j++){

                    add();
                }

            }).start();
        }

        while(Thread.activeCount()>2){// main、gc线程
            Thread.yield();// 线程礼让

        }
        System.out.println(num);

    }
}

指令重排

什么是指令重排：你写的程序，计算机并不是按照你写的那样去执行。

源代码–>编译器优化的重排–>指令并行也可能会重排–>内存系统也会重排–>执行。

处理器在进行指令重排的时候，考虑：数据之间的依赖性！

java复制代码int x=1;// 1
int y=2;// 2
x=x+5;// 3
y=x*x;// 4

执行顺序不一样

可能造成影响的结果：a b x v这四个值默认都是 0；

线程A	线程B
x=a	y=b
b=1	a=2

正常的结果：x=0,y=0;

线程A	线程B
b=1	a=2
x=a	y=b

指令重排导致的诡异结果:x=2;y=1;

非计算机专业

volatile可以避免指令重排

内存屏障。CPU指令。作用：
1、保证特定的操作的执行顺序！

2、可以保证某些变量的内存可见性（利用这些特性volatile实现了可见性）

volatile是可以保持可见性。不能保证原子性，由于内存屏障，可以保证指令重排的现象产生！

彻底玩转单例模式

饿汉式单例

构造器私有，别人无法去new出对象

java复制代码package com.jxau.signal;

public class Hungry {
    // 饿汉式 可能会浪费空间
    private Hungry(){}
    public static final Hungry hungry=new Hungry();
    public static Hungry getInstance(){
        return hungry;
    }
}

懒汉式单例

java复制代码package com.jxau.signal;

public class LazyMan {

    private LazyMan(){
        System.out.println(Thread.currentThread().getName()+" "+"OK");
    }

    private volatile static  LazyMan lazyMan;// volatile 防止指令重排

    public static LazyMan getInstance(){
        // 双重检测锁检测+volatile避免指令重排
        if(lazyMan==null){
            synchronized (LazyMan.class){// synchronized保证原子性
                if(lazyMan==null) lazyMan=new LazyMan(); // 单线程下是没事的
                /*
                * 1、分配内存空间
                * 2、执行构造方法，初始化对象
                * 3、把这个对象指向这个空间
                * */
            }

        }
        return lazyMan;
    }


}

class Test{

    public static void main(String[] args) {
        for(int i=0;i<10;i++){
            new Thread(()->{
                LazyMan.getInstance();//  多线程下出现不安全的情况
            }).start();
        }
    }

        }

反射破坏单例

java复制代码package com.jxau.signal;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

public class LazyMan {

    private LazyMan(){
        System.out.println(Thread.currentThread().getName()+" "+"OK");
    }

    private volatile static  LazyMan lazyMan;// volatile 防止指令重排

    public static LazyMan getInstance(){
        // 双重检测锁检测+volatile避免指令重排
        if(lazyMan==null){
            synchronized (LazyMan.class){// synchronized保证原子性
                if(lazyMan==null) lazyMan=new LazyMan(); // 单线程下是没事的
                /*
                * 1、分配内存空间
                * 2、执行构造方法，初始化对象
                * 3、把这个对象指向这个空间
                * */
            }

        }
        return lazyMan;
    }


}

class Test{

    public static void main(String[] args) throws Exception {

       // 用反射破坏单例模式
        LazyMan lazyMan=LazyMan.getInstance();

        Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null);
        declaredConstructor.setAccessible(true);
        LazyMan lazyMan1 = declaredConstructor.newInstance();
        System.out.println(lazyMan);
        System.out.println(lazyMan1);

    }

}

三重检测锁———反射new出两个对象

jaVA复制代码package com.jxau.signal;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

public class LazyMan {

    private LazyMan(){

        synchronized (LazyMan.class){
            if(lazyMan!=null){
                System.out.println(Thread.currentThread().getName()+" "+"OK");
                throw new RuntimeException("不要试图使用反射破坏单例模式");
            }
        }

    }

    private volatile static  LazyMan lazyMan;// volatile 防止指令重排

    public static LazyMan getInstance(){
        // 双重检测锁检测+volatile避免指令重排
        if(lazyMan==null){
            synchronized (LazyMan.class){// synchronized保证原子性
                if(lazyMan==null) lazyMan=new LazyMan(); // 单线程下是没事的
                /*
                * 1、分配内存空间
                * 2、执行构造方法，初始化对象
                * 3、把这个对象指向这个空间
                * */
            }

        }
        return lazyMan;
    }


}

class Test{

    public static void main(String[] args) throws Exception {

       // 用反射破坏单例模式
        //LazyMan lazyMan=LazyMan.getInstance();

        Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null);
        declaredConstructor.setAccessible(true);
        LazyMan lazyMan1 = declaredConstructor.newInstance();
        LazyMan lazyMan2 = declaredConstructor.newInstance();
        System.out.println(lazyMan2);
        System.out.println(lazyMan1);

    }

}

设置红绿灯—–反射发i百年关键字

java复制代码package com.jxau.signal;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

public class LazyMan {

    private static boolean flag=false;
    private LazyMan(){

        synchronized (LazyMan.class){

            if(flag==false){
                flag=true;
            }else{
                throw new RuntimeException("不要试图使用反射破坏单例模式");
            }

        }

    }

    private volatile static  LazyMan lazyMan;// volatile 防止指令重排
    public static LazyMan getInstance(){
        // 双重检测锁检测+volatile避免指令重排
        if(lazyMan==null){
            synchronized (LazyMan.class){// synchronized保证原子性
                if(lazyMan==null) lazyMan=new LazyMan(); // 单线程下是没事的
                /*
                * 1、分配内存空间
                * 2、执行构造方法，初始化对象
                * 3、把这个对象指向这个空间
                * */
            }

        }
        return lazyMan;
    }


}

class Test{

    public static void main(String[] args) throws Exception {

        // 用反射破坏单例模式
        //LazyMan lazyMan=LazyMan.getInstance();

        Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null);
        declaredConstructor.setAccessible(true);
        LazyMan lazyMan1 = declaredConstructor.newInstance();
        LazyMan lazyMan2 = declaredConstructor.newInstance();
        System.out.println(lazyMan2);
        System.out.println(lazyMan1);

    }

}



 // 用反射破坏单例模式
        //LazyMan lazyMan=LazyMan.getInstance();
        Field flag = LazyMan.class.getDeclaredField("flag");
        flag.setAccessible(true);

        Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null);

        declaredConstructor.setAccessible(true);
        LazyMan lazyMan1 = declaredConstructor.newInstance();
        flag.set(lazyMan1,false);
        LazyMan lazyMan2 = declaredConstructor.newInstance();
        System.out.println(lazyMan2);
        System.out.println(lazyMan1);

内部类版

java复制代码package com.jxau.signal;

public class Holer {

    private static Holer holer;
    private Holer(){}

    public static Holer getInstance(){
        return InnerClass.HOLDER;
    }

    public static class InnerClass{
        private static final Holer HOLDER=new Holer();
    }
}

枚举类反射无法破解

java复制代码package com.jxau.signal;

import java.lang.reflect.Constructor;

public enum EnumSignalTest {

    ENUM_SIGNAL_TEST;

    public static EnumSignalTest getEnumSignalTest(){
        return EnumSignalTest.ENUM_SIGNAL_TEST;
    }

}

class Test02{


    public static void main(String[] args) throws Exception {
        EnumSignalTest enumSignalTest = EnumSignalTest.ENUM_SIGNAL_TEST;

        System.out.println(EnumSignalTest.getEnumSignalTest());
        System.out.println(EnumSignalTest.getEnumSignalTest());
        Constructor<EnumSignalTest> constructor = EnumSignalTest.class.getDeclaredConstructor(String.class,int.class);
        constructor.setAccessible(true);
        System.out.println(constructor.newInstance());

    }
}

CAS

什么是CAS

CAS：比较当前工作内存中的值和主存中的值，如果这个值是期望的，那么则者自行操作！如果不是就不更新

缺点：

1、你会耗时

2、一次性只能保证一个你共享变量的原子性

3、ABA问题

java复制代码package com.jxau.cas;

import java.util.concurrent.atomic.AtomicInteger;

public class Test {

    public static void main(String[] args) {

        AtomicInteger atomicInteger=new AtomicInteger(2020);
        System.out.println(atomicInteger.compareAndSet(2020, 2021));
        System.out.println(atomicInteger.get());
        atomicInteger.getAndIncrement();
        System.out.println(atomicInteger.compareAndSet(2020, 2021));
        System.out.println(atomicInteger.get());


    }
}

Unsafe

对应的地址上如果是这个var5，那就加上var4（1）

内存操作，效率很高！

原子引用解决ABA问题

什么是ABA问题

在atomiinteger这个类中,他用cas 保证原子性问题,但同时也引发了新的问题;

ABA,一句话,狸猫换太子,举个例子,

(V,内存值,A旧的预期值,B,要求个更新值);

举例:

有两个线程,同时操作一个变量,线程1执行时间比线程2执行时间长,线程2执行快

线程1读取值,此时读到的值是A,这时候线程被挂起,

线程2也读到值,并将A修改为X,然后又做了操作,X又改为Z,最后又将Z改为A;线程2交出执行权;

线程1此时拿到执行权了,此时进行compareAndSwap,发现内存值和期望值是一样,于是正常执行,

但是内存值在这期间已经被操作过;

ABA问题带来的影响

aba不解决资源会被提前挪用，这不是我们所希望的

解决ABA问题，引入原子引用！对应的思想：乐观锁！

带版本号的原子操作！

java复制代码package com.jxau.abaproblem;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicStampedReference;

public class Test01 {

    public static void main(String[] args) {
        // 通过原子引用解决ABA问题  乐观锁
        AtomicStampedReference<Integer> atomicStampedReference=new AtomicStampedReference<>(123,1);// 指定初始数据，指定时间戳（版本号）

        new Thread(()->{
            // 引出ABA问题

            System.out.println(Thread.currentThread().getName()+"A1-->"+atomicStampedReference.getStamp());
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            atomicStampedReference.compareAndSet(123,
                                    124,
                                    atomicStampedReference.getStamp(),
                                    atomicStampedReference.getStamp()+1);

            System.out.println(Thread.currentThread().getName()+"A2-->"+atomicStampedReference.getStamp());
            atomicStampedReference.compareAndSet(124,
                    123,
                    atomicStampedReference.getStamp(),
                    atomicStampedReference.getStamp()+1);

            System.out.println(Thread.currentThread().getName()+"A3-->"+atomicStampedReference.getStamp());

        }).start();

        new Thread(()->{
            int stamp=atomicStampedReference.getStamp();
            System.out.println(Thread.currentThread().getName()+"B1-->"+atomicStampedReference.getStamp());
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(atomicStampedReference.compareAndSet(123,
                    124,
                    stamp,
                    stamp+ 1));

            System.out.println(Thread.currentThread().getName()+"B2-->"+atomicStampedReference.getStamp());

        }).start();

    }


}

各种锁的理解

公平锁和非公平锁

公平锁：非常公平：需要排队等待其他线程执行完毕

非公平锁：非常不公平，可以插队（默认都是公平的）

java复制代码 public ReentrantLock() {
        sync = new NonfairSync();
    }

public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }

可重入锁

java复制代码package com.jxau.locks;

public class Test01 {

    public static void main(String[] args) {

        Phone phone=new Phone();
        new Thread(()->{
            phone.call();
        },"A").start();

        new Thread(()->{
            phone.call();
        },"B").start();
    }
}


class Phone{
    public synchronized void call(){

        System.out.println(Thread.currentThread().getName()+" "+"call");
        email();
    }

    public synchronized void email(){

        System.out.println(Thread.currentThread().getName()+" "+"email");
    }
}

java复制代码package com.jxau.locks;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Test02 {
    public static void main(String[] args) {
        Phone1 phone=new Phone1();
        new Thread(()->{
            phone.call();
        },"A").start();

        new Thread(()->{
            phone.call();
        },"B").start();
    }

}

class Phone1{

    Lock lock=new ReentrantLock();
    public  void call(){
        lock.lock();
        try{
            System.out.println(Thread.currentThread().getName()+" "+"call");
            email();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }

    public  void email(){


        lock.lock();
        try{
            System.out.println(Thread.currentThread().getName()+" "+"email");
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
}

自旋锁

java复制代码package com.jxau.locks;

import java.util.concurrent.atomic.AtomicReference;

public class SpinLock {

    AtomicReference<Thread> atomicReference=new AtomicReference<>();

    public void myLock(){
        Thread thread=Thread.currentThread();
        System.out.println(Thread.currentThread().getName()+" "+"-->Lock");
        while(!atomicReference.compareAndSet(null,thread)){

        }

    }

    public void myUnlock(){
        Thread thread=Thread.currentThread();
        System.out.println(Thread.currentThread().getName()+" "+"-->UnLock");
        while(!atomicReference.compareAndSet(thread,null)){

        }
    }
}

java复制代码package com.jxau.locks;

import java.util.concurrent.TimeUnit;

public class SpinLockTest {

    public static void main(String[] args) {

        SpinLock spinLock=new SpinLock();

        new Thread(()->{

            spinLock.myLock(); // 使用CAS自旋锁

            try{
                TimeUnit.SECONDS.sleep(5);

            }catch (Exception e){
                e.printStackTrace();
            }finally {
                spinLock.myUnlock();
            }

        },"A").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(()->{

            spinLock.myLock();
            try{
                TimeUnit.SECONDS.sleep(1);
            }catch (Exception e){
                e.printStackTrace();
            }finally {
                spinLock.myUnlock();
            }

        },"B").start();

    }
}

死锁

java复制代码package com.jxau.locks;

import java.util.concurrent.TimeUnit;

public class DeadLock {
    public static void main(String[] args) {

        Object o1=new Object();
        Object o2=new Object();
        new Thread(new Test(o1,o2),"T1").start();
        new Thread(new Test(o2,o1),"T2").start();
    }
}

class Test implements Runnable{

    private Object object1;
    private Object object2;

    public Test(Object object1, Object object2) {
        this.object1 = object1;
        this.object2 = object2;
    }

    @Override
    public void run() {

        synchronized (object1){

            System.out.println(Thread.currentThread().getName()+" get Object1 ==> Object2");

            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (object2){
                System.out.println(Thread.currentThread().getName()+" get Object2 ==> Object1");
            }
        }
    }
}

面试，工作中！排查问题：

1、日志

2、堆栈

本文转载自: 掘金

开发者博客 – 和开发相关的这里全都有

SQL告警，执行时间长？教你写一手好 SQL ！

发表于 2021-11-04

博主(编码砖家)负责的项目主要采用阿里云数据库MySQL，最近频繁出现慢SQL告警，执行时间最长的竟然高达5分钟。导出日志后分析，主要原因竟然是没有命中索引和没有分页处理。

其实这是非常低级的错误，我不禁后背一凉，团队成员的技术水平亟待提高啊。改造这些SQL的过程中，总结了一些经验分享给大家，如果有错误欢迎批评指正。

MySQL性能

最大数据量

抛开数据量和并发数，谈性能都是耍流氓。MySQL没有限制单表最大记录数，它取决于操作系统对文件大小的限制。

《阿里巴巴Java开发手册》提出单表行数超过500万行或者单表容量超过2GB，才推荐分库分表。性能由综合因素决定，抛开业务复杂度，影响程度依次是硬件配置、MySQL配置、数据表设计、索引优化。500万这个值仅供参考，并非铁律。博主曾经操作过超过4亿行数据的单表，分页查询最新的20条记录耗时0.6秒，SQL语句大致是 select field_1,field_2 from table where id < #{prePageMinId} order by id desc limit 20，prePageMinId是上一页数据记录的最小ID。虽然当时查询速度还凑合，随着数据不断增长，有朝一日必定不堪重负。分库分表是个周期长而风险高的大活儿，应该尽可能在当前结构上优化，比如升级硬件、迁移历史数据等等，实在没辙了再分。对分库分表感兴趣的同学可以阅读分库分表的基本思想。

最大并发数

并发数是指同一时刻数据库能处理多少个请求，由maxconnections和maxuserconnections决定。**maxconnections是指MySQL实例的最大连接数，上限值是16384，maxuserconnections是指每个数据库用户的最大连接数。MySQL会为每个连接提供缓冲区，意味着消耗更多的内存。如果连接数设置太高硬件吃不消，太低又不能充分利用硬件。一般要求两者比值超过10%，计算方法如下：

查看最大连接数与响应最大连接数：

在配置文件my.cnf中修改最大连接数

查询耗时0.5秒

建议将单次查询耗时控制在0.5秒以内，0.5秒是个经验值，源于用户体验的 3秒原则。如果用户的操作3秒内没有响应，将会厌烦甚至退出。响应时间=客户端UI渲染耗时+网络请求耗时+应用程序处理耗时+查询数据库耗时，0.5秒就是留给数据库1/6的处理时间。

实施原则

相比NoSQL数据库，MySQL是个娇气脆弱的家伙。它就像体育课上的女同学，一点纠纷就和同学闹别扭(扩容难)，跑两步就气喘吁吁(容量小并发低)，常常身体不适要请假(SQL约束太多)。如今大家都会搞点分布式，应用程序扩容比数据库要容易得多，所以实施原则是数据库少干活，应用程序多干活。

充分利用但不滥用索引，须知索引也消耗磁盘和CPU。
不推荐使用数据库函数格式化数据，交给应用程序处理。
不推荐使用外键约束，用应用程序保证数据准确性。
写多读少的场景，不推荐使用唯一索引，用应用程序保证唯一性。
适当冗余字段，尝试创建中间表，用应用程序计算中间结果，用空间换时间。
不允许执行极度耗时的事务，配合应用程序拆分成更小的事务。
预估重要数据表(比如订单表)的负载和数据增长态势，提前优化。

数据表设计

数据类型

数据类型的选择原则：更简单或者占用空间更小。

如果长度能够满足，整型尽量使用tinyint、smallint、medium_int而非int。
如果字符串长度确定，采用char类型。
如果varchar能够满足，不采用text类型。
精度要求较高的使用decimal类型，也可以使用BIGINT，比如精确两位小数就乘以100后保存。

尽量采用timestamp而非datetime。

相比datetime，timestamp占用更少的空间，以UTC的格式储存自动转换时区。

避免空值

MySQL中字段为NULL时依然占用空间，会使索引、索引统计更加复杂。从NULL值更新到非NULL无法做到原地更新，容易发生索引分裂影响性能。尽可能将NULL值用有意义的值代替，也能避免SQL语句里面包含 is not null的判断。

text类型优化

由于text字段储存大量数据，表容量会很早涨上去，影响其他字段的查询性能。建议抽取出来放在子表里，用业务主键关联。

索引优化

索引分类

普通索引：最基本的索引。
组合索引：多个字段上建立的索引，能够加速复合查询条件的检索。
唯一索引：与普通索引类似，但索引列的值必须唯一，允许有空值。
组合唯一索引：列值的组合必须唯一。
主键索引：特殊的唯一索引，用于唯一标识数据表中的某一条记录，不允许有空值，一般用primary key约束。
全文索引：用于海量文本的查询，MySQL5.6之后的InnoDB和MyISAM均支持全文索引。由于查询精度以及扩展性不佳，更多的企业选择Elasticsearch。

索引优化

分页查询很重要，如果查询数据量超过30%，MYSQL不会使用索引。
单表索引数不超过5个、单个索引字段数不超过5个。
字符串可使用前缀索引，前缀长度控制在5-8个字符。
字段唯一性太低，增加索引没有意义，如：是否删除、性别。
合理使用覆盖索引，如下所示：

select loginname, nickname from member where login_name = ?
loginname, nickname两个字段建立组合索引，比login_name简单索引要更快

SQL优化

分批处理

博主小时候看到鱼塘挖开小口子放水，水面有各种漂浮物。浮萍和树叶总能顺利通过出水口，而树枝会挡住其他物体通过，有时还会卡住，需要人工清理。MySQL就是鱼塘，最大并发数和网络带宽就是出水口，用户SQL就是漂浮物。不带分页参数的查询或者影响大量数据的update和delete操作，都是树枝，我们要把它打散分批处理，举例说明：业务描述：更新用户所有已过期的优惠券为不可用状态。SQL语句：update status=0 FROMcoupon WHERE expire_date <= #{currentDate} and status=1;如果大量优惠券需要更新为不可用状态，执行这条SQL可能会堵死其他SQL，分批处理伪代码如下：

操作符<>优化

通常<>操作符无法使用索引，举例如下，查询金额不为100元的订单：select id from orders where amount != 100;如果金额为100的订单极少，这种数据分布严重不均的情况下，有可能使用索引。鉴于这种不确定性，采用union聚合搜索结果，改写方法如下：

OR优化

在Innodb引擎下or无法使用组合索引，比如：

OR无法命中mobileno + userid的组合索引，可采用union，如下所示：

此时id和product_name字段都有索引，查询才最高效。

IN优化

IN适合主表大子表小，EXIST适合主表小子表大。由于查询优化器的不断升级，很多场景这两者性能差不多一样了。
尝试改为join查询，举例如下：

select id from orders where user_id in (select id from user where level = ‘VIP’);

采用JOIN如下所示：

不做列运算

通常在查询条件列运算会导致索引失效，如下所示：查询当日订单

date_format函数会导致这个查询无法使用索引，改写后：

避免Select all

如果不查询表中所有的列，避免使用 SELECT *，它会进行全表扫描，不能有效利用索引。

Like优化

like用于模糊查询，举个例子(field已建立索引)：

这个查询未命中索引，换成下面的写法：

去除了前面的%查询将会命中索引，但是产品经理一定要前后模糊匹配呢?全文索引fulltext可以尝试一下，但Elasticsearch才是终极武器。

Join优化

join的实现是采用Nested Loop Join算法，就是通过驱动表的结果集作为基础数据，通过该结数据作为过滤条件到下一个表中循环查询数据，然后合并结果。如果有多个join，则将前面的结果集作为循环数据，再次到后一个表中查询数据。

驱动表和被驱动表尽可能增加查询条件，满足ON的条件而少用Where，用小结果集驱动大结果集。
被驱动表的join字段上加上索引，无法建立索引的时候，设置足够的Join Buffer Size。
禁止join连接三个以上的表，尝试增加冗余字段。

Limit优化

limit用于分页查询时越往后翻性能越差，解决的原则：缩小扫描范围，如下所示：

先筛选出ID缩小查询范围，写法如下：

如果查询条件仅有主键ID，写法如下：

如果以上方案依然很慢呢?只好用游标了，感兴趣的朋友阅读JDBC使用游标实现分页查询的方法

其他数据库

作为一名后端开发人员，务必精通作为存储核心的MySQL或SQL Server，也要积极关注NoSQL数据库，他们已经足够成熟并被广泛采用，能解决特定场景下的性能瓶颈。

本文转载自: 掘金

开发者博客 – 和开发相关的这里全都有

Elastic search介绍和安装

发表于 2021-11-04

「这是我参与11月更文挑战的第4天，活动详情查看：2021最后一次更文挑战」

简介

Elasticsearch是一个需要安装配置的软件。

ELK技术栈说明

Elastic有一条完整的产品线：Elasticsearch、Logstash、Kibana等，前面说的三个就是大家常说的ELK技术栈（开源实时日志分析平台）。

Logstash 的作用就是一个数据收集器，将各种格式各种渠道的数据通过它收集解析之后格式化输出到Elasticsearch ，最后再由Kibana 提供的比较友好的 Web 界面进行汇总、分析、搜索。

ELK 内部实际就是个管道结构，数据从 Logstash 到 Elasticsearch 再到 Kibana 做可视化展示。这三个组件各自也可以单独使用，比如 Logstash 不仅可以将数据输出到Elasticsearch ，也可以到数据库、缓存等

Elastic

Elastic官网：www.elastic.co/cn/

Elastic有一条完整的产品线：Elasticsearch、Logstash、Kibana等，前面说的三个就是大家常说的ELK技术栈。

Elasticsearch

Elasticsearch官网：www.elastic.co/cn/products…

功能：

分布式的搜索引擎：百度、Google、站内搜索

全文检索：提供模糊搜索等自动度很高的查询方式，并进行相关性排名，高亮等功能

数据分析引擎（分组聚合）：电商网站—一周内手机销量Top10

对海量数据进行近乎实时处理：水平扩展，每秒钟可处理海量事件，同时能够自动管理索引和查询在集群中的分布方式，以实现极其流畅的操作。

如上所述，Elasticsearch具备以下特点：

高速、扩展性、最相关的搜索结果

分布式：节点对外表现对等，每个节点都可以作为入门，加入节点自动负载均衡
JSON：输入输出格式是JSON
Restful风格，一切API都遵循Rest原则，容易上手
近实时搜索，数据更新在Elasticsearch中几乎是完全同步的，数据检索近乎实时
安装方便：没有其它依赖，下载后安装很方便，简单修改几个参数就可以搭建集群
支持超大数据：可以扩展到PB级别的结构化和非结构化数据

版本

目前Elasticsearch最新的版本是7.x，企业内目前用的比较多是6.x，我们以6.2.4进行讲解，需要JDK1.8及以上。

安装和配置

为了快速看到效果我直接在本地macOS下安装Elasticsearch。环境要求：JDK8及以上版本

第一步：把今天资料文件夹中准备好的软件放到一个没有中文没有空格的位置，解压即可

第二步：修改配置文件

1、修改索引数据和日志数据存储的路径

第33行和37行，修改完记得把注释打开

perl复制代码path.data: /Users/xxx/Documents/class/es/data
#
# Path to log files:
#
path.logs: /Users/xxx/Documents/class/es/log

第三步：进入bin目录中直接双击图下的命令文件

如果启动失败，需要修改虚拟机内存的大小找到jvm.options文件如图修改

Xms 是指设定程序启动时占用内存大小。一般来讲，大点，程序会启动的快一点，但是也可能会导致机器暂时间变慢。
Xmx 是指设定程序运行期间最大可占用的内存大小。如果程序运行需要占用更多的内存，超出了这个设置值，就会抛出OutOfMemory异常。

访问

启动后台输出如下

可以看到绑定了两个端口:

9300：集群节点间通讯接口，接收tcp协议

9200：客户端访问接口，接收Http协议

我们在浏览器中访问：http://127.0.0.1:9200

安装kibana

什么是Kibana

Kibana是一个基于Node.js的Elasticsearch索引库数据统计工具，可以利用Elasticsearch的聚合功能，生成各种图表，如柱形图，线状图，饼图等。

而且还提供了操作Elasticsearch索引数据的控制台，并且提供了一定的API提示，非常有利于我们学习Elasticsearch的语法。

安装

因为Kibana依赖于node，需要先安装Node.js

查看到node版本

1	复制代码node -v

然后安装kibana，与elasticsearch保持一致，也是6.2.4

配置运行

配置

进入安装目录下的confifig目录，修改kibana.yml文件的第21行（注释放开即可）：

运行

发现kibana的监听端口是5601

我们访问：http://127.0.0.1:5601

控制台

选择左侧的DevTools菜单，即可进入控制台页面

在页面右侧，我们就可以输入请求，访问Elasticsearch了

安装ik分词器

Lucene的IK分词器早在2012年已经没有维护了，现在我们要使用的是在其基础上维护升级的版本，并且开发为Elasticsearch的集成插件了，与Elasticsearch一起维护升级，版本也保持一致
github.com/medcl/elast…

安装

解压elasticsearch-analysis-ik-6.2.4.zip后,将解压后的文件夹拷贝到elasticsearch-6.2.4\plugins下，并重命名文件夹为ik

重新启动ElasticSearch，即可加载IK分词器

安装Head插件

elasticsearch-head 简介

elasticsearch-head是一个界面化的集群操作和管理工具，可以对集群进行傻瓜式操作。你可以通过插件把它集成到es（首选方式）,也可以安装成一个独立webapp。

es-head主要有三个方面的操作：

显示集群的拓扑,并且能够执行索引和节点级别操作
搜索接口能够查询集群中原始json或表格格式的检索数据
能够快速访问并显示集群的状态

官方的文档：github.com/mobz/elasti…

elasticsearch-head安装（基于谷歌浏览器）

直接下载压缩包，地址：fifiles.cnblogs.com/fifiles/san…
解压
在谷歌浏览器中点击“加载已解压的压缩程序”，找到elasticsearch-head文件夹，点击打开即可进行安装。

本文转载自: 掘金

开发者博客 – 和开发相关的这里全都有

静态关键字：static

发表于 2021-11-04

这是我参与11月更文挑战的第1天，活动详情查看：2021最后一次更文挑战

static 修饰成员变量

成员变量可以分为2类：

静态成员变量（有static修饰，属于类，内存中加载一次）：常表示如在线人数信息，等需要被共享的信息，可以被共享访问。
实例成员变量（无static修饰，存在于每个对象中）：常表示姓名、年龄等属于每个对象的信息。

ini复制代码
public class User {
    // 在线人数信息：静态成员变量
    public static int onLineNumber;
    // 实例成员变量
    private String name;
    private int age;

    public static void main(String[] args) {
        //1. 类名，静态成员变量
        User.onLineNumber ++;
        // 注意：同一个类中访问静态成员变量，类名可以省略不写
        System.out.println(onLineNumber);

        // 2. 对象.实例成员变量
        User u1 = new User();
        u1.name = "二师兄";
        u1.age = 30;
        System.out.println(u1.name);
        System.out.println(u1.age);
        // 对象.静态成员变量
        u1.onLineNumber ++;
        System.out.println(u1.onLineNumber);

        User u2 = new User();
        u2.name = "大师兄";
        u2.age = 30;
        System.out.println(u2.name);
        System.out.println(u2.age);
        // 对象.静态成员变量
        u2.onLineNumber ++;
        System.out.println(u2.onLineNumber);
        System.out.println(onLineNumber);

    }
}

static 修饰成员方法的基本用法

成员方法的分类：

静态成员方法（有static修饰，属于类）建议用类名访问，也可以使用对象访问。

实例成员方法（无static修饰，属于对象），只能用对象触发访问。

使用场景：

表示对象自己的行为的，且方法中更需要访问实例成员的，则该方法必须申明成实例方法。

如果该方法是以执行一个通用功能为目的，或者需要方便访问，则可以申明成静态方法。

csharp复制代码
public class Student {
    private String name;
    private int age;

    // 实例方法： 无static修饰，属于对象的，通常表示对象自己的行为，可以访问对象的成员变量
    public void study(){
        System.out.println(name + "在好好学习，天天向上~~");
    }

    // 静态方法： 有static 修饰，属于类，可以被类和对象共享访问
    public static void getMax(int a, int b){
        System.out.println(a > b? a : b);
    }

    public static void main(String[] args) {
        // 1.类名，静态方法
        Student.getMax(10,100);
        // 注意：同一个类中访问静态成员 可以省略类名不写
        getMax(200,20);
        // 2. 对象.实例方法
        // study(); // 报错的
        Student s = new Student();
        s.name = "全蛋";
        s.study();

        // 3. 对象.静态方法(不推荐)
        s.getMax(10,2);
    }
}

1.成员方法的分类和访问分别是什么样的？

静态成员方法（有static 修饰，属于类和对象共享）访问格式

类名.静态成员方法。

对象.静态成员方法。（不推荐）

实例成员方法（无static修饰，属于对象）的访问格式：

对象.实例成员方法。

每种成员方法的使用场景是什么样的？

表示对象自己的行为的，且方法中需要访问实例成员的，则该方法必须申明成实例方法。

如果该方法是以执行一个通用功能为目的，或者需要方便访问，则可以申明成静态方法。

static修饰成员方法的内存原理

加载类的时候，同时静态方法会暴露出调用接口，供调用

static 实际应用案例：使用静态方法定义工具类

工具类：

对于一些应用程序中，多次需要用的功能，可以将这些功能封装成静态方法。放在一个类中，这个类就是工具类。

工具类的作用：一是方便调用，二是提高了代码复用。

工具类原理和延伸：

一次编写，处处可用。

建议将工具类的构造器私有，不让工具类对外产生对象。

typescript复制代码public class Login {
    public static void main(String[] args) {
        System.out.println("验证码："+ VerifyTool.creteCode(5));
    }
}

arduino复制代码

public class VerifyTool {

    // 私有构造器
    private VerifyTool(){
        
    }

    // 静态方法
    public static String creteCode(int n){
        //1. 使用String开发一个验证码
        String chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
        //2. 定义一个变量 用于存储5位随机字符作为验证码
        String code = "";
        Random r = new Random();
        for (int i = 0; i<n; i++){
            int index = r.nextInt(chars.length());
            code += chars.charAt(index);
        }
        System.out.println("验证码："+code);
        return code;
    }
}

工具类不需要创建对象，构造器私有化。让调用者使用类名来调用，节约内存。

本文转载自: 掘金

开发者博客 – 和开发相关的这里全都有

数据仓库

发表于 2021-11-04

这是我参与11月更文挑战的第4天，活动详情查看：2021最后一次更文挑战

一、数据仓库

1.1 概念

数据仓库（Data Warehourse，简称 DW），是一个用于存储、分析、报告的数据系统。

数据仓库的目的是构建面向分析的集成化的数据环境，分析结果为企业提供决策支持（Decision Support）

最稳妥的方法就是基于业务数据开展数据分析，基于分析的结果给决策提供支持。这就是所谓的数据驱动决策的制定。在哪里进行数据分析呢？数据库可以吗？

可以但是没必要。

OLTP 系统的核心是面向业务，支持业务，支持事务。所有的业务操作可以分为读、写两种操作，一般来说读的压力明显大于写的压力。如果在 OLTP 环境直接开展各种分析，有以下问题需要考虑：

+ 数据分析也是对数据进行读取操作，会让读取压力倍增；
+ OLTP 仅存储数周或数月的数据；
+ 数据发散在不同系统不同表中，字段类型属性不统一；

因此，我们需要构建一个集成统一的数据分析平台，该平台面向数据分析，并非代替数据库。

1.2 特点

数据仓库本身并不生产任何数据，其数据来源于不同外部系统
同时数据仓库自身也不需要消费任何的数据，其结果开发给各个外部应用使用。

1.2.1 面向主题性（Subject-Oriented）

数据库中，最大特点是面向应用进行数据的组织，各个业务系统可能是相互分离
而数据仓库则是面向主题的。主题是一个抽象的概念，是较高层次上企业信息系统中的数据综合、归类并进行分析利用的抽象。在逻辑意义上，它是对应企业中某一宏观分析领域所涉及的分析对象。
操作型处理（传统数据）对数据的划分并不适用于决策分析。而基于主题组织的数据则不同，它们被划分为各自独立的领域，每个领域有各自的逻辑内涵但互不交叉，在抽象层次上对数据进行完整、一致和准确的描述。

1.2.2 集成性

确定主题之后，就需要获取和主题相关的数据。当下企业中主题相关的数据通常会分布在多个操作型系统中，彼此独立。
因此在数据进入数据仓库之前，必然要经过统一和综合，对数据进行抽取、清理、转换和汇总，这一步是数据仓库建设中最关键、最复杂的一步，所要完成的工作有：

+ 要统一源数据中所有矛盾之处，如字段的同名异义、单位不统一、字长不统一等；
+ 进行数据综合和计算，数据仓库中的数据综合工作可以在从原有数据库抽取数据时生成，但许多是在数据仓库内部生成的，即进入数据仓库之后进行综合生成的。

例如下面的例子，将数据纳入之前进行数据清洗：

1.2.3 非易失性、非异变性

数据仓库是分析数据的平台，而不是创造数据的平台。我们是通过数仓去分析数据中的规律，而不会去改变它们。
操作型数据库主要服务于日常的业务操作，每隔一段时间把一批新的数据导入数据仓库。
数据仓库的数据反映的是一段相当长的时间内历史数据的内容，是不同时点的数据库快照的集合，以及基于这些快照进行统计、综合和重组的导出数据。
数据仓库的用户对数据的操作大多是数据查询或比较复杂的挖掘。

1.2.4 时变性

数据仓库包含各种粒度的历史数据，数据可能与某个特定日期、星期、月份、季度或者年份有关。
数据仓库的数据需要随着时间更新，以适应决策的需要。

二、OLTP 和 OLAP

联机事务处理 OLTP
联机分析处理 OLAP

2.1 OLTP

操作型处理，叫联机事务处理 OLTP，主要目标是做数据处理，它是针对具体业务在数据库联机的日常操作，通常对少数记录进行查询、修改。
用户较为关心操作的响应时间、数据的安全性、完整性和并发支持的用户数等问题。
传统的关系型数据库系统（RDBMS）作为数据管理的主要手段，主要用于操作型处理。

2.2 OLAP

分析型处理，叫联机分析处理 OLAP，目标做数据分析
一般针对某些主题的历史数据进行复杂的多维分析，支持管理决策
数据仓库 OLAP 系统的一个典型实例，主要用于数据分析。

三、数据仓库和数据库

数据库与数据仓库的区别实际讲的是 OLTP 与 OLAP 的区别
数据仓库不是大型的数据库，并不是要取代数据库。
数据库是面向事务的涉及，一般存储业务数据；数据仓库是面向主题设计的，一般存储历史数据，面向分析而设计的。

四、数仓架构

4.1 分层思想和标准

根据业务需求分成不同的层次，但是最基础的分层思想，理论上分为三个层：操作型数据层（ODS）、数据仓库层（DW）、数据应用层（DA）。
企业在实际运用中可以基于这个基础分层之上添加新的层次，来满足不同的业务需求

4.2 阿里巴巴数仓 3层架构

为了更好的理解数据仓库分层的思想以及每层的功能意义，下面结合阿里巴巴提供除出的数仓分层架构图进行分析
阿里数仓是非常经典的3层架构，从下往上依次是：ODS、DW、DA
通过元数据管理和数据质量监控来把控整个数仓中数据的流传过程，血缘依赖关系和生命周期。

分层好处：

分层能对数据有一个更加清晰的掌握，主要有下面几个原因：

清晰数据结构

+ 每个数据分层都有它的作用域，在使用表的时候能更方便的定位和理解

数据血缘追踪

+ 最终给业务呈现的是一个能直接使用的业务表

减少重复开发

+ 规范数据分层，开发一些通用的中间层数据，能够减少极大的重复计算。

把复杂问题简单化

五、ETL、ELT 区别

数据仓库从各数据源获取数据及在数据仓库内的数据转换和流动都可以认为是 ETL（抽取、转化、装载）的过程

但是在实际操作中讲数据加载打仓库却产生了两种不同做法：ETL 和 ELT。

5.1 ETL 是什么？

ETL ：首先从数据源提取数据，数据保存在临时暂存数据库中（ODS），然后执行转换操作，讲数据结构化并转换为适合目标数据仓库系统的形式，然后将结构化数据加载到仓库中，以备分析。

5.2 ELT（比较多）

使用 ELT，数据在数据池中提取后立即加载，没有专门的临时数据库（ODS），这意味着数据会立即加载到单一的集中存储库中，数据在数据仓库系统中进行转换。

本文转载自: 掘金

开发者博客 – 和开发相关的这里全都有

1、筛选

2、映射

3、查找与匹配

4、归约操作

5、数值流

5.1 基础类型流特化

5.2 数值范围

6、构建流

引言

功能部件

实现逻辑

前提准备

实现Demo

相关文章

前言

一、Java集合

二、List

三、ArrayList

四、Vector

五、LinkedList

小白练习，花样出错

低阶方法：

get(), size(), isEmpty(), containsKey(), containsValue()

哪里不会装哪里

复习回顾

calendar 模块概述

calendar 相关方法

小试牛刀

总结

线程和进程

Lock锁

生产者和消费者问题

八锁问题

集合类不安全

Runnable

常见的辅助类（可以解决高并发限流）

CountDownLatch

CyclicBarrier

Semaphore

读写锁

阻塞队列

四组常用API

SynchronousQueue

线程池

函数式接口

流式计算

ForkJoin

异步回调

JMM

Volatile

彻底玩转单例模式

CAS

原子引用解决ABA问题

各种锁的理解

公平锁和非公平锁

可重入锁

自旋锁

死锁

MySQL性能

最大数据量

最大并发数

查询耗时0.5秒

实施原则

数据表设计

数据类型

避免空值

text类型优化

索引优化

索引分类

索引优化

SQL优化

分批处理

操作符<>优化

OR优化

IN优化

不做列运算

避免Select all

Like优化

Join优化

简介