大数据（9f）Flink状态编程

news2024/10/6 1:42:47

文章目录

  • 概述
  • Managed State
    • Operator State
      • ListState
      • BroadcastState
    • Keyed State
      • ValueState
      • ListState
      • MapState
    • ReducingState
    • AggregatingState
  • 状态后端
  • Appendix

概述

流式计算 分为 无状态计算 和 有状态计算

流处理的状态功能：去重、监控……

状态分类Managed StateRaw State
状态管理方式Flink Runtime托管，自动存储，自动恢复，自动伸缩用户自己管理
状态数据结构Flink提供多种数据结构，例如：ListState、MapState等字节数组：byte[]
使用场景多数Flink算子所有算子

Managed State

RawState是在已有算子和ManagedState不够用时才使用
一般来说，ManagedState已经够用，下面重点学习

Managed State 分类Operator StateKeyed State
译名算子状态键控状态
状态分配1个算子的子任务对应1个State1个算子处理多个Key，1个Key对应1个State
出场率较低较高

本文开发环境是WIN10+IDEA；Flink版本是1.14

<properties>
    <maven.compiler.source>8</maven.compiler.source>
    <maven.compiler.target>8</maven.compiler.target>
    <flink.version>1.14.6</flink.version>
    <scala.binary.version>2.12</scala.binary.version>
    <slf4j.version>2.0.3</slf4j.version>
    <log4j.version>2.17.2</log4j.version>
    <fastjson.version>2.0.19</fastjson.version>
    <lombok.version>1.18.24</lombok.version>
</properties>
<!-- https://mvnrepository.com/ -->
<dependencies>
    <!-- Flink -->
    <dependency>
        <groupId>org.apache.flink</groupId>
        <artifactId>flink-java</artifactId>
        <version>${flink.version}</version>
    </dependency>
    <dependency>
        <groupId>org.apache.flink</groupId>
        <artifactId>flink-streaming-java_${scala.binary.version}</artifactId>
        <version>${flink.version}</version>
    </dependency>
    <dependency>
        <groupId>org.apache.flink</groupId>
        <artifactId>flink-clients_${scala.binary.version}</artifactId>
        <version>${flink.version}</version>
    </dependency>
    <dependency>
        <groupId>org.apache.flink</groupId>
        <artifactId>flink-runtime-web_${scala.binary.version}</artifactId>
        <version>${flink.version}</version>
    </dependency>
    <!-- 日志 -->
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-api</artifactId>
        <version>${slf4j.version}</version>
    </dependency>
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-log4j12</artifactId>
        <version>${slf4j.version}</version>
    </dependency>
    <dependency>
        <groupId>org.apache.logging.log4j</groupId>
        <artifactId>log4j-to-slf4j</artifactId>
        <version>${log4j.version}</version>
    </dependency>
</dependencies>

Operator State

  • 算子状态可用在所有算子上，每个算子子任务（SubTask）共享一个状态
    算子子任务之间的状态不能互相访问
  • 下面以列表状态和广播状态为例

ListState

列表状态 可与 检查点 合用，来 定期保存和清空状态

import org.apache.flink.api.common.functions.MapFunction;
import org.apache.flink.api.common.state.ListState;
import org.apache.flink.api.common.state.ListStateDescriptor;
import org.apache.flink.runtime.state.FunctionInitializationContext;
import org.apache.flink.runtime.state.FunctionSnapshotContext;
import org.apache.flink.streaming.api.checkpoint.CheckpointedFunction;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.source.SourceFunction;

