从
void processCachedData() {
rwl.readLock().lock();
if (!cacheValid) {
// Must release read lock before acquiring write lock
5: rwl.readLock().unlock();
6: rwl.writeLock().lock();
// Recheck state because another thread might have acquired
// write lock and changed state bef
浏览 2提问于2013-06-04得票数 6
回答已采纳
3回答
我在实践中读到了Java并发。
所以写着
When thread A executes a synchronized block, and subsequently thread B enters a synchronized block guarded by the same lock
两个线程如何一次锁定同一个对象？谢谢。
浏览 1提问于2014-03-16得票数 0
回答已采纳
1回答
我正在尝试构建一个层次锁定系统，以避免死锁。这意味着将代码分成层(或层)和每一层，以便只允许下一层中的锁。在同一级别内，您应该使用预定义的顺序进行锁定。这可以防止大多数死锁。类似这样的
对于互斥来说，这就像是一个护身符，但是对于读写锁，它就失败了。例如，如果我获取一个读锁，然后想要将其转换为写锁，这意味着我正在获取同一级别的一个新锁，这是这个算法所禁止的。
如何更改算法以适用于RW和互斥锁？有没有其他我应该考虑的算法？
PS:我正在编写C++程序，但这个问题实际上也是一个理论问题
浏览 1提问于2016-10-06得票数 0
3回答
我只是有一个关于并发运行的线程和它们在对象上的锁的问题。据我所知，调用wait()方法的线程将进入等待列表，并允许阻塞列表中的另一个线程接管对象上的锁(在同步的代码中)。如果现在拥有对象锁的这个线程调用了notify()方法，它就会唤醒调用wait()的线程，并将其移到阻塞列表中。
调用notify()方法的线程会发生什么。它是否仍然拥有对象上的锁，或者它现在是否在等待列表中？
问候
浏览 4提问于2012-01-25得票数 5
回答已采纳
1回答
我对二叉树中的Peterson算法有一些疑问。
我正在做“多处理器编程的艺术”一书的一些练习，我被困在第2章，例如第13章：
“推广双线程Peterson锁的另一种方法是在二叉树中排列若干个2线程Peterson锁。假设n是2的幂。每个线程被分配一个与另一个线程共享的叶锁。每个锁将一个线程视为线程0，另一个线程作为线程1。”
没关系，但是什么？如果彼得森只处理两个线程，这棵树会是怎样的呢？一棵只有一片叶子的树？(因为如果我有两个线程，每片叶子处理两个线程.结果是一棵单叶的树？)
“在树锁的获取方法中，线程从该线程的叶子到根获取每两个线程Peterson锁。树锁的释放方法用于树锁的解锁，从根到其
浏览 3提问于2013-08-30得票数 4
回答已采纳
1回答
我正在阅读Python线程锁定API。
。
我想知道下面的陈述是什么意思。
“当状态被锁定时，and ()会阻塞，直到在另一个线程中释放()的调用将其更改为解锁，然后获取()调用将其重置为blocks并返回。”
我已经读了100遍这份声明。还是拿不到。
为什么要解锁另一个线程？“那么”之后的陈述是什么意思？
对此有什么好的解释吗？
浏览 3提问于2017-12-18得票数 2
回答已采纳
我从oracle.com得到了一段代码，它解释了一般的并发性，特别是死锁。守则来自：
我试图通过调试和手动运行代码来了解发生了什么以及是什么导致了这里的死锁，但是没有结果。
如果有人能打断这段代码的流，并解释为什么代码被阻塞，以及代码在哪里被阻塞，我会非常感激(我是在我的机器上运行的)。
非常感谢
public class Deadlock {
static class Friend {
private final String name;
public Friend(String name) {
this.name = name;
浏览 0提问于2019-08-18得票数 1
回答已采纳
我必须解决这个问题：
两个进程，A和B，每个进程都需要数据库中的三个记录，1、2和3。如果A按顺序1、2、3和B以相同顺序请求它们，则不可能出现死锁。但是，如果B按顺序3、2、1请求它们，那么死锁是可能的。有三种资源，就有三种！或者六个可能的组合，每个进程都可以在其中请求它们。所有组合中的哪一部分保证是无死锁的？
我在一本书里看到了解决这个问题的方法：
123无死锁
132无死锁
213可能的死锁
231可能的死锁
312种可能的死锁
321可能的死锁
因为六个中的四个可能导致死锁，因此有1/3的机会可以避免死锁，2/3的机会可以避免死锁。
但我不知道这个解决方案背后的逻辑是什么。
有谁
浏览 1提问于2021-12-31得票数 0
回答已采纳
我用pthread编写了一个多线程程序，使用生产者-消费者模型。
当我使用英特尔VTune profiler分析我的程序时，我发现生产者和消费者在pthread_mutex_unlock上花费了大量时间。我不明白为什么会发生这种事。我认为线程可能会等待很长时间才能获得互斥锁，但释放互斥锁应该很快，对吧？
下面的快照来自英特尔VTune。它显示了消费者尝试从缓冲区获取项目的代码，以及每个代码行所消耗的时间。
我的问题是，为什么pthread_mutex_unlock有这么大的开销？问题出在pthread互斥锁本身还是我使用它的方式上？
浏览 4提问于2013-06-03得票数 15
回答已采纳
假设我们有
class A {
void m1() {
synchronized (this) {
}
blah blah blah
synchronized (this) {
}
}
}
我怀疑在执行blah时，当前正在执行的带有对象o释放锁的线程，此时如果其他对象o的线程获得了锁，就会出现死锁。那么，我们怎么能说我们应该尝试使用同步块而不是同步方法呢？
假设执行静态同步方法的线程t1获得了类级锁，其他线程可以获取该类实例的锁来执行其他同步方法吗？
浏览 2提问于2013-10-07得票数 0
回答已采纳
2回答
我在浏览可重入锁的Java时发现了以下文本：
锁的公平性不能保证线程调度的公平性。因此，使用公平锁的多个线程中的一个可以连续多次获得该锁，而其他活动线程则没有进展，目前也没有保存该锁。
根据我的理解，如果OS调度程序调度相同的线程(之前获取锁)，并且再次尝试获取相同的锁，Java将允许它获取并且不服从公平参数值。有人能告诉我公平参数的目的是什么吗?在什么情况下应该使用它。
我只是在想，如果它只是一个优先级值，这可能会影响调度程序，但不能保证线程执行顺序。
浏览 0提问于2021-12-03得票数 0
回答已采纳
2回答
我想我见过“拥有一台显示器”和“拥有一把锁”这两个短语。我想验证一下，只有监视器才能被“拥有”。锁是“获得的”，而不是拥有的。如果这是错误的，我希望在Java多线程的上下文中正确使用"own“和"acquire”。
浏览 1提问于2016-03-11得票数 0
我最近遇到了一个面试问题(发表在一个论坛上).看起来这是一个真正的面试问题)：
设计一个类，它只在没有可能死锁的情况下提供锁。
没有提供任何其他信息。我不太清楚如何解释这一点。假设class模型，面试官是否在寻找锁管理器类？任何想法都会有帮助。
浏览 0提问于2011-03-02得票数 9
回答已采纳
1回答
这个设计的项目最终会陷入僵局，不是吗？
两个方法在共享对象中同步。这两个线程最终会发现自己在其中一个方法中，并试图调用另一个方法。我认为。
package main;
import java.util.ArrayList;
import java.util.List;
import myThread.MyThread;
import sharedObject.SharedObject;
import uncooperativeThread.UncooperativeThread;
public class Main {
public static void main(Strin
浏览 2提问于2021-06-02得票数 0
回答已采纳
1回答
public class driver{
public static void main(String[] args) {
PrintNum firstObjectForThread = new PrintNum(0); // the argument is not used, ignore it
firstObjectForThread.startNewThread();
PrintNum secondObjectForThread = new PrintNum(0);
secondObjectForThread.startNewThread();
浏览 5提问于2021-12-08得票数 1
回答已采纳
下面有一个简单的代码来测试死锁
public class ClassB {
public synchronized void fooB(Classs A) throws InterruptedException{
System.out.print("Thread : " + Thread.currentThread().getName()+ " entered to fooB \n");
Thread.sleep(1000);
System.out.print("ClassB locked the
浏览 1提问于2015-05-28得票数 5
回答已采纳
2回答
这段代码中会出现死锁吗？
我多次运行它，但没有一个，但是任务要求解释是否可能出现死锁情况。
public class DeadlockTest {
public static void main(String[] args) {
ReentrantLock[] locks = new ReentrantLock[3];
for (int i = 0; i < 3; i++) {
locks[i] = new ReentrantLock();
}
WorkerThread[] threads = new WorkerThread[3]
浏览 4提问于2016-09-12得票数 1
回答已采纳
两个线程允许假设t1和t2都试图同时在copyOnWriteArrayList中执行更新操作，......then将首先在原始列表中复制哪些线程更改？
浏览 1提问于2019-01-24得票数 0
回答已采纳
这是ReentrantLock#tryLock的源代码：
public boolean tryLock() {
return sync.nonfairTryAcquire(1);
}
我的问题是：
ReentrantLock中有两种类型的同步器: FairSync和NonFairSync。为什么只使用NonFairSync？
浏览 1提问于2017-10-08得票数 0
当应用一个锁时，它被锁定了，如果另一个线程在它已经在执行另一个块的时候访问这个reentrantReadWriteLock，会发生什么？(因此，在它到达.unlock之前)
方法被取消了吗？或者它可能停滞不前？:O
浏览 2提问于2011-08-20得票数 0
阅读有关java.util.concurrent.locks.Condition接口的Java8文档，将给出以下示例：
class BoundedBuffer {
final Lock lock = new ReentrantLock();
final Condition notFull = lock.newCondition();
final Condition notEmpty = lock.newCondition();
final Object[] items = new Object[100];
int putptr, takeptr, coun
浏览 0提问于2016-04-05得票数 12
回答已采纳
我试图编写一个代码来显示ReentrantLock的不公平(当ctor被传递给fair=false时)。令我惊讶的是，ReentrantLock是完全公平的。
我的测试有以下逻辑:生成20个线程，其"id“从0到19。所有线程共享一个ReentrantLock。然后，按时间顺序排列：
线程0锁定锁。
线程1到19块在lock()上，顺序是1，然后是2，然后是3，.，然后是19
线程0解锁锁。这是对公平性的第一次测试，如果锁是公平的，线程1应该在此后得到它。
当线程1有锁时，他也会释放它。第二个公平性测试:线程2现在应该得到它。
等
我原以为，有时候，一个线程
浏览 1提问于2017-02-24得票数 3
如果当前线程持有监视器，那么来自不同线程的同步块请求会发生什么？例如:下面是同步块：
ABC.java：
public class ABC {
...
public void setValue(){
Example object = Example.getinstance();
// Example is a singleton class which maintains the arraylist of objects of class ABC
synchronized (object) {
obje
浏览 2提问于2015-08-14得票数 2
回答已采纳
1回答
给定在包装器类中定义和初始化的以下对象：
// (thread-safe) List of Requests made by users
private static List<Request> requests = Collections.synchronizedList(new ArrayList<Request>());
在update循环中经常调用以下代码：
// <-- (Thread 1 executes the following code @ Runtime=1.0000000ms)
synchronized(requests) {
浏览 4提问于2015-06-07得票数 0
回答已采纳
2回答
任何实时场景的解释都将不胜感激。除了这些线程之外，还有其他方法来处理同步吗？互斥与递归互斥(任何实时场景)有何不同？
浏览 1提问于2013-08-03得票数 9
3回答
因此，如果当前线程再次获得锁，则重入锁将使计数增加1。我无法理解的是，这对我们有什么帮助或好处呢？
浏览 0提问于2018-08-30得票数 1
回答已采纳
3回答
为什么这段代码不会导致死锁？
private static readonly object a = new object();
..。
lock(a)
{
lock(a)
{
....
}
}
浏览 0提问于2011-02-18得票数 58
回答已采纳
1回答
线程读写锁是FIFO吗？
、、、
在图书馆pthread.h是pthread_rwlock_t FIFO吗？
在下面的示例中，我们有多个线程。假设每个线程都保证按顺序运行。
// Thread 1 - does a write lock
pthread_rwlock_wrlock(&lock);
// Thread 2 - does a read but has to wait for 1
pthread_rwlock_rdlock(&lock);
// Thread 3 - does a read but has to wait for 1
pthread_rwlock_rdlock(&lock)
浏览 2提问于2017-04-18得票数 2
回答已采纳
1回答
我有一个关于coherence锁定-解锁机制的测试样本，如下所示：
public class Test {
public static void main(String[] args) throws InterruptedException, IOException, IllegalArgumentException, IllegalAccessException {
Trt test=new Trt();
test.lock();
Thread a=new Thread(test);
a.start();
浏览 3提问于2012-06-13得票数 2
回答已采纳
4回答
我有一个与Java线程活动锁相关的有趣问题。这就对了。
有四个全局锁- L1、L2、L3、L4
有四个线程- T1、T2、T3、T4
T1需要锁定L1，L2，L3 T2需要锁定L2 T3需要锁定L3，L4 T4需要锁定L1，L2
因此，问题的模式是-任何线程都可以以任何顺序运行和获取锁。如果任何一个线程检测到它需要的锁不可用，它会释放它之前获得的所有其他锁，等待一段固定时间后再重试。该循环重复，从而导致活动锁定条件。
因此，为了解决这个问题，我有两个解决方案
1)让每个线程随机等待一段时间后再重试。
OR,
2)让每个线程以特定的顺序获取所有锁(即使线程不需要所有锁)
我不相信这是我唯一的两个
浏览 4提问于2013-04-22得票数 3
1回答
我听说，对对象使用synchronized关键字会创建一个等待池，该池存储与对象关联的等待线程。它在记忆中是如何表示的？
浏览 2提问于2016-02-24得票数 0
回答已采纳
至于公平的ReentrantReadWriteLock，如果线程t1持有读锁并忘记解锁，而线程t2试图获取写入锁，那么所有试图获取读或写锁的后续线程都将永远阻塞。
但是，jstack -l只能检测哪个线程持有写入锁，但不能检测哪个线程持有读锁。
有没有一种方法可以检测哪个线程持有读锁？
例如,
public static void main(String[] args) throws InterruptedException {
ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
Th
浏览 10提问于2022-07-13得票数 1
2回答
释放互斥锁。
、、
“Mutex类强制线程标识，因此互斥锁只能由获得它的线程释放。相比之下，Semaphore类不强制线程标识。”
这就是描述所说的..但是根据我的问题，我试图释放一个互斥锁，即使我没有得到它。它在执行下一个线程时向我显示了一个异常。这是否意味着不能访问互斥锁的线程释放了它？有没有人可以帮我理解这个概念，如果我做错了什么，请指点我。
浏览 0提问于2012-05-02得票数 1
1回答
我的代码中有一个自旋锁，它在两个线程之间共享。当一个线程持有锁，而另一个线程试图获得锁时，第二个线程将继续在处理器上旋转。那么，如果在线程为锁旋转的处理器上发生中断，会发生什么情况呢？
我使用spin_lock()来获取锁，而不是spin_lock_irqsave()，因为我不想在本地处理器上禁用中断。
当我在内核中检查spin_lock()函数的代码时，我发现在默认情况下，抢占是禁用的，而不是任何IRQ。因此，我假设中断将获得优先于旋转线程。那么，自旋锁是一个非睡眠锁意味着什么呢？
浏览 7提问于2017-03-27得票数 7
回答已采纳
我有个问题。我想在我的程序中使用互斥。发生的事情是这样的:我正在构造一个包含std::timed_mutex的对象。在创建时，这个对象锁定互斥量，因为它应该在以后被解锁。创建互斥锁的同一线程现在应该等待那个互斥锁，而另一个线程在后台工作。加入线程是没有选择的。
class A{
std::timed_mutex mutex;
A(){
mutex.lock();
}
bool waitForIt(int timeout){
if(mutex.try_lock_for(std::chrono::milliseconds(timeo
浏览 4提问于2014-02-28得票数 1
2回答
使用测试和设置实现锁
、、、
下面是在中给出的关于使用测试和set指令实现锁的代码。我的问题是，在这样的实现中，一个不持有锁的线程不能调用解锁函数并拿走锁吗？
typedef struct __lock_t {
int flag;
} lock_t;
void init(lock_t *lock) {
// 0 indicates that lock is available, 1 that it is held
lock->flag = 0;
}
void lock(lock_t *lock) {
while (TestAndSet(&lock->flag, 1) == 1)
;
浏览 5提问于2018-07-25得票数 0
在我的测试程序中，我启动了两个线程，每个线程只执行以下逻辑：
1) pthread_mutex_lock()
2) sleep(1)
3) pthread_mutex_unlock()
但是，我发现一段时间后，两个线程中的一个将在pthread_mutex_lock()上永久阻塞，而另一个线程正常工作。这是一种非常奇怪的行为，我认为这可能是一个潜在的严重问题。通过Linux手册，在获取pthread_mutex_t时并不禁止使用sleep()。所以我的问题是:这是一个真正的问题，还是我的代码中有任何bug？
以下是测试程序。在代码中，第一个线程的输出被定向到stdout
浏览 1提问于2011-11-11得票数 4
2回答
Anderson等人(1990)描述了一种教学上简单的自旋锁，它使用长度N的数组来实现用于互斥的FIFO机制。在Herlihy等人的“多处理器编程艺术”第7.5.1节中。(第二版，2020年)，该锁的实现方式如下(逐字摘自该书)：
public class ALock {
ThreadLocal<Integer> mySlotIndex = new ThreadLocal<>() {
@Override protected Integer initialValue() { return 0; }
};
AtomicInteger
浏览 15提问于2022-10-15得票数 0
回答已采纳
2回答
线程、锁和条件的状态
、、、、
在Java中，如果一个线程t2试图从同步(目前由另一个线程t1使用)获得锁，那么t2将从runnable切换到阻塞。对，是这样?那ReentrantLock呢？
如果线程t1使用锁完成，那么t2会自动切换回runnable，还是需要使用notifyAll()？在没有条件的情况下使用ReentrantLock会怎么样？如果没有使用条件，如何通知线程t2它应该切换回可运行状态？在没有条件的情况下使用重入锁是明智的，甚至是可能的吗？
如果这个问题已经回答了(我找不到)，如果你能把它和我联系起来，我将不胜感激。
浏览 1提问于2017-01-03得票数 2
回答已采纳
4回答
我对have中的多线程很陌生。我编写了一些类来测试同步函数，我有一些使用同步的方法：
public class ShareUtil {
private static Queue<Integer> queue = new LinkedList<Integer>();
public static synchronized void do1(){
System.out.println("do1");
sleep();
}
public sta
浏览 0提问于2014-11-14得票数 0
回答已采纳
4回答
我写了一个程序，据我理解，它不应该打印。
'Didn't hang, it should've.作为shouldHang方法是静态同步的，我已经采取了类级锁。
我无法理解这种行为。有人能帮我吗，
public class Test1 {
synchronized static public void shouldHang() {
System.out.println("Didn't hang, it should've.");
}
static public voi
浏览 2提问于2017-05-25得票数 0
回答已采纳
考虑一下这个JDK标准接口：
public interface ReadWriteLock{
public Lock readLock();
public Lock writeLock();
}
B. Goetz在Java中的并发性实际上提到了从readLock升级到writeLock是很容易死锁的。
如果两个读取器同时尝试升级到写锁，则两者都不会实现读锁。
让我感到困惑的是，是两个阅读器试图升级。但即使是一个读者也足够了，不是吗？如果读取器试图升级，它还没有释放读锁。试图用所持有的读锁获取写锁是死锁。
因此，从这一点来看，我认为提供升级操作在理论上甚至是荒谬的。或者一
浏览 5提问于2016-05-07得票数 3
回答已采纳
ReentrantLock允许线程多次进入对资源锁定，
这在执行/效率/功能方面有什么好处？
请参阅此链接，
我不明白使用内锁的意义，因为一旦外锁被任何线程获取，就不会有其他线程进入外锁之后的部分(直到时间锁被这个线程持有为止)，而且可以肯定的是，外锁之后/之后的部分一次只会被一个线程执行，那么内锁的意义是什么，这意味着多次进入锁的意义是什么？
代码：
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.ExecutorService;
import java.util
浏览 2提问于2019-01-08得票数 1
2回答
带回调的Java同步
、、、
我正在开发我的系统内的一个模块，其中基于一些事件的用户必须收到短信。
我有以下情况
synchronized(notificationPhoneNumber)
{
SmsProvider.sendSms(notificationPhoneNumber, smsText);
}
方法sendSms的代码正在异步运行：
public static void send(final NotificationPhoneNumber npn, final String smsText)
{
Thread smsSender = new Thread(new Runnable()
{
浏览 2提问于2013-09-04得票数 1
2回答
当我试图实现python代码来模拟死锁时，我遇到了一些有趣的问题：
1)我使用了以下代码来模拟死锁。
1 from threading import *
2 import time
3
4
5 def thread_one(lock1, lock2):
6 print("thread 1 is trying to acquire lock 1")
7 lock1.acquire()
8 print("lock1 acquired by thread 1")
9 time.sleep(1)
10
浏览 0提问于2020-04-19得票数 2
回答已采纳
2回答
正在写入互斥锁的共享资源
、、、、
我有一个由多个线程处理的C++列表。
每个线程在列表上创建一个pthread_mutex_lock，这样其他线程就不能“干扰”该列表。作为处理的一部分，每个线程还push_back列表上的数据。
我的问题是--在互斥列表中使用push_back是个坏主意吗？当线程在列表中使用更多数据时，互斥锁是否仍然有效？我在pthread_mutex_lock上看到的大多数文档/示例都只是“读”，所以我很想知道获得锁的同一个线程在共享资源上写会发生什么。
浏览 0提问于2012-01-24得票数 0
回答已采纳
我编写这个程序是为了检查在两个不同对象上持有锁的线程t1 : Lock.class和MyThread.class是否在MyThread.class实例上使用MyThread.class.wait()进入等待模式.It没有释放Lock.class实例上的锁。为什么会这样呢？我一直在想，一旦线程进入等待模式，或者它死了，它就会释放所有获得的锁。
public class Lock {
protected static volatile boolean STOP = true;
public static void main(String[] args) throws InterruptedExc
浏览 0提问于2012-07-16得票数 6
回答已采纳
我正在阅读“理解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
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
即时通信 IM
腾讯会议活动推荐
腾讯云开发者
