我需要计算一个大文件(或其中一部分)的SHA-256哈希值.我的实现工作正常,但它比C++的CryptoPP计算慢得多(25分钟与10分钟~30GB文件).我需要的是在C++和Java中类似的执行时间,因此哈希几乎可以在几乎同时准备好.我也尝试了Bouncy Castle实现,但它给了我相同的结果.这是我如何计算哈希:
int buff = 16384;
try {
RandomAccessFile file = new RandomAccessFile("T:\\someLargeFile.m2v", "r");
long startTime = System.nanoTime();
MessageDigest hashSum = MessageDigest.getInstance("SHA-256");
byte[] buffer = new byte[buff];
byte[] partialHash = null;
long read = 0;
// calculate the hash of the hole file for the test
long offset = file.length();
int unitsize;
while (read < offset) {
unitsize = (int) (((offset - read) >= buff) ? buff : (offset - read));
file.read(buffer, 0, unitsize);
hashSum.update(buffer, 0, unitsize);
read += unitsize; …我正在使用带有logback的slf4j日志记录,并在我编写的应用程序的开头
InternalLoggerFactory.setDefaultFactory(new Slf4JLoggerFactory());
然后我在管道中添加了一个新LoggingHandler(InternalLogLevel.DEBUG)实例.不幸的是,这仍然没有记录任何东西,我正在调试,调试级别是问题,只是跳过日志记录本身.
我该如何设置才能使用它LoggingHandler？
我有一个 Kubernetes (v1.18.6)，其中有 1 个服务（负载均衡器）、2 个 pod：
apiVersion: v1
kind: Service
metadata:
name: app-service
spec:
selector:
app: app
ports:
- protocol: "TCP"
port: 6000
targetPort: 5000
type: LoadBalancer
访问互联网的网络策略（这对我来说是必要的）：
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: internet-access
spec:
podSelector:
matchLabels:
networking/allow-internet-access: "true"
policyTypes:
- Ingress
- Egress
ingress:
- {}
部署配置文件
apiVersion: apps/v1
kind: Deployment
metadata:
name: app-deployment
spec:
progressDeadlineSeconds: 120
selector:
matchLabels:
app: app
replicas: 2
template:
metadata:
labels:
app: app
spec:
imagePullSecrets:
- name: myregistrykey
containers:
- name: app …我正在尝试调查docker的IO性能开销,所以我在特定的机器上创建了一个mysql docker容器,并运行了sysbench mysql基准来测量IO性能.Sysbench基本上在一段时间内执行一些读/写事务,然后输出已完成事务的数量和事务/秒速率.
当我在本机上运行基准测试时,我每秒获得779.5次事务.当我在mysql容器中运行基准测试时,我得到336个事务/秒.几乎是每秒交易数量的一半.这是docker的正常性能开销吗？这对于在生产系统中的容器中运行数据库是一个巨大的缺点,特别是对于IO /数据库密集型应用程序
我们计划在我们的REST API中使用Jersey的参考实现.作为一个原型工作,我也在使用ContainerRequestFilters,我实现了多个.有没有办法控制执行这些过滤器的顺序？
我在这里考虑的方案是确保安全过滤器必须是第一个运行,并且如果需要,建立SecurityContext然后执行其他过滤器.
#include <string>
#include <iostream>
#include <tuple>
#include <utility>
template<typename... T> struct test {
using args_type = std::tuple<T...>;
args_type x;
template<std::size_t... I>
void callme(std::index_sequence<I...>) {
int _[] = {(std::get<I>(x).std::tuple_element<I, args_type>::type::~type(), true)...};
}
};
int main() {
}
错误消息是
clang-3.7 -std=gnu++1y -Wc++14-extensions test.cpp
test.cpp:15:56: error: expected ')'
int _[] = {(std::get<I>(x).std::tuple_element<I, args_type>::type::~type(), true)...};
^
test.cpp:15:20: note: to match this '('
int _[] = {(std::get<I>(x).std::tuple_element<I, args_type>::type::~type(), true)...};
^
1 error generated.
使用G ++ 4.9.2可以编译相同的代码.我还没找到任何有关Clang的相关错误报告.
假设 MAX-HEAPIFY 操作。其中父元素值大于其子元素值。
siftDown 将一个太小的节点与其最大的子节点交换（从而将其向下移动），直到它至少与它下面的两个节点一样大。
siftUp 将一个太大的节点与其父节点交换（从而将其向上移动），直到它不大于其上方的节点。buildHeap 函数接受一个未排序项的数组并移动它们，直到它们都满足堆属性。
有两种方法可以用于 buildHeap。一种是从堆的顶部（数组的开头）开始，并在每个项目上调用 siftUp。在每一步，先前筛选的项目（数组中当前项目之前的项目）形成一个有效的堆，向上筛选下一个项目会将其放置在堆中的有效位置。筛选每个节点后，所有项目都满足堆属性。第二种方法则相反：从数组的末尾开始，然后向后向前移动。在每次迭代中，您筛选一个项目，直到它位于正确的位置。
让数组 a 有 5 个元素 a[4,2,3,5,6] 。
筛选-
输入- a[4,2,3,5,6]
加工-
从数组的开头应用 siftUp 操作。
siftUp(4) -
没有交换，因为它是根
heapified Array-a[4]
筛选（2） -
没有交换，因为父值（4）更多
heapified Array-a[4,2]
筛选(3) -
没有交换，因为父值（4）更多
heapified Array-a[4,2,3]
筛选(5) -
它的父值是 2 所以交换 (5,2)。
Array-a[4,5,3,2]
现在 5 的父值是 4，所以再次交换 (5,4)。
heapified Array-a[5,4,3,2]
筛选(6) -
首先在 (6,4) 之间交换，然后在 (6,5) 之间交换
heapified Array-a[6,5,3,2,4]
输出-a[6,5,3,2,4]
筛选-
输入- a[4,2,3,5,6]
加工-
从数组的末尾，我们将一一应用 siftDown 操作。
筛选(6) -
它没有孩子所以没有交换。同样适用于 siftDown(5) 和 siftDown(3) 也因为他们没有任何孩子。所以他们不能进一步向下移动。
到现在为止的数组 …
我想使用预处理语句插入一个大整数值,我有一个名为xid的字符串变量(41527820021925053)
preparedStatement = conn.prepareStatement(sql);
preparedStatement.setObject(1,XOBJ);
preparedStatement.setObject(2,YOBJ);
preparedStatement.setBigInteger(3, xid);
preparedStatement.setInt(4, 23);
preparedStatement.executeUpdate();
preparedStatement.close();
我是新手,如何实现这一目标.
我在边缘设备上安装了 MySQL 8 docker 安装，该设备有以下两个表可供写入
video_paths | CREATE TABLE `video_paths` (
`entry` int(11) NOT NULL AUTO_INCREMENT,
`timestamp` bigint(20) NOT NULL,
`duration` int(11) NOT NULL,
`path` varchar(255) NOT NULL,
`motion` int(11) NOT NULL DEFAULT '0',
`cam_id` varchar(255) NOT NULL DEFAULT '',
`hd` tinyint(1) NOT NULL DEFAULT '0',
PRIMARY KEY (`entry`),
KEY `cam_id` (`cam_id`),
KEY `timestamp` (`timestamp`)
) ENGINE=InnoDB AUTO_INCREMENT=7342309 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci
和
CREATE TABLE `tracker` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`table_name` varchar(255) NOT NULL,
`primary_key_name` varchar(255) NOT NULL,
`pointer` …我发现在java中计算sha256很慢.例如,它比python慢.我写了两个简单的基准测试来计算1GB零的sha256.在这两种情况下,结果都是相同且正确的,但是python时间是5653ms,java时间是8623ms(慢了53%).结果每次都相似,这对我来说是一个重要的区别.
如何更快地在java中进行计算？
基准:
Java的:
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
public class BenchmarkSha256 {
public static void main(String... args) throws NoSuchAlgorithmException {
int size = 1024 * 1024;
byte[] bytes = new byte[size];
MessageDigest md = MessageDigest.getInstance("SHA-256");
long startTime = System.nanoTime();
for (int i = 0; i < 1024; i++)
md.update(bytes, 0, size);
long endTime = System.nanoTime();
System.out.println(String.format("%1$064x", new java.math.BigInteger(1, md.digest())));
System.out.println(String.format("%d ms", (endTime - startTime) / 1000000));
}
}
蟒蛇:
#!/usr/bin/env python
import hashlib
import time
size = 1024 * 1024 …