java复制代码static class Node {
    int key, value; //保存该节点的Key、Value
    Node next; //指向下一个节点

    public Node(int key, int value) {
        this.key = key;
        this.value = value;
    }
}

java复制代码private final int CAPACITY = 10000;
Node[] nodes = new Node[CAPACITY];

java复制代码public V get(Object key) {
    Node<K,V> e;
    return (e = getNode(hash(key), key)) == null ? null : e.value;
}

static final int hash(Object key) {
    int h;
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}


final Node<K,V> getNode(int hash, Object key) {
   Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
   if ((tab = table) != null && (n = tab.length) > 0 &&
       (first = tab[(n - 1) & hash]) != null) {
       if (first.hash == hash && // always check first node
           ((k = first.key) == key || (key != null && key.equals(k))))
           return first;
       if ((e = first.next) != null) {
           if (first instanceof TreeNode)
               return ((TreeNode<K,V>)first).getTreeNode(hash, key);
           do {
               if (e.hash == hash &&
                   ((k = e.key) == key || (key != null && key.equals(k))))
                   return e;
           } while ((e = e.next) != null);
       }
   }
   return null;
}

java复制代码public static int hashCode(int value) {
    return value;
}

python复制代码private int getIndex(int key) {
    int hash = Integer.hashCode(key);
    //高16位异或低16位
    hash ^= (hash >>> 16);
    //与数组长度取模，得到对应的索引下标
    return hash % CAPACITY;
}

java复制代码public int get(int key) {
    int idx = getIndex(key);
    Node now = nodes[idx];

    if (now != null) {
        if (now.key == key) {
            return now.value;
        } else {
            while (now != null) {
                if (now.key == key) {
                    return now.value;
                }
                now = now.next;
            }
        }
    }

    return -1;
}

python复制代码final Node<K,V> getNode(int hash, Object key) {
 Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (first = tab[(n - 1) & hash]) != null) {
        
        //如果是首节点，那么直接返回
        if (first.hash == hash && // always check first node
            ((k = first.key) == key || (key != null && key.equals(k))))
            return first;
        if ((e = first.next) != null) {
			//红黑树判断不用管
            if (first instanceof TreeNode)
                return ((TreeNode<K,V>)first).getTreeNode(hash, key);
            //遍历获取
            do {
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    return e;
            } while ((e = e.next) != null);
        }
    }
    //如果还没有就返回null值
    return null;
}

java复制代码public void put(int key, int value) {
    int idx = getIndex(key);
    Node now = nodes[idx], tmp = now;
    
    if (tmp != null) {
        Node prev = null;
        while (tmp != null) {
            if (tmp.key == key) {
                tmp.value = value;
                return;
            }
            prev = tmp;
            tmp = tmp.next;
        }
        tmp = prev;
    }

    Node node = new Node(key, value);
    if (tmp != null) {
        tmp.next = node;
    } else {
        nodes[idx] = node;
    }
}

python复制代码 public void remove(int key) {
 	 //得到索引
     int idx = getIndex(key);
     //拿到首节点
     Node now = nodes[idx];

	 //非空判断
     if (now != null) {
     	 //保存前节点
         Node prev = null;
         //遍历查找
         while (now != null) {
             //如果找到
             if (now.key == key) {
             	 //这里有两种情况
             	 //1. 如果要删除的节点是首节点，那么直接让当前数组下标对应的首节点位为其下一个节点
             	 //2. 如果不是，那么让前一个节点的下一个节点指向当前要删除节点的下一个节点就实现了删除效果
                 if (prev != null) {
                     prev.next = now.next;
                 }else {
                     nodes[idx] = now.next;
                 }
                 //不管是怎么删除的，都让当前节点的下一个节点为null，方便垃圾挥手（加分点哦）
                 now.next = null;
                 return;
             }
             //如果没找到，让前节点指向当前节点，当前节点指向其下一个节点
             prev = now;
             now = now.next;
         }
     }
 }

java复制代码public static void main(String[] args) {
    MyHashMap map = new MyHashMap();
    map.put(1,1);
    map.put(2,2);
    map.put(1,40);
    map.put(2,200);

    System.out.println(map.get(1));
    System.out.println(map.get(2));
}

java复制代码public class MyHashMap {

    static class Node {
        int key, value;
        Node next;

        public Node(int key, int value) {
            this.key = key;
            this.value = value;
        }
    }

    private final int CAPACITY = 10000;
    Node[] nodes = new Node[CAPACITY];

    public void put(int key, int value) {
        int idx = getIndex(key);
        Node now = nodes[idx], tmp = now;
        if (tmp != null) {
            Node prev = null;
            while (tmp != null) {
                if (tmp.key == key) {
                    tmp.value = value;
                    return;
                }
                prev = tmp;
                tmp = tmp.next;
            }
            tmp = prev;
        }

        Node node = new Node(key, value);
        if (tmp != null) {
            tmp.next = node;
        } else {
            nodes[idx] = node;
        }
    }

    public int get(int key) {
        int idx = getIndex(key);
        Node now = nodes[idx];

        if (now != null) {
            if (now.key == key) {
                return now.value;
            } else {
                while (now != null) {
                    if (now.key == key) {
                        return now.value;
                    }
                    now = now.next;
                }
            }
        }

        return -1;
    }

    public void remove(int key) {
        int idx = getIndex(key);
        Node now = nodes[idx];

        if (now != null) {
            Node prev = null;
            while (now != null) {
                if (now.key == key) {
                    if (prev != null) {
                        prev.next = now.next;
                    }else {
                        nodes[idx] = now.next;
                    }
                    now.next = null;
                    return;
                }
                prev = now;
                now = now.next;
            }
        }
    }

    private int getIndex(int key) {
        int hash = Integer.hashCode(key);
        hash ^= (hash >>> 16);
        return hash % CAPACITY;
    }

}

复制代码（1）用户端功能

（2）用户信息管理  用户信息管理

（3）发布信息管理  发布信息管理

（4）数据统计模块  统计系统信息及交易信息

xml复制代码<!--easy excel start-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>easyexcel</artifactId>
            <version>2.2.6</version>
        </dependency>
<!--easy excel end-->

java复制代码/**
 * @author ：Nickels
 * @date ：2020/7/27
 * @desc ：
 */
@FunctionalInterface
public interface ExcelConsumer<E> {

    void excute(List<E> e);
}

csharp复制代码/**
 * @author ：Nickels
 * @date ：2020/7/27
 * @desc ：
 */
// 有个很重要的点 DemoDataListener 不能被spring管理，要每次读取excel都要new,然后里面用到spring可以构造方法传进去
public class ExcelListener<T> extends AnalysisEventListener<T> {

    /**
     * 每隔5条存储数据库，实际使用中可以3000条，然后清理list ，方便内存回收
     */
    private static final int BATCH_COUNT = 1000;
    List<T> list = new ArrayList<T>();
    /**
     * 假设这个是一个DAO，当然有业务逻辑这个也可以是一个service。当然如果不用存储这个对象没用。这里我们传入自己的function作为参数
     */
    ExcelConsumer consumer;

    public ExcelListener() {
    }

    /**
     * 如果使用了spring,请使用这个构造方法。每次创建Listener的时候需要把spring管理的类传进来
     */
    public ExcelListener(ExcelConsumer consumer) {
        this.consumer = consumer;
    }


    @Override
    public void invoke(T t, AnalysisContext analysisContext) {
        list.add(t);
        if (list.size() > BATCH_COUNT){
            //超出界限值，保存数据库，避免oom
            //执行函数
            consumer.excute(list);

            // 存储完成清理 list
            list.clear();

        }
    }

    @Override
    public void doAfterAllAnalysed(AnalysisContext analysisContext) {
        // 这里也要保存数据，确保最后遗留的数据也存储到数据库
        consumer.excute(list);
    }

}

less复制代码/**
 * @author ：Nickels
 * @date ：2020/7/27
 */
@Getter
@Setter
public class SendAddressTemplate {

    @ExcelProperty(value = "公司名称",index = 0)
    private String companyName;

    @ExcelProperty(value = "姓名",index = 1)
    private String name;

    @ExcelProperty(value = "电话",index = 2)
    private String phone;

    @ExcelProperty(value = "详细地址",index = 3)
    private String addressDetail;

    @ExcelProperty(value = "备注",index = 4)
    private String remak;

}

scss复制代码EasyExcel.read(file.getInputStream(), SendAddressTemplate.class,new ExcelListener(p->{
                    //保存逻辑（可封装一个普通的sevice）p-为我们执行函数时传入的list
                    //sendAddressService.importExcel(p);
                })).sheet().doRead();

xml复制代码<dependency>
    <groupId>org.flowable</groupId>
    <artifactId>flowable-spring-boot-starter</artifactId>
    <version>6.4.2</version>
</dependency>

python复制代码└─database                                   # 数据库文件
    └─create
        └─all
            └─flowable.mysql.all.create.sql

ini复制代码jdbc:mysql://127.0.0.1:3306/flowable?allowMultiQueries=true&useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai&useSSL=false&nullCatalogMeansCurrent=true

