小编oli*_*ren的帖子

我们已经让我们的glassfish实例每两周下降一段时间java.lang.OutOfMemoryError: PermGen space.我将PermGen空间增加到512MB,并将startet转储内存使用量jstat -gc.两周后,我想出了下图,显示了PermGen空间是如何稳定增加的(x轴上的单位是分钟,y轴是KB).

我试着用谷歌搜索某种可以查明错误的分析工具,并在SO上提到一个线程提到jmap,这被证明是非常有帮助的.在倾倒的大约14000行中jmap -permstats $PID,大约包含12500行groovy/lang/GroovyClassLoader$InnerLoader,指向我们自己的Groovy代码或Groovy本身的某种内存泄漏.我必须指出,Groovy构造的相关代码库不到1%.

示例输出如下:

class_loader    classes bytes   parent_loader   alive?  type

<bootstrap> 3811    14830264      null      live    <internal>
0x00007f3aa7e19d20  20  164168  0x00007f3a9607f010  dead    groovy/lang/GroovyClassLoader$InnerLoader@0x00007f3a7afb4120
0x00007f3aa7c850d0  20  164168  0x00007f3a9607f010  dead    groovy/lang/GroovyClassLoader$InnerLoader@0x00007f3a7afb4120
0x00007f3aa5d15128  21  181072  0x00007f3a9607f010  dead    groovy/lang/GroovyClassLoader$InnerLoader@0x00007f3a7afb4120
0x00007f3aad0b40e8  36  189816  0x00007f3a9d31fbf8  dead    org/apache/jasper/servlet/JasperLoader@0x00007f3a7d0caf00
....

那么我该如何进一步了解导致此问题的代码呢？

在本文中,我推断我们的Groovy代码是在某处动态创建类.从jmap的转储我可以看到大多数死对象/类(？)都有相同的parent_loader,虽然我不确定这在这个上下文中意味着什么.我不知道怎么从这里开始.

附录

对于后来者来说,值得指出的是,接受的答案并不能解决问题.它只是通过不存储如此多的类信息来延长重启前所需的时间十倍.实际修复我们问题的是摆脱生成它的代码.我们使用验证(按合同设计)框架OVal,其中可以使用Groovy编写自定义约束作为方法和类的注释.在普通Java中删除注释以支持显式的前置条件和后置条件是很无聊的,但它完成了工作.我怀疑每次检查OVal约束时都会创建一个新的匿名类,并且关联的类数据以某种方式导致内存泄漏.

我们在尝试将文件从一个目录移动到另一个目录时错误的程序.经过多次调试后,我通过编写一个只将一个文件从一个目录移动到另一个目录的小实用程序来找到错误(下面的代码).事实证明,在本地文件系统上移动文件时工作正常,尝试将文件移动到另一个文件系统失败.

为什么是这样？问题可能是特定于平台的 - 如果重要的话,我们在ext3上运行Linux.

第二个问题; 我应该使用除了班级renameTo()方法以外的其他东西File吗？似乎这只适用于本地文件系统.

测试(以root身份运行):

touch /tmp/test/afile

java FileMover /tmp/test/afile /root/
The file move was successful

touch /tmp/test/afile

java FileMover /tmp/test/afile /some_other_disk/
The file move was erroneous

码:

import java.io.File;

public class FileMover {
    public static void main(String arguments[] ) throws Exception {
        boolean success;
        File file = new File(arguments[0]);
        File destinationDir = new File(arguments[1]);
        File destinationFile = new File(destinationDir,file.getName() );
        success = file.renameTo(destinationFile);
        System.out.println("The file move was " + (success?"successful":"erroneous"));
    }
}

在过去的两天里,我试图了解 Java如何处理图形,但是在这方面却惨遭失败.我的主要问题是如何以及何时应该调用paint()(或更新的paintComponent()).

在下面的代码中我看到了什么时候创建的东西,paintComponent()从不被调用,除非我自己手动添加一个调用或者调用JFrame.paintAll()/ JFrame.paintComponents().

