我正在尝试理解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
3回答
未并发运行的线程
、、
我希望这不是一个重复的问题，但我已经看过其他问题的所有答案，没有一个能满足我的问题。
我有一个程序已经解决了就餐哲学家的问题，当我运行这个程序时，线程会等到下一个线程完成后再运行另一个线程。这会导致线程的输出如下所示：
Philosopher 1 is EATING.
Philosopher 1 is THINKING.
Philosopher 5 is EATING.
Philosopher 5 is THINKING.
Philosopher 3 is EATING.
Philosopher 3 is THINKING.
..。诸若此类。预期输出没有顺序。线程应该并发运行。下面是我的代码，
浏览 1提问于2015-04-23得票数 0
我想让它先于子线程执行父进程。我不确定我在哪里弄错了我的程序输出的顺序。
int status = 0;
void *print_child(void *arg)
{
while (status == 0)
{
printf("Signal hasn't changed..\n");
sleep(1);
}
printf("The child has started...\n");
printf("The child is done! \n ");
}
int
浏览 20提问于2017-02-15得票数 0
1回答
Java同步似乎被忽略了
、、、
我得到了下面的代码，我预计在打印出"Main: pre-sync“后会死锁。但是看起来synchronized并没有做我期望的事情。这里发生了什么？
import java.util.*;
public class deadtest {
public static class waiter implements Runnable {
Object obj;
public waiter(Object obj) {
this.obj = obj;
}
public void run() {
Sy
浏览 0提问于2010-03-23得票数 4
回答已采纳
来自：
io_service( std::size_t concurrency_hint)；
构造，并提示所需的并发级别。
参数
concurrency_hint对实现的建议，即它应该允许多少线程同时运行。
什么是“对实施的建议”？
如果我用'2‘构造对象，它是否只能启动一个线程？
如果我有一个有4个核心的CPU，并且用'4‘或'5’构造对象，那么会发生什么呢？
浏览 5提问于2016-11-27得票数 3
回答已采纳
1回答
我有一个Spring引导应用程序，其中有用于缓存的Hazelcast。当使用Hazelcast群集多个实例时，我在解锁操作上有此异常：
java.lang.IllegalMonitorStateException: Current thread is not owner of the lock! -> Owner: 33ce48f8-dda3-471f-abae-994d25dcc030, thread ID: 55
at com.hazelcast.concurrent.lock.operations.UnlockOperation.unlock(UnlockOperation
浏览 0提问于2019-07-03得票数 2
回答已采纳
3回答
我试图编写一个线程安全结构，以保持键值对，并在一定时间延迟后自动删除它们。问题是，容器应该通知其他线程删除。
我还尝试在同步块中使用notifyAll()，但问题仍然存在。
import java.util.Objects;
import java.util.concurrent.*;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.strea
浏览 2提问于2019-07-22得票数 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
package threads;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class text implements Runnable {
static Lock lock = new ReentrantLock();
public static void main(String[] args) throws InterruptedException {
testts();
new Th
浏览 3提问于2015-04-03得票数 0
每当出现到IBM的网络/连接问题时，我们都会看到基于Apache camel的应用程序中挂起频繁的JVM。
记录器明确表示发生了连接问题，Spring正在尝试重置底层MQ连接。看起来，在重新设置连接时，Spring和IBM之间存在一个次要的问题。
Jul 13, 2018 8:51:48 PM org.springframework.jms.connection.CachingConnectionFactory onException
WARNING: Encountered a JMSException - resetting the underlying JMS Connection
co
浏览 5提问于2018-07-18得票数 1
回答已采纳
关于下面的代码，我的理解是线程1获取一个锁，检查条件，解锁时钟，将自己设置为睡眠状态。然后，线程2声明相同的锁和递增计数，然后唤醒休眠线程。我的问题是，现在的条件仍然是假的，但它唤醒了休眠线程，会发生什么？而且条件变量是一组线程，所以如果有许多线程同时执行代码，那么wait()如何处理这种情况呢？最后请解释一下这段代码的正确执行顺序，非常感谢！
thread 1:
pthread_mutex_lock(&mutex);
while (!condition)
pthread_cond_wait(&cond, &mutex);
/*
浏览 3提问于2015-09-28得票数 1
2回答
易挥发的与不易挥发的
、、、
让我们考虑一下Java中的以下代码
int x = 0;
int who = 1
Thread #1:
(1) x++;
(2) who = 2;
Thread #2
while(who == 1);
x++;
print x; ( the value should be equal to 2 but, perhaps, it is not* )
(我不知道Java内存模型--假设它是强内存模型，我的意思是：(1)和(2)将不交换)
Java内存模型保证了对32位变量的访问/存储是原子的，因此我们的程序是安全的。但是，我们应该使用属性volatil
浏览 6提问于2017-05-06得票数 1
回答已采纳
1回答
一个接一个地运行工作线程
、、、
我有两个工作线程要依次运行，分别是thread1和thread2。为了控制它们，我使用了两个CEvent(MFC api)同步对象。我目前的实现(如下)并不完美，为什么有时它会进入死锁conditions.Please建议我如何改进我的代码。
//My Code
vector<MyClass> globalVector; // global variable being accessed across two thread
CEvent event1 = CreateEvent(NULL,TRUE,TRUE,"Event1");
CEvent event2
浏览 0提问于2016-01-14得票数 0
我正在寻找类似于Java中的CopyOnWriteSet的东西，一个支持add、remove和来自多线程的某种类型的iterators的集合。
浏览 1提问于2009-09-10得票数 2
回答已采纳
我正在学习java.util.concurrent库，并在源代码中找到了许多无限循环，就像这个
//java.util.concurrent.atomic.AtomicInteger by Doug Lea
public final int getAndSet(int newValue) {
for (;;) {
int current = get();
if (compareAndSet(current, newValue))
return current;
}
}
我想知道，在什么情况下，实际值不能等于预期值(在本例中
浏览 6提问于2011-02-06得票数 4
回答已采纳
我有一段代码(简化)：
if(reentrantLockObject.isLocked()) {
reentrantLockObject.unlock();
}
其中reentrantLockObject是java.util.concurrent.locks.ReentrantLock。有时我会得到IllegalMonitorStateException。它认为锁定是在check和unlock()调用之间释放的。如何防止此异常？
浏览 0提问于2010-05-11得票数 12
回答已采纳
3回答
首先，我想描述一下我想要实现的锁定解决方案的机制。基本上，一个项目可以在读或写模式下打开。但是，如果用户在写入模式下打开该项目，则其他任何用户都不能在编辑模式下打开它。该项目指的是客户服务应用程序中的案例。
为了做到这一点，我想出了以下几点:表格将包含一个标志和一个“结束时间”，当这个标志有效时，该标志将指示一个项目是否被签出以进行编辑。它的默认值是3分钟，如果在这段时间内没有用户交互，则下次用户尝试打开同一项目时可以忽略该标志。
在UI端，我使用jQuery监视用户是否处于活动状态。如果他或她是，定期的AJAX调用将延长他或她的时间范围，以便他或她可以继续处理该项目。当用户保存项目时，该标志
浏览 3提问于2012-03-20得票数 1
回答已采纳
我有个问题。我想在我的程序中使用互斥。发生的事情是这样的:我正在构造一个包含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
1回答
这是SAP PI的要求
资料来源: XY_Client
中间件: PI系统
目标系统: SAP
将XML文件接收到PI系统，为每个XML文件生成一个内部文件，以跟踪store_number和计数xml文件。
如何工作:假设如果XML_FILE_1到达PI，则创建名为sequence_gen的内部文件。该文件包含XML文件中的存储号，计数将初始化为1。因此，
sequence_gen file contains Store: 1001 Count:1
(经过一段时间间隔)如果XML_FILE_2达到PI，第二次，
sequence_gen file contains Stor
浏览 3提问于2015-06-25得票数 0
我正在使用Cornerstone作为SVN客户端，并尝试使用锁定功能。
这个想法是让团队成员知道他们不能编辑特定的文件。
我在产品网站上读到了有关锁的内容，然而，当设置了svn:needs lock时，无论锁状态如何，都会设置只读属性。
当属性设置为yes并且设置了lock时，我期望文件变为只读。
请确认svn:needs lock正在替换lock，为了锁定具有只读属性的文件，我只需设置svn:needs lock即可。
浏览 2提问于2014-04-10得票数 1
3回答
什么时候不用挥发？
、、、、
在线程之间共享对象的类成员中，是否有不使用易失性的场景？我的理解是易失性关键字确保对象值不被线程缓存，而是总是从内存中读取，但不标记它易失性并不意味着它总是被线程缓存。所以我的问题是，我们能不能保证不标记这样一个类是易失性的，或者代码会对随机行为开放吗？
编辑:我明白，使用易失性并不能保证我的逻辑的正确性。我的问题更多是一个理论性质的问题，是我试图理解Java内存模型的问题。
浏览 5提问于2014-11-19得票数 2
回答已采纳
5回答
我查看了java并发集合的代码，我发现它们只是在操作开始时锁定了一些锁，最后解锁了简单的集合。
那volatile呢？如果后端集合不是易失性的，其他线程可能会漏掉更改，因此线程保存有点中断。我知道synchronized可以解决这个问题，但是他们只使用锁而没有任何进一步的同步。
这是个问题还是我遗漏了什么？
更新：
经过稍微的讨论，我想把这个问题重新表述一下。
我想在多线程环境中使用java集合。(例如，目前我谈论的是PriorityBlockingQueue)
我希望确保一个线程对集合(push/pop)所做的更改对其他线程立即可见。
java并发集合可以防止我陷入麻烦，以便在线程数更新时
浏览 14提问于2010-11-23得票数 8
回答已采纳
2回答
我需要在不同的线程中使用ReentrantLock。这有可能吗？附注:在secondMethod "lock.unlock()“抛出IllegalMonitorStateException。
public class SomeClass {
private static ConcurrentHashMap<String, String> hashMap = new ConcurrentHashMap<>();
private final Lock lock = new ReentrantLock();
public void first
浏览 6提问于2016-11-14得票数 0
我看不出有什么区别。我读到了这个：
想要测试一下。代码如下：
public class Test {
public static void main(String[] args){
Test test = new Test();
test.inturreptWork();
//Main group
System.out.println("Main Thread group: "+Thread.currentThread().getThreadGroup().getName());
//System group is the parent
浏览 0提问于2017-06-18得票数 2
C++11，多平台代码，带有std::thread的线程。我有一个打开的文件和多个线程必须从中读取。
前提:一开始我只有一个包含文件路径的字符串，然后每个新线程打开文件，读取它，然后关闭它。这工作得很好，但在某种程度上，我意识到对于我的目的来说，它可能有点慢。因此，我现在有了一个在类构造函数中打开并在销毁中关闭的FILE*，以及从同一文件读取数据的多个线程。只有阅读，没有写作。
我知道这在其他问题中已经讨论了很长时间，但我还没有找到我的具体问题的答案，即：
1)这样做安全吗? 2)让多个线程访问同一个处理程序比让每个线程执行打开/关闭任务更快吗? 3)操作系统是否会以某种方式干扰我的线程？
一
浏览 1提问于2015-07-08得票数 0
2回答
这是我试图演示嵌套锁问题的代码，
import java.util.concurrent.locks.*;
class SharedResource{
private static final Lock lock = new ReentrantLock();
private void methodThree(String name,int x) throws Exception{
lock.lock();
while(x <= 15){
System.out.println("METHOD-T
浏览 2提问于2012-02-08得票数 3
回答已采纳
2回答
我读过这个，答案很有帮助，但是仍然有一个问题。
我听说同步块中共享字段的更改对其他线程是可见的。
对于这样的代码：
Thread1：
synchronized(lock) {
obj.field1 = value1;
}
Thread2：
synchronized(lock) {
System.out.println(obj.field1);
}
假设thread1先于thread2，据说根据thread2规范，它可能如下所示：
hb(write to obj.field1 in threadOne, unlock in threadOne) AND
hb(unlock in t
浏览 1提问于2020-03-27得票数 0
回答已采纳
我们最近在我的操作系统类中讨论了很多线程，有一个问题浮现在我的脑海中。
由于Go (和Java)使用用户空间线程而不是内核线程，这是否意味着您不能有效地利用多核，因为操作系统只将CPU时间分配给进程，而不是线程本身？
浏览 0提问于2009-11-16得票数 14
回答已采纳
显示器到底是什么？.是所有对象都有监视器，还是仅在同步对象上有监视器？什么是进出监视器？..它们是如何存储在内存中的？也就是说，它们是与之相关的对象的一部分吗？提前谢谢..。PS :我指的是Java多线程
浏览 5提问于2013-09-23得票数 1
回答已采纳
2回答
我在实践中读过java.util.concurrent，这是一个很好的参考，但我希望看到java.util.concurrent包用例的简明的单页摘要。
例如：
为什么在同步collection?When上使用并发集合比显式锁定更倾向于原子类?什么时候应该使用锁而不是synchronization?What是等待()和通知()、notifyAll()?When应该使用CompletionService的替代方法？
有哪些优点/缺点和陷阱值得注意？
浏览 5提问于2009-09-04得票数 5
回答已采纳
1回答
C++并发队列：>1个线程慢一些
、、、、
队列与两个不同的锁同时存在:一个用于enqueue()，用于同时保护多个线程，另一个用于dequeue()，效果相同。
如果队列已满，Add(enqueue)将跳过(返回)插入。如果队列为空，则Remove(dequeue)跳过删除。
我使用doRandom()生成0到1之间的随机数。我使用这些数字来决定是否添加/删除。
性能：--我尝试过使用静态/动态线程分配测试队列。对于两个分配算法，>1个线程的执行时间都要慢得多。
//g++ -std=c++0x -pthread -o block blocking.cpp;./block
#include <iostrea
浏览 4提问于2017-03-10得票数 0
回答已采纳
在Java语言中，我们如何使用wait, notify (最好是)或其他高级构造来确保3个或更多线程之间的序列。
例如，对于3个线程，T1、T2和T3打印1、4、7...2,5,8...3、6、9……分别应依次执行T1 > T2 > T3 > T1 > T2 > T3 > T1等...最终输出如下所示：
T1 1
T2 2
T3 3
T1 4
T2 5
T3 6
T1 7
。
。
。
请注意编号。线程的数量作为用户的输入，并不是硬编码的。
我知道如果要按顺序运行多个线程，使用多个线程是没有意义的，但这是一个实践问题。
请尽可能使用代码片段提供帮助。
浏览 3提问于2015-08-08得票数 0
我来自Java，所以我熟悉同步，而不是互斥。我想知道pthread_mutex_t是否也是可重入的。如果没有，有没有其他机制来解决这个问题？
谢谢
浏览 4提问于2012-07-20得票数 4
回答已采纳
为了实践，我想将java同步关键字实现为一个java对象。你认为下面的代码是一个很好的设计吗？我猜AtomicReference的性能应该和AtomicBoolean差不多吧？
在建议之后更新代码：
public class SynchronizedBlock implements Runnable{
private final Lock lock;
private final Runnable runnable;
public SynchronizedBlock(Runnable r, Lock l){
runnable = r;
lock = l;
}
public
浏览 0提问于2013-10-07得票数 0
3回答
获取锁以进行序列化
、、、、
我是Java新手。我通过编写小程序来练习。
在其中一个程序中，我有一个对象，它包含一些配置。此配置可以在运行时更改。我通过序列化对象将配置保存到文件中。
在我看来，我必须在序列化之前对正在序列化的对象进行锁定，以确保它在序列化期间不会更改。
synchronized (myObject)
{
output.writeObject(myObject);
}
然而，我读到应该尽量避免在同步块中或在任何其他形式的锁下进行IO操作(例如写入文件)。这是有意义的，因为IO操作可能需要相对较长的时间，从而使其他线程保持等待/阻塞。
我想知道，是否有一种方法可以避免锁下的序列化……欢迎提出任何建议
浏览 1提问于2017-06-23得票数 1
我正在编写以下代码。
CreateThread.java
import java.util.concurrent.locks.*;
class CreateThread
{
public static void main(String[] args)
{
StampedLock lock = new StampedLock();
MyThread[] t = new MyThread[5];
for(int i=0; i<2; i++)
{
浏览 3提问于2020-03-25得票数 0
1回答
CodeBlockA;
Lock;
CodeBlockB;
Unlock;
CodeBlockC
代码块可能包含很多代码，只需将其作为一个单元。
CodeBlockA CodeBlockB CodeBlockC是否始终以串行方式执行？lock是如何做到这一点的？
浏览 14提问于2021-07-29得票数 0
4回答
java meomry模型要求在同一监视器上同步的synchronize块对在这些块中修改的变量执行预实现。示例：
// in thread A
synchronized( lock )
{
x = true;
}
// in thread B
synchronized( lock )
{
System.out.println( x );
}
在这种情况下，只要线程A已经传递了x==true -block，线程B就会看到该线程。现在，我正在重写大量代码，以便在java.util.concurrent中使用更灵活(据说更快)的锁，特别是ReentrantReadWriteLock。这个
浏览 0提问于2010-04-05得票数 8
回答已采纳
线程在执行之前需要获取多个锁，所以我将所有锁放到一个列表中，并迭代tryLock()它们，如果tryLock()成功，我将获取的锁添加到一个名为acquiredLocks的列表中，因此当任何lock'tryLock()失败时，我可以解锁已经获取的锁，但是当回滚发生时，它通过ReenrantLock抛出java.lang.IllegalMonitorStateException，因为锁不是由当前线程持有的。我检查了acquiredLocks列表，其中的一些锁确实是由另一个线程获取的，但在将它添加到acquiredLocks列表之前，我调用了tryLock()。
private final
浏览 1提问于2021-01-14得票数 0
我有以下课程：
public class Example {
private AtomicBoolean isValueSet = new AtomicBoolean(false);
private int value = 0; // I DON'T want to make this volatile.
private void initializeValue(int value) {
// as you can see, value can only ever be set once.
if (isValueSet.com
浏览 0提问于2015-01-31得票数 0
2回答
我的问题是，如何让线程运行，然后再运行一次，然后再运行一次，然后再重复一次。
我有一个主文件
private static ThreadManager threadManager;
public static void main(String[] args)
{
threadManager = new ThreadManager();
}
然后我有一个ThreadManager类
public class ThreadManager {
public static final Object lock1 = new Object();
public static ConcT
浏览 0提问于2011-03-27得票数 0
1回答
我正在开发一个人工智能程序来探索给定的资源空间。
我想运行多个场景，以便收集数据并输出到一个文件。
我在gui中使用了“多个运行”选项，当一个模块运行完成时(所有的资源都已经被探索过了)，我就执行stop()。问题是当它第二次运行模型时，它不能正常工作。
我的意思是，在运行一次之后，我总是需要通过退出来终止应用程序，因为重新启动选项不能正常工作。
有没有“重新启动”忘记做的事情？因为如果我退出应用程序并再次运行它，它会完美地工作
编辑后的内容更清晰：
我使用平台来模拟对火星的探索。我有三种代理人，侦察，挖掘和运输。它们之间进行通信，以安排任务和其他事情。
我第一次运行模拟时，一切都运行得很顺利
浏览 0提问于2010-12-01得票数 1
回答已采纳
如果我从具有SurfaceView的正在运行的活动中启动一个新活动，有时我会继续获得ANR。有人知道这锁是怎么回事吗？我使用android支持包来使用片段，我的表面视图是一个片段。
----- pid 5281 at 2012-04-05 10:59:42 -----
Cmd line: com.customlbs.android
DALVIK THREADS:
(mutexes: tll=0 tsl=0 tscl=0 ghl=0 hwl=0 hwll=0)
"main" prio=5 tid=1 WAIT
| group="main" sCount=1
浏览 3提问于2012-04-05得票数 8
我从一本烹饪书中了解到，单词之间的主要区别是:并行和并发。
并行:使用多个核心/CPU处理多个任务
并发性:使用一个核心/ CPU处理多个任务，但使用时间框架机制。
因此，我还了解到，Java是一种使用多个核的强大功能同时实现多个任务处理的语言。但是它在此功能上的包名称为java.util.concurrency。
为什么java使用并发一词而不是并行？
浏览 15提问于2021-08-10得票数 0
回答已采纳
1回答
共享资源的先到先得策略
、、、
试题：
资源在N个线程之间共享，因此访问是在先到先得的基础上进行的.解释一下你将如何实施先到先得的政策。
我的回答是(注:课程是基于Java的)：
使用信号量(二进制)控制对共享资源的访问。然后创建一个馈线类/线程来访问信号量。馈线线程使用FIFO队列来实现先到先得.当信号量空闲时，它允许线程(队列的头)访问共享资源。
我刚才在纸上草草记下了上述方法，看来是可行的。
这个问题在一个20个标记的问题中值8个分数，所以我怀疑使用new ReentrantLock(true)是否足以达到满分。
你们觉得怎么样？
浏览 5提问于2012-07-23得票数 2
回答已采纳
1回答
模拟交通信号(单盒)
、、、
我想实现一个交通信号(一个盒子)。我看到其中有很多问题，但我觉得它们不是完整的代码。
下面是完整的来源。我使用lock和condition来决定哪个线程将实际运行。
TrafficSignalSimulationUsingLock.java
package com.example.practice.third;
import java.util.concurrent.locks.Condition;
import com.example.practice.third.custom.lock.TrafficLock;
import com.example.practice.third.thr
浏览 1提问于2020-05-31得票数 0
我正在尝试使用ReentrantLock实现阻塞FIFO。除了抛出IllegalMonitorStateException之外，一切都很好。当我们试图释放未被线程锁定的资源时，可能会发生此错误。但我找不到为什么这个错误出现在这里。
package edu.utdallas.blockingFIFO;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import edu.ut
浏览 2提问于2016-10-27得票数 1
回答已采纳
根据手册页
pthread_mutex_lock锁定给定的互斥对象。如果互斥锁当前已被解锁，则它将被锁定并由调用线程拥有，并且pthread_mutex_lock将立即返回。如果互斥锁已被另一个线程锁定，pthread_mutex_lock将挂起调用线程，直到互斥锁解除为止。
我理解的是，当line 3执行时，main thread拥有mtx的所有权。然后执行其规范区域操作，然后到达line 4并解锁mtx。我的问题是-
当mtx被锁定时，其他线程能并发运行吗？
line 2的用途是什么，因为newThread只有在执行了line 4之后才能解锁mtx，从而使line 2变得冗
浏览 0提问于2018-11-28得票数 0
回答已采纳
1回答
线程安全QQueue
、、、
在Qt应用程序中，我需要从一个线程中添加项目，并从另一个线程中使用它们。当Qt声明容器类时：
..。当所有用于访问它们的线程将它们作为只读容器使用时，它们是线程安全的。
我假设我需要创建一个线程安全版本，或者使用互斥锁来保护它。有没有推荐的解决方案？比如直接使用Qt事件循环，或者我遗漏的任何线程安全类？
浏览 4提问于2015-02-05得票数 1
我想从JBoss桌面应用程序中调用部署在java 7中的无状态会话Bean。
我创建了InitialContext实例，如果在同一线程中查找和调用bean方法(下面代码中的bean1)，一切都是正常的。
但是如果我在另一个线程中从InitialContext获取bean代理，那么当我从bean (下面代码中的bean2)调用方法时，程序就会抛出异常。
我使用的部分源代码：
public class Tester1 implements Runnable
{
InitialContext ctx;
static String beanAddr = "MobileSubsc
浏览 1提问于2013-05-25得票数 2
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
实时音视频
即时通信 IM活动推荐
腾讯云开发者
