Tomcat中的JNDI配置(JNDI configuration in Tomcat)

 我不认为你可以使用锁定功能来做同样的事情，因为你会试图从内部屈服。 话虽如此，这在任何一种语言中看起来都是一种危险的方法，因为它意味着锁可以保持任意时间（例如，如果一个线程调用Enumerate()但不会一直枚举所产生的IEnumerable<_> ，那么锁将继续保持）。 
 
 反转逻辑可能更有意义，提供了一个iter方法： 
 
let iter f =
  if synchronize then
    lock locker (fun () -> Seq.iter f dict)
  else
    Seq.iter f dict
 
 这将迭代置于您的控制之下，确保序列完全迭代（假设f不会被阻止，这在任何情况下都是必要的假设），并且此后立即释放锁。 
 
 编辑 
 
 以下是可以永久保存锁的代码示例。 
 
let cached = enumerate() |> Seq.cache
let firstFive = Seq.take 5 cached |> Seq.toList
 
 我们已经锁定了开始列举前5项。 然而，我们没有继续完成其余的顺序，所以锁定不会被释放（也许我们会根据用户的反馈或其他事情来列举其余的方式，在这种情况下锁定会最终被释放） 。 
 
 在大多数情况下，正确编写的代码将确保它处理原始枚举器，但是一般情况下无法保证。 因此，你的序列表达式应该被设计为健壮的，只能被部分枚举。 如果你打算要求你的调用者一次枚举所有的集合，那么迫使他们通过你的函数来应用到每个元素要比返回他们可以随意列举的序列要好。 

I don't think that you'll be able to do the same thing with the lock function, since you would be trying to yield from within it. Having said that, this looks like a dangerous approach in either language, since it means that the lock can be held for an arbitrary amount of time (e.g. if one thread calls Enumerate() but doesn't enumerate all the way through the resulting IEnumerable<_>, then the lock will continue to be held).
 
It may make more sense to invert the logic, providing an iter method along the lines of:
 
let iter f =
  if synchronize then
    lock locker (fun () -> Seq.iter f dict)
  else
    Seq.iter f dict
 
This brings the iteration back under your control, ensuring that the sequence is fully iterated (assuming that f doesn't block, which seems like a necessary assumption in any case) and that the lock is released immediately thereafter.
 
EDIT
 
Here's an example of code that could hold the lock forever.
 
let cached = enumerate() |> Seq.cache
let firstFive = Seq.take 5 cached |> Seq.toList
 
We've taken the lock in order to start enumerating through the first 5 items. However, we haven't continued through the rest of the sequence, so the lock won't be released (maybe we would enumerate the rest of the way later based on user feedback or something, in which case the lock would finally be released).
 
In most cases, correctly written code will ensure that it disposes of the original enumerator, but there's no way to guarantee that in general. Therefore, your sequence expressions should be designed to be robust to only being enumerated part way. If you intend to require your callers to enumerate the collection all at once, then forcing them to pass you the function to apply to each element is better than returning a sequence which they can enumerate as they please.