我将paint()方法重命名为paintComponent(),希望能解决我永远不会被调用的问题(即使在repaint()),但没有运气.

package jpanelpaint;

import java.awt.*;
import javax.imageio.*;
import javax.swing.*;
import java.io.*;
import java.util.ArrayList;

public class ImageLoadTest extends JComponent {
 ArrayList<Image> list;

 public ImageLoadTest() {
  list = new ArrayList<Image>();

  try { //create the images (a deck of 4 cards)
   for(String name : createImageFileNames(4)){
    System.err.println(name);
    list.add(ImageIO.read(new File(name)));
   }
  } catch (IOException e) {  }
 }

    protected void paintComponent(Graphics g) {
     int yOffset=0;
  System.err.println("ImageLoadTest.paintComponent()");
     for(Image img : list) {
      g.drawImage(img, 0, yOffset,  null);
      yOffset+=20;
     }
    }

 public static …

tldr; 我希望一次将我的JS项目转换为TS一个文件，而无需构建步骤即可运行Mocha测试。

我在当前的javascript代码中使用了很多Babel转换（类props，jsx等），Mocha在运行时通过注册babel加载器（基本上是mocha --require @babel/register）来处理。这意味着运行单个测试很快，并且不需要整个项目的构建步骤。

我遵循了有关使用Microsoft（相对）新的babel插件进行TypeScript入门的指南：@babel/preset-typescript。在基本情况下，此方法效果很好：将app.js转换为app.ts。

它没有涉及的是如何进行逐步过渡。对我来说，修复3978个打字错误（执行之后的实际计数<code>find</code> ...）有点不知所措，并且会使开发停滞两周。刚react-redux花了一个多小时，才使我的200个LOC帮助程序lib可以很好地编译来自的定义。

尽管git mv app.{j,t}s运行良好，但对其他任何文件进行操作都是灾难。现有的Mocha测试由于无法找到正确的文件而迅速崩溃，即使在注册Babel并添加适当的扩展名时也是如此：

mocha --extension js,jsx,ts,tsx --require @babel/register

通常，如果这样做git mv Logger.{j,t}s我会得到Error: Cannot find module './lib/logging/Logger'。

有没有办法让Mocha的模块加载器识别打字稿文件并通过Babel透明地运行它们？

在我正在进行的一项任务中,我们需要使用位向量,但我不确定如何在Python中执行此操作.它们应该能够从4位到20位.我以前从未使用过位向量,但我想可以创建一个使用通常的AND/OR/XOR操作操作的无符号字节数组.

这里的重要限制是:除了标准Python提供的库之外,我不能依赖任何库.

我想我知道如何使用8位无符号字节的数组在C中执行此操作:例如,将零数组的第18位转换为1,我会做类似my_bit_array [3]&= 1 << 2的操作

但由于Python是动态类型的,并且没有内置数组类型,我将如何以pythonic方式执行此操作？

是否有可能(如何？)表达大小为20的位向量？我在考虑制作一个24位/ 3字节向量并忽略4位.

我最近使用了John Resig的一个小实用程序库,名为inherit.js.我经常尝试理解我正在使用的库的核心部分,经过大量的讨论后我终于理解了代码的硬件(即他如何调用超类的相应方法).

我没有得到的1%位与正则表达式有关

fnTest = /xyz/.test(function(){xyz;}) ? /\b_super\b/ : /.*/;

1. regex/xyz /针对函数进行测试.无论MSDN和MDN状态test需要一个字符串作为参数.没有提到功能,但由于控制台没有错误,我想它必须飞,但它是如何工作的？
2. 下一个WTF是功能体xyz;.此功能无法执行,否则会导致" ReferenceError: xyz is not defined".对？那它是做什么的？
3. 如果测试结果为真,那么fnTest等于_super在字边界上检查的正则表达式,或者在任何东西上匹配的正则表达式.双WTF; 又如何以及为什么.

后来有一段相关的代码,正在使用这个正则表达式.