public class Hello {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment().setParallelism(1);
        //每3秒1次Checkpointing
        env.enableCheckpointing(3000L);
        //创建数据源，每秒1个数据
        DataStreamSource<Integer> dss = env.addSource(new MySource());
        //测试状态和检查点
        dss.map(new MyMapFunction()).print();
        //流环境执行
        env.execute();
    }

    private static class MyMapFunction implements MapFunction<Integer, String>, CheckpointedFunction {
        private ListState<Integer> state;

        @Override
        public String map(Integer value) throws Exception {
            state.add(value);
            return state.get().toString();
        }

        @Override
        public void snapshotState(FunctionSnapshotContext context) {
            System.out.println("Checkpoint时调用snapshotState，清空状态");
            state.clear();
        }

        @Override
        public void initializeState(FunctionInitializationContext context) throws Exception {
            System.out.println("创建状态");
            state = context.getOperatorStateStore().getListState(new ListStateDescriptor<>("", Integer.class));
        }
    }

    public static class MySource implements SourceFunction<Integer> {
        public MySource() {}

        @Override
        public void run(SourceContext<Integer> sc) throws InterruptedException {
            for (int i = 0; i < 99; i++) {
                sc.collect(i);
                Thread.sleep(1000L);
            }
        }

        @Override
        public void cancel() {}
    }
}

测试结果

创建状态
[0]
[0, 1]
Checkpoint时调用snapshotState，清空状态
[2]
[2, 3]
[2, 3, 4]
Checkpoint时调用snapshotState，清空状态
[5]
[5, 6]
[5, 6, 7]
Checkpoint时调用snapshotState，清空状态
[8]
……

BroadcastState

import org.apache.flink.api.common.state.BroadcastState;
import org.apache.flink.api.common.state.MapStateDescriptor;
import org.apache.flink.api.common.state.ReadOnlyBroadcastState;
import org.apache.flink.streaming.api.datastream.BroadcastConnectedStream;
import org.apache.flink.streaming.api.datastream.BroadcastStream;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.co.BroadcastProcessFunction;
import org.apache.flink.streaming.api.functions.source.SourceFunction;
import org.apache.flink.util.Collector;

import java.util.Scanner;

public class Hello {
    final static String STATE_KEY = "";

    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment().setParallelism(3);
        //1、主数据流
        DataStreamSource<Integer> mainStream = env.addSource(new AutomatedSource());
        //1、控制主数据的辅助流
        DataStreamSource<String> branchStream = env.addSource(new ManualSource());
        //2、创建状态描述符
        MapStateDescriptor<String, Long> stateDescriptor = new MapStateDescriptor<>("", String.class, Long.class);
        //2、创建广播流
        BroadcastStream<String> broadcastStream = branchStream.broadcast(stateDescriptor);
        //3、主数据流 连接 广播流
        BroadcastConnectedStream<Integer, String> b = mainStream.connect(broadcastStream);
        //BroadcastProcessFunction<IN1, IN2, OUT>
        b.process(new BroadcastProcessFunction<Integer, String, String>() {
            //processBroadcastElement(final IN2 value, final Context ctx, final Collector<OUT> out)
            @Override
            public void processBroadcastElement(String value, Context ctx, Collector<String> out) throws Exception {
                //4、获取广播状态
                BroadcastState<String, Long> state = ctx.getBroadcastState(stateDescriptor);
                //4、修改广播状态
                state.put(STATE_KEY, Long.valueOf(value));
            }

            //processElement(final IN1 value, final ReadOnlyContext ctx, final Collector<OUT> out)
            @Override
            public void processElement(Integer value, ReadOnlyContext ctx, Collector<String> out) throws Exception {
                //5、获取只读广播状态
                ReadOnlyBroadcastState<String, Long> state = ctx.getBroadcastState(stateDescriptor);
                //5、从广播状态中取值
                Long stateValue = state.get(STATE_KEY);
                //6、输出
                if (stateValue != null) {
                    out.collect("有请" + value + "号佳丽进入" + stateValue + "号舞台");
                }
            }
        }).print();
        //流环境执行
        env.execute();
    }

    /** 手动输入的数据源 */
    public static class ManualSource implements SourceFunction<String> {
        public ManualSource() {}

        @Override
        public void run(SourceFunction.SourceContext<String> sc) {
            Scanner scanner = new Scanner(System.in);
            while (true) {
                String str = scanner.nextLine().trim();
                if (str.equals("STOP")) {break;}
                if (!str.equals("")) {sc.collect(str);}
            }
            scanner.close();
        }

        @Override
        public void cancel() {}
    }

    /** 自动输入的数据源 */
    public static class AutomatedSource implements SourceFunction<Integer> {
        public AutomatedSource() {}

        @Override
        public void run(SourceFunction.SourceContext<Integer> sc) throws InterruptedException {
            for (int i = 0; i < 999; i++) {
                Thread.sleep(2000);
                sc.collect(i);
            }
        }

        @Override
        public void cancel() {}
    }
}