java复制代码/** 运行时Service（用于运行时流程实例、流程变量、流程节点） */
@Autowired
private RuntimeService runtimeService;
/** 资源存储Service（用于模型、流程定义） */
@Autowired
private RepositoryService repositoryService;
/** 流程引擎Service */
@Qualifier("processEngine")
@Autowired
private ProcessEngine processEngine;
/** 任务Service（用于运行时的用户任务、审批日志） */
@Autowired
private TaskService taskService;
@Autowired
protected ManagementService managementService;
/** 历史Service（用于历史记录，可以找到历史的流程实例、流程节点） */
@Autowired
protected HistoryService historyService;

java复制代码 @Override
public boolean importProcessDefinition(MultipartFile file) {
    try {
        Deployment deployment = repositoryService.createDeployment()
                // .key()
                // .name(name)
                // .category(category)
                // .tenantId()
                // 通过压缩包的形式一次行多个发布
                // .addZipInputStream()
                // 通过InputStream的形式发布
                .addInputStream(file.getOriginalFilename(), file.getInputStream())
                // 通过存放在classpath目录下的文件进行发布
                // .addClasspathResource("p1.bpmn20.xml")
                // 通过xml字符串的形式
                // .addString()
                .deploy();
        ProcessDefinition processDefinition = repositoryService.createProcessDefinitionQuery().deploymentId(deployment.getId()).singleResult();
        if (processDefinition == null) {
            return false;
        }
    } catch (Exception e) {
        throw new BusinessException("导入流程定义失败：" + e.getMessage());
    }
    return true;
}

css复制代码workflow-server
  └─src
     └─main
         ├─java
         └─resources
             ├─mapper
             └─processes
                 └─请假流程1.bpmn20.xml

java复制代码// 创建 ProcessDefinitionQuery 
ProcessDefinitionQuery processDefinitionQuery = repositoryService.createProcessDefinitionQuery();
// 根据流程定义ID
// processDefinitionQuery.processDefinitionId(requestDTO.getId());
// 根据流程定义Key
// processDefinitionQuery.processDefinitionKeyLike("%" + requestDTO.getKey().trim() + "%");
// 根据流程定义名称
// processDefinitionQuery.processDefinitionNameLike("%" + requestDTO.getName().trim() + "%");
//
// 获取总数
long count = processDefinitionQuery.count();
// 获取单个 
ProcessDefinition processDefinition = processDefinitionQuery.singleResult();
// 获取列表
List<ProcessDefinition> processDefinitions = processDefinitionQuery.list();
// 获取分页
List<ProcessDefinition> processDefinitions = processDefinitionQuery.listPage(0, 10)

java复制代码public String getXmlResource(String id) {
     ProcessDefinition processDefinition = repositoryService.createProcessDefinitionQuery().processDefinitionId(id).singleResult();
     InputStream inputStream = repositoryService.getResourceAsStream(processDefinition.getDeploymentId(),
                                                                     processDefinition.getResourceName());
     try {
         return IOUtils.toString(inputStream, StandardCharsets.UTF_8);
     } catch (Exception e) {
         throw new BusinessException("获取资源失败：" + e.getMessage());
     } finally {
         try {
             IOUtils.close(inputStream, null);
         } catch (IOException ignored) {
         }
     }
}

java复制代码public String getDiagramImageResource(String id) {
    // 理论上我用这种形式也是行的，但是我获取出来会有乱码，我也比较奇怪，所以换了通过 bpmnModel 的方式
    // ProcessDefinition processDefinition = repositoryService.createProcessDefinitionQuery().processDefinitionId(id).singleResult();
    // InputStream inputStream = repositoryService.getResourceAsStream(processDefinition.getDeploymentId(),
    //                                                                 processDefinition.getDiagramResourceName());
    // 获取bpmnModel对象
    BpmnModel bpmnModel = repositoryService.getBpmnModel(id);
    // 生成图片流
    ProcessEngineConfiguration configuration = processEngine.getProcessEngineConfiguration();
    ProcessDiagramGenerator diagramGenerator = configuration.getProcessDiagramGenerator();
    InputStream inputStream = diagramGenerator.generateDiagram(bpmnModel, "png", Collections.emptyList(),
                                                               Collections.emptyList(), "宋体", "宋体", "宋体",
                                                               this.getClass().getClassLoader(), 1.0, true);
    try {
        return "data:image/png;base64," + Base64.encode(inputStream);
    } catch (Exception e) {
        throw new BusinessException("获取资源失败：" + e.getMessage());
    } finally {
        try {
            IOUtils.close(inputStream, null);
        } catch (IOException ignored) {
        }
    }
}

java复制代码public void deleteByIds(List<String> ids) {
     List<ProcessDefinition> processDefinitions = repositoryService.createProcessDefinitionQuery().processDefinitionIds(new HashSet<>(ids)).list();
     // repositoryService.deleteDeployment(String deploymentId, boolean cascade)
     // 删除给定的部署和级联删除流程实例、历史流程实例和作业。
     processDefinitions.forEach(v -> repositoryService.deleteDeployment(v.getDeploymentId(), true));
 }

java复制代码@Data
@ApiModel("流程实例-审批意见请求参数")
public class ProcessInstanceCommentRequestDTO implements Serializable {

    @ApiModelProperty(value = "流程定义Key")
    private String processInstanceId;
    @ApiModelProperty(value = "任务ID（缺省）")
    private String taskId;
    @ApiModelProperty(value = "类型 CommentEntity: event/comment")
    private String type;

    @ApiModelProperty(value = "用户ID")
    private String userId;
    @ApiModelProperty(value = "用户昵称")
    private String nickname;
    @ApiModelProperty(value = "执行类型")
    private String executeType;
    @ApiModelProperty(value = "执行类型（参考ExecuteTypeEnum）SUBMIT-提交;YES-同意;NO-拒绝;STOP-流程终止;DELETE-流程删除")
    private String executeTypeValue;
    @ApiModelProperty(value = "内容")
    private String content;
    @ApiModelProperty(value = "额外携带的内容")
    private String ext;
}

java复制代码// 添加流程实例审批记录
public void addProcessInstanceComment(ProcessInstanceCommentRequestDTO requestDTO) {
    CommentWrapper wrapper = new CommentWrapper();
    wrapper.setUserId(requestDTO.getUserId());
    wrapper.setNickname(requestDTO.getNickname());
    wrapper.setExecuteType(requestDTO.getExecuteType());
    wrapper.setExecuteTypeValue(requestDTO.getExecuteTypeValue());
    wrapper.setContent(requestDTO.getContent());
    wrapper.setExt(requestDTO.getExt());
    String message = JSON.toJSONString(wrapper);
    // 使用 taskService 添加一条审批意见
    taskService.addComment(requestDTO.getTaskId(), requestDTO.getProcessInstanceId(), requestDTO.getType(), message);
}

java复制代码@Data
@ApiModel("流程实例-启动请求参数")
public class ProcessInstanceStartRequestDTO implements Serializable {

    @ApiModelProperty(value = "流程定义Key")
    @NotEmpty(message = "流程定义Key 不可以为空")
    private String processDefinitionKey;
    @ApiModelProperty(value = "流程实例名称")
    @NotEmpty(message = "流程实例名称 不可以为空")
    private String name;
    @ApiModelProperty(value = "项目ID")
    @NotEmpty(message = "项目ID 不可以为空")
    private String communityId;
    @ApiModelProperty(value = "全局变量")
    private Map<String, Object> variables;

}

java复制代码@Transactional(rollbackFor = Exception.class)
public ProcessInstanceStartResponseDTO startProcessInstance(ProcessInstanceStartRequestDTO requestDTO) {
    ValidatorUtils.validate(requestDTO);
    //
    ProcessDefinitionQuery processDefinitionQuery = repositoryService.createProcessDefinitionQuery();
    processDefinitionQuery.processDefinitionKey(requestDTO.getProcessDefinitionKey());
    ProcessDefinition processDefinition = processDefinitionQuery.latestVersion().singleResult();
    AssertUtils.notEmpty(processDefinition, "找不到流程定义");
    // 启动流程
    ProcessInstanceBuilder builder = runtimeService.createProcessInstanceBuilder();
    builder.processDefinitionKey(requestDTO.getProcessDefinitionKey());
    builder.name(requestDTO.getName());
    // variables("name", "value") 
    // 可以添加流程过程的变量，比如这里我添加了我不少业务变量进来，方面流程流转的时候处理业务
    builder.variables(requestDTO.getVariables());
    builder.variable(VAR_COMMUNITY_ID, VAR_COMMUNITY_ID_EQ + requestDTO.getCommunityId());
    builder.variable(VAR_PROCESS_INSTANCE_NAME, VAR_PROCESS_INSTANCE_NAME_EQ + requestDTO.getName());
    builder.variable(VAR_CREATE_USER_ID, VAR_CREATE_USER_ID_EQ + SecurityUser.getUserId());
    builder.variable(VAR_CREATE_USER_NICKNAME, VAR_CREATE_USER_NICKNAME_EQ + SecurityUser.get().getName());
    builder.variable(VAR_PROCESS_DEFINITION_NAME, VAR_PROCESS_DEFINITION_NAME_EQ + processDefinition.getName());
    builder.transientVariables(requestDTO.getTransientVariables());
    // builder.tenantId("101");
    ProcessInstance processInstance = builder.start();
    // 添加审批意见
    ProcessInstanceCommentRequestDTO commentRequestDTO = new ProcessInstanceCommentRequestDTO();
    commentRequestDTO.setProcessInstanceId(processInstance.getProcessInstanceId());
    commentRequestDTO.setTaskId(null);
    commentRequestDTO.setUserId(SecurityUser.getUserId());
    commentRequestDTO.setNickname(SecurityUser.get().getName());
    commentRequestDTO.setExecuteType(ExecuteTypeEnum.SUBMIT.name());
    commentRequestDTO.setExecuteTypeValue(ExecuteTypeEnum.SUBMIT.getValue());
    commentRequestDTO.setContent(requestDTO.getName() + " 提交流程");
    commentRequestDTO.setExt("");
    this.addProcessInstanceComment(commentRequestDTO);
    // 构建 ResponseDTO
    ProcessInstanceStartResponseDTO responseDTO = new ProcessInstanceStartResponseDTO();
    responseDTO.setProcessInstanceId(processInstance.getProcessInstanceId());
    responseDTO.setProcessDefinitionId(processInstance.getProcessDefinitionId());
    responseDTO.setProcessDefinitionKey(processInstance.getProcessDefinitionKey());
    responseDTO.setProcessDefinitionName(processInstance.getProcessDefinitionName());
    responseDTO.setName(processInstance.getName());
    responseDTO.setBusinessKey(processInstance.getBusinessKey());
    responseDTO.setDescription(processInstance.getDescription());
    //
    return responseDTO;
}

