小编ant*_*tak的帖子

我需要一个按键锁定机制来保护键绑定的关键部分.

虽然a ConcurrentMap<K, Semaphore>足以满足并发性,但我也不希望地图累积旧密钥并无限增长.

理想情况下,数据结构最终(或直接)释放用于未使用锁的密钥的内存.

我有点认为Guava的Cache构建weakValues()可以解决这个问题:

private static final LoadingCache<K, Semaphore> KEY_MUTEX = CacheBuilder.newBuilder()
        .weakValues()
        .build(new CacheLoader<K, Semaphore>() {
            @Override
            public Semaphore load(K key) throws Exception {
                return new Semaphore(1);
            }
        });

是否有任何理由可能无法提供足够的并发控制？

或者为什么这可能不会导致未使用的对被垃圾收集？

我有：

>>> As = [1, 2, 5, 6]
>>> Bs = [2, 3, 4, 5]

我想要zip_fn以下内容：

>>> Rs = zip_fn(As, Bs, cmp)
>>> Rs
[(1, None), (2, 2), (None, 3), (None, 4), (5, 5), (6, None)]

换句话说，给定两个任意序列As和Bs，我想生成一个元组列表，Rs以便将满足cmp(a, b) == 0条件的选择配对到它们自己的元组中(a, b)，但是将匹配的对象As和Bs不匹配的对象分别作为(a, None)和输出(None, b)。

一些要点：

• 我不担心重复As或不会重复的事情Bs。
• Rs 可以是产生相同序列的迭代器。
• 的顺序Rs不重要。

我已经使用简单直接的预排序循环实现了满足功能要求的内容，但大约需要30行。我正在寻找可以更好地利用内置itertools函数或esque库的功能，以缩短代码长度并加快运行速度（C本机）。

编辑：

我应该更清楚地说明这一点。为了简洁起见，尽管在上面的示例中使用了纯数字列表，但是我实际使用的元素是元组，并且cmp …

在下面由 表示的 vim 窗口中，如何从函数中visible area获取X相对于 的水平位置？Y

Y------------------------+
1 File contents          |
|                        |
|   +-X--------------+   |
|   |4|              |   |
|   |5| Visible area |   |
|   |6|              |   |
|   +-+--------------+   |
$    ^                   |
+----|-------------------+
     \
       line numbers

例如，相对的垂直位置是四，因为窗口中向下滚动四行。我可以将其作为从零开始的索引。XYline("w0") - 1

我如何确定在给定时刻窗口向右滚动了多少列？我已经尝试过virtcol(".") - wincol()，但如果光标位于双角字符上，那么仅此一点就会稍微偏离。

在编写API时,我倾向于定义将超时参数作为参数的方法long timeout, TimeUnit unit.这遵循许多java.util.concurrent具有相同要求的方法.

在Java 8中,我注意到了包中的新Duration类java.time,并想知道我是否可以将新方法定义为具有Duration timeout参数.

我可以从中看到的优势是:

• 用户编写常量更容易:

  private static final Duration ACQUIRE_TIMEOUT = Duration.ofMinutes(10);
  
  someResource.acquire(ACQUIRE_TIMEOUT);
  

  Run Code Online (Sandbox Code Playgroud)

  VS

  private static final long ACQUIRE_TIMEOUT_MILLIS = TimeUnit.MINUTES.toMillis(10);
  
  someResource.acquire(ACQUIRE_TIMEOUT_MILLIS, TimeUnit.MILLISECONDS);
  

  Run Code Online (Sandbox Code Playgroud)

但这是一个可能的问题:

