小编Mon*_*son的帖子

我的目标是开发一个可以输出指定类对象的类.

public class GetMe<T> {
    public T get() {
        Object obj = generateObject();
        return (T) obj;
    }
}

现在,我知道由于擦除,这是不可能的.因此,我们可以传入一个类实例并使用它来进行转换.

public class GetMe<T> {
    public GetMe<T>(Class<T> clazz) {
        this.clazz = clazz;
    }

    public T get() {
        Object obj = generateObject();
        return clazz.cast(obj);
    }
}

这很棒!只要该类没有参数化.如果是,那我就有问题了.

我不允许使用List<String>.class.如果我传入ParameterizedType(这本身很难生成),则没有cast方法可以使用.

有没有办法摆脱这个泥潭？

我在Mongo有一套文件.说:

[
    { summary:"This is good" },
    { summary:"This is bad" },
    { summary:"Something that is neither good nor bad" }
]

我想计算每个单词的出现次数(不区分大小写),然后按降序排序.结果应该是这样的:

[
    "is": 3,
    "bad": 2,
    "good": 2,
    "this": 2,
    "neither": 1,
    "nor": 1,
    "something": 1,
    "that": 1
]

知道怎么做吗？聚合框架将是首选,因为我已经在某种程度上理解它:)

我想这个问题适用于死锁,实时锁定或只是锁定等待超时.

我试图找出导致阻止另一个查询执行的锁的查询.Oracle(如果内存服务)有一个LOCK表,您可以将其连接到自身以确定哪些查询正在锁定其他查询.我需要一种在MySQL中完成相同的方法.

方案是我们有长时间运行的作业,偶尔会创建一个更新进度字段的嵌套事务.这样,我们就不会失去工作的交易性,同时让用户了解进度(即完成百分比).嵌套事务有时会抛出锁定超时异常.

这很奇怪,因为其他任何工作都不应该从Job表中写入 - 甚至是读取 - .筛选原始SQL日志确认了这一点.这是SHOW ENGINE INNODB状态的交易部分:

------------
TRANSACTIONS
------------
Trx id counter 0 479427
Purge done for trx's n:o < 0 479425 undo n:o < 0 0
History list length 19
LIST OF TRANSACTIONS FOR EACH SESSION:
---TRANSACTION 0 0, not started, OS thread id 3192
MySQL thread id 31, query id 17417 localhost 127.0.0.1 root
show engine innodb status
---TRANSACTION 0 0, not started, OS thread id 3776
MySQL thread id 29, query id 13062 …

我真的很想尝试仿制药,但到目前为止,他们造成的麻烦超过了任何好处.拜托,请告诉我,我错了.

我理解在使用无泛型框架(Spring,Hibernate)时添加@SuppressWarnings("unchecked")的必要性.仅这一点确实降低了泛型的价值,因为要求将类传递给构造函数以避免擦除的缺陷.然而,真正的刺似乎总是在铸造.我通常尝试一段时间来使语法正确,但然后放弃我对纯度的尝试,添加@SuppressWarnings,继续我的生活.

这是一个例子:我正在反思一个bean来寻找两个实例之间的差异.一些属性实现Comparable,使得(a.equals(b)== false)但是(a.compareTo(b)== 0)(例如BigDecimal,Date).在这些情况下,我希望该属性被认为是相同的.

MyObject original = getOriginal();
MyObject updated = getUpdated();
for (PropertyDescriptor pd : BeanUtils.getPropertyDescriptors(MyObject.class)) {
    // Assume I'm putting in the try/catch block
    Object pOriginal = pd.getReadMethod().invoke(original, (Object[]) null);
    Object pUpdated = pd.getReadMethod().invoke(updated, (Object[]) null);

    boolean isPropertySame;

    if (Comparable.class.isAssignableFrom(pOriginal.getClass())) {
        // Type safety: The method compareTo(Object) belongs to the raw type Comparable. References to generic type Comparable<T> should be parameterized
        isPropertySame = Comparable.class.cast(pOriginal).compareTo(Comparable.class.cast(pUpdated)) == 0;

        // The method compareTo(capture#19-of ?) in the type Comparable<capture#19-of ?> is …

我有一个看起来像这样的仓库表:

CREATE TABLE Warehouse (
  id BIGINT(20) UNSIGNED NOT NULL AUTO_INCREMENT,
  eventId BIGINT(20) UNSIGNED NOT NULL,
  groupId BIGINT(20) NOT NULL,
  activityId BIGINT(20) UNSIGNED NOT NULL,
  ... many more ids,
  "txtProperty1" VARCHAR(255),
  "txtProperty2" VARCHAR(255),
  "txtProperty3" VARCHAR(255),
  "txtProperty4" VARCHAR(255),
  "txtProperty5" VARCHAR(255),
  ... many more of these
  PRIMARY KEY ("id")
  KEY "WInvestmentDetail_idx01" ("groupId"),
  ... several more indices
) ENGINE=INNODB;

现在,以下查询在查询时间内花费大约0.8 秒,在获取时间花费0.2 秒,总共大约一秒钟.查询返回~67,000行.

SELECT eventId
FROM Warehouse
WHERE accountId IN (10, 8, 13, 9, 7, 6, 12, 11)
  AND …

我花了一天时间尝试在Python脚本中调试内存问题.我正在使用SQL Alchemy作为我的ORM.这里有几个令人困惑的问题,我希望如果我把它们全部列出来,有人可以指出我正确的方向.

为了达到我正在寻找的性能,我读了一张表中的所有记录(~400k),然后遍历电子表格,匹配我之前读过的记录,然后创建新记录(~800k)进入另一张桌子.这大致是代码的样子:

dimensionMap = {}
for d in connection.session.query(Dimension):
   dimensionMap[d.businessKey] = d.primarySyntheticKey

# len(dimensionMap) == ~400k, sys.getsizeof(dimensionMap) == ~4MB

allfacts = []
sheet = open_spreadsheet(path)
for row in sheet.allrows():
    dimensionId = dimensionMap[row[0]]
    metric = row[1]

    fact = Fact(dimensionId, metric)
    connection.session.add(fact)
    allfacts.append(fact)

    if row.number % 20000 == 0:
        connection.session.flush()

# len(allfacts) == ~800k, sys.getsizeof(allfacts) == ~50MB

connection.session.commit()

sys.stdout.write('All Done')

400k和800k对我来说似乎不是特别大的数字,但我仍然遇到内存问题,一台4GB内存的机器.这对我来说真的很奇怪,因为我在我的两个最大的集合上运行了sys.getsizeof,它们都处于任何可能导致问题的大小之下.

在试图解决这个问题时,我注意到脚本运行的确非常非常慢.所以我在其上运行了一个配置文件,希望结果会引导我朝向内存问题的方向,并提出两个混淆问题.

首先,87%的程序时间花在提交上,特别是在这行代码上:

self.transaction._new[state] = True

这可以在session.py:1367. self.transaction._new是一个实例weakref.WeakKeyDictionary().为什么weakref:261:__setitem__要占用这么多时间？

其次,即使程序完成('All Done'已经打印到stdout),脚本仍在继续,看似永远,使用了2.2GB的内存.

我已经对weakrefs进行了一些搜索,但没有看到有人提到我面临的性能问题.最终,由于它被深埋在SQL Alchemy中,我无法做很多事情,但是我仍然很欣赏任何想法.

重点学习

正如@zzzeek所提到的,维护持久对象需要很多开销.这是一个显示增长的小图表. …