java复制代码public String getProcessImage(String processInstanceId) {
    // 1.获取当前的流程实例
    ProcessInstance processInstance = runtimeService.createProcessInstanceQuery().processInstanceId(processInstanceId).singleResult();
    String processDefinitionId;
    List<String> activeActivityIds = new ArrayList<>();
    List<String> highLightedFlows = new ArrayList<>();
    // 2.获取所有的历史轨迹线对象
    List<HistoricActivityInstance> historicActivityInstances = historyService.createHistoricActivityInstanceQuery()
            .processInstanceId(processInstanceId).activityType(BpmnXMLConstants.ELEMENT_SEQUENCE_FLOW).list();
    historicActivityInstances.forEach(historicActivityInstance -> highLightedFlows.add(historicActivityInstance.getActivityId()));
    // 3. 获取流程定义id和高亮的节点id
    if (processInstance != null) {
        // 3.1 正在运行的流程实例
        processDefinitionId = processInstance.getProcessDefinitionId();
        activeActivityIds = runtimeService.getActiveActivityIds(processInstanceId);
    } else {
        // 3.2 已经结束的流程实例
        HistoricProcessInstance historicProcessInstance = historyService.createHistoricProcessInstanceQuery()
                .processInstanceId(processInstanceId).singleResult();
        processDefinitionId = historicProcessInstance.getProcessDefinitionId();
        // 3.3 获取结束节点列表
        List<HistoricActivityInstance> historicEnds = historyService.createHistoricActivityInstanceQuery()
                .processInstanceId(processInstanceId).activityType(BpmnXMLConstants.ELEMENT_EVENT_END).list();
        List<String> finalActiveActivityIds = activeActivityIds;
        historicEnds.forEach(historicActivityInstance -> finalActiveActivityIds.add(historicActivityInstance.getActivityId()));
    }
    // 4. 获取bpmnModel对象
    BpmnModel bpmnModel = repositoryService.getBpmnModel(processDefinitionId);
    // 5. 生成图片流
    ProcessEngineConfiguration configuration = processEngine.getProcessEngineConfiguration();
    ProcessDiagramGenerator diagramGenerator = configuration.getProcessDiagramGenerator();
    InputStream inputStream = diagramGenerator.generateDiagram(bpmnModel, "png", activeActivityIds,
                                                               highLightedFlows, "宋体", "宋体", "宋体",
                                                               this.getClass().getClassLoader(), 1.0, true);
    // 6. 转化成Base64网络传输
    return "data:image/png;base64," + Base64.encode(inputStream);
}

java复制代码@Override
public List<ProcessInstanceCommentResponseDTO> findProcessInstanceCommentList(String processInstanceId) {
    List<Comment> processInstanceComments = taskService.getProcessInstanceComments(processInstanceId);
    List<ProcessInstanceCommentResponseDTO> list = processInstanceComments.stream()
            .map(this::convertComment)
            .filter(Objects::nonNull).collect(Collectors.toList());
    return list;
}

private ProcessInstanceCommentResponseDTO convertComment(Comment v) {
    String fullMessage = v.getFullMessage();
    if (StringUtils.startsWith(fullMessage, "{")) {
        CommentWrapper wrapper = JSON.parseObject(fullMessage, CommentWrapper.class);
        ProcessInstanceCommentResponseDTO responseDTO = new ProcessInstanceCommentResponseDTO();
        responseDTO.setProcessInstanceId(v.getProcessInstanceId());
        responseDTO.setType(v.getType());
        responseDTO.setTaskId(v.getTaskId());
        responseDTO.setTime(v.getTime());
        responseDTO.setUserId(wrapper.getUserId());
        responseDTO.setNickname(wrapper.getNickname());
        responseDTO.setExecuteType(wrapper.getExecuteType());
        responseDTO.setExecuteTypeValue(wrapper.getExecuteTypeValue());
        responseDTO.setContent(wrapper.getContent());
        responseDTO.setExt(wrapper.getExt());
        return responseDTO;
    }
    return null;
}

java复制代码@Data
@ApiModel("流程实例-执行下一步请求参数")
public class ProcessInstanceExecuteNextStepRequestDTO implements Serializable {

    @ApiModelProperty(value = "流程实例ID")
    @NotEmpty(message = "流程实例ID 不可以为空")
    private String processInstanceId;
    @ApiModelProperty(value = "任务ID")
    private String taskId;
    @ApiModelProperty(value = "ExecuteTypeEnum 执行类型")
    @NotEmpty(message = "执行类型 不可以为空")
    private String executeType;
    @ApiModelProperty(value = "审批意见")
    @NotEmpty(message = "审批意见 不可以为空")
    private String commentContent;
    @ApiModelProperty(value = "变量参数")
    private HashMap<String, Object> variables;

}

java复制代码@Transactional(rollbackFor = Exception.class)
public void executeNextStep(ProcessInstanceExecuteNextStepRequestDTO requestDTO) {
    ValidatorUtils.validate(requestDTO);
    //
    if (ExecuteTypeEnum.of(requestDTO.getExecuteType()).isNone()) {
        throw new BusinessException("未知执行状态");
    }
    TaskQuery taskQuery = taskService.createTaskQuery();
    taskQuery.taskId(requestDTO.getTaskId());
    Task task = taskQuery.singleResult();
    AssertUtils.notEmpty(task, "找不到任务");
    //
    // 添加审批意见
    ProcessInstanceCommentRequestDTO commentRequestDTO = new ProcessInstanceCommentRequestDTO();
    commentRequestDTO.setProcessInstanceId(task.getProcessInstanceId());
    commentRequestDTO.setTaskId(task.getId());
    // commentRequestDTO.setType("event");
    commentRequestDTO.setUserId(SecurityUser.getUserId());
    commentRequestDTO.setNickname(SecurityUser.get().getName());
    commentRequestDTO.setExecuteType(requestDTO.getExecuteType());
    commentRequestDTO.setExecuteTypeValue(ExecuteTypeEnum.of(requestDTO.getExecuteType()).getValue());
    commentRequestDTO.setContent(task.getName() + "：" + requestDTO.getCommentContent());
    commentRequestDTO.setExt("");
    //
    this.addProcessInstanceComment(commentRequestDTO);
    // 处理流程审批
    HashMap<String, Object> variables = requestDTO.getVariables();
    if (variables == null) {
        variables = new HashMap<>(8);
    }
    // 这里会put一个执行变量executeType,也就是流程定义xml中的那个变量名称，这个变量决定了流程再走向
    variables.put(WorkflowConstants.EXECUTE_TYPE, requestDTO.getExecuteType());
    // 添加执行人
    variables.put("_execute_user_id=" + SecurityUser.getUserId(), "_execute_user_id=" + SecurityUser.getUserId());
    taskService.complete(task.getId(), variables);
}

java复制代码@Data
@ApiModel("流程实例-分页请求参数")
public class ProcessInstanceStopRequestDTO implements Serializable {

    @ApiModelProperty(value = "流程实例ID")
    @NotEmpty(message = "流程实例ID 不可以为空")
    private String processInstanceId;
    @ApiModelProperty(value = "审批意见")
    @NotEmpty(message = "审批意见 不可以为空")
    private String commentContent;

}