测试结果截图

Keyed State

  • ValueState<T>
    存储单个值
  • ListState<T>
    存储元素列表
  • MapState<UK, UV>
    存储键值对
  • ReducingState<T>
    存储单个值；当使用add时，ReducingState会使用指定的ReduceFunction进行聚合
  • AggregatingState<IN, OUT>
    类似ReducingState，区别是：AggregatingState的 聚合结果OUT 与 输入IN 可以不同

ValueState

import org.apache.flink.api.common.state.ValueState;
import org.apache.flink.api.common.state.ValueStateDescriptor;
import org.apache.flink.configuration.Configuration;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.KeyedProcessFunction;
import org.apache.flink.util.Collector;

public class Hello {
    public static void main(String[] args) throws Exception {
        //创建流执行环境，并行度=1
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment().setParallelism(1);
        //创建数据源
        DataStreamSource<Integer> dss = env.fromElements(9, 5, 2, 7);
        dss
                .keyBy(i -> true)
                .process(new KeyedProcessFunction<Boolean, Integer, String>() {
                    //1、声明状态变量
                    private ValueState<Integer> state;

                    @Override
                    public void open(Configuration parameters) {
                        //2、key范围内，实例化状态变量，状态变量是单例的
                        state = getRuntimeContext().getState(new ValueStateDescriptor<>("", Integer.class));
                    }

                    @Override
                    public void processElement(Integer i, Context context, Collector<String> out) throws Exception {
                        //3、获取上一次状态的值
                        Integer lastStateValue = state.value();
                        if (lastStateValue != null) {
                            //输出
                            out.collect("当前输入：" + i + "；上次状态值：" + lastStateValue);
                        }
                        //4、更新状态的值
                        state.update(i);
                    }
                })
                .print();
        env.execute();
    }
}
print
当前输入：5；上次状态值：9
当前输入：2；上次状态值：5
当前输入：7；上次状态值：2

ListState

import org.apache.flink.api.common.state.ListState;
import org.apache.flink.api.common.state.ListStateDescriptor;
import org.apache.flink.configuration.Configuration;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.KeyedProcessFunction;
import org.apache.flink.util.Collector;

public class Hello {
    public static void main(String[] args) throws Exception {
        //创建流执行环境，并行度=1
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment().setParallelism(1);
        //创建数据源
        DataStreamSource<Integer> dss = env.fromElements(9, 5, 2, 7);
        dss
                .keyBy(i -> true)
                .process(new KeyedProcessFunction<Boolean, Integer, String>() {
                    //1、声明状态列表
                    private ListState<Integer> state;

                    @Override
                    public void open(Configuration parameters) {
                        //2、实例化状态列表（key范围内单例）
                        state = getRuntimeContext().getListState(new ListStateDescriptor<>("", Integer.class));
                    }

                    @Override
                    public void processElement(Integer i, Context context, Collector<String> out) throws Exception {
                        //3、添加状态值
                        state.add(i);

                        //4、获取并收集状态列表
                        out.collect(state.get().toString());
                    }
                })
                .print();
        env.execute();
    }
}
print
[9]
[9, 5]
[9, 5, 2]
[9, 5, 2, 7]

MapState

import org.apache.flink.api.common.state.MapState;
import org.apache.flink.api.common.state.MapStateDescriptor;
import org.apache.flink.configuration.Configuration;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.KeyedProcessFunction;
import org.apache.flink.util.Collector;