  // Check if we're overwriting an existing function
  prototype[name] = typeof prop[name] == "function" &&
    typeof _super[name] == "function" && fnTest.test(prop[name])
        ? aFunctionThatCanCallSuper /* Lots of code */
        : prop[name];

我在这里想知道的是fnTest.test(prop[name]).我理解所有其他测试,检查属性是否存在,是一个函数等,但不是正则表达式测试的作用.任何人？

通过查询字符串传递的值的类型始终是字符串。例如，当HTTP客户端需要发送号码时42，in实际上是"42"。里面的一切查询字符串实际上是一个字符串。

通过标头传递的值的类型是否相同？

换句话说，如果我们发送的HTTP请求的"FooBar"标头值为42，而另一个请求的值为"42"，则服务器是否接收到相同的值（即"42"）？

谢谢。

我有一个myModule Node.js模块，其中包含：

function b() {
  console.log('original b');
}

function a() {
  b();
}

exports.a = a
exports.b = b;

以及以下使用mocha + sinon.js的测试套件：

const myModule = require('./myModule.js');
const sinon = require('sinon');
const sinonChai = require('sinon-chai');

chai.use(sinonChai);

describe('not working stub', () => {
  it('should call the stub', () => {
    let stub = sinon.stub(myModule, 'b', () => { console.log('stubbed b')});
    myModule.a();
    expect(stub).to.have.been.called;
  })
});

我期望存根被调用，但是原来的b被调用了，为什么？

如今，大多数项目中并不常见Java 对象到二进制形式的内置序列化，这些项目倾向于使用 ProtoBufs、XML、JSON 等在服务器之间进行数据传输。CORBA 和所有这些似乎都属于 2000 年左右的项目。老实说，我只见过它实现一次（在十年前的 J2EE 项目中），而且看起来有点奇怪。Serializable不过，每次 IntelliJ 抱怨serialVersionUID某些课程缺失时，我仍然会想起整件事！如今，这种情况主要发生在我使用 Jackson 处理 JSON 序列化/反序列化时，因为它的类型注释表明某些类必须实现Serializable. 通常是这样的东西

StdDeserializer<T> extends JsonDeserializer<T> implements Serializable, Gettable

（我没有看到T需要可序列化，只有序列化器？）

现在，我不明白的是，当我们现在主要处理 JSON 和 XML 时，为什么仍然处理二进制 java 对象序列化的概念。为什么杰克逊（和其他“新”图书馆）会选择处理这个问题？

我唯一的猜测是，这与 Jakcson 客户端序列化的域类无关，但某些高级 JVM 用法可以在 JVM 之间传输正在使用的各种对象或类似的东西，这需要 和 的稳定writeObject()接口readObject()。但我在这里真的如履薄冰。

在我的项目（最新提交）中，我的 package.json 中有两个导出：

  "exports": {
    ".": "./dist/index.js",
    "./react-lazy": "./dist/react-lazy.js"
  },

在 JS 项目中使用它效果很好，但 TS 项目抱怨在我将一个模块拆分为子路径导出后找不到类型。

然后我尝试了我在另一个答案中看到的“扩展”导出版本：

  "exports": {
    ".": {
      "import": "./dist/index.js",
      "types": "./types/index.d.ts"
    },
    "./react-lazy": {
      "import": "./dist/react-lazy.js",
      "types": "./types/react-lazy.d.ts"
    }
  },

不去。

然后我尝试了另一种方法typesVersion：

  "typesVersions": {
    "*": {
      ".": "./types/index.d.ts",
      "./react-lazy": "./types/react-lazy.d.ts"
    }
  },

还有，不去。是什么赋予了？现在我对这里的问题有点困惑。

尝试此操作时，我从测试项目中npm link启动了该项目并运行。npm link @fatso83/retry-dynamic-importtsc --lib es2015,dom --noEmit main.ts

我基本上只是测试这些行是否通过编译器：

import { dynamicImportWithRetry } from "@fatso83/retry-dynamic-import";

import reactLazy from "@fatso83/retry-dynamic-import/react-lazy";

目前，上述所有尝试都以

$ tsc --lib es2015,dom …