java复制代码public void stopProcessInstance(ProcessInstanceStopRequestDTO requestDTO) {
    ValidatorUtils.validate(requestDTO);
    // 修改流转执行状态
    runtimeService.setVariable(requestDTO.getProcessInstanceId(), WorkflowConstants.EXECUTE_TYPE, ExecuteTypeEnum.STOP.name());
    //
    ProcessInstance processInstance = runtimeService.createProcessInstanceQuery()
            .processInstanceId(requestDTO.getProcessInstanceId()).singleResult();
    // 添加一条审批记录
    ProcessInstanceCommentRequestDTO commentRequestDTO = new ProcessInstanceCommentRequestDTO();
    commentRequestDTO.setProcessInstanceId(processInstance.getProcessInstanceId());
    commentRequestDTO.setTaskId(null);
    commentRequestDTO.setUserId(SecurityUser.getUserId());
    commentRequestDTO.setNickname(SecurityUser.get().getName());
    commentRequestDTO.setExecuteType(ExecuteTypeEnum.STOP.name());
    commentRequestDTO.setExecuteTypeValue(ExecuteTypeEnum.STOP.getValue());
    commentRequestDTO.setContent(StringUtils.defaultString(requestDTO.getCommentContent(), "终止流程"));
    commentRequestDTO.setExt("");
    this.addProcessInstanceComment(commentRequestDTO);
    /// 执行终止
    List<Execution> executions = runtimeService.createExecutionQuery().parentId(requestDTO.getProcessInstanceId()).list();
    List<String> executionIds = executions.stream().map(v -> v.getId()).collect(Collectors.toList());
    // 获取流程结束点
    BpmnModel bpmnModel = repositoryService.getBpmnModel(processInstance.getProcessDefinitionId());
    Process process = bpmnModel.getMainProcess();
    List<EndEvent> endNodes = process.findFlowElementsOfType(EndEvent.class);
    String endId = endNodes.get(endNodes.size() - 1).getId();
    // 执行跳转
    runtimeService.createChangeActivityStateBuilder()
            .moveExecutionsToSingleActivityId(executionIds, endId)
            .changeState();
}

java复制代码/**
 * 实例映射 Flowable 的 act_hi_varinst 表
 */
@Data
public class HistoryVariable implements Serializable {

    public static final HistoryVariable EMPTY = new HistoryVariable();

    private String id;
    private String rev;
    private String processInstanceId;
    private String executionId;
    private String taskId;
    private String name;
    private String varType;
    private String scopeId;
    private String subScopeId;
    private String scopeType;
    private String bytearrayId;
    private Double doubleValue;
    private Long longValue;
    private String text;
    private String text2;
    private Date createTime;
    private Date lastUpdatedTime;

    /*
    act_hi_varinst 字段列表：
    ID_
    REV_
    PROC_INST_ID_
    EXECUTION_ID_
    TASK_ID_
    NAME_
    VAR_TYPE_
    SCOPE_ID_
    SUB_SCOPE_ID_
    SCOPE_TYPE_
    BYTEARRAY_ID_
    DOUBLE_
    LONG_
    TEXT_
    TEXT2_
    CREATE_TIME_
    LAST_UPDATED_TIME_
     */
}

java复制代码@Override
public List<HistoryVariable> findHistoryVariableList(Collection<String> processInstanceIds) {
    if (CollectionUtils.isEmpty(processInstanceIds)) {
        return Collections.emptyList();
    }
    QueryWrapper<HistoryVariable> ew = new QueryWrapper<>();
    ew.in("t.PROC_INST_ID_", processInstanceIds);
    return this.baseMapper.findHistoryVariableList(ew);
}

java复制代码List<HistoryVariable> findHistoryVariableList(@Param("ew") QueryWrapper<HistoryVariable> ew);

xml复制代码<select id="findHistoryVariableList" resultType="cn.leadersheep.xz.workflow.server.entity.flowable.HistoryVariable">
    SELECT
    t.ID_ AS id,
    t.REV_ AS rev,
    t.PROC_INST_ID_ AS process_instance_id,
    t.EXECUTION_ID_ AS execution_id,
    t.TASK_ID_ AS task_id,
    t.NAME_ AS name,
    t.VAR_TYPE_ AS var_type,
    t.SCOPE_ID_ AS scope_id,
    t.SUB_SCOPE_ID_ AS sub_scope_id,
    t.SCOPE_TYPE_ AS scope_type,
    t.BYTEARRAY_ID_ AS bytearray_id,
    t.DOUBLE_ AS double_value,
    t.LONG_ AS long_value,
    t.TEXT_ AS text,
    t.TEXT2_ AS text2,
    t.CREATE_TIME_ AS create_time,
    t.LAST_UPDATED_TIME_ AS last_update_time

    FROM act_hi_varinst t
    <where>
        ${ew.sqlSegment}
    </where>
</select>

java复制代码@Data
@EqualsAndHashCode(callSuper = true)
@ApiModel("流程实例-分页请求参数")
public class ProcessInstancePageRequestDTO extends PageParamsEntity {

    @ApiModelProperty(value = "项目ID")
    private String communityId;
    @ApiModelProperty(value = "查找范围：MY_TODO-我的待办；MY_DONE-我的已办；MY_SCOPE-我的范围；MY_CREATE-我的创建；")
    private String searchScope;
    @ApiModelProperty(value = "任务名称")
    private String processInstanceName;

}

java复制代码@Data
@ApiModel("流程定义-分页响应结果")
public class ProcessInstancePageResponseDTO implements Serializable {

    @ApiModelProperty(value = "项目ID")
    private String communityId;
    @ApiModelProperty(value = "项目名称")
    private String communityName;
    @ApiModelProperty(value = "流程实例ID")
    private String processInstanceId;
    @ApiModelProperty(value = "流程实例名称")
    private String processInstanceName;
    @ApiModelProperty(value = "流程定义ID")
    private String processDefinitionId;
    @ApiModelProperty(value = "流程定义名称")
    private String processDefinitionName;
    @ApiModelProperty(value = "任务ID")
    private String taskId;
    @ApiModelProperty(value = "任务名称")
    private String taskName;
    @ApiModelProperty(value = "开始时间")
    private Date startTime;
    @ApiModelProperty(value = "结束时间")
    private Date endTime;
    @ApiModelProperty(value = "持续时间")
    private String duration;
    @ApiModelProperty(value = "创建人ID")
    private String createId;
    @ApiModelProperty(value = "创建人名称")
    private String createName;

}