public class Hello {
    public static void main(String[] args) throws Exception {
        //创建流执行环境，并行度=1
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment().setParallelism(1);
        //创建数据源
        DataStreamSource<Integer> dss = env.fromElements(9, 5, 2, 7);
        dss
                .keyBy(i -> true)
                .process(new KeyedProcessFunction<Boolean, Integer, String>() {
                    //1、声明状态映射
                    private MapState<String, Integer> state;

                    @Override
                    public void open(Configuration parameters) {
                        //2、实例化状态映射（分区范围内单例）
                        state = getRuntimeContext()
                                .getMapState(new MapStateDescriptor<>("", String.class, Integer.class));
                    }

                    @Override
                    public void processElement(Integer i, Context context, Collector<String> out) throws Exception {
                        //3、添加键值对put(key,value)
                        state.put(i.toString(), i);

                        //4、并收集状态
                        out.collect("keys：" + state.keys().toString());
                        out.collect("values：" + state.values().toString());
                    }
                })
                .print();
        env.execute();
    }
}
print
keys：[9]
values：[9]
keys：[5, 9]
values：[5, 9]
keys：[2, 5, 9]
values：[2, 5, 9]
keys：[2, 5, 7, 9]
values：[2, 5, 7, 9]

ReducingState

import org.apache.flink.api.common.state.ReducingState;
import org.apache.flink.api.common.state.ReducingStateDescriptor;
import org.apache.flink.configuration.Configuration;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.KeyedProcessFunction;
import org.apache.flink.util.Collector;

public class Hello {
    public static void main(String[] args) throws Exception {
        //创建流执行环境，并行度=1
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment().setParallelism(1);
        //创建数据源
        DataStreamSource<Integer> dss = env.fromElements(9, 5, 2, 7);
        dss
                .keyBy(i -> true)
                .process(new KeyedProcessFunction<Boolean, Integer, String>() {
                    //1、声明状态
                    private ReducingState<Integer> state;

                    @Override
                    public void open(Configuration parameters) {
                        //2、实例化状态列表（key范围内单例）
                        state = getRuntimeContext()
                                .getReducingState(new ReducingStateDescriptor<>("", Integer::sum, Integer.class));
                    }

                    @Override
                    public void processElement(Integer i, Context context, Collector<String> out) throws Exception {
                        //3、添加状态值
                        state.add(i);

                        //4、获取并收集状态结果
                        out.collect("归约值：" + state.get());
                    }
                })
                .print();
        env.execute();
    }
}
print
归约值：9
归约值：14
归约值：16
归约值：23

AggregatingState

import org.apache.flink.api.common.functions.AggregateFunction;
import org.apache.flink.api.common.state.AggregatingState;
import org.apache.flink.api.common.state.AggregatingStateDescriptor;
import org.apache.flink.api.common.typeinfo.Types;
import org.apache.flink.configuration.Configuration;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.KeyedProcessFunction;
import org.apache.flink.util.Collector;

public class Hello {
    public static void main(String[] args) throws Exception {
        //创建流执行环境，并行度=1
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment().setParallelism(1);
        //创建数据源
        DataStreamSource<Long> dss = env.fromElements(9L, 5L, 2L, 7L);
        dss
                .keyBy(i -> true)
                //KeyedProcessFunction<K, I, O>
                .process(new KeyedProcessFunction<Boolean, Long, Integer>() {
                    //1、声明状态AggregatingState<IN, OUT>
                    private AggregatingState<Long, Integer> state;

                    @Override
                    public void open(Configuration parameters) {
                        //2、创建状态描述器；AggregatingStateDescriptor<IN, ACC, OUT>
                        AggregatingStateDescriptor<Long, String, Integer> stateDescriptor =
                                //AggregatingStateDescriptor(String name,aggFunction,TypeInformation<ACC> stateType)
                                new AggregatingStateDescriptor<>("",
                                        //aggFunction：AggregateFunction<IN, ACC, OUT>
                                        new AggregateFunction<Long, String, Integer>() {
                                            @Override
                                            public String createAccumulator() {
                                                return "";
                                            }

                                            @Override
                                            public String add(Long value, String accumulator) {
                                                return accumulator + value;
                                            }

                                            @Override
                                            public Integer getResult(String accumulator) {
                                                return Integer.valueOf(accumulator);
                                            }

                                            @Override
                                            public String merge(String a1, String a2) {
                                                return a1 + a2; //合并两个累加器
                                            }
                                        }, Types.STRING);
                        //3、分区范围内创建状态单例对象
                        state = getRuntimeContext().getAggregatingState(stateDescriptor);
                    }

                    @Override
                    public void processElement(Long value, Context ctx, Collector<Integer> out) throws Exception {
                        //5、添加到状态
                        state.add(value);

                        //6、获取并收集状态列表
                        out.collect(state.get());
                    }
                })
                .print();
        env.execute();
    }
}
print
9
95
952
9527

