Concurrency question

interface messageInterface{
   getMessage( message )
class B implements messageInterface{
   private int A;
   private int B;
   public synchronized it(parmA, parB){
      A=parmA;
      B=parmB;
      sendMessage();
// get message from server
   public void getMessage(message){
        methodZ( A )
   private void methodZ (int ){
The potential problem I see is that A and B could change, if method it() is called twice before getMessage() gets a response from the server and has a chance to use it. What are some possible ways to synchronize this better.

It doesn't matter what the actual method calls do.
The point is that A and B are changing on one thread when the it() method is called.
It then sends a message to the server and wait for a response which it receives in getMessage().
getMessage needs to use A and B for some calculation with the message it receives.
What it really needs to do is:
Get A and B( it() )
send a message to server to get some more information
Use A,B, and message from server to perform a calculation.
But A, B could change if it() is called before a message is received from the server.
One way it could work is that it() could wait unitl getMessage() receives it's message from server and performs it's
calculation before returning. I imagine it could some kind of wait() notify() or thread.sleep periodically waiting for getMessage to be done.
Just looking for some suggestions. How would the wait/notify work?

Similar Messages

Concurrency questions, Secondary Databases, etc.

Hi,
i have the following requirements:
- Multiple threads, every thread opens one ore more database
- Databases have RefCounting if they are used in more than one thread
- Every database has a SecondaryDatabase associated
- All Threads are performing only put operations one the databases
- Keys and SecondaryKeys are unique (no duplicates)
I tested with normal Databases and SecondaryDatabases:
- no Transactions used
- deferredWrite is on true
Everything worked and the performance is within our expectations.
my Questions now:
- Does this setup work as long as all threads are only writing (put)
(i read in another post that SecondaryDatabases work only with transactions...
i think thats true only if you read/write ??)
- Is there anything i should take care of? I already checked my SecondaryKeyCreator
for concurrency issues...
- Does it help (in this setup) to disable the CheckpointerThread? The Databases are
synced and closed after all writes are finished. We don't need recovery...
- Are there any penalties if i increase the LogFileSize? We are writing around 80 to 150GB
of data and with the default size (10MB) we get a lot of files...
- Caching is a non-issue as long as we are only writing... is this correct?
Sorry for the amount of questions & thanks in advance for any answers!
Greets,
Chris

Hi Chris,
- Does this setup work as long as all threads are only writing (put)(i read in another post that SecondaryDatabases work only with transactions...
i think thats true only if you read/write ??)>
When using secondaries, if you don't configure transactions and there is an exception during the write operation, corruption can result. If you are reading and writing, lock conflict exceptions are likely to occur -- with transactions you can simply retry, but without transactions you can't. Since you are not reading, it is unlikely that this type of exception will occur. See below for more.
- Is there anything i should take care of? I already checked my SecondaryKeyCreatorfor concurrency issues...>
Since your secondary keys are unique, you'll get an exception if you attempt to write a primary record containing a secondary key that already exists. To avoid corruption, you'll have to prevent this from happening. If you are assigning secondary keys from a sequence, or something similar, then you'll be fine. Another way is to check the keys for existence in the secondary before the write. To do this, open the secondary as a regular database (openDatabase not openSecondaryDatabase). You don't want to read the primary (that could cause lock conflicts), which is what happens when you use openSecondaryDatabase and read via the secondary.
- Does it help (in this setup) to disable the CheckpointerThread? The Databases aresynced and closed after all writes are finished. We don't need recovery...>
Yes, if you don't care about recovery time, then disabling the checkpointer during the write operations will reduce the amount of disk space used and overall overhead.
When you say you don't need recovery, what do you mean? In general, this means that if there is a crash, you can either 1) revert to a backup or 2) recreate the data from scratch.
- Are there any penalties if i increase the LogFileSize? We are writing around 80 to 150GBof data and with the default size (10MB) we get a lot of files...>
The log cleaner may become inefficient if the log files are too large, so I don't recommend a file size larger than 50 MB.
- Caching is a non-issue as long as we are only writing... is this correct?The JE cache is not just a cache, it's the memory space for internal information and the Btree. For good performance during the write operations you should configure the cache large enough to hold all internal Btree nodes. The DbCacheSize program (in com.sleepycat.je.util) can be used to calculate this size.
An exception to this rule is when you are inserting keys sequentially. If both the primary keys and secondary keys are assigned and written sequentially, then the cache size can normally be much smaller, perhaps only 10 MB. But this is an unusual use case, especially with secondaries.
--mark

General concurrency question

Hello,
          We are in the process of writing an EJB-based application
          running on top of WLS in a clustered environment and wonder
          about the following:
          1. We have transactional control in a session bean to make sure
          that proper synchronization is used when concurent clients (JSPs)
          invoke services on instances of the same session bean.
          Would this work fine in the clustered environment? i.e. is any
          additional code/care needed so that the same
          transaction/synchronization control work equally well in the
          clustered environment?
          2. Some entity EJBs will certainly be replicated. Does the
          clustering automatically take care of data validity? i.e. in
          cluster 1 the database info the entity bean gets updated while
          in cluster 2 a client (say a session bean) accesses the entity bean,
          do we have guarantee that cluster 2's client gets the data as
          was updated by cluster 1's client?
          Any information would be greatly appreciated. Many thanks
          in advance!
          Please Cc your replies to [email protected], if
          not a burden.
          -Mourad


The dbIsShared property of the deployment descriptor will also address the
          concerns in your second question.
          --Joe Sherwin
          Senthil Kumar S wrote:
          > Mourad Zerroug wrote:
          >
          > > Hello,
          > >
          > > We are in the process of writing an EJB-based application
          > > running on top of WLS in a clustered environment and wonder
          > > about the following:
          > >
          > > 1. We have transactional control in a session bean to make sure
          > > that proper synchronization is used when concurent clients (JSPs)
          > > invoke services on instances of the same session bean.
          > >
          > > Would this work fine in the clustered environment? i.e. is any
          > > additional code/care needed so that the same
          > > transaction/synchronization control work equally well in the
          > > clustered environment?
          >
          > Statefull session bean`s Home can be clusterable not the remote objects.
          > So if the client connects to a session bean then it will be pinned
          >
          > Stateless session beans:
          > In this case u have ot make sure the services are idempotent. The
          > implementation should take care of those duplicate calls
          >
          > >
          > > 2. Some entity EJBs will certainly be replicated. Does the
          > > clustering automatically take care of data validity? i.e. in
          > > cluster 1 the database info the entity bean gets updated while
          > > in cluster 2 a client (say a session bean) accesses the entity bean,
          > > do we have guarantee that cluster 2's client gets the data as
          > > was updated by cluster 1's client?
          >
          > It depends on the isolation level u set.
          > weblogic.com/docs51/classdocs/API_ejb/EJB_reference.html#1056190
          >
          > >
          > >
          > > Any information would be greatly appreciated. Many thanks
          > > in advance!
          > >
          > > Please Cc your replies to [email protected], if
          > > not a burden.
          > >
          > > -Mourad

Lame Concurrency Question

I am seriously thread retarded. I can always get my threaded code to work without
any problems but that doesnt mean I have a clue about what is going on.
What is the best way to code the following common functionality:
class Runner implement Runnable{
public void run(){
while(run.booleanValue() == true){
do something();
Thread.sleep(some time);
public void stopRunning(){
run = new Boolean(false);
Boolean run = new Boolean(true);
}Do you just make stopRunning() synchronized?
Or do you lock on the "run" object?
If so, do you have to use a "synchronized(run)" block in both methods?
If you synchronize on an object should you use "synchronized(object)" every
place the object is used?
public void run(){
while(true){
synchronized(run){
if(run.booleanValue() == false){
break;
do something();
Thread.sleep(some time);
public void stopRunning(){
synchronized(run){
run = new Boolean(false);
}(By the way, ive never done the above. I usually just make stopRunning() synchronized.)

TuringPest wrote:
ignore my concurrency ignorance, lol, but i thought that whenever you had one
thread changing the values of something in another thread it had to be synchronized -
even if its a primitive?Yes. Or the variable has to be volatile. But, as already discussed, you don't need the running flag here.
while (!Thread.interrupted()) {
doStuff();
try {
    Thread.sleep(millis);
catch (InterruptedException exc) {
    log it?
    Thread.currentThread().interrupt();
}

ConcurrentSkipListMap concurrency question

I am not much familiar with the internals of that class...
Is it thread-safe to add entries to that map and in another thread to clone the map ?
What about the ConcurrentHashMap ?
Thanks.

yes. You will get a consistent copy of the data.
However if you add multiple entries as a group e.g. with addAll or putAll, there is no guarentee you will get all or none. You could get some of them but not all.
Because these classes are concurrent, you may find you don't need to clone them. If you want to snapshot of the data, you are unlikely to need to update the snapshot in a multi-threaded manner so you can just copy the data to a plain TreeMap or HashMap.

Java concurrency question

I read few articles about Java Threads but I am confused over one issue.
If I spawn a new thread (say "user thread") from my Main thread in which conditions will the Main thread wait for the user thread to complete the execution to exit the system?
My understanding was, once the user thread is spawned, Main thread will go ahead with its execution and if it reaches end point before the user thread finishes its task, it will simply exit causing premature end of the user thread.
I wrote a code to test it and realized that only if I exit Main thread with System.exit() function, the user thread ends prematurely. Otherwise the Main thread waits for the user thread to complete the execution (even without the join() method). In all the articles I read, this concept is not really clearly described or at least I have not picked it up properly. Could you guys please care to explain?

A thread can either be a daemon thread or a 'regular' thread. You control this through a setter method on Thread. By default threads are 'regular' threads.
When the main thread finishes execution, it will wait for all 'regular' threads to finish their execution first before the program exits. If these threads are not designed to finish, your program will hang waiting for them. If you only have daemon threads left running, the program will exit immediately.

Function Concurrency Question

Hello,
I have two functions which I desire to be run in paralell, but are currently not. They both read a lot of the same values (scalars), but write to different memories. However they also both access a common memory. This memory is a true dual port block RAM. Neither function writes to this memory, they only read from it. However both functions utilize both memory ports, which I believe prevents them functions from being scheduled for parallel execution. How do I verify that this is the case and if I'm correct how would I address it?
Thanks!
Edit: Fixed a couple of typos.

hi
I thought about one way of doing that.
At the moment, it's much more cheating than a warkaround - so especially this time, verify, verify again, use at your own and verify some more.
using similar topology as my previous examples, the trick here is to make the shared memory external - as you had tried.
here you need an explicit synchronize the functions, otherwise from a dependency point of view the 3 sub function are totally independant and will all execute in parallel.
once alpha() completes, foo() and bar() can start. Notice that the tool should report min latency == latency of alpha and max latency == latency of alpha + max ( latency of foo , latency of bar )
bool alpha( ... ) {
return 1;
void top(
data_t array_input[array_dim],
data_t array_common_write_port[array_dim],
data_t array_common_read_port_1[array_dim],
data_t array_common_read_port_2[array_dim],
data_t array_output_1[array_dim],
data_t array_output_2[array_dim]
#pragma HLS interface bram port=array_common_write_port
#pragma HLS interface bram port=array_common_read_port_1
#pragma HLS interface bram port=array_common_read_port_2
hls::stream<bool> sync_stream;
sync_stream << alpha( array_input, array_common_write_port );
if( sync_stream.read() ) {
foo( array_common_read_port_1, array_output_1 );
bar( array_common_read_port_2, array_output_2 );
Once again verify the behavior of this creative approach.
I hope this helps!

Performance issue when accessing a CRL file

Hi,
In an application we receive sign and verify files(ordinary information files) as seperate processes. When signing files we do a check on the CRL of the signing certificate. Below are the steps in which the check is done:
1- Receive a file. Get its signing certificate from a repository.
2-save/cache the CRL file in a directory(we do check if the file already exists when creating). We have configured a time out period with which the CRL will be updated in case of modifications.
File file = new File(cacheDirSystem.getProperty("file.separator")+crlUrl(url));+
fs = new FileOutputStream(file);
X509CRL crl.writeTo(fs);
3-Get the CRL Distribution Point from the signing certificate and load the file that was saved to check with the Certificate Revocation Lists.
String as[] = getDistributionPointNameURIs((GeneralNames)dpName);
File file = new File(cacheDirSystem.getProperty("file.separator")+modifyUrl(as));+
lastModified=file.lastModified();
fstream = new FileInputStream(file);
crlObject.crl=new X509CRL(fstream);
When running signing processes with more than 150 files(the file size can go upto 2MB) over a period of time, the CRL is sometimes not found and InvalidCRLException is thrown. I think its some problem with accessing the CRL file concurrently since it could also be updated at some point.
Im trying to figure out if a file lock or some other way would help to reslove this. I need help/suggestions on this.
Thanks in advance

I think its some problem with accessing the CRL file concurrentlyUndoubtedly. You should write the new data to a new file and do a delete/rename operation. All clients should cope with not finding the CRL file by retrying a couple of times in case they tried between the delete and the rename.
This is a file handling question, or concurrency question, not really a security question.

Creating Daemons in Java

I am making a server in Java, and when I run it, it seems to hog all of the CPU time. Is there any way to optimize code so that it uses less resources?
I know one way to create daemons is to use "daemon threads." However, daemon threads die when all normal threads die (such as the main program thread). However, I want one thread to operate until explicitly closed.
The main reason I did not post this under the "Concurrency" section is because it is more about optimization in general. For example, will empty for (;;) loops tax the system more since the code will have to be re-evaluated? Is there any other way to block a thread so it doesn't die?
Help would be appreciated. A resource on Java optimization would be greatly appreciated.

http://java.sun.com/docs/books/tutorial/essential/concurrency/simple.html
Actually, this is very much a concurrency question.
A for(;;) loop will tax 100% of the CPU, so you need to yield control when you have nothing to do. The page above has a nice "while thread.isAlive()" loop to give you an example.
Here is the beginning of the Concurrency tutorial. Wouldn't hurt for you to go through it, I'm sure.
http://java.sun.com/docs/books/tutorial/essential/concurrency/index.html

Concurrent report export using enterprise SDK question

Hello, 
Our company uses Enterprise SDK to export report to PDF. We test our software using CR Server 2008 trial version. I am looking for advices for following questions: 
1. As out testing server is trial version at the moment, it does not complain or generate any warning messages on numbers of concurrent users (we can only view current sessions and licenses from CMC). Could someone please let me know what will happen when full version CR server detects that max limit concurrent users access has reached? Will the server notify SDK, and SDK will generate exception; or the request will be queued until any other concurrent user end his session. 
2. We implement an EJB to invoke SDK process. While EJB itself is thread safe, I am not quite sure if enterprise SDK is thread safe too. My assumption is that one SDK will be instantiated per JVM (like JRC?). It will issue a new thread to each report request (from EJB). Please correct me if I am completely wrong. 
3. This is about licensing. Our scenario is there will be multiple (and concurrent) end users use our J2EE system, and may request report from CR server. Our J2EE system, however, will use one user account to login to CR server through enterprise SDK. In the other word, CR server will treat our J2EE system as one user (even if there are multiple or concurrent request). My question is that does it violate legal agreement with Business Object if I configure the user account our J2EE system uses as Named user?! If it is, we will get concurrent user licenses instead. Please advice. Thank you =) 
Kind Regards, 
mlie

Hello Adam, 
Thanks for your reply. It is very helpful. 
As for point 1, what exact SDKException will SDK throw (e.g. SDKException.Unexpected)? 
In point 2, "There have been issues reported previously that only occur when using EJB's.". Is it possible to let me know what kind of issues they are? 
In point 3, as CMS supports Window AD authentication, and our system uses same mechanism to perform authentication, I guess the best strategy is to implement single sign on? Please advice. Thank you 
Regards, 
mlie

A question about concurrency and static getter methods

Hello
I have a class with some static methods. they just return a reference and doesnt apply any changes.
something like this:
public class FieldMapper {
 private static Map<Class,Map<String,String>> fieldMap = new HashMap<Class,Map<String,String>>();
 public static getFields(Class clazz){
 return fieldMap.get(clazz);
}my question is, let's consider many users connect to my server and each has its own session, now assume one user want to use FieldMapper.getFields(User.class) and another is going to call FieldMapper.getFields(Employee.class) at same time or a bit milli seconds after, and this method is not synchronized, is there any conflict in calling the method? would this method return wrong reference to the first invocation?
in genereal, may the concurrency make problem on reading resources? or just on changing resources?
Thank you very much in advance.

To publish an object safely, both the reference to the object and the object's state must be made visible to other threads at the same time. A properly constructed object can be safely published by:
Initializing an object reference from a static initializer;
Storing a reference to it into a volatile field or AtomicReference;
Storing a reference to it into a final field of a properly constructed object; or
Storing a reference to it into a field that is properly guarded by a lock. The internal synchronization in thread-safe collections means that placing an object in a thread-safe collection, such as a Vector or synchronizedList, fulfills the last of these requirements. If thread A places object X in a thread-safe collection and thread B subsequently retrieves it, B is guaranteed to see the state of X as A left it, even though the application code that hands X off in this manner has no explicit synchronization.
Now in the case you have specified you are using HashMap. Which is not designed to be threadsafe as opposed to HashTable or concurrentHashMap. In such a case I would advise against using this. The concurrency problem is caused by race conditions on mutable objects, whether it is reading or writing. If it is mutable, it is susceptible to race conditions. IMHO
&spades;

Question related to Java Concurrent Program

Hi Friends,
I have a basic question related to Java Concurrent Program in the Oracle application. I would like to know the how Java concurrent program is executed in Oracle applications.Also, want to know where can I find the document for the AOL packages for Java concurrent program. Document for packages like oracle.apps.fnd.cp.request.* , oracle.apps.fnd.util.*.
Please let me know.
-Thanks,
Satya

You may also check:
Note: 250964.1 - How to Register Sample Java Concurrent Program
https://metalink.oracle.com/metalink/plsql/ml2_documents.showDocument?p_database_id=NOT&p_id=250964.1
Note: 186301.1 - How to register and execute Java Concurrent Program ?in Oracle Applications R11i?
https://metalink.oracle.com/metalink/plsql/ml2_documents.showDocument?p_database_id=NOT&p_id=186301.1

A quick question about WebDynpro SLD and R/3 with concurrent users

Hello ,
I have a very quick question about Webdynpros and SLD connecting to an R/3 system, when you configure a webdynpro to connect to an R/3 system using SLD, you configure a user name and password from the R/3 for the SLD to use. What I would like to know is when I have concurrent users of my webdynpro, how can I know what one user did in R/3 and what another user did? Is there a way for the users of the web dynpro to use their R/3 credentials so SLD can access the R/3? Like dynamically configuring the SLD for each user?
- I would like to avoid leaving their their passwords open in the code ( configuring two variable to get the users username and password and use these variables as JCO username and password )
Thanks Ubergeeks,
Guy

Hi Guy
You will have to use Single Sign On to achieve this. In the destination you have defined to connect to R/3 , there is an option to 'useSSO' instead of userid and password. This will ensure that calls to R/3 will be with the userid that has logged into WAS. You wont need to pass any passwords because a login ticket is generated from WAS and passed on to R/3. The userid is derived from this ticket.
For this to happen you will have to maintain a trust relation ship between R/3 and your WAS ,there is detailed documentation of this in help files. Configuration is very straight forward and is easy to perform
Regards
Pran

Java.util.concurrent.ExecutorService question!!!

HI,
I'm working with java.util.concurrent.ExecutorService. I need to know: Is there a possibility to know that all executions are done, that there is nothing to execute?????
All ideas are welcome!:)
Thanks a lot!:)
Best,
Aram.

If I understood If I will use maxpoolsize of 1 that will be like Executors.newSingleThreadPool()?????It will be like SingleThreadPool, except that you can supply your own queue, with its own queueing characteristics. Also, there is no need to use five question-marks; four will suffice.
Your tasks will be executed in the order they are in in the queue; read the documentation for the queue you choose for details. "Priority" is not a built-in concept in Java. You must implement the Comparable interface so that the priority-queue can tell which task should be executed next.
And what "second queue"? A given executor will execute tasks off one queue.
M.

Question on example from "Java concurrency in practice"

"Java concurrency in practice" 14.9 listing ( [Orig here|http://www.javaconcurrencyinpractice.com/listings/ThreadGate.java] ):
+...The condition predicate used by await is more complicated than simply testing isOpen. This is needed because if N threads are waiting at the gate at the time it is opened, they should all be allowed to proceed. But, if the gate is opened and closed in rapid succession, all threads might not be released if await examines only isOpen: by the time all the threads receive the notification, reacquire the lock, and emerge from wait, the gate may have closed again. So ThreadGate uses a somewhat more complicated condition predicate: every time the gate is closed, a "generation" counter is incremented, and a thread may pass await if the gate is open now or if the gate has opened since this thread arrived at the gate...+
public class ThreadGate {
    private boolean isOpen;
    private int generation;
    public synchronized void close() {
        isOpen = false;
    public synchronized void open() {
        ++generation;
        isOpen = true;
        notifyAll();
    public synchronized void await() throws InterruptedException {
        int arrivalGeneration = generation;
        while (!isOpen && arrivalGeneration == generation) {
            wait();
Question:
Guys, could anyone explain me
1) the work of code in term of "thread T1 waits, thread T2 closes..." the part arrivalGeneration == generation is unclear?
2) Why both english and french editions say "every time the gate is closed, a generation counter is incremented"? How this is possible?
3) Give an example how "the gate may have closed again" ? How this is possible?
I posted this in other forums, but never had any explanations. Thanks.
Edited by: maxim_2004 on Jul 14, 2010 9:19 AM

Generation is a counter of how many times the gate has opened. We use it to determine if the gate has opened since a waiting thread arrived. The criteria for a waiting thread to proceed is not, "Is the gate open now?" but rather "Has the gate opened at least once since this thread started waiting?"
Say you have N waiting threads and one controller thread. When the controller thread calls open(), we want all N waiting threads to be able to proceed. But the controller thread may call close() at any time, and depending on when he calls close(), how many waiting threads there are (that is, how large N is) and how the scheduler on that JVM/OS is operating, the controller thread may call close() before all of the waiting threads have completed the await() method.
So a waiting thread may be stuck in the while loop call wait(), and by the time he has been notified, gets CPU cycles, acquires the lock, and goes back to test isOpen, the gate may have opened and closed. But we want him to be able to go, just because the gate did open. We don't care if he didn't get through before it closed again--he's supposed to be able to go anyway.
Therefore, we don't just wait if the gate is closed. We wait if the number of times it has opened is the same as when we arrived. In other words we wait only, if it hasn't opened since this waiting thread arrived.
Gate opens 1st time. (generation = 1)
Gate closes.
Gate opens 2nd time. (gen = 2)
T2 arrives. (arrivalGen = 2)
T2 calls wait()
Gate opens 3rd time. (gen = 3)
Gate closes.
T2 gets CPU time and lock. Executes while test. Gate is closed. BUT gen=3 and arrivalGen=2, so even though the gate is closed now, it has opened since T2 arrived, so T2 is allowed to proceed (arrivalGen != gen)
Edited by: jverd on Jul 14, 2010 10:05 AM
Edited by: jverd on Jul 14, 2010 10:08 AM

Concurrency question

Similar Messages

Maybe you are looking for