java复制代码public PageDTO<ProcessInstancePageResponseDTO> findPage(ProcessInstancePageRequestDTO requestDTO) {
    // 在这里实现数据过滤
    String filterSql = StringUtils.defaultString(processFilterSQL("TEXT_", requestDTO.getCommunityId(), true), "");
    filterSql = filterSql.replace("('", "('" + WorkflowConstants.VAR_COMMUNITY_ID_EQ);
    filterSql = filterSql.replace(", '", ", '" + WorkflowConstants.VAR_COMMUNITY_ID_EQ);
    // TEXT_ IN ('_community_id=1545645315843546', '_community_id=15456453158436521')
    // System.out.println("filterSQL = " + filterSQL);
    //
    PageDTO<ProcessInstancePageResponseDTO> page = this.buildPage(requestDTO);
    if ("MY_TODO".equals(requestDTO.getSearchScope())) {
        // 我的待办
        QueryWrapper<ProcessInstancePageResponseDTO> ew = buildEmptyQueryWrapper();
        ew.like(StringUtils.isNotEmpty(requestDTO.getProcessInstanceName()), "t4.NAME_", requestDTO.getProcessInstanceName());
        ew.eq("1", 1);
        ew.apply(CoreUtil.isNotEmpty(filterSql), "t3." + filterSql);
        ew.orderByDesc("t.CREATE_TIME_");
        ew.groupBy("t.PROC_INST_ID_");
        //
        if (!AuthHelper.isRoleSuperAdmin(SecurityUser.current().getRoleCodeSet())) {
            // 不是超级管理员,需要过滤
            ew.and(and -> and.in("t2.GROUP_ID_", SecurityUser.current().getRoleCodeSet()).or(or -> {
                or.eq("t2.USER_ID_", SecurityUser.getUserId());
            }));
        }
        page = this.baseMapper.findMyTodo(page, ew);
    } else if ("MY_DONE".equals(requestDTO.getSearchScope())) {
        // 我的已办
        QueryWrapper<ProcessInstancePageResponseDTO> ew = buildEmptyQueryWrapper();
        ew.like(StringUtils.isNotEmpty(requestDTO.getProcessInstanceName()), "t.NAME_", requestDTO.getProcessInstanceName());
        ew.eq("t2.TEXT_", "_execute_user_id=" + SecurityUser.getUserId());
        ew.apply(filterSql.length() > 0, "t3." + filterSql);
        ew.orderByDesc("t.START_TIME_");
        ew.groupBy("t.ID_");
        //
        page = this.baseMapper.findMyDonePage(page, ew);
    } else if ("MY_SCOPE".equals(requestDTO.getSearchScope())) {
        // 我的范围
        QueryWrapper<ProcessInstancePageResponseDTO> ew = buildEmptyQueryWrapper();
        ew.like(StringUtils.isNotEmpty(requestDTO.getProcessInstanceName()), "t.NAME_", requestDTO.getProcessInstanceName());
        ew.eq("1", 1);
        ew.apply(filterSql.length() > 0, "t4." + filterSql);
        ew.orderByDesc("t.START_TIME_");
        ew.groupBy("t.ID_");
        //
        if (!AuthHelper.isRoleSuperAdmin(SecurityUser.current().getRoleCodeSet())) {
            // 不是超级管理员,需要过滤
            ew.and(and -> and.in("t3.GROUP_ID_", SecurityUser.current().getRoleCodeSet()).or(or -> {
                or.eq("t3.USER_ID_", SecurityUser.getUserId());
            }));
        }
        page = this.baseMapper.findMyScopePage(page, ew);
    } else if ("MY_CREATE".equals(requestDTO.getSearchScope())) {
        // 我发起的
        QueryWrapper<ProcessInstancePageResponseDTO> ew = buildEmptyQueryWrapper();
        ew.like(StringUtils.isNotEmpty(requestDTO.getProcessInstanceName()), "t.NAME_", requestDTO.getProcessInstanceName());
        ew.eq("t2.TEXT_", "_create_user_id=" + SecurityUser.getUserId());
        ew.apply(filterSql.length() > 0, "t3." + filterSql);
        ew.orderByDesc("t.START_TIME_");
        ew.groupBy("t.ID_");
        //
        page = this.baseMapper.findMyDonePage(page, ew);
    }
    //
    if (CollectionUtils.isNotEmpty(page.getRecords())) {
	    // 填充其他属性
        List<String> processInstanceIds = page.getRecords().stream().map(v -> v.getProcessInstanceId()).distinct().collect(Collectors.toList());
        List<HistoryVariable> variableList = this.findHistoryVariableList(processInstanceIds);
        Map<String, HistoryVariable> variableMap = variableList.stream()
                .collect(Collectors.toMap(v -> v.getProcessInstanceId() + "_" + v.getName(), v -> v));
        page.getRecords().forEach(v -> {
            String prefix = v.getProcessInstanceId() + "_";
            //
            HistoryVariable variable = variableMap.getOrDefault(prefix + VAR_COMMUNITY_ID, HistoryVariable.EMPTY);
            String text = Optional.ofNullable(variable.getText()).map(t -> t.replace(VAR_COMMUNITY_ID_EQ, "")).orElse(null);
            v.setCommunityId(text);
            //
            // variable = variableMap.getOrDefault(prefix + VAR_PROCESS_INSTANCE_NAME, HistoryVariable.EMPTY);
            // text = Optional.ofNullable(variable.getText()).map(t -> t.replace(VAR_PROCESS_INSTANCE_NAME_EQ, "")).orElse(null);
            // v.setProcessInstanceName(text);
            //
            variable = variableMap.getOrDefault(prefix + VAR_CREATE_USER_ID, HistoryVariable.EMPTY);
            text = Optional.ofNullable(variable.getText()).map(t -> t.replace(VAR_CREATE_USER_ID_EQ, "")).orElse(null);
            v.setCreateId(text);
            //
            variable = variableMap.getOrDefault(prefix + VAR_CREATE_USER_NICKNAME, HistoryVariable.EMPTY);
            text = Optional.ofNullable(variable.getText()).map(t -> t.replace(VAR_CREATE_USER_NICKNAME_EQ, "")).orElse(null);
            v.setCreateName(text);
            //
            variable = variableMap.getOrDefault(prefix + VAR_PROCESS_DEFINITION_NAME, HistoryVariable.EMPTY);
            text = Optional.ofNullable(variable.getText()).map(t -> t.replace(VAR_PROCESS_DEFINITION_NAME_EQ, "")).orElse(null);
            v.setProcessDefinitionName(text);
        });
        sysOrganizationRemote.fillOrganization(page.getRecords(), v -> v.getCommunityId(), (v, c) -> v.setCommunityName(c.getName()));
    }
    return page;
}

java复制代码/**
 * 获取我的待办任务
 *
 * @author houyu for.houyu@qq.com <br>
 * @param page 分页
 * @param ew 参数包装器
 * @return PageDTO<ProcessInstancePageResponseDTO>
 */
PageDTO<ProcessInstancePageResponseDTO> findMyTodo(@Param("page") PageDTO<ProcessInstancePageResponseDTO> page, @Param("ew") QueryWrapper<ProcessInstancePageResponseDTO> ew);

/**
 * 获取我的范围内的任务
 *
 * @author houyu for.houyu@qq.com <br>
 * @param page 分页
 * @param ew 参数包装器
 * @return PageDTO<ProcessInstancePageResponseDTO>
 */
PageDTO<ProcessInstancePageResponseDTO> findMyScopePage(@Param("page") PageDTO<ProcessInstancePageResponseDTO> page, @Param("ew") QueryWrapper<ProcessInstancePageResponseDTO> ew);

/**
 * 获取我的已办（我的发起 / 我审批的）
 *
 * @author houyu for.houyu@qq.com <br>
 * @param page 分页
 * @param ew 参数包装器
 * @return PageDTO<ProcessInstancePageResponseDTO>
 */
PageDTO<ProcessInstancePageResponseDTO> findMyDonePage(@Param("page") PageDTO<ProcessInstancePageResponseDTO> page, @Param("ew") QueryWrapper<ProcessInstancePageResponseDTO> ew);

xml复制代码<select id="findMyTodo" resultType="cn.leadersheep.xz.workflow.client.dto.flowable.response.ProcessInstancePageResponseDTO">
    SELECT
    t.ID_ AS task_id,
    t.PROC_INST_ID_ AS process_instance_id,
    t4.NAME_ AS process_instance_name,
    t.NAME_ AS task_name,
    t.PROC_DEF_ID_ as process_definition_id,
    t.CREATE_TIME_ as start_time,
    NULL as end_time

    FROM act_ru_task t
    LEFT JOIN act_ru_identitylink t2 ON t2.TASK_ID_ = t.ID_
    LEFT JOIN act_ru_variable t3 ON t3.PROC_INST_ID_ = t.PROC_INST_ID_
    LEFT JOIN act_hi_procinst t4 ON t4.PROC_INST_ID_ = t.PROC_INST_ID_
    <where>
        ${ew.sqlSegment}
    </where>
</select>

<select id="findMyScopePage" resultType="cn.leadersheep.xz.workflow.client.dto.flowable.response.ProcessInstancePageResponseDTO">
    SELECT
    t.PROC_INST_ID_ AS process_instance_id,
    t.NAME_ AS process_instance_name,
    t.PROC_DEF_ID_ as process_definition_id,
    t.START_TIME_ as start_time,
    t.END_TIME_ as end_time

    FROM act_hi_procinst t
    LEFT JOIN act_hi_taskinst t2 ON t2.PROC_INST_ID_ = t.ID_
    LEFT JOIN act_hi_identitylink t3 ON t3.TASK_ID_ = t2.ID_
    LEFT JOIN act_hi_varinst t4 ON t4.PROC_INST_ID_ = t.ID_
    <where>
        ${ew.sqlSegment}
    </where>
</select>

<select id="findMyDonePage" resultType="cn.leadersheep.xz.workflow.client.dto.flowable.response.ProcessInstancePageResponseDTO">
    SELECT
    t.PROC_INST_ID_ AS process_instance_id,
    t.NAME_ AS process_instance_name,
    t.PROC_DEF_ID_ as process_definition_id,
    t.START_TIME_ as start_time,
    t.END_TIME_ as end_time

    FROM act_hi_procinst t
    LEFT JOIN act_hi_varinst t2 ON t2.PROC_INST_ID_ = t.ID_
    LEFT JOIN act_hi_varinst t3 ON t3.PROC_INST_ID_ = t.ID_
    <where>
        ${ew.sqlSegment}
    </where>
</select>

复制代码whereis java

bash复制代码java：
/var/lib/jdk/jdk1.8.0_211/bin/java

jre 字体目录（复制到这里）：
/var/lib/jdk/jdk1.8.0_211/jre/lib/fonts

bash复制代码/usr/share/fonts

复制代码reboot

ini复制代码 public ArrayMap() { 
        this(0, false);
    }
 public ArrayMap(int capacity) {
        this(capacity, false);
    }
/**
* identityHashCode: 是否使用系统的System.identityHashCode(key),跟对象存储位置地址值相关 , 
* false时使用对象的hashCode,如果重写就使用对象的hashCode方法(String 重写了,所以map键常用的字符串是一致的),未重写则使用object的hashcode
* 同系统的调用同一个本地方法,结果值一致
*/
public ArrayMap(int capacity, boolean identityHashCode) {
        mIdentityHashCode = identityHashCode;

        // 这是同HashMap不同的地方,如果当前没有设置大小默认为0,hashMap默认数组为16,节约空间了吧
        if (capacity < 0) {
            mHashes = EMPTY_IMMUTABLE_INTS;
            mArray = EmptyArray.OBJECT;
        } else if (capacity == 0) {
            mHashes = EmptyArray.INT;
            mArray = EmptyArray.OBJECT;
        } else {
            // 初始化值,根据提供的大小,但同HashMap会改变(注意并非指定多少即为多大空间数组)
            allocArrays(capacity); 
        }
        mSize = 0;
}