状态后端

  • 状态后端（state backend）
    一个可插入的组件，用来 存储、访问以及维护 状态
  • 作用：
    本地的状态管理（本地状态存储在TaskManager的内存中）
    将checkpoint状态写入文件系统（如HDFS)
分类本地状态存储checkpoint状态存储特点备注
MemoryStateBackendTaskManager的内存JobManager的内存快、不稳弃用的
FsStateBackendTaskManager的内存文件系统稳弃用的
RocksDBStateBackendTaskManager的内存和RocksDB文件系统稳超大状态的作业

然而发现Flink1.14.6弃用了MemoryStateBackend和FsStateBackend的写法

env.setStateBackend(new MemoryStateBackend());
env.setStateBackend(new FsStateBackend(String checkpointDataUri));
//URI (e.g., 'file://', 'hdfs://', or 'S3://')

于是改用下面

//允许Checkpointing，每3秒1次
env.enableCheckpointing(3000L);
//设置状态后端
env.setStateBackend(new HashMapStateBackend());
//获取Checkpointing配置
CheckpointConfig config = env.getCheckpointConfig();
//检查点状态 存储到 JobManager的内存
config.setCheckpointStorage(new JobManagerCheckpointStorage());
//检查点状态 存储到 文件系统
config.setCheckpointStorage(new FileSystemCheckpointStorage(String checkpointDirectory));

Appendix

英🔉中
runtimeˈrʌntaɪmn. 运行时间；运行时(环境)
contextˈkɑːntekstn. 上下文，语境
managedˈmænɪdʒdadj. 受监督的；v. 经营（manage 的过去式及过去分词）
operatorˈɑːpəreɪtərn. （机器的）操作员；运算符号；算子
descriptordɪˈskrɪptərn. 描述符号

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/30659.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

半诚实模型与恶意模型

半诚实模型与恶意模型

原创 洪澄 开放隐私计算 开放隐私计算 开放隐私计算OpenMPC是国内第一个且影响力最大的隐私计算开放社区。社区秉承开放共享的精神&#xff0c;专注于隐私计算行业的研究与布道。社区致力于隐私计算技术的传播&#xff0c;愿成为中国 “隐私计算最后一公里的服务区”。 178篇…
阅读更多...
【Unity】自定义Untiy天空

【Unity】自定义Untiy天空

3、需求&#xff1a;更改默认天空盒&#xff0c;360显示所需的内容。 实施&#xff1a; 准备材料&#xff1a;一张8K图&#xff08;更清晰&#xff09; 步骤&#xff1a; 1、更改Camera为天空盒&#xff1b; 2、制作图片&#xff0c;怎么制作不说了&#xff0c;分辨率8192…
阅读更多...
Linux服务器安装部署最新稳定版本mongoDB社区版- Ubuntu-20.04版本

Linux服务器安装部署最新稳定版本mongoDB社区版- Ubuntu-20.04版本

没有玩过mongoDB&#xff0c;安装一次真&#x1f92c;波折&#xff0c;再次建议大家安装之前&#xff0c;一定要确定好服务器的操作系统&#xff0c;可以参考查看linux操作系统版本&#xff1a;Ubuntu&#xff1f;Centos&#xff1f;还是其他&#xff1f; 接前面在本地自测需要…
阅读更多...
解决jupyter下载好了库，但是无法使用的问题。以及补充jupyter如何下载新的库。

解决jupyter下载好了库，但是无法使用的问题。以及补充jupyter如何下载新的库。

文章目录出现原因验证解决步骤补充国内常用镜像源出现原因 出现这个问题的主要原因是&#xff0c;jupyter的内核&#xff08;或者说他使用的Python环境&#xff09;与下载库的环境不一样&#xff0c;解决办法就是更改kernel。换句话说就是将jupyter下载库的环境加入到内核环境…
阅读更多...
模拟双色球系统——Java