• 用户如何指定无限时间？

  someResource.acquire(Long.MAX_VALUE, TimeUnit.MILLISECONDS); // No timeout
  

  Run Code Online (Sandbox Code Playgroud)

  VS

  someResource.acquire(Duration.ofSeconds(Long.MAX_VALUE)); // Is this how it's done?
  

  Run Code Online (Sandbox Code Playgroud)

  哪里acquire(Duration)可以实现为:

  public boolean acquire(Duration timeout) {
      long millis;
      try { millis = timeout.toMillis(); }
      catch (ArithmeticException ignore) { millis = Long.MAX_VALUE; } // yuck! …

  Run Code Online (Sandbox Code Playgroud)

使用服务器游标获取结果和使用流获取结果在行为方面有什么区别？

前者（服务器游标）可以被激活：

• 通过设置useCursorFetch=true和defaultFetchSize=N连接属性中的每个语句。（其中N是大于零的数字。）

• 或者单独的语句通过最初的设置useCursorFetch=true或com.mysql.jdbc.Connection.setUseCursorFetch(true)在连接上，然后是java.sql.Statement.setFetchSize(N)在语句上。

后者（流）可以被激活：

• 通过设置java.sql.Statement.setFetchSize(Integer.MIN_VALUE)或调用语句在单个语句com.mysql.jdbc.Statement.enableStreamingResults()上。

• 并且可能通过defaultFetchSize=X在连接属性中设置在每个语句上，其中X是一个等于Integer.MIN_VALUE.

使用这些替代方法进行开发时需要考虑什么？ 一个好的答案可能涉及性能、锁持有和资源分配（/释放）等主题。

它是不好的做法,有我的图书馆摆脱抛出不是其他的东西方法OperationCancelledException当CancellationToken.IsCancelRequested检测到？

例如:

async Task<TcpClient> ConnectAsync(string host, int port, CancellationToken ct)
{
    var client = new TcpClient();
    try
    {
        using (ct.Register(client.Close, true))
        {
            await client.ConnectAsync(host, port);
        }

        // Pick up strugglers here because ct.Register() may have hosed our client
        ct.ThrowIfCancellationRequested();
    }
    catch (Exception)
    {
        client.Close();
        throw;
    }

    return client;
}

取消后,这有可能抛出ObjectDisposedException或NullReferenceException取决于时间.(因为TcpClient.ConnectAsync()在TcpClient.Close()同时调用时可以抛出任何一个.)

现在,我可以解决这个问题:

async Task<TcpClient> ConnectAsync(string host, int port, CancellationToken ct)
{
    var client = new TcpClient();
    try …

在看到从另一个线程中删除之后的操作之前,在调用之前的一个线程中的操作是否ConcurrentMap.remove()保证发生？

有关放入集合中的对象的文档说明:

在将对象放入任何并发集合之前的线程中的操作发生在从另一个线程中的集合访问或移除该元素之后的操作之前.

示例代码:

{
    final ConcurrentMap map = new ConcurrentHashMap();
    map.put(1, new Object());

    final int[] value = { 0 };

    new Thread(() -> {
        value[0]++;
        value[0]++;
        value[0]++;
        value[0]++;
        value[0]++;

        map.remove(1); // A

    }).start();

    new Thread(() -> {
        if (map.get(1) == null) { // B
            System.out.println(value[0]); // expect 5
        }

    }).start();
}

是一个在之前发生有关系乙？因此,如果该程序只打印5？

我正在使用带有连接池的 MySQL 临时表.

通常,在会话中创建的临时表会保留在该会话中,并在关闭连接时被删除.但是,由于我正在使用连接池,并且在java.sql.Connection.close()调用时实际上并未关闭物理连接,因此我发现临时表停留并影响下一个会话.

这会导致DB上的资源泄漏,因为临时表不会立即释放,以及由于表名冲突而导致的名称冲突.

直观地说,当我借用连接时,我期待一个干净的名单.如何实现这一目标？

• 似乎没有与MySQL 相同的SQL Serversp_reset_connection.
• 即使有,我也看不到dbcp2如何配置为在返回连接时调用它.
• 返回池时始终关闭物理连接可以正常工作,但我无法看到dbcp2如何配置来执行此操作.

除临时表外,此问题还会影响:

• 用户定义的变量(即SET @foo = 1)范围
• 释放用户级别锁(即GET_LOCK())

该收益为受影响的行多项源自,这是有据可查的在多个地方.INSERT ... SELECT... ON DUPLICATE KEY UPDATE(inserted count) + (updated count) * 2

但是在MySQL命令行工具的输出中,我注意到了这个额外的信息:

> INSERT INTO ...
-> SELECT ... FROM ...
-> ON DUPLICATE KEY UPDATE ...
-> ;
Query OK, 97 rows affected (0.03 sec)
Records: 2425  Duplicates: 28  Warnings: 0

即,数字Records:和Duplicates:.

分析确定:

• 将97 rows affected是受影响的行(又名ROW_COUNT()).
• Records: 2425是SELECT部件提取的行数.
• Duplicates: 28是ON DUPLICATE …

在bash中,我可以cat在以下命令行中以某种方式摆脱部分(以及它带来的分支)吗？

cat >some_file