scss复制代码    @Override
    public V put(K key, V value) {
        final int osize = mSize;
        final int hash;
        int index;
        if (key == null) { //key是空，则通过indexOfNull查找对应的index,支持存储null键
            hash = 0;
            index = indexOfNull();
        } else { //否则 通过key查找下标index 
            hash = mIdentityHashCode ? System.identityHashCode(key) : key.hashCode(); //构造函数中指定使用哪种hash值
            index = indexOf(key, hash); //稍后解释(根据hash值及key找到对应的下标index ,存在为正,不然为 ~位置 一个负数值)
        }
        if (index >= 0) { //找到了当前存储的key键在mArray中替换成新值value并返回旧值
            index = (index<<1) + 1;
            final V old = (V)mArray[index];
            mArray[index] = value;
            return old;
        }

        index = ~index; //将indexOf中找到的~index在次~即为(~~index) == index一个正值,即为数据将要插入的位置
        if (osize >= mHashes.length) { //判断是否需要扩容大小,扩容为默认 4 ->8 -> 12 -> 18(不足向上取,比如初始7个数据则数组大小为8),扩容后赋值并回收原有数组
            final int n = osize >= (BASE_SIZE*2) ? (osize+(osize>>1))
                    : (osize >= BASE_SIZE ? (BASE_SIZE*2) : BASE_SIZE);

            if (DEBUG) Log.d(TAG, "put: grow from " + mHashes.length + " to " + n);
            //将原来的数组赋值保存后在使用allocArrays(n)对原来数组根据新大小n进行扩容
            final int[] ohashes = mHashes;
            final Object[] oarray = mArray;
            allocArrays(n); //具体的扩容函数,创建一个新的数据,可能存在缓存数组,稍后讲解

            if (CONCURRENT_MODIFICATION_EXCEPTIONS && osize != mSize) { //对于两个线程同时扩容报错,同HashMap一致是非线程安全
                throw new ConcurrentModificationException();
            }

            if (mHashes.length > 0) { 
                //将上方保存的原有数据拷贝到新数组中,注意下标从0开始及大小原有数组长度
                if (DEBUG) Log.d(TAG, "put: copy 0-" + osize + " to 0");
                System.arraycopy(ohashes, 0, mHashes, 0, ohashes.length);
                System.arraycopy(oarray, 0, mArray, 0, oarray.length);
            }
            //释放原有数组,已经在上方拷贝过了,这里涉及到缓存数据
            //查看是否数据还有利用价值,其后会讲到,大致是对数据量为4或者8做一个缓存以便其后还会利用到
            //如果数据量超过8就就没有必要占用内存去缓存它了
            freeArrays(ohashes, oarray, osize);
        }

        if (index < osize) {  //index是指当前数据key的hash值下标即key应该插入数组的位置不是最后一位则移动他将插入位置及其后的所有数据腾出位置给其插入使用
            if (DEBUG) Log.d(TAG, "put: move " + index + "-" + (osize-index)
                    + " to " + (index+1));
            //注意: 将mHashes的index 位置以后的向后移动一位,同时mArray也是同时向后移动2位,给key.hash,跟(key,value)插入让出位置
            System.arraycopy(mHashes, index, mHashes, index + 1, osize - index);
            System.arraycopy(mArray, index << 1, mArray, (index + 1) << 1, (mSize - index) << 1);
        }

        if (CONCURRENT_MODIFICATION_EXCEPTIONS) {
            if (osize != mSize || index >= mHashes.length) { //再次判断是否线程安全
                throw new ConcurrentModificationException();
            }
        }
        mHashes[index] = hash; //在特定位置插入mHashes,及mArray数组上
        mArray[index<<1] = key;
        mArray[(index<<1)+1] = value;
        mSize++; //数据值+1
        return null;
    }

ini复制代码final int n = osize >= (BASE_SIZE*2) ? (osize+(osize>>1))
                : (osize >= BASE_SIZE ? (BASE_SIZE*2) : BASE_SIZE);

ini复制代码    private void allocArrays(final int size) {
        if (mHashes == EMPTY_IMMUTABLE_INTS) {
            throw new UnsupportedOperationException("ArrayMap is immutable");
        }
        //设置缓存用的,当数据量由24 降为 8时不用再次重新创建加载,而是直接使用mTwiceBaseCache缓存的数组即可
        if (size == (BASE_SIZE*2)) {
            synchronized (ArrayMap.class) {
                if (mTwiceBaseCache != null) { //缓存 8数据存在 
                    final Object[] array = mTwiceBaseCache;
                    mArray = array; 
                    mTwiceBaseCache = (Object[])array[0]; 
                    mHashes = (int[])array[1]; 
                    array[0] = array[1] = null;
                    mTwiceBaseCacheSize--;
                    if (DEBUG) Log.d(TAG, "Retrieving 2x cache " + mHashes
                            + " now have " + mTwiceBaseCacheSize + " entries");
                    return;
                }
            }
        } else if (size == BASE_SIZE) {
            synchronized (ArrayMap.class) {
                if (mBaseCache != null) {
                    final Object[] array = mBaseCache;
                    mArray = array;
                    mBaseCache = (Object[])array[0];
                    mHashes = (int[])array[1];
                    array[0] = array[1] = null;
                    mBaseCacheSize--;
                    if (DEBUG) Log.d(TAG, "Retrieving 1x cache " + mHashes
                            + " now have " + mBaseCacheSize + " entries");
                    return;
                }
            }
        }

        mHashes = new int[size];
        mArray = new Object[size<<1];
    }

arduino复制代码
    int indexOf(Object key, int hash) {
        final int N = mSize;

        // Important fast case: if nothing is in here, nothing to look for.
        if (N == 0) {
            return ~0;
        }
        // 使用二分查找到当前hash值在mHashes数组中的下标,如果不存在返回(~当前需要插入的位置)后续在~即为正在需要插入的位置 (~~A == A)
        int index = binarySearchHashes(mHashes, N, hash);

        if (index < 0) { //如果没有找到就返回一个负值
            return index;
        }

        //如果当前index下标的key同查找的一致就返回
        if (key.equals(mArray[index<<1])) {
            return index;
        }

        // 先向上查找相同hash值是否key一致,否则向下查找
        int end;
        for (end = index + 1; end < N && mHashes[end] == hash; end++) {
            if (key.equals(mArray[end << 1])) return end;
        }
       
        for (int i = index - 1; i >= 0 && mHashes[i] == hash; i--) {
            if (key.equals(mArray[i << 1])) return i;
        }

        // 如果都没有找到,将返回需要插入位置的负值,注意这里是相同hash值的最后一个其后添加数据
        return ~end;
    }

ini复制代码public V removeAt(int index) {
        final Object old = mArray[(index << 1) + 1]; 
        final int osize = mSize; //msize是当前存储实际数据大小,mHashes.length为当前申请的数组大小
        final int nsize;
        if (osize <= 1) {
            // 当实际数据为1时,即移除以后恢复成默认值null
            if (DEBUG) Log.d(TAG, "remove: shrink from " + mHashes.length + " to 0");
            final int[] ohashes = mHashes;
            final Object[] oarray = mArray;
            mHashes = EmptyArray.INT;
            mArray = EmptyArray.OBJECT;
            freeArrays(ohashes, oarray, osize);
            nsize = 0;
        } else {
            nsize = osize - 1; 
            // 如果当前数组大于 8并且实际数据量小于 数组长度的 1/3 则重新分配内存空间
            if (mHashes.length > (BASE_SIZE*2) && mSize < mHashes.length/3) {
                //重新分配后实际数组的大小
                final int n = osize > (BASE_SIZE*2) ? (osize + (osize>>1)) : (BASE_SIZE*2);

                if (DEBUG) Log.d(TAG, "remove: shrink from " + mHashes.length + " to " + n);
                //备份数据以便后期复制使用
                final int[] ohashes = mHashes;
                final Object[] oarray = mArray;
                allocArrays(n); //重新分配数据,注意里面会用到已经缓存的4和8的数据

                if (CONCURRENT_MODIFICATION_EXCEPTIONS && osize != mSize) { //判断是否线程安全
                    throw new ConcurrentModificationException();
                }
                //移除index上的数据分两个部分移除,首先复制0--index大小的数据就是到 (index -1)处
              
                if (index > 0) {
                    if (DEBUG) Log.d(TAG, "remove: copy from 0-" + index + " to 0");
                    System.arraycopy(ohashes, 0, mHashes, 0, index);
                    System.arraycopy(oarray, 0, mArray, 0, index << 1);
                }
                //  再次从index + 1 处移动nsize - index的数据复制到新数组中
                if (index < nsize) {
                    if (DEBUG) Log.d(TAG, "remove: copy from " + (index+1) + "-" + nsize
                            + " to " + index);
                    System.arraycopy(ohashes, index + 1, mHashes, index, nsize - index);
                    System.arraycopy(oarray, (index + 1) << 1, mArray, index << 1,
                            (nsize - index) << 1);
                }
            } else { //不用重新分配内存,直接可用的则直接移动其后的数据,并将最后一位设置成默认null
                if (index < nsize) {
                    if (DEBUG) Log.d(TAG, "remove: move " + (index+1) + "-" + nsize
                            + " to " + index);
                    System.arraycopy(mHashes, index + 1, mHashes, index, nsize - index);
                    System.arraycopy(mArray, (index + 1) << 1, mArray, index << 1,
                            (nsize - index) << 1);
                }
                mArray[nsize << 1] = null;
                mArray[(nsize << 1) + 1] = null;
            }
        }
        if (CONCURRENT_MODIFICATION_EXCEPTIONS && osize != mSize) {
            throw new ConcurrentModificationException();
        }
        mSize = nsize; //减少一位并返回删除的旧值
        return (V)old;
    }