模拟双色球系统——Java

目录 一、内容简介 二、 基本流程 三、具体步骤 1.菜单栏 2.随机生成幸运号码 3.用户输入 4.判断中奖情况 5.打印数组 四、代码实现 五、效果展示 一、内容简介 双色球是彩票的一种玩法&#xff0c;规则如下&#xff1a; 红球一共6组&#xff0c;每组从1——33中随…
阅读更多...
微信h5 使用jssdk支付成功后,点击完成 页面关闭了,引出微信“点金计划“

微信h5 使用jssdk支付成功后,点击完成 页面关闭了,引出微信“点金计划“

可能会迷惑 为啥我们之前没有碰见过这种情况! 这样的情况只有两种情况,就是 你只是普通商户不是微信特约商户你的支付跳转功能还未被微信回收 那么怎么才能支付成功重新跳回自己的网站页面 刚开始经历这种情况的童鞋, 可能有点懵逼 先看个微信的之前发的一个公告吧 微信支付公…
阅读更多...
面试系列分布式事务：谈谈3PC的理解

面试系列分布式事务：谈谈3PC的理解

3PC就是三阶段提交是在二阶段提交上的改进版本&#xff0c;3PC最关键要解决的就是协调者和参与者同时挂掉的问题&#xff0c;所以3PC把2PC的准备阶段再次一分为二&#xff0c;这样三阶段提交。处理流程如下 &#xff1a; 阶段一 a) 协调者向所有参与者发出包含事务内容的 canCo…
阅读更多...
【深入浅出Java并发编程指南】「实战篇」教你如何使用AbstractQueuedSynchronizer实现自己的同步器组件

【深入浅出Java并发编程指南】「实战篇」教你如何使用AbstractQueuedSynchronizer实现自己的同步器组件

前提概要 之前的文章中会涉及到了相关AQS的原理和相关源码的分析&#xff0c;所谓实践是检验真理的唯一标准&#xff01;接下来就让我们活化一下AQS技术&#xff0c;主要针对于自己动手实现一个AQS同步器。 定义MyLock实现Lock Doug Lea大神在JDK1.5编写了一个Lock接口&#xf…
阅读更多...
【C++】模拟实现STL容器：vector

【C++】模拟实现STL容器：vector

目录 一、vector迭代器失效问题 1、Visual Studio和g对迭代器失效问题的表现 2、解决迭代器失效的方法 二、模拟实现构造函数调用不明确 1、问题描述 2、解决调用不明确的方法 三、reserve中的深浅拷贝问题 1、reserve中浅拷贝发生原因 2、浅拷贝发生的图解 3、解决方…
阅读更多...
vue.js毕业设计，基于vue.js前后端分离外卖点餐系统设计与实现（H5移动项目）

vue.js毕业设计，基于vue.js前后端分离外卖点餐系统设计与实现（H5移动项目）

功能介绍 【后台管理员功能】 会员列表&#xff1a;查看所有注册会员信息&#xff0c;支持删除 录入资讯&#xff1a;录入资讯标题、内容等信息 管理资讯&#xff1a;查看已录入资讯列表&#xff0c;支持删除和修改 广告设置&#xff1a;上传图片和设置小程序首页轮播图广告地…
阅读更多...
用Python代码画世界杯吉祥物拉伊卜（附代码）

用Python代码画世界杯吉祥物拉伊卜（附代码）

用Python代码画世界杯吉祥物拉伊卜&#xff08;附代码&#xff09; 世界杯正在火热进行中&#xff0c;世界杯的吉祥物拉伊卜也非常火。 本文用Python代码画世界杯吉祥物。不废话&#xff0c;可以直接先看视频效果。 视频效果 用Python代码画世界杯吉祥物拉伊卜实现方法介绍 …
阅读更多...
运用滤波反投影的方法对图像进行重建matlab仿真

运用滤波反投影的方法对图像进行重建matlab仿真

目录 1.算法描述 2.仿真效果预览 3.MATLAB部分代码预览 4.完整MATLAB程序 1.算法描述 直接由正弦图得到反投影图像&#xff0c;会存在严重的模糊&#xff0c;这是早期 CT 系统所存在的问题。傅立叶中心切片定理表明&#xff0c;投影的一维傅立叶变换是得到投影区域的二维傅…
阅读更多...
360安全卫士弹窗广告怎么彻底关闭

360安全卫士弹窗广告怎么彻底关闭

如何关闭360广告弹窗&#xff1f;有时候我们在电脑上看一些视频或者整理一些文件时&#xff0c;经常莫名其妙会出现一些广告弹窗&#xff0c;即使是关了也还会出现&#xff0c;很是影响用户体验感&#xff0c;那么怎么彻底关闭呢&#xff1f;下面给大家介绍具体教程&#xff0c…
阅读更多...
【单目3D目标检测】GUPNet论文精读与代码解析

【单目3D目标检测】GUPNet论文精读与代码解析

文章目录PrefaceAbstractContributionsPipelineBackboneNeckHeadLossGUPIn PaperIn CodeHTLIn PaperIn CodeRefernecePreface Lu Y, Ma X, Yang L, et al. Geometry uncertainty projection network for monocular 3d object detection[C]. Proceedings of the IEEE/CVF Intern…
阅读更多...
ActivitiListener

ActivitiListener

ActivitiListener目录概述需求&#xff1a;设计思路实现思路分析1.ActivitiListener2.Activity3.Gateway5.FieldExtensionIOSpecification参考资料和推荐阅读Survive by day and develop by night. talk for import biz , show your perfect code,full busy&#xff0c;skip ha…
阅读更多...
骨传导原理是什么？哪些骨传导耳机值得入手

骨传导原理是什么？哪些骨传导耳机值得入手

​骨传导耳机是目前耳机市场比较流行耳机&#xff0c;深受年轻一族和运动达人的喜爱。但尽管这种产品受到很多人的青睐&#xff0c;相较传统耳机&#xff0c;大众对骨传导耳机的认识和程度并不高&#xff0c;也有很多小伙伴不知道骨传导耳机的原理是怎么发声的&#xff0c;骨传…
阅读更多...
Vue子组件传自定义属性给父组件

Vue子组件传自定义属性给父组件

我们知道组件之间是不能够之间进行通信的&#xff0c;都是相互独立的&#xff0c;你用不了我的状态和方法&#xff0c;我也用不了你的&#xff0c;那如何实现通信呢&#xff0c;可以间接实现&#xff1b; 实现父组件和子组件的通信&#xff1a; 子组件想用父组件的状态需要父…
阅读更多...
Java并发之线程池

Java并发之线程池

文章目录前言一、Java中线程池概览1.1 类图1.2 内部流程图二、源码探索2.1 构造参数2.2 线程池状态2.3 Worker 的添加和运行2.4 阻塞队列2.5 任务拒绝策略三、实际使用3.1 动态线程池3.2 拓展使用3.3 springboot 中线程池参考前言 在高并发的 Java 程序设计中&#xff0c;编写…
阅读更多...
数字化安全生产平台 DPS 重磅发布

数字化安全生产平台 DPS 重磅发布

11 月 5 日&#xff0c;在 2022 杭州 云栖大会上&#xff0c;数字化安全生产平台 DPS 重磅发布&#xff0c;助力传统运维向 SRE 转型。 阿里巴巴资深技术专家 周洋 十四五规划下&#xff0c;各行各业全面加速数字化转型与升级。随着企业数字化业务规模变大&#xff0c;迭代速…
阅读更多...
Dubbo服务远程调用的简介及使用教程

Dubbo服务远程调用的简介及使用教程

一、Dubbo的简介 Dubbo是阿里巴巴公司开源的一个高性能、轻量级的 Java RPC 框架。 致力于提供高性能和透明化的 RPC 远程服务调用方案&#xff0c;以及 SOA 服务治理方案。 官网&#xff1a;https://dubbo.apache.org/ SOA架构&#xff1a;&#xff08;Service-Oriented Arch…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023