1回答
这是一个死锁吗?请看代码
、、、
这是一个死锁吗？它似乎锁定了java.io.PrintStream很多。它的发生是非常随机的，如果你愿意看看的话。id为0x67804350的printstream对象被同一线程同时锁定。
"service-j2ee-247" prio=5 tid=0x00ea34b0 nid=0x13b runnable [1bb2d000..1bb2f678]
at java.nio.CharBuffer.wrap(CharBuffer.java:347)
at sun.nio.cs.StreamEncoder$CharsetSE.implWrite(StreamEncod
浏览 0提问于2011-10-24得票数 1
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提问于2011-09-16得票数 5
2回答
我尝试了一些代码来证明同步块锁定机制的可靠性。考虑我的示例代码
我的时钟对象。
public class MyLock {
final static Object lock=new Object();
}
使用同步块初始化
public class Sample {
public void a(String input) {
System.out.println(input+" method a");
synchronized (lock) {
System.out.println("inside synchronized block
浏览 0提问于2013-11-26得票数 0
2回答
锁定类的静态成员
、、、、
根据我的理解，下面这段代码应该会导致死锁。原因是，当线程t1锁定静态对象firstData时，他已经获得了类上的锁。因此，当他试图锁定另一个静态对象secondData时，请求应该会阻塞。
但是，该程序运行良好，并打印*** Successfully acquired both the locks
这里缺少的关于锁定静态对象的内容是什么？
public class Deadlock {
public static void main(String[] args) {
Thread t1 = new Thread(new DeadlockRunnable());
浏览 0提问于2012-04-20得票数 6
回答已采纳
可重入性意味着锁是在每个线程而不是每个调用的基础上获得的。
由于内部锁是由线程持有的，这是否意味着线程运行一次就等于调用基础？
谢谢，这似乎意味着:在一个线程中，如果我在处理调用函数doB的函数doA时得到了一个锁lockA，而doB也需要一个锁lockA，那么就会有一个可重入性。在Java中，这种现象是按线程获取的，所以我不需要考虑死锁？
浏览 2提问于2013-05-12得票数 45
回答已采纳
3回答
如果我在两个方法中使用synchronize(this)，其中一个调用另一个方法，我是否会陷入死锁的情况，或者它会因为线程已经拥有锁而工作吗？
想象一下下面的类：
public class Test {
public void foo() {
synchronize(this) {
bar();
}
}
public void bar() {
synchronize(this) {
// do something
}
}
}
如您所见，有两个方法foo和bar，它们都依赖于同步。
当调用foo()时，将在(This)上获
浏览 1提问于2012-06-26得票数 4
回答已采纳
尝试创建一个可以使用threading.lock锁定对象的类：
class ObjectLock(object):
def __init__(self):
self._lock = threading.Lock()
self._value = False
def __str__(self):
self.acquire()
try:
if(self._value):
return self._value
else:
浏览 9提问于2013-03-04得票数 2
回答已采纳
1回答
在两个对象上持有锁
、、、
我有一个关于锁和同步的问题。
我有一个锁定对象1的方法，还有一个锁定对象2的方法：
private void a(){
synchronized(obj1){
System.out.println("Object 1 being used");
}
System.out.println("Object 1 finished");
}
private void b(){
synchronized(obj2){
System.out.println("Object 2 being u
浏览 0提问于2016-10-01得票数 2
我对Java和OOP很陌生。我正在阅读java中的并发性，在第2章中，它谈到了可重入性。我不太明白僵局是怎么发生的。有人能打破这种情况，让我一条条地了解细节吗？
提前谢谢你。
如果内部锁不是可重入的，那么对super.doSomething的调用将永远无法获得锁，因为它将被视为已持有，并且线程将永久停止等待它永远无法获得的锁。
public class Widget {
public synchronized void doSomething() {
...
}
}
public class LoggingWidget extends Widget {
浏览 1提问于2014-02-03得票数 1
回答已采纳
3回答
我一直在尝试理解可重入锁和信号量(可重入锁的嵌套与释放/解锁机制)。
似乎拥有一个信号量需要您编写一个经过更彻底测试的应用程序，因为release()方法不会检查释放许可证的线程是否真的持有它。当我测试我的测试代码时，我发现这可能会随后增加超过初始限制的许可数量。另一方面，如果一个线程在调用解锁方法时没有持有可重入锁，我们就会得到一个IllegalMonitorException。
因此，可以说没有真正的理由使用二进制信号量，因为二进制信号量可以做的所有事情都可以由ReentrantLock完成。如果我们使用二进制信号量，我们将不得不检查整个方法调用堆栈，看看之前是否获得了许可(如果有后续获取
浏览 3提问于2013-07-17得票数 35
回答已采纳
假设我有这样的代码：
public void bar(){
synchronized(foo){foo.remove(0)}
}
public void doStuff(){
synchronized(foo){
bar()
}
}
synchronized是否会意识到我所在的当前链有这个锁并继承它，或者它会死锁？
浏览 0提问于2012-04-22得票数 0
回答已采纳
1回答
同步方法中的可重入性
、、、
是同步方法，可重入的
我有这样的代码：
public class Main {
synchronized void m1() {
//some code
m2();
//some code
}
synchronized void m2(){
//some code
}
}
假设两个线程(线程A和线程B)同时尝试访问m1()。线程首先使用锁。过了一段时间，线程A调用m2()，这也是在同一个对象上同步的。
由于我不想做任何猜测，有人能告诉我:当线程A调用m2()时，
浏览 3提问于2020-10-10得票数 1
回答已采纳
从
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情况下会出现死锁吗
1-
synchronized(obj) {
obj.syncMethod(); // the method signature: public synchronized void syncMethod() {...}
}
2-
synchronized(obj) {
if (condition)
throw new Exception(); // deadlock because obj lock is not released?
// do other stuff
}
谢谢。
浏览 0提问于2012-04-12得票数 1
回答已采纳
3回答
我今天参加了一个面试，面试官问了我以下问题：
可重入性和互斥是线程安全的吗？你能解释一下为什么吗？
我对并发编程比较陌生，不能回答这个问题。但是我说..。
互斥是线程安全的。但可重入性不是，这就是为什么我们有可重入锁的原因。
面试官转移到下一个问题，尽管是不同的领域。我想我搞砸了这个..。
当他问我这个问题的时候，他想让我说什么？
浏览 2提问于2010-09-20得票数 6
回答已采纳
4回答
在编写可重入代码时，我正在查看有关推荐实践的。
有关此主题的其他参考资料和资源有哪些？
哪些类似lint的工具可以用来检查这些问题？
浏览 0提问于2010-07-14得票数 7
回答已采纳
4回答
我总是很困惑。有人能解释一下在不同背景下的含义吗？你为什么要使用“重入者”与“不可重入者”？
比如说，p线程(posix)锁定原语，它们是否是可重入的？使用它们时应该避免哪些陷阱？
互斥是可重入的吗？
浏览 3提问于2009-08-21得票数 129
回答已采纳
2回答
下面的代码是可重入的吗？
如果this.NextToExecuteIndex被声明为private int NextToExecuteIndex = 0;而不是在其他任何地方计算，那么它是线程安全的吗？
protected override void Poll(object sender, System.Timers.ElapsedEventArgs e)
{
int index;
object locker = new object();
lock (locker)
{
Interlo
浏览 0提问于2011-10-06得票数 1
回答已采纳
最近，我一直在学习java中的多线程概念。我有一些疑问，没有通过查找StackOverflow上的相关线程来解决。以下问题我找不到满意的答案：
方法使线程等待直到获得锁。然而，等待(长超时)方法使线程等待‘超时值’否。如果它仍然没有得到锁，则返回可运行状态。但是要真正进入运行状态，它需要锁。那么等待(长超时)方法有什么意义呢？然而，当线程处于等待状态时，线程会释放它获得的锁。因此，区别甚至不是它所获得的资源。如果线程保持在等待状态或可运行状态，会有什么不同？与等待()方法相比，等待(长超时)方法的优点是什么？
同步关键字或块提供对调用方法或块的对象的锁定。它导致另一个线程试图获取同一个
浏览 0提问于2019-08-10得票数 3
回答已采纳
谁能给我解释一下，为什么当一个线程两次尝试获取同一个自旋锁时会出现死锁？(假设自旋锁是非递归的)
常规自旋锁使用：
lock = false;
while(acquiring_lock(lock)) {} //sit in the loop and wait for lock to become available
....critical section....
release_lock(lock);
但是，我不明白为什么第二次调用acquiring_lock(lock)会导致死锁？
浏览 0提问于2013-04-08得票数 1
回答已采纳
3回答
这种情况下会出现死锁吗？
、、、
我说得对吗?在以下情况下，僵局应该发生：
对象P调用对象A的同步方法，
调用对象B的同步方法，
它调用对象A的同步方法。
抱歉，如果我看起来很蠢，很可能是。但这就是为什么我要问。谢谢!
浏览 7提问于2010-09-09得票数 2
回答已采纳
5回答
我想知道在Java中，如果我在同一个对象上同步两次，会不会有什么奇怪的行为？
场景如下
pulbic class SillyClassName {
object moo;
...
public void method1(){
synchronized(moo)
{
....
method2();
....
}
}
public void method2(){
synchronized(moo)
{
浏览 3提问于2008-10-30得票数 57
回答已采纳
3回答
我有这个C#代码：
public class Locking
{
private int Value1; private int Value2;
private object lockValue = new Object();
public int GetInt1(int value1, int value2)
{
lock (lockValue)
{
Value1 = value1;
Value2 = value2;
return GetResult()
浏览 0提问于2013-06-18得票数 3
回答已采纳
2回答
与自己的竞争条件
、、、
我有一个包含成员函数的类，在执行它们的操作之前，需要在相应的互斥锁上获取一个boost::unique_lock。但是，当存在现有的boost::unique_lock时调用成员函数时，它会死锁自己。
#include <iostream>
#include "boost/thread.hpp"
#include "boost/foreach.hpp"
#include <list>
class example {
private:
std::list< int > int_array;
std::li
浏览 0提问于2011-04-25得票数 1
回答已采纳
当我运行这段代码时，没有任何块，它们都很好，很棒：
List<Category> cats = null;
cats = await cat.GetAllAsync();//no blocks here
cats = await cat.GetAllAsync();//no blocks here
cats = await cat.GetAllAsync();//no blocks here
cats = await cat.GetAllAsync();//no blocks here
cats = await cat.GetAllA
浏览 2提问于2017-05-01得票数 3
为什么下面的代码不会导致死锁？我的意思是在我调用getNumber(.)类测试的对象应该是锁定的，所以我应该不能访问getNumber2(.)。
class Test() {
synchronized int getNumber(int i){
return getNumber2(i);
}
synchronized int getNumber2(int i) {
return i;
}
public static void main(String[] args) {
System.out.printl
浏览 0提问于2013-03-04得票数 5
回答已采纳
2回答
使用NSLock在日志中看到此消息
*** -[NSLock lock]: deadlock (<NSLock: 0x6100000cbec0> '(null)')
*** Break on _NSLockError() to debug.
这是否意味着应用程序遇到了致命错误并将停止工作？还是以某种“优雅”的方式来处理？
浏览 1提问于2016-10-15得票数 2
回答已采纳
4回答
Java中的同步？
、、、
我是线程安全编程的新手，我想知道我是否有类似下面的东西，一旦编译和运行，它会安全地避免死锁吗？
public class Foo
{
protected CustomClass[] _mySynchedData = new CustomClass[10];
public void processData()
{
synchronized(_mySynchedData) {
// ...do stuff with synched variable here
}
}
}
public class
浏览 0提问于2009-11-02得票数 1
回答已采纳
我在一个java类中有两个方法，这两个方法都有一个使用相同对象进行同步的代码块。我知道在JAVA同步方案中，线程获取的锁是可重入的。有了这些，我可以放心地说，下面这段代码在所有情况下都不会导致任何问题？
public class Someclass
{
private static final Object LCK_OBJ = new Object();
//.....
publc void method1()
{
//some code....
synchronized(LCK_OBJ)
{
//som
浏览 0提问于2011-04-26得票数 6
回答已采纳
我开始学习锁，并立即提出了一个问题。
在这里说：
lock语句获取给定对象的互斥锁，执行语句块，然后释放锁。当锁被持有时，持有锁的线程可以再次获取和释放锁。任何其他线程都被阻止获取锁，并等待直到锁被释放，。
我做了一个简单的例子，证明了另一个没有lock关键字的方法可以很容易地改变实例的数据，而这个实例被使用第一个线程的锁的方法占用。从阻塞中删除注释是值得的，并且工作是按照预期完成的。我认为锁会阻止其他线程对实例的访问，即使它们在其方法中不对该实例使用锁。
问题
我是否正确地理解在一个线程上锁定一个实例允许在该实例上修改来自另一个线程的数据，除非另一个线程也使用该实例的锁？如果是这
浏览 2提问于2022-01-26得票数 0
回答已采纳
2回答
假设我在控制台应用程序中有一个托管的wcf服务，如下所示：
public class MyService : IContract
{
public static readonly object _locker_ = new object();
public static void DoSomething()
{
lock (_locker_)
{
//block 1
DoAnotherWork();
}
}
void IContract.Foo1()
{
lock (_locker_)
{
浏览 0提问于2012-01-25得票数 1
回答已采纳
在同一线程中的一个处理器上，首先调用raw_spin_lock()，然后它启动一个hrtimer并再次返回到raw_spin_lock()，在那里它将在那里旋转。在hrtimer中断处理函数中，将调用raw_spin_unlock()。
这会不会导致死锁？在raw_spin_lock()上旋转会禁用中断吗？
浏览 0提问于2012-10-09得票数 2
回答已采纳
我试图让p线程同时运行多个函数实例，以提高运行时的速度和效率。当队列中有更多的项目时，我的代码应该生成线程并保持其打开。那么这些线程就应该做些什么。代码应该要求“继续吗？”当队列中没有更多的项时，如果我键入"yes"，则应该将项添加到队列中，并且线程应该继续执行“某事”。这就是我目前所拥有的，
# include <iostream>
# include <string>
# include <pthread.h>
# include <queue>
using namespace std;
# define NUM_THREA
浏览 1提问于2014-08-28得票数 1
回答已采纳
2回答
说
如果使用信号模块实现异步信号处理程序，则可能无法在这些处理程序中使用日志记录。这是因为线程模块中的锁实现并不总是可重入的，因此不能从这样的信号处理程序中调用。
这意味着不应该直接或间接地从信号处理程序调用的代码中调用日志。如果你偶尔做一次，程序就会留下一种状态，而只有杀死-9才会有帮助。
下面是我的重要问题。当其他线程在主线程处理信号时调用日志方法时，是否也会出现此锁定问题？
浏览 7提问于2011-01-05得票数 11
回答已采纳
我正在创建我的互斥锁：
FMutex := TMutex.Create(nil, False, 'SomeDumbText');
并在一个方法中使用它，该方法使用相同创建的互斥锁调用另一个方法：
procedure a;
begin
FMutex.Acquire;
try
//do some work here and maybe call b
finally
FMutex.Release;
end;
end;
procedure b;
begin
FMutex.Acquire;
try
//do some work here
浏览 18提问于2018-12-14得票数 3
回答已采纳
InterProcessMutex和InterProcessSemaphoreMutex的区别是什么？说InterProcessSemaphoreMutex是同一个InterProcessMutex，只是它不是可重入的。但我不知道可重入是什么意思。
浏览 0提问于2017-10-09得票数 3
3回答
class Program
{
static object test = new object();
static void Main(string[] args)
{
new Program().test2();
Console.ReadKey();
}
public void test1()
{
lock (test)
{
Console.WriteLine("test1");
}
}
public vo
浏览 0提问于2012-06-30得票数 4
回答已采纳
2回答
我很想知道其他人是否见过这个问题。我有一个应用程序，它通过这种方式锁定一个静态声明的对象：
lock(Group.IsisGroups)
{
do some stuff
}
do-some stuff执行各种操作，我调用的其中一个例程尝试锁定相同的锁。线程死锁。
我猜这个问题可能与我使用反射有关:在调用堆栈的中途，我通过在类定义中查找方法并调用.Invoke()来调用该方法。调用堆栈的结果如下：
[In a sleep, wait, or join]
[External Code]
ConsoleApplication2.exe!Isis.Group.doLook
浏览 13提问于2011-01-24得票数 0
回答已采纳
部分地，这个问题与有一些相似之处，但由于另一个问题没有被正确地问(而且没有完全被问到)，所以我试图一般地问它，所以这个问题不能被认为是一个重复。
问题是如何理解 AsyncLock实际上是如何工作的。(在这种情况下，我指的是库，但是，我认为它在AsyncLock实现中使用了通用方法)。
所以。例如，我们有一个主线程(让它是一个UI线程)：
static void Main(string[] args)
{
Console.WriteLine("Press Esc for exit");
var lck = new AsyncLo
浏览 0提问于2019-09-06得票数 3
回答已采纳
可能重复：
我想知道在使用ReentrentLock和同步(对象)方面有很大的不同吗？
为什么它被称为reentrentLock？允许来自同一个线程的递归调用吗？
浏览 4提问于2012-01-08得票数 9
回答已采纳
2回答
第1部分：
假设下面的代码
void method1(){
synchronized (lockObject){
method2();
System.out.println("line4");
}
}
void method2(){
System.out.println("line1");
synchronized (lockObject){
System.out.println("line2");
}
System.out.println(
浏览 0提问于2015-03-19得票数 1
回答已采纳
1回答
我有两个独立的进程，一个客户端进程和一个服务器进程。它们使用共享内存进行链接。
客户端将通过首先将共享存储器的某一部分改变为输入值，然后翻转指示输入是有效的并且该值尚未被计算的位来开始其响应。
服务器等待终止信号或新数据进入。现在，相关的服务器代码如下所示：
while(!((*metadata)&SERVER_KILL)){
//while no kill signal
bool valid_client = ((*metadata)&CLIENT_REQUEST_VALID)==CLIENT_REQUEST_VALID;
b
浏览 21提问于2018-01-23得票数 0
1回答
我有一个反序列化Xml文档并从它创建对象的函数。
我希望将对象存储到缓存中，这样就不必在每次需要从xml中获取数据时都对xml进行反序列化。
public class XMLDeserializer
{
public event OnElementDeserialized OnElementDeserializedCallback;
public void DeserializeXml(string xmlPath)
{
// implementation
}
}
public class XMLDeserializerFacade
{
浏览 3提问于2012-11-08得票数 4
回答已采纳
2回答
Win32 Mutex不等待
、、、、
我正在创建一个实现进程间通信的应用程序。为此，我建立了一个共享缓冲区，它似乎运行良好。现在，我需要一种方法，让数据生成应用程序(用c++编写)告诉数据接收应用程序(用freepascal/lazarus编写)何时读取数据。
我正试着用互斥物来达到这个目的。我对windows编程没有多少经验。
所以，我的问题是，在下面的FreePascal代码中，互斥不能等待。我可以调用TMutex.Wait()函数，它不会返回错误或任何东西，但它不会等待。
构造函数TMutex.Create(sName: AnsiString)；
开始
:=‘’+sName；
(2) := CreateMutexA(
//默
浏览 7提问于2009-10-16得票数 0
读取C#中的锁。我认为能够多次获取同一对象上的锁是可能的，因为监视器是可重入的。维基百科中定义的可重入代码似乎不太适合这种情况。您能帮助我理解什么是C#上下文中的可重入性，以及它如何应用于监视器吗？据我所知，当一个线程获得一个锁时，它不会在临界区中途放弃锁--即使它产生了CPU..as，结果是，没有其他线程能够获得monitor..where。
浏览 2提问于2016-01-06得票数 4
2回答
单个进程-中的死锁？
、、、、
当单个进程/线程被阻塞，试图获取相同的互斥量时，这种情况是否可以称为“死锁”？
Mutex_lock(互斥)-成功
..。
mutex_lock(& mutex ) -已阻止，mutex未释放
看起来“不可切分的资源”的条件不适用:这里只有一个进程/线程，所以没有不可切分的资源持有和等待的情况:这里只有一个进程，所以不会等待另一个进程释放所请求的资源
浏览 0提问于2012-05-13得票数 3
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
腾讯会议
实时音视频活动推荐
腾讯云开发者