ini复制代码    private static void freeArrays(final int[] hashes, final Object[] array, final int size) {
        if (hashes.length == (BASE_SIZE*2)) { //如果当前缓存的大小为8
            synchronized (ArrayMap.class) {
                if (mTwiceBaseCacheSize < CACHE_SIZE) {
                    array[0] = mTwiceBaseCache; //第一次的array[0] = null, 但是其后的将会是一个链表结构这一次缓存中的array[0] ->指向的是上一次缓存的整体数字,但是array的中长度依然是 16 ,最多缓存 10个
                    array[1] = hashes;
                    for (int i=(size<<1)-1; i>=2; i--) {
                        array[i] = null;
                    }
                    mTwiceBaseCache = array;
                    mTwiceBaseCacheSize++;
                    if (DEBUG) Log.d(TAG, "Storing 2x cache " + array
                            + " now have " + mTwiceBaseCacheSize + " entries");
                }
            }
        } else if (hashes.length == BASE_SIZE) { //同上所述不过缓存的数据为4,array的总长度为8,最多缓存10个
            synchronized (ArrayMap.class) {
                if (mBaseCacheSize < CACHE_SIZE) {
                    array[0] = mBaseCache;
                    array[1] = hashes;
                    for (int i=(size<<1)-1; i>=2; i--) {
                        array[i] = null;
                    }
                    mBaseCache = array;
                    mBaseCacheSize++;
                    if (DEBUG) Log.d(TAG, "Storing 1x cache " + array
                            + " now have " + mBaseCacheSize + " entries");
                }
            }
        }
    }

ini复制代码
    private void allocArrays(final int size) {
        if (mHashes == EMPTY_IMMUTABLE_INTS) {
            throw new UnsupportedOperationException("ArrayMap is immutable");
        }
        if (size == (BASE_SIZE*2)) { //8数据同下
            synchronized (ArrayMap.class) {
                if (mTwiceBaseCache != null) {
                    final Object[] array = mTwiceBaseCache;
                    mArray = array;
                    mTwiceBaseCache = (Object[])array[0];
                    mHashes = (int[])array[1];
                    array[0] = array[1] = null;
                    mTwiceBaseCacheSize--;
                    if (DEBUG) Log.d(TAG, "Retrieving 2x cache " + mHashes
                            + " now have " + mTwiceBaseCacheSize + " entries");
                    return;
                }
            }
        } else if (size == BASE_SIZE) { //如果当前缓存的有数据,则array是一个大小为8的链式结构,加入缓存了多次,但是被复用以后其被赋值给mArray的时候依然是一个大小为8且在后续会被重新赋值的,所以不用担心链式多层结构问题
            synchronized (ArrayMap.class) {
                if (mBaseCache != null) {
                    final Object[] array = mBaseCache;
                    mArray = array;
                    mBaseCache = (Object[])array[0];  //将下一层缓存的数据重新赋值给4个缓存
                    mHashes = (int[])array[1]; //当前为4的数组赋值给mHashes
                    array[0] = array[1] = null; 
                    mBaseCacheSize--; //缓存池中数量减1
                    if (DEBUG) Log.d(TAG, "Retrieving 1x cache " + mHashes
                            + " now have " + mBaseCacheSize + " entries");
                    return;
                }
            }
        }

        mHashes = new int[size];
        mArray = new Object[size<<1];
    }

dart复制代码static Object[] mBaseCache; 
static int mBaseCacheSize;
static Object[] mTwiceBaseCache;
static int mTwiceBaseCacheSize;

java复制代码//成员变量分析
public class SparseArray<E> implements Cloneable {
    private static final Object DELETED = new Object(); //数组中的数据如果被删除,可能仅仅标记value为DELETED并不会每次都重新移动数组,太消耗时间了,同时可以直接在Deleted位置上put数据覆盖之
    private boolean mGarbage = false; //是否需要垃圾回收,即value中存在DELETED,但并不一定会被回收的,在delete(key)时被标记为Deleted
    private int[] mKeys; //一个key对应一个value,且key是int型不可重复,多在从0-N有序列使用,比如RecycleView中的viewType就是有序且不可重复的,缓存即使用SparseArray
    private Object[] mValues;
    private int mSize;
 public SparseArray() { //默认keys和values数组长度为10
        this(10);
    }

ini复制代码public void put(int key, E value) {
        int i = ContainerHelpers.binarySearch(mKeys, mSize, key);
        //如果找到i则i对应的value数组位置修改值
        if (i >= 0) {
            mValues[i] = value;
        } else {
            i = ~i; //没有找到,这个只是根据二分查找到第一个大于i的位置插入这里,其后值向后移动

            if (i < mSize && mValues[i] == DELETED) { //如果当前位置被标记为Deleted删除标记,表示该位置可用
                mKeys[i] = key;
                mValues[i] = value;
                return;
            }
            //有Deleted则mGarbage = true,数组是可以靠移动而不是扩容就能容纳该put新值的
            if (mGarbage && mSize >= mKeys.length) {
                gc(); //新gc将deleted标志都删除掉
 
                // Search again because indices may have changed.
                i = ~ContainerHelpers.binarySearch(mKeys, mSize, key);
            }
            //如果位置没有Deleted,且数组已经满了,则二倍的扩容
            mKeys = GrowingArrayUtils.insert(mKeys, mSize, i, key);
            mValues = GrowingArrayUtils.insert(mValues, mSize, i, value);
            mSize++;
        }
    }

ini复制代码private void gc() {
        // Log.e("SparseArray", "gc start with " + mSize);
        int n = mSize;
        int o = 0;
        int[] keys = mKeys;
        Object[] values = mValues;
        for (int i = 0; i < n; i++) {
            Object val = values[i];
            if (val != DELETED) {
                if (i != o) {
                    keys[o] = keys[i];
                    values[o] = val;
                    values[i] = null;
                }
                o++;
            }
        }
        mGarbage = false;
        mSize = o;
        // Log.e("SparseArray", "gc end with " + mSize);
    }

ini复制代码public E get(int key, E valueIfKeyNotFound) {
        int i = ContainerHelpers.binarySearch(mKeys, mSize, key);

        if (i < 0 || mValues[i] == DELETED) {
            return valueIfKeyNotFound;
        } else {
            return (E) mValues[i];
        }
    }

    /**
     * Removes the mapping from the specified key, if there was any.
     */
    public void delete(int key) {
        int i = ContainerHelpers.binarySearch(mKeys, mSize, key);

        if (i >= 0) {
            if (mValues[i] != DELETED) {
                mValues[i] = DELETED;
                mGarbage = true;
            }
        }
    }

ini复制代码final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        HashMap.Node<K, V>[] tab;
        HashMap.Node<K, V> p;
        int n, i;
        if ((tab = table) == null || (n = tab.length) == 0) //列表为空或者长度为0 初始化一个HashMap
            n = (tab = resize()).length;
        if ((p = tab[i = (n - 1) & hash]) == null)  //当前位置上没有数据new一个链表
            tab[i] = newNode(hash, key, value, null);
        else { //当前数组Hash位置上面已经存在了值
            HashMap.Node<K, V> e;
            K k;
            if (p.hash == hash &&
                    ((k = p.key) == key || (key != null && key.equals(k)))) //有相同的hash键,直接替换
                e = p;
            else if (p instanceof HashMap.TreeNode) //如果当前是红黑树使用红黑树的添加
                e = ((HashMap.TreeNode<K, V>) p).putTreeVal(this, tab, hash, key, value);
            else { //当前为链表结构的添加
                for (int binCount = 0; ; ++binCount) { //计算当前链表的长度
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null); //放到链表尾部
                        /**
                         * 当前链表从0开始遍历一直到 7,所以长度大于等于 8转化为红黑树存储,如果remove时树的数据量=<6 ,红黑树会转化成链表结构存储
                         *
                         * 解析:因为红黑树的平均查找长度是log(n)，长度为8的时候，平均查找长度为3，如果继续使用链表，平均查找长度为8/2=4，这才有转换为树的必要。
                         * 链表长度如果是小于等于6，6/2=3，虽然速度也很快的，但是转化为树结构和生成树的时间并不会太短。
                         * 选择6和8，中间有个差值7可以有效防止链表和树频繁转换,而导致的不停转化树与链表导致效率低下的问题;
                         */
                        if (binCount >= TREEIFY_THRESHOLD - 1)
                            treeifyBin(tab, hash); //如果
                        break;
                    }
                    if (e.hash == hash &&
                            ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount; //记录变化次数,防止在多线程中迭代器取值导致错误,fail-fill检查机制
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }

#### HashMap头添加扩容导致死循环分析


* 在JDK1.7之前HashMap的扩容是从头部添加元素,导致在多线程环境下put操作使得Entry链表形成环形数据结构,则next节点永不为null,导致死循环获取Entry
* 主要是在put元素HashMap扩容阶段:JDK1.7的扩容函数为:

* 分析,如果对于线程A , B分别对HashMap扩容
	1. 对于上方的扩容函数当两个线程A,B运行到Entry<K,V> next = e.next, 时
	2. 对于 旧Hash表中的3 ->7线程A此时 e =3, e.next = next = 7 , 3指向的是 7 运行到这个时候A挂起了,
	3. 这个时候B开始正常运行扩容 这个时候还是 3->7 添加到新表时先添加3,在3的前面添加7 此时运行完成以后是 7->3,即7.next = 3 , 3.next = null ,这个时候还是正常的操作
	4. 但是,还记得我们上面的线程A是3->7的时候挂起了,如果此时开始运行下面代码 e.next = newTable[i]; e = 3 ,而此时newTable[i]已经被线程B修改成7了,因此3.next = 7这一步替换了3步中的3.next = null,happened before原则满足 ,将3重新添加到链表头结点处,e重新赋值为7 ,还记得3中的 7.next = 3,注意这里并没有修改7.next的值哦,因此put进入死循环中
	5. 为了防止这个JDK1.8优化了从尾部添加元素,安全性无法保证多线程会被覆盖!


### Hashtable(默认容量 11 ,加载因子0.75)


* 概述


和HashMap一样儿,Hashtable也是一个散列表,它存储的内容是键值对,implements Map<>
* 成员变量的含义:table, count, threshold, loadFactor, modCount


	+ table是一个Entry[]数组类型,Entry就是一个单向链表,而key-value 键值对就是存储在entry中
	+ count是Hashtable的大小,是保存键值对的数量
	+ threshold为判断是否需要扩容 = 容量 \* 加载因子
	+ loadFactor 加载因子
	+ modCount用来实现fail-fast同步机制
* put方法


	1. 判断value 是否为null,为空抛出异常;
	2. 计算key的hash值获得key在table数组的位置index,如果table[index]元素不为空,进行迭代,如果遇到相同的key,则直接替换,并返回旧的value
	3. 否则将其插入到table[index]位置上

#### Hashtable与HashMap的比较


1. HashMap 是非线程安全的，HashTable 是线程安全的；HashTable 内部的方法基本都经过`synchronized` 修饰。（如果你要保证线程安全的话就使用 ConcurrentHashMap 吧！）；


	1. 因为线程安全的问题，HashMap 要比 HashTable 效率高一点。另外，HashTable 基本被淘汰，不要在代码中使用它 ;
	2. **对Null key 和Null value的支持：** HashMap 中，null 可以作为键，这样的键只有一个，可以有一个或多个键所对应的值为 null。。但是在 HashTable 中 put 进的键值只要有一个 null，直接抛出 NullPointerException。
	3. **初始容量大小和每次扩充容量大小的不同 ：** ①创建时如果不指定容量初始值，Hashtable 默认的初始大小为11，之后每次扩充，容量变为原来的2n+1。HashMap 默认的初始化大小为16。之后每次扩充，容量变为原来的2倍。②创建时如果给定了容量初始值，那么 Hashtable 会直接使用你给定的大小，而 HashMap 会将其扩充为2的幂次方大小。也就是说 HashMap 总是使用2的幂作为哈希表的大小。
	4. **底层数据结构：** JDK1.8 以后的 HashMap 在解决哈希冲突时有了较大的变化，当链表长度大于阈值（默认为8）时，将链表转化为红黑树，以减少搜索时间。Hashtable 没有这样的机制。


##### HashMap jdk1.8红黑树


* 为何在1.8以后使用红黑树替换链表优化hash碰撞,首先链表容易维护但不利于查找O(n),红黑树是一种特殊的二叉树,其利于查找(二分查找法O(logn)),但相对应的维护比较复杂(需要左旋,右旋及更改节点颜色等)
* 因此对于数量小于等于6的hash碰撞使用链表存储,对于数量大于等于8的hash碰撞优化成使用红黑树存储,增删改查比较快捷,空出数字7是为了频繁的在6-8之间增加删除而导致不停的变化数据起到一个缓冲作用
	+ 选择红黑树是为了解决二叉查找树的缺陷，二叉查找树在特殊情况下会变成一条线性结构（这就跟原来使用链表结构一样了，造成很深的问题），遍历查找会非常慢。而红黑树在插入新数据后可能需要通过左旋，右旋、变色这些操作来保持平衡，引入红黑树就是为了查找数据快，解决链表查询深度的问题，我们知道红黑树属于平衡二叉树，但是为了保持“平衡”是需要付出代价的，但是该代价所损耗的资源要比遍历线性链表要少，所以当长度大于8的时候，会使用红黑树，链表长度低于6，就把红黑树转回链表，因为根本不需要引入红黑树，引入反而会慢。


###### 红黑树


* \*\*在红黑树中的hash值一致,他是根据comporeTo()来比较数值的:\*\*比如对于常见的String键来说,相同的hash值是根据native compareTo()比较两个字符串差值来计算出红黑树的大小,因此红黑树中不存在相同数值的数据,一旦相同就表示是存储的相同的键(equals方法相同)需要替换值了
* 简单说一下什么是红黑树:**特点**
	1. 根节点为黑色
	2. 子节点跟他的父节点不能同时是红色:即红色节点的子节点都是黑色节点
	3. 从根节点到任何一个叶子结点其经过的黑色节点个数相同
	4. 所有空叶子结点都是黑色的，这里的叶子结点指的是空结点，常用 NIL 表示,一般可以省略,但在用到的时候需要补全它
	+ **注意:由于特性2,3可确保没有一条路径会比其他路径长出俩倍,因此它是一个相对平衡的二叉树**,相对于普通二叉树可能退化成链表更优秀,同时相对于完全二叉树(最大跟最小最多差1且最深的节点都位于左边),平衡二叉树(左子树跟右子树深度差的绝对值不能超过1,且左右子树也是平衡二叉树)需要转化步骤更少,通过更少的更改数据既能达到相对平衡的效果,对于Hash冲突解决最优,无非还是空间换取时间操作
* 左旋跟右旋的理解
![image](https://gitee.com/songjianzaina/juejin_p14/raw/master/img/510b513ce85b647f09aa339cb62a62464c7a5792859443a0f120b2b5ec07c5eb)
* 分析:
	1. **对L进行左旋就是将L的右节点设置成x的父节点,即将L变成一个左节点==>左旋中的左是指将旋转的节点变成一个左节点**
	2. **对P进行右旋就是将P的左节点设置成p的父节点,即将P变成一个右节点==>右旋中的右是指将旋转的节点变成一个右节点**


###### 查找 时间复杂度O(logN)


* 对于红黑树的查找来说
![image](https://gitee.com/songjianzaina/juejin_p14/raw/master/img/dc4ec82a7e701df79e592c02c5caba8cbfdd94ca287d540803a05d787806cb0c)


###### 插入


* 注意:
	1. 红黑树插入节点均是最底层的叶子节点处
	2. 插入节点颜色为红色,不为黑色是因为根据特性3,任何一个叶子节点经过黑色节点个数相同,如果是黑色一定会更改其中个数导致不相同而需要重新左旋右旋更改颜色等多余操作,如果是红色则有可能不需要做任何操作也达到平衡了
* 假设: 待插入节点为N,其父节点为P, 其祖父节点为G,U是N的叔叔节点(P的兄弟节点),则插入红黑色有下面几种情况:
	1. N是根节点,即红黑树的第一个节点
	2. N的父节点P为黑色
	3. P是红色的不是根节点(根节点一定是黑色),他的兄弟节点U也是红色的
	4. P为红色,而U为黑色
* 对于以上1,2,3情况来说,他们都不涉及旋转,只涉及颜色翻转而已
	1. 对于情况1 , 2 并不影响红黑树的性质即不会破坏平衡,直接插入即可
	2. 对于3来说,P,U均为红色,直接变色即可,P和U变成黑色,G变成红色,如果G是根节点,直接变黑,否则则将G作为插入节点,递归向上检查是否造成不平衡
* 对于情况4来说,**P为红色,U为黑色**,这种分成四种情况:
	1. P是G的左孩子,若N是P的左孩子,则将祖父节点G右旋即可
	2. P是G的左孩子,若N是P的右孩子,则将P先左旋转(左转后情况如1),然后再将祖父节点G右旋转
	3. P是G的右孩子,若N是P的右孩子,则将祖父节点G左旋转即可
	4. P是G的右孩子,若N是P的左孩子,则先将P右旋转(右旋转后情况如3),然后在将祖父节点G左旋转
* 由于添加只能是叶子节点,所以只能是这四种情况,注意黑色U可能是Nul节点的


###### 删除


* 对于删除操作来说,只能是一下四种情况:
	1. 删除节点的左,右子树都不为Nul;
	2. 删除节点的左子树为Nul,右子树非空;
	3. 删除节点的右子树为Nul,左子树非空;
	4. 删除节点的左,右子树均为Nul;
	在TreeMap源码中可以查看以上四种情况分析: **对于1来说,删除节点最终还是删除非空的一个叶子节点**

bash复制代码mkdir -p /usr1/redis/redis-cluster/8001 /usr1/redis/redis-cluster/8002

bash复制代码cp /usr1/redis-5.0.3/redis.conf /usr1/redis/redis-cluster/8001