3回答
我一直在学习Java多线程概念。我经历得越多，我就越迷茫。
现在，我还不了解Java中类级别、对象级别、显式锁定和内在锁定之间的区别。谁能告诉我哪一种是什么？此外，如果我能得到一些例子来理解，这将对我很有帮助。
浏览 3提问于2014-10-31得票数 5
回答已采纳
我是多线程方面的新手，我很困惑，为什么在java同步.Also中需要读锁我理解写lock.In的用例，我们需要限制线程的读取器访问。假设我们在java中没有读锁，那么有什么问题呢？
浏览 1提问于2015-07-06得票数 1
4回答
目前我们正在分析一个tomcat线程转储。在tomcat上同时运行的所有线程的单线程转储包含以下行：
...
"soldOutJmsConsumerContainer-1" prio=10 tid=0x00007f8409c14800 nid=0x231 in Object.wait() [0x00007f8403a9f000]
java.lang.Thread.State: WAITING (on object monitor)
at java.lang.Object.wait(Native Method)
at java.lang.Object.wai
浏览 2提问于2012-01-19得票数 4
回答已采纳
可能重复：
我试图理解java中的可重入锁，我正在寻找一个简单的解释。为什么锁必须重新进入？它解决了什么问题？举个例子会有帮助。
浏览 1提问于2011-09-16得票数 5
13回答
我正在研究java线程和死锁，我理解死锁的例子，但我想知道是否有通用的规则来防止它。
我的问题是，是否有一些规则或技巧可以应用于java中的源代码，以防止死锁？如果是，你能解释一下如何实现它吗？
浏览 1提问于2013-05-28得票数 47
回答已采纳
我有一个C++程序，它使用POSIX建议锁锁定文件。也就是说，它使用进行锁操作。我想要一个Java程序与那个C++程序进行互操作，所以我希望我的Java程序也使用POSIX咨询锁。Java 中的文件锁定使用标准的类。但是，可以理解的是，API文档对于如何实现锁定是模糊的：
此文件锁定API的目的是直接映射到底层操作系统的本机锁定工具。因此，对于所有访问该文件的程序来说，文件上的锁都应该是可见的，而不管这些程序是用什么语言编写的。
如果我在POSIX操作系统上运行Java的通用实现(Oracles，Open )，或者更具体地说是在GNU系统上运行，那么假设FileLock类使用POSIX
浏览 6提问于2014-05-09得票数 5
回答已采纳
1回答
我可以使用object.wait、object.notify和synchronized blocks来解决生产者和消费者类型的问题。同时，我可以使用java.util.concurrent包中的locks和conditions。我确信我不能理解为什么我们需要条件，而我们可以使用object.wait和notify来使线程在某种条件下等待，比如队列为空或已满。如果我们使用java.util.concurrent.locks.Condition，我们还能获得其他好处吗？
浏览 2提问于2010-06-02得票数 3
回答已采纳
我从锁检查器中得到了这个：
Error:(52, 30) java: [method.guarantee.violated] @ReleasesNoLocks method proc() calls method unfree() with a weaker @MayReleaseLocks side effect guarantee
我可以发布代码，但这无关紧要。我只是不理解关于调用副作用方法的文档。
浏览 4提问于2016-09-20得票数 0
2回答
我当时正在研究Java中的可重入锁。需要对这个概念进行某些澄清，即它实际上是如何工作的。下面是我所理解的代码片段：
class Test{
public synchronized a(){
some code;
b();
some code;
}
public synchronized b(){
some code;
}
}
上面的代码有这个可重入锁问题的场景。
我在这里所理解的是，假设我们有两个线程:在测试共享对象上执行应用程序中的T1和T2。
无论T1或T2获取a()和b()上的锁获取。让
浏览 1提问于2018-10-27得票数 4
我理解为了实现线程安全和同步，我们使用同步块或方法。
但我不能理解这句话-
“Java中的同步块是某些对象上的同步”
任何现实世界的例子都是有帮助的。
浏览 1提问于2018-10-06得票数 2
回答已采纳
2回答
我在浏览可重入锁的Java时发现了以下文本：
锁的公平性不能保证线程调度的公平性。因此，使用公平锁的多个线程中的一个可以连续多次获得该锁，而其他活动线程则没有进展，目前也没有保存该锁。
根据我的理解，如果OS调度程序调度相同的线程(之前获取锁)，并且再次尝试获取相同的锁，Java将允许它获取并且不服从公平参数值。有人能告诉我公平参数的目的是什么吗?在什么情况下应该使用它。
我只是在想，如果它只是一个优先级值，这可能会影响调度程序，但不能保证线程执行顺序。
浏览 0提问于2021-12-03得票数 0
回答已采纳
1回答
我最近在阅读oracle website.Today中的java教程中的并发，我读到了关于死锁/同步的内容，我能够理解的事情很少。
同步：
同步方法:没有两个线程可以在给定的时间点调用同一object.Meaning的两个不同的同步方法，每个对象只能执行一个同步方法，即使有多个其他同步方法也是如此。
我的理解是否正确。
死锁：
在下面的代码中出现了死锁，但我就是不能理解为什么？为什么这两个线程都在等待对方退出bow方法？
package com.tutorial;
public class Deadlock {
static class Friend {
privat
浏览 0提问于2014-08-04得票数 3
3回答
我在Java规范中看到了下面的语句。
线程在多个对象上持有(直接或间接)锁的程序应该使用传统的技术来避免死锁，如果必要的话，应该创建更高级别的锁定原语，而不是死锁。
那么，为了避免死锁，应该遵循什么“常规技术”呢？我对此不太清楚(没有正确理解，需要解释)。
浏览 6提问于2011-03-01得票数 1
回答已采纳
我原以为我会理解Java中并发的概念，但现在有一件事打破了我的理解：
为什么在同步块中必须将调用括起来来等待()和通知()方法？
假设我有两个线程:线程A和线程B。我也有一个对象，我将使用它作为锁。现在，在某个时候，线程A调用对象上的wait()，然后被阻塞，直到其他线程调用同一对象上的notify()。到目前为止，这是我的理解，这很好。但是现在我需要将这些调用封装在这个对象上同步的块中--实际上，如果不这样做，我就会得到一个IllegalMonitorStateException。如果我加了这些块，效果很好--但为什么？？
如果我使用这些同步块，那么线程A将永远保持对象上的锁，因为wait(
浏览 0提问于2018-02-24得票数 1
回答已采纳
1回答
Java
、
我正在学习Java，并试图理解GetStringUTFChars & ReleaseStringUTFChars。不过，我还是不能理解ReleaseStringUTFChars。根据我从某篇文章中的理解，在大多数情况下，GetStringUTFChars返回对原始字符串数据的引用，而不是副本。因此，实际上，ReleaseStringUTFChars释放jstring或const *(如果复制)或两者兼而有之。
如果我能得到以下问题的答案，我就能得到更好的理解。
在下面的代码中，我需要在for循环中调用ReleaseStringUTFChars，还是只调用一次(使用任何一个const *
浏览 8提问于2015-08-07得票数 1
回答已采纳
1回答
在站点上有一个活锁的概念，首先说线程不被阻塞，然后说线程被阻塞……“他们还在互相阻挡”，所以我不太理解...如果它们被阻塞了，它看起来就像死锁。
有没有人能给我一个简单的活锁情况的Java代码，如果它能够模拟Java网站上报道的Alphonse和Gaston示例，效果会更好？
浏览 0提问于2010-08-05得票数 2
1回答
为了理解Java 8中的乐观锁定，我遇到了以下代码。。
正如在博客中解释的那样，这段代码试图将读锁转换为写lock.The代码，如果读锁转换为写锁失败，则请求显式写锁。
令我费解的是，，当父线程已经持有读锁时，怎么可能会授予显式写锁呢？--在强制请求写锁之前，它看起来并不像读取锁在任何时候都被释放。据我错误的理解，线程会无限地等待写锁，因为读取锁从未释放，从而造成死锁。
，为什么这不会导致这里的死锁？
ExecutorService executor = Executors.newFixedThreadPool(2);
StampedLock lock = new StampedLock();
浏览 8提问于2021-01-13得票数 0
1回答
重入锁不锁定线程
、、、、
我可能很难理解线程是如何工作的，这可能是我遇到这个问题的原因。问题是，我有一个REST客户端和一个Web客户端，它们都在确认已经下过的订单(订单属于将从每个客户端收到销售额的卖方)。两个客户端都访问写入数据库的相同代码，让我们称其为Exclusive_Code_Block。
这个Exclusive_Code_Block位于类中的一个方法中，我试图对Exclusive_Code_Block设置一个锁，如下所示：
try {
confirmSerially.lock.lock();
***** code that accesses database is he
浏览 4提问于2022-02-13得票数 0
2回答
监视器和锁的澄清
、、、、
我把同步的概念理解为: Java中的每个对象都有一个监视器和一个锁。锁是一个可以被线程获取或释放的实体，而监视器是一个实例的机制，它决定了线程是否可以获得对象上的锁。
我想澄清一下下面的例子。首先，我想创建两个对象：
MyClass obj1 = new MyClass();
MyClass obj2 = new MyClass();
是否每个实例都有自己的监视器和锁？还是共享的？
如果我在一个类上同步：
synchronized (MyClass.class) {
...
}
它会有什么样的表现？此同步是否会阻止获取obj1和obj2锁？如果有，Java中有没有锁的
浏览 0提问于2015-11-19得票数 2
我是Java并发性的新手，我正在努力更好地理解监视器。
假设我有一个对象，它的一个方法接受某种引用参数，并在synchronized块中将该参数用作监视器：
class Entity() {
public void myMethod(Object monitor) {
synchronized(monitor) {
// critical stuff
}
}
}
如果两个线程使用不同的对象作为监视器，那么它们是否可以同时进入同一实体的该部分？
final Entity myEntity = new Entity();
fo
浏览 1提问于2020-12-12得票数 2
根据Java在实践中的并发性，第11.4.3章指出：
锁拆分有时可以扩展到在不同大小的独立对象集上的分区锁定，在这种情况下，它被称为锁条带。例如，ConcurrentHashMap的实现使用一个由16个锁组成的数组，每个锁保护1/16个哈希桶；桶N由锁N 16保护。
我仍然有问题，以理解和形象化锁条纹和桶机制。有人能用很好的理解词来解释这一点吗:)
提前谢谢。
浏览 1提问于2013-04-22得票数 28
回答已采纳
6回答
我试图理解对象上同步的概念。使用Java Cert Book中的这个示例，您能帮助我理解以下2段代码之间在行为上的区别吗(其中一段代码是在我们希望保护其方法/操作不受争用条件影响的对象上同步的，另一段代码是使用助手对象作为锁以实现相同的目标)：
1.
class Client {
BankAccount account;
public void updateTransaction() {
synchronized (account) {
account.update(); // update is safe because of loc
浏览 3提问于2011-06-22得票数 2
回答已采纳
我正在阅读“理解JVM高级特性和最佳实践”，其中有一个代码段，可以解释发生的情况--在java中的规则之前。我听不懂。守则如下：
private int value = 0;
//executed by Thread A
public void setValue(int value){
this.value = value;
}
//executed by Thread B
public void getValue(){
return value;
}
假设线程A在代码中的线程B之前启动。我可以理解，我们不知道线程B中的getValue()返回的结果，因为它不是线程安全的。但是
浏览 2提问于2016-08-20得票数 5
回答已采纳
如果在一个对象中有几个可变属性，这些属性将由多个线程执行，我理解它们应该是同步的。
class Doggie {
private String name;
private int age;
public void setName(String name) { this.name = name; }
public String getName() { return this.name; }
public void setAge(int age) { this.age = age; }
public int getAge() { return
浏览 11提问于2010-06-19得票数 10
回答已采纳
我是高级Java和学习重入锁的新手。我理解ReentrantLock有一个公平的参数，它确保锁被分配给大多数饥饿的线程(与同步内部锁中的情况不同)。
但是，可重入也意味着同一个线程可以通过增量holdCount一次又一次地重新获取锁。如果同一个线程永远获取锁，它如何保证公平性？
浏览 0提问于2018-04-30得票数 3
回答已采纳
2回答
我对java中的mutli线程很陌生，并试图理解关键字synchronization，我有以下代码：
class LockObject {
int threadsGoingThrough = 0;
synchronized void locked() {
threadsGoingThrough++;
try {
wait(1000);
} catch (Exception e) {
System.out.println("Exception " + e);
浏览 3提问于2012-04-03得票数 0
回答已采纳
3回答
Java线程内部
、、、、
我学习Java的内部结构已经有一段时间了。我很想了解和理解Java中线程/锁定是如何发生的。
因此，为了访问同步方法或同步块，线程必须首先获取对象的锁。所以，现在，我需要更多的光。
因此，每当线程获取对象上的锁时，它是否会在内部增加信号量的值？如果答案是肯定的，那么让我们来看看这个场景。
class ABC{
public void method_1(){
synchronized(xyz){
....
}
}
public void method_2(){
...
synch
浏览 6提问于2010-02-21得票数 1
7回答
为了正确理解Java并发的问题和解决方案，我阅读了正式的Java教程。在其中一个页面中，他们定义了内在锁和同步 。在这一页中，他们说：
只要一个线程拥有一个内部锁，任何其他线程都无法获得相同的锁。另一个线程在尝试获取锁时会阻塞。
此外，他们在同步方法锁一节中提到：
当线程调用同步方法时，它会自动获取该方法的对象的内部锁，并在该方法返回时释放它。即使返回是由非正常异常引起的，也会发生锁释放。
对我来说，这意味着一旦我从其中一个线程调用了一个同步方法，我将拥有线程的内部锁，并且从
内部锁在同步的两个方面都起着作用:强制对对象状态的独占访问，并在对可见性至关重要的关系之前建立。
浏览 21提问于2016-07-05得票数 14
回答已采纳
我是Java的新手，尝试着用实现来学习Java概念。这里使用ReentrantLock类的原因是为了理解锁。
我正在生成3个线程，在这些线程中，我只是增加了一个全局计数器。我使用锁保护计数器被其他线程覆盖。
import java.util.concurrent.locks.ReentrantLock;
class ReentryHandledSingleThread extends Thread
{
static long counter = 0;
private int myId;
private final ReentrantLock myLock = ne
浏览 1提问于2014-10-07得票数 1
回答已采纳
我试图证明在我的SCJD中使用synchronized语句与Java Concurrent API是合理的。
到目前为止，我能给出的唯一原因是它更简单，更容易理解，更干净。
还有更好的技术原因吗？
浏览 0提问于2011-08-10得票数 0
2回答
我试图理解java中同步块的概念。在我阅读的文档中，我了解到如果我们获得一个锁(使用实例变量的同步块)，那么我们就不能在该类中的同一个对象上获得一个同步锁。但是当我尝试使用下面的片段时，我发现我的理解出了问题。
也就是说，我能够同时在两个不同的方法中获得锁(同一实例变量上的同步块)。当线程启动时，它将运行方法并无限期地等待，并且不会从同步块中出来。同时，如果我使用相同的线程调用stop方法，它会进入同步块并执行notify语句。我在Java文档中搜索，但找不到。
这是代码片段：
public class MyClass extends Thread
{
private Object l
浏览 2提问于2016-03-02得票数 2
回答已采纳
下面有一个spring (稍微编辑一下)--这个bean负责向内部连接(this.sockets)添加/删除websocket连接。新的条件可以添加/删除，并在每次需要发送消息时迭代。
正如您可以看到的，sockets字段上的每个操作都封装在一个synchronized()块中--它是私有的，不在该类之外使用，这个字段的每次使用都在我下面粘贴的代码中。
但是，我还是不时地得到一个ConcurrentModificartionException，它发生在onApplicationEvent调用的for循环中。这个调用确实可以由应用程序中的多个线程调用，但我的理解是，如果每个实际修改或迭代this
浏览 11提问于2022-03-23得票数 0
回答已采纳
2回答
Java中同步块的简化
、、、
我很难理解Java中同步块的概念。我觉得我已经很好地理解了同步方法。所以我想了一个类比来帮助我从同步方法的角度理解同步块。请让我知道我提出的这个等价性是否正确。另外，我现在只对一个非静态同步块提到了这一点。但是，静态同步块上的点也是受欢迎的。
public void method()
{
//code snipppet A
synchronized(objRef)
{
//code snipppet B
}
//code snipppet C
}
等于
public void method() {
//code snippet A
objRef.sync_met
浏览 1提问于2016-10-30得票数 0
回答已采纳
1回答
我试图理解Java语言中的同步和锁之间的区别，我发现了另一个我仍然不能完全理解的问题：What is the equivalent of synchronized( object ) in Reentrant lock in Java? 特别是，我不明白为什么lock.lock()被写在try块之外。 据我所知，锁是在方法体中使用的，lock.lock()是作为try块中的第一件事编写的，以确保一次只有一个线程可以执行try块中的内容，直到使用lock.unlock()调用解锁为止，该调用是在try块之后的finally块中编写的。 但是，如果在方法体和块的外部调用lock.lock()，这
浏览 15提问于2021-06-27得票数 1
回答已采纳
1回答
我试图使用作为java.util.concurrent.*的一部分添加的特性来理解Java中的多线程。首先，有一个线程可以尝试lock来获取的概念；如果一个线程不能获得，它可以执行其他一些任务。
我在网上也读过一些书，但从来没有见过他们真正实现的东西。如果一个线程不能获得一个锁，它怎么可能执行其他任务；难道一个线程不应该做一个“工作”吗？如果它能够/不能获得一个锁，它如何能够基于多个逻辑执行？
有什么真正的实现，我可以参考，以了解，加强概念；否则，似乎太抽象，如何在现实生活中实现。
有什么解释吗？
浏览 1提问于2018-02-15得票数 0
1回答
我目前正在大量试验java的安全机制，以便理解如何最好地在沙箱中执行不受信任的代码。您要防止的事情之一是无限循环，这就是为什么在理想情况下，您希望在其自己的线程中运行不受信任的代码。当然，现在恶意代码可能会进行一些繁重的处理，从而导致线程挂起。要从根本上摆脱这个线程，唯一的方法就是使用java的过时的Thread.stop()机制。这有问题的主要原因是线程持有的所有锁都被释放了，这可能会导致对象损坏。
问题是:使用Java的SecurityManager和自定义类加载器，我能够跟踪，例如，哪些类可以加载，哪些系统资源可以访问。是否有办法通知(并可能禁止)代码获取锁(例如，定义在当前线程进入同步
浏览 1提问于2013-06-06得票数 5
回答已采纳
1回答
带锁的Java条件
、、、
这里的Java文档，
我正在努力理解条件的概念。在下面的代码中，在相同的锁上放置并接受两个等待。文档说，在调用任何condition.await()之前，我们需要获得相应的锁(here line 2 : final Lock lock = new ReentrantLock();).
我的问题是，让我们说缓冲区已经满了。在这种情况下，如果我们尝试插入一个对象，线程将被阻塞，直到count == items.length，但是这里的锁仍然保留在试图放置的线程中。我们如何调用方法we ()来减少计数，因为can ()需要获得相同锁的控制。我认为这将是死锁，因为put()不能被调用，同样的，如果条目
浏览 2提问于2021-10-28得票数 2
回答已采纳
如何在非线程的对象上调用wait()和notify()方法？这真的没什么意义，不是吗？
当然，它必须有意义，因为这两个方法对所有Java对象都是可用的。有没有人能解释一下？我在理解如何使用wait()和notify()在线程之间通信时遇到了问题。
浏览 0提问于2013-04-25得票数 50
回答已采纳
3回答
大家好，我正在做一个简单的程序，计算从0到99的数字和。我正在阅读java中的线程，我试图理解它是如何工作的，特别是多线程，所以我写了一个简单的程序来理解这个概念。但是我的程序的输出是不同的，因为它输出0和4950。好像有两个线程在运行？主线程，然后是对象线程？我有一个来自输出的问题，因为它们不同步。我希望我在正确的轨道上，但不确定，需要指导。有人能解释一下如何使用同步来解决这个问题吗？理解它有困难吗？
public class Testing {
public static void main(String[] args) {
ThreadB b = new Thre
浏览 1提问于2014-10-22得票数 2
4回答
我一直在读Effective Java
第46项:每个循环优先于传统的for循环
在提到的部分中，需要迭代器/for循环的情况是for-每个循环的，这里有以下几点：
并行迭代--如果您需要并行遍历多个集合，那么您需要对迭代器或索引变量进行显式控制，以便所有迭代器或索引变量都可以同步前进。
现在，我了解了对迭代器/索引变量的显式控制是什么意思(而不是每个循环的控制器)。但从这个意义上说，我无法理解“锁步”的含义。我试图在谷歌上搜索，并在上找到一篇文章，其中写道：
锁步系统是并行运行同一组操作的容错计算机系统。
这是我理解的，例如，对于失败的服务器来说，这是可以的。但是，我
浏览 3提问于2014-03-07得票数 9
回答已采纳
2回答
下面是来自的java示例程序
// Create a new thread.
class NewThread implements Runnable {
Thread t;
NewThread() {
// Create a new, second thread
t = new Thread(this, "Demo Thread");
System.out.println("Child thread: " + t);
t.start(); // Start the thread
}
//
浏览 3提问于2013-07-31得票数 0
回答已采纳
1回答
我一直在学习Java中的并发性，我遇到了生产者-消费者问题。这显然是标准的，我在许多地方都看到了几乎相同的答案。
public synchronized void put(int num){
while (!empty) {
try{
wait(); }
catch {}
}
buffer=num;
empty=false;
notify();
}
public synchronized int take(){
while (empty) {
try{
浏览 1提问于2011-12-12得票数 3
回答已采纳
3回答
下面是我在Java中实现一个简单计数信号量的尝试。请分享你的意见。
/*
* A simple counting semaphore implementation.
* Acquire calls block until a resource is available.
* Supports fairness option which serves Acquire calls
* in FIFO order.
*/
import java.util.Deque;
import java.util.ArrayDeque;
public class MySemaphore {
浏览 0提问于2017-08-11得票数 1
1回答
我对java很陌生，在理解Java多线程的同时，我发现了这个链接：。
在本教程中，下面的代码被称为一种良好的实践，以避免出现滑落的情况：
public class Lock {
private boolean isLocked = true;
public void lock(){
synchronized(this){
while(isLocked){
try{
this.wait();
} catch(InterruptedException e){
//
浏览 3提问于2015-01-04得票数 2
回答已采纳
1回答
Java日志线程阻塞
、、、、
我对java记录器有一个问题，如下所示。我们的猫服务器将在运行3到4个小时后挂起来。在tomcat重启后，它将再次运行，大约4小时，然后再挂起。好像IVM被绞死了。
在我得到线程转储之后，它将显示如下代码。据我理解，它与日志锁定或硬盘读/写操作有问题。任何人都知道这是Java1.6问题，否则它将在java 7中修复。
我使用的是java 1.6.0_18和apache-tomcat-7.0.25。
catalina-exec-49" daemon prio=10 tid=0x00007f2fb000f800 nid=0x2a29 waiting for monitor entry [0
浏览 1提问于2013-09-11得票数 3
当我阅读ArrayBlockingQueue.take方法的源代码时，我遇到了一个问题。
然后，我认为两个线程并发调用采取方法，只有一个线程可以成功地获得锁，而另一个线程将在行处等待锁：lock.lockInterruptibly();--这是get的源代码：
public E take() throws InterruptedException {
final ReentrantLock lock = this.lock;
lock.lockInterruptibly();
try {
while (count == 0)
no
浏览 2提问于2018-05-30得票数 0
回答已采纳
2回答
我在这里有一个代码，用来解释信号量是如何工作的。无论我多么努力地尝试，我都不理解下面和那里的行，而是通过调用信号量来编写代码。
基本上，这段代码试图模拟许多连接.
import java.util.concurrent.Semaphore;
public class Connection {
private static Connection instance = new Connection();
private Semaphore sem = new Semaphore(10, true);
private int connections = 0;
浏览 1提问于2013-12-24得票数 1
回答已采纳
6回答
我想了解如何在Java中对静态方法进行锁定。
假设我有以下课程：
class Foo {
private static int bar = 0;
public static synchronized void inc() { bar++; }
public synchronized int get() { return bar; }
我的理解是，当我调用f.get()时，线程获取对象f上的锁，当我执行Foo.inc()时，线程获取类Foo上的锁。
我的问题是，这两个呼叫是如何相互同步的？调用静态方法是否也会获得所有实例化的锁，或者相反(这似乎更合理)？
编辑：
我的问
浏览 0提问于2011-03-26得票数 10
回答已采纳
我正在尝试理解LockSupport.java，并参考了它的文档。在那里，它有代码片段，其中作者提供了使用LockSupport#park()和LockSupport#Unpark()实现互斥的示例。
我使用了该示例，并创建了一个使用该示例FIFOMutex的程序。
FIFOMutex代码(摘自LockSupport.java)
package com.example.java.locking.studies.locksupport.from.javadoc;
import java.util.Queue;
import java.util.concurrent.ConcurrentLink
浏览 0提问于2020-06-16得票数 1
我想我错过了一些东西，但我不能理解Java中的文件锁是如何工作的。更准确地说，它是如何实现的。
在单个JVM中，我似乎无法获取(甚至不能尝试获取)同一文件的两个或多个锁。第一个锁将被成功获取，所有进一步尝试获取更多锁将导致OverlapingFileLockException。然而，它适用于不同的进程。
我想实现由文件系统支持的数据存储，该文件系统旨在处理多个并发请求(包括读和写)。我想使用文件锁定来锁定存储中的特定文件。
似乎我必须在JVM级别引入另一个同步(独占)，然后才能在文件上同步以避免此异常。
有人做过这样的事吗？
我准备了简单的测试用例来显示我的问题所在。我用的是Mac，Java6
浏览 8提问于2011-04-19得票数 5
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
即时通信 IM
实时音视频活动推荐
腾讯云开发者
