Re: Using ReentrantLock
RVince wrote:
It seems based on everyone's comments (please correct me if I am
wrong), that all I really need do is make lockObject a static variable
As others have said, no, do not make it static.
from the calling thread. This way, all see it, and there is only one
copy that all threads called would be working from. This seems simple,
solid and robust. For example:
class MyCallingClass{
static ReentrantLock lockObject = new ReentrantLock(false);
myCalledThread=newMyCalledThread(lockObject);
^^
This will not compile.
myCalledThread.t.start();
^^
This will not compile. Even if it did, since thread 't' never is assigned
anything you'd get a NullPointerException.
class MyCalledThread{
Why do you use a nested class? Why is it an inner class?
Thread t;
ReentrantLock lockObject;
MyCalledThread(ReentrantLock lockObject){
this.lockObject=lockObject;
Why pass 'lockObject' to a constructor when the outer class variable is
already visible to the inner class? Since you do pass it in, why is the
inner-class variable not 'final'?
}
public void run(){
try {
lockObject.lock();
output.write(merchLinklengthBytes(response));
output.write(headerControl);
output.write(response.getBytes());
}
catch (Exception e) {
e.printStackTrace();
}
finally {
if (null != lockObject) {
I asked before, and you didn't answer: Under what circumstances could
'lockObject == null'? Why don't those circumstances pertain to the call to
'lockObject.lock()'?
Perhaps you will answer this time. They're important questions, and asked in
order to help you get certain things clear. You should not ignore them. They
will help you.
lockObject.unlock();
}
}
}
}
}
Does anyone see any glaring problem - grotesquely stupid mistake I am
making here. Again, I'm just very unsure on this approach to doing
this, and trying to keep it as simple & robust as possible. Based on
your critiques, I think this accomplishes that end. But in X decades
of writing code, I can;t think of ANYTIME, ANYTHING, has ever run as I
thought it would on the first pass!
That could be an indicator that you need to revise your mental model of how
these programs behave.
--
Lew