Thread Safety : Marking arguments of static method as final

Hi,
I have a class with static method. This class will be hit by several threads and I need to make the code thread safe. If I declare the arguments of this method as "final", will it guratnee that these variables cannot be changed by another thread calling this method?
Thanks in advance,
Rtameh

No, the only condtion where parameters or local variables might be shared with another thread is if you create a local class which uses them, and the compiler won't allow you to do that if they aren't final.
Local variables are always thread-safe.

Similar Messages

Are static methods in Java thread safe?

Are static methods in Java thread safe?
thanks,
suresh

if static method use the instance variable
You mean member variable, where member variables are either class variables (static) or instance variables (non-static).
then you have to make it thread safe using
synchronization Not necessarily. Depends on requirements and usage context.
else in case of local var. it
is thread safe. Not necessarily. That local variable could refer to an object that's visible to multiple threads.
Statements like "Local variables are threadsafe but member variables aren't" are an oversimplification.
Something is threadsafe if it cannot be made to behave incorrectly simply by running it in a multithreaded context. Determining that can be very difficult.

Help on calling static method in a multithreaded environment

Hi,
I have a basic question.. pls help and it is urgent.. plss
I have a class with a static method which does nothing other than just writing the message passed to a file. Now i have to call this static method from many threads..
What actually happens ???
Does all the thread start to execute the static method or one method executes while the other threads wait for the current thread to complete execution?. I am not talking about synchronizing the threads...my question is what happens when multiple threads call a static method??
Pls reply.. I need to design my project accordingly..
Thanks
Rajeev

HI Omar,
My doubt is just this..
I wanted to know what might happen if two threads try to access a static method.. Logically only one thread can use the method since it is only only copy... but i was wondering what might happens if f threads try to access the same static method.. My Situation is this.. I have a cache which is just a hash table which will be only one copy for the whole application.. No when i get a request I have to check if the id is avaible in the cache. if it is available i call method 1 if not i call method2. Now Ideally the cache should be a static object and the method to check the id in the cache will be a normal instance method..
I was just wondering what might happen if i make the method static.. If i can make it static i can can save a lot of space by not creating the object each time.. u know what i mean.. That y i wanted to know what happens..
Rajeev

Are Static methods Thread safe?

Hello All
I have a static method that takes a integer and returns a mathematically processed result.
Since this method is frequently required, I have placed it in a common class and declared it as static.
I want to know whether this method is thread safe?

There's nothing special about static methods, with regard to thread safety. If they access shared objects, then such access will usually need to be controlled by synchronisation; this might be on the object being accessed, some higher-level object or a special object allocated purely as a lock. The only way that you might think of them as special is that there's no instance of the Class on which you can synchronise.
You can declare a static method as synchronised. If you do, it will be synchronised on the single Class object of the class in which it is declared. This means that only one thread can be executing any part of the method at any one time. However, I understand that the Java Runtime itself sometimes synchronises on this Class object for its own reasons, therefore you might sometimes find a synchronised static method blocks when no other thread is executing it. Usually better, therefore, to explicitly synchronise on some object or other, than to use synchronised static methods.

Question on thread safety with Sevlet action method

I have an application that runs well but seems to have trouble with multiple users and I suspect that there is some thread safety issue involved.
It is a Struts application and I have all of my execute methods of the Acton classes are all synchronized which I thought would take care of any cross user issues but it does not seem to have done that.
The Action classes do have some instance variables which may be the problem as well as possibly a few utility string classes with static methods that are not synchornized. I keep some db connection cached in the session object but this should not be shared between users.
My question is, with the execute method synchronized how or where could I be getting crosstalk between users (each with their own sessions)?
I was thinking of packaging my Action class as seperate object with the actual Action class just allocate what I need (messages and locale) and pass them through a freshly instantiated "old action class". That should solve any instance variable cross talk.
I am assuming that any local variables in the execute method would not have any exposure as they should be thread specific and allocated on the runtime stack for that thread call.
Am I missing anything important?
Thanks in advance
---John Putnam

     * Creates a new instance of a {@link javax.xml.parsers.DocumentBuilder}
     * using the currently configured parameters.
    public DocumentBuilder newDocumentBuilder()
        throws ParserConfigurationException
        /** Check that if a Schema has been specified that neither of the schema properties have been set. */
        if (grammar != null && attributes != null) {
            if (attributes.containsKey(JAXPConstants.JAXP_SCHEMA_LANGUAGE)) {
                throw new ParserConfigurationException(
                        SAXMessageFormatter.formatMessage(null,
                        "schema-already-specified", new Object[] {JAXPConstants.JAXP_SCHEMA_LANGUAGE}));
            else if (attributes.containsKey(JAXPConstants.JAXP_SCHEMA_SOURCE)) {
                throw new ParserConfigurationException(
                        SAXMessageFormatter.formatMessage(null,
                        "schema-already-specified", new Object[] {JAXPConstants.JAXP_SCHEMA_SOURCE}));
        try {
            return new DocumentBuilderImpl(this, attributes, features, fSecureProcess);
        } catch (SAXException se) {
            // Handles both SAXNotSupportedException, SAXNotRecognizedException
            throw new ParserConfigurationException(se.getMessage());
    }It appears to be thread-safe. The 'attributes' and 'features' instances variables are hashtables, which are synchronized. Unless you are modifying DocumentBuilderFactory itself in another thread (say, changing whether it is namespace aware), I do not see any issues with a simple call to newDocumentBuilder().
- Saish

Threading with static methods

If I have a multithreading capabilities in my program, then I invoke a static method that writes timestamp to a file. What will happen? will all threads use this same static method? or will the program crash?

static or otherwise isn't the issue. The issue is that it's not a good idea to have two threads trying to write to the same file at the same time.
To prevent this you need to have each thread reserve the file until it's done it's thing. If you put the synchronized keyword on the method declaration you lock any all synchronized statis methods in the class, which is probably not idea. Probably better to use some comon object as the montor e.g.
static File timeStamp = new File("timestamp.txt");
public static void setTimeStamp() throws IOException {
     synchronized(timeStamp) {
          Writer out = new FileWriter(timeStamp);
          out.close();
     }

Static method,new thread performance question

Hey guys i just have two questions about two methods used in many controllers/servlets in my app:
1-what is the difference between calling a static method in a util class or a non static method (like methods dealing with dates i.e getting current time,converting between timezones), which is better ? 2-what is the difference between calling a method(contain too many logic like sending emails) in the controller directly or running this method in a different thread ?

cs.student wrote:
Hey guys i just have two questions about two methods used in many controllers/servlets in my app:
1-what is the difference between calling a static method in a util class or a non static method (like methods dealing with dates i.e getting current time,converting between timezones), which is better ?Depends on the design. It's impossible to say straight why one way would be better than another. Programming isn't that straight forward.
2-what is the difference between calling a method(contain too many logic like sending emails) in the controller directly or running this method in a different thread ?Threads can be run at the same time. So what you're asking is "what's the difference between doing one thing after another and doing two things at the same time".

Instance methods faster than sync. static methods in threaded env?

consider the following please:
(-) i have "lots" of instances of a single Runnable class running concurrently..
(-) each instance uses a common method: "exponential smoothing" and they do a lot of smoothing.
so:
(option #1): include a "smooth()" instance method in the Runnable class.
(option #2): include a "smooth()" synchronized static method in the Runnable class.
(option #3): create a MathUtility class, and have "smooth()" as an instance method in this class.
(option #4): make "smooth()" a synchronized static method in the MathUtility class.
from OOP point of view, i think i should externalize "smooth()" to a MathUtility class, and then make
is "synchronized static".
but then from a performance point of view....
would not it be optimal to make "smooth()" an instance method in MathUtility and then have each
instance of the Runnable create its own MathUtility instance so that each thread has its own copy
of the "smooth()" method??
well, i can't image there would be a measurable difference so maybe i should not post.
but, if there is a flaw in my thinking, please let me know.
thanks.

kogose wrote:
from OOP point of view, i think i should externalize "smooth()" to a MathUtility class, and then make
is "synchronized static".From an OOP point of view you should probably have a class that represents the data that provides a (non-static) smooth() method that either modifies the data or returns a new smoothed data object (depending on whether you want your data objects to be immutable or not).
but then from a performance point of view....
would not it be optimal to make "smooth()" an instance method in MathUtility and then have each
instance of the Runnable create its own MathUtility instance so that each thread has its own copy
of the "smooth()" method??No, methods are not "copied" for each instance. That just doesn't happen.
well, i can't image there would be a measurable difference so maybe i should not post.If you don't know, then you should probably try it.
but, if there is a flaw in my thinking, please let me know.The flaw in your thinking is that you can think that you can intuitively grasp the difference in performance of a change at that level.
I have yet to meet anyone who can reliably do that.
Performance optimization is not an intuitive task at that level and you should never do performance optimizations without proving that they are improvements for your particular use case.
First part: Is the smooth() method really thread-unsafe? Does it use some shared state? My guess would be that it uses only local state and therefore doesn't need any synchronization at all. That would also be the fastest alternative, most likely.

Static methods in multi-threaded environment

Hi,
I am wondering what happens when several threads try to access the same static method ?
The static method is not synchronized.
Will this create any performance issues ?
The actual scenario is of a J2EE server, where several Session Bean instances try to access a static method in a utility class. Will some session beans have to wait till others are being serviced ?
thnx n regards
s giri

thanx for replying.
yes. the operations are thread-safe. we do not change the state of any object.
but we make an rmi call to another application thru this static method.
is it ok?
Currently, my session bean has too many private methods - each calling the other application. Due to some quality metrics (a class must be restricted to 700 lines) we have to consider moving these private methods into some Helper class in the form of "public static methods". We have made many utility methods as static, but have some reservations abt doing a similar thing for these methods that call other application.
regards
Shivraman

Static methods in multi-thread environment.

Sorry for this silly question, but I have no clue...
If you're using classes with static methods in a application server environment, would that imply all threads use that same 'one in the jvm' method and would there be a possibility for performance loss?
Is calling another static method from a static method a good idea in a multi-thread environment, with respect to performance? Somehow I seem to get this java.lang.NoClassDefFoundError. Any ideas? The classes are in the same package. I only get these kind of problems calling static methods from static methods in a multi-thread environmnent. The static methods are pure utility functions and of course do not use class state.
Thanks for your help.

Sorry for this question, wasn't thinking straight. I have the answer, won't post question on multiple forums.

Static method and threads?

I have a question regarding "static". for example, I have the following code
class Test{
public int i=0;
public static calculateInt(){
....some operations on i;
if two processes attempt to call Test.calculateInt() at the same time. What will the effects be? shall these two calls be implemented totally independent? each call holds it own "i" for calculation. OR there will be operation conflicit on i.
what if I change "public i" to :private i", the same effects?

You can't operate on i in a static method, since i is an instance variable.
If you make i static, then you can operate on it in a static method. In that case, all threads will share a single i--there's only one i for the whole class, and threads don't change that. Making it private won't change that.
If you make the method into an instance (non-static) method, then any threads operating on the same instance will share the same i, regardless of whether it's public or private. Different threads operating on different instances will each have their own i.
Java's Thread Tutorial
JavaWorld: Introduction to Java threads
IBM: Introduction to Java threads
Google: java+threads+tutorial
Also check out http://java.sun.com/j2se/1.4.2/docs/api/java/lang/ThreadLocal.html

How to find the arguments of a static method from the class file

Hi,all !
How to find the arguments of a static method from the class file? for example, when we meet a bytecode "invokestatic", how can I know the arguments of this static method?

Hi,all !
How to find the arguments of a static method from the
class file? for example, when we meet a bytecode
"invokestatic", how can I know the arguments of this
static method?You mean
1. The values?
2. Argument names?
3. Argument signatures.
I would suppose for the last that the easiest way would be to parse the signature string.
The first is not possible - not from the class file.
The second is only in the debug information stored in the optional part of the class file. And figuring out the format for that is going to be a problem.

MessageFormat.format - Thread safety - vital question

Hello Forum
This question is especially on the function *"public static String format(String pattern, Object... arguments)"* in Message format class. No information is given in Javadoc for this function regarding thread safety. However a generic message for the entire class is given in the javadoc stating that the - *"Message formats are not synchronized. It is recommended to create separate format instances for each thread. If multiple threads access a format concurrently, it must be synchronized externally."*
It is for this reason I believe the code scanning tools like Fortify catch this function as having lack of thread safety for web applications.
However, if you look at the decompiled source of the function - no shared object is being accessed. The decompiled source of this function is below -
+public static String format(String pattern, Object ... arguments) {+
MessageFormat temp = new MessageFormat(pattern);
return temp.format(arguments);
+}+
Here no shared object is being accessed, a new object is created within the static method and the same is used for formatting. This decompiled version indicates that this method is actually thread safe (since no shared object is present and each method stack in each thread will have its own copy of MessageFormat. No sharing happens).
Could you tell us if this is the case in the current scenario. This particular format method is actually thread safe when compared to other format methods.
regards
Phani Lanka

user10855645 wrote:
Hello Forum
This question is especially on the function *"public static String format(String pattern, Object... arguments)"* in Message format class. No information is given in Javadoc for this function regarding thread safety. However a generic message for the entire class is given in the javadoc stating that the - *"Message formats are not synchronized. It is recommended to create separate format instances for each thread. If multiple threads access a format concurrently, it must be synchronized externally."*Doesn't sound like much of a question. They're not threadsafe, so use separate instances for separate threads, or use appropriate synchronization. Open and shut.
However, if you look at the decompiled source of the function......you're doing it wrong. The implementation is the wrong place to look, and you can't rely on that. Go by the documentation, not by the implementation.
And you're confused as well. The docs for that method say: "Creates a MessageFormat..." So you have your answer right there.
Here no shared object is being accessed, a new object is created within the static method and the same is used for formatting. This decompiled version indicates that this method is actually thread safeWrong. The documentation indicates that it's threadsafe. The deompiled code only tell you what that particular implementation is doing.
I'm not sure what you're concerned or confused about in the first place. The docs for the class say "use a separate instance for each thread," and the docs for that method say, "creates a new instance." So where's the confusion?

Urgent question about Thread-safety

Hi all,
the new tiger release provides an "isReachable()" method for the "InetAddress" object.
I've found, this method is not thread-safe (see the source and output below).
It returns true for all threads, when multiple threads using this method with different adresses are running at a time and one of the addresses is reachable. This happens only on WinXp. Running on Linux, the output is like expected.
I've tried to report this as a bug. But the gurus answered, taking care of thread safety would be a "programmers task".
My question is, what can I do, to be thread-safe in my case?
W.U.
import java.util.*;
import java.net.*;
public class IsReachableTest_1 extends Thread{
    static volatile int inst=1;
    static final String NET_ADDR="192.168.111.";
    int instance=inst++;
    public void run(){
        for(int i=19;i<23;i++){
            try{
                long start=System.nanoTime();
                if(InetAddress.getByName(NET_ADDR+i).isReachable(1000))
                    System.out.println(""+instance+"--host found at:"+NET_ADDR+i+"--time:"+(System.nanoTime()-start)/1000000);
                else
                    System.out.println(""+instance+"--no host at:"+NET_ADDR+i);
            }catch(Exception e){System.out.println(""+instance+"--ERROR "+e.toString());}
        System.out.println(""+instance+"--done.");
    public static void main(String[] args) {
        System.out.println(
            System.getProperty("java.vendor")+" "+
            System.getProperty("java.version")+" running on "+
            System.getProperty("os.name")+" "+
            System.getProperty("os.version"));
        Vector v=new Vector();
        System.out.println("\nTest 1: One after another:");
        for(int i=0;i<10;i++){
            IsReachableTest_1 t;
            t=new IsReachableTest_1();
            t.start();
            try{
                t.join();
            }catch(Exception e){System.out.println("MAIN1: "+e.toString());}
        System.out.println("\nTest 2: All together:");
        inst=1;
        for(int i=0;i<10;i++){
            IsReachableTest_1 t;
            t=new IsReachableTest_1();
            t.start();
            v.addElement(t);
        for(Iterator i=v.iterator();i.hasNext();)
            try{
                ((IsReachableTest_1)i.next()).join();
            }catch(Exception e){System.out.println("MAIN2: "+e.toString());}
            System.out.println("\nALL DONE");
And here is the output, when running on WinXp:
Sun Microsystems Inc. 1.5.0-beta running on Windows XP 5.1
Test 1: One after another:
1--no host at:192.168.111.19
1--no host at:192.168.111.20
1--host found at:192.168.111.21--time:2
1--no host at:192.168.111.22
1--done.
2--no host at:192.168.111.19
2--no host at:192.168.111.20
2--host found at:192.168.111.21--time:4
2--no host at:192.168.111.22
2--done.
3--no host at:192.168.111.19
3--no host at:192.168.111.20
3--host found at:192.168.111.21--time:1
3--no host at:192.168.111.22
3--done.
4--no host at:192.168.111.19
4--no host at:192.168.111.20
4--host found at:192.168.111.21--time:1
4--no host at:192.168.111.22
4--done.
5--no host at:192.168.111.19
5--no host at:192.168.111.20
5--host found at:192.168.111.21--time:3
5--no host at:192.168.111.22
5--done.
6--no host at:192.168.111.19
6--no host at:192.168.111.20
6--host found at:192.168.111.21--time:1
6--no host at:192.168.111.22
6--done.
7--no host at:192.168.111.19
7--no host at:192.168.111.20
7--host found at:192.168.111.21--time:1
7--no host at:192.168.111.22
7--done.
8--no host at:192.168.111.19
8--no host at:192.168.111.20
8--host found at:192.168.111.21--time:1
8--no host at:192.168.111.22
8--done.
9--no host at:192.168.111.19
9--no host at:192.168.111.20
9--host found at:192.168.111.21--time:1
9--no host at:192.168.111.22
9--done.
10--no host at:192.168.111.19
10--no host at:192.168.111.20
10--host found at:192.168.111.21--time:1
10--no host at:192.168.111.22
10--done.
Test 2: All together:
1--no host at:192.168.111.19
2--no host at:192.168.111.19
3--no host at:192.168.111.19
4--no host at:192.168.111.19
5--no host at:192.168.111.19
6--no host at:192.168.111.19
7--no host at:192.168.111.19
8--no host at:192.168.111.19
9--no host at:192.168.111.19
10--no host at:192.168.111.19
2--no host at:192.168.111.20
3--no host at:192.168.111.20
6--host found at:192.168.111.20--time:924 <----- this host does not exist!!
5--host found at:192.168.111.20--time:961 <----- this host does not exist!!
10--host found at:192.168.111.20--time:778 <----- this host does not exist!!
9--host found at:192.168.111.20--time:815 <----- this host does not exist!!
2--host found at:192.168.111.21--time:37
7--host found at:192.168.111.20--time:888 <----- this host does not exist!!
8--host found at:192.168.111.20--time:852 <----- this host does not exist!!
4--host found at:192.168.111.20--time:997 <----- this host does not exist!!
1--host found at:192.168.111.20--time:1107 <----- this host does not exist!!
3--host found at:192.168.111.21--time:38
6--host found at:192.168.111.21--time:1
5--host found at:192.168.111.21--time:1
10--host found at:192.168.111.21--time:2
2--host found at:192.168.111.22--time:3 <----- this host does not exist!!
9--host found at:192.168.111.21--time:2
7--host found at:192.168.111.21--time:1
4--host found at:192.168.111.21--time:3
1--host found at:192.168.111.21--time:39
2--done.
1--host found at:192.168.111.22--time:5 <----- this host does not exist!!
1--done.
10--host found at:192.168.111.22--time:40 <----- this host does not exist!!
3--host found at:192.168.111.22--time:192 <----- this host does not exist!!
6--host found at:192.168.111.22--time:75 <----- this host does not exist!!
8--host found at:192.168.111.21--time:230
5--host found at:192.168.111.22--time:155 <----- this host does not exist!!
4--host found at:192.168.111.22--time:78 <----- this host does not exist!!
9--host found at:192.168.111.22--time:77 <----- this host does not exist!!
7--host found at:192.168.111.22--time:76 <----- this host does not exist!!
10--done.
6--done.
4--done.
5--done.
3--done.
7--done.
9--done.
8--no host at:192.168.111.22
8--done.
ALL DONE

I created this test (it's basically the same as your class):
import java.util.*;
import java.net.*;
public class IsReachableTest_2 implements Runnable {
    private final String[] addresses = new String[] {
         "www.sun.com",
         "129.42.16.99" // www.ibm.com which is not reachable
    public void run(){
        try {
            for (int i = 0; i < addresses.length; i++) {
                final long start = System.nanoTime();
                final String address = addresses;
     if (InetAddress.getByName(address).isReachable(5000)) {
     System.out.println(Thread.currentThread().getName() + ": Host found at: " + address +
          " --time: " + (System.nanoTime() - start) / 1000);
     } else System.out.println("no host at: " + address);
} catch(Exception e){
e.printStackTrace();
System.out.println("Thread " + Thread.currentThread().getName() + " DONE");
public static void main(String[] args) {
System.out.println(
     System.getProperty("java.vendor") +
     " " +
     System.getProperty("java.version") +
     " running on " +
     System.getProperty("os.name") +
     " " +
     System.getProperty("os.version")
for (int i = 0; i < 10; i++) {
     final Thread t = new Thread(new IsReachableTest_2(), "THREAD " + (i+1));
     t.start();
And I get:
Sun Microsystems Inc. 1.5.0-beta running on Windows 2000 5.0
THREAD 1: Host found at: www.sun.com --time: 217653
THREAD 3: Host found at: www.sun.com --time: 214404
THREAD 6: Host found at: www.sun.com --time: 214900
THREAD 4: Host found at: www.sun.com --time: 215901
THREAD 5: Host found at: www.sun.com --time: 216666
THREAD 10: Host found at: www.sun.com --time: 216620
THREAD 9: Host found at: www.sun.com --time: 217405
THREAD 2: Host found at: www.sun.com --time: 220705
THREAD 7: Host found at: www.sun.com --time: 220845
THREAD 8: Host found at: www.sun.com --time: 221384
no host at: 129.42.16.99
Thread THREAD 4 DONE
no host at: 129.42.16.99
Thread THREAD 6 DONE
no host at: 129.42.16.99
no host at: 129.42.16.99
no host at: 129.42.16.99
no host at: 129.42.16.99
no host at: 129.42.16.99
no host at: 129.42.16.99
no host at: 129.42.16.99
no host at: 129.42.16.99
Thread THREAD 5 DONE
Thread THREAD 10 DONE
Thread THREAD 9 DONE
Thread THREAD 7 DONE
Thread THREAD 3 DONE
Thread THREAD 1 DONE
Thread THREAD 2 DONE
Thread THREAD 8 DONE
HOWEVER: I was getting some strange results every so often. Results like:
Sun Microsystems Inc. 1.5.0-beta running on Windows 2000 5.0
THREAD 3: Host found at: www.sun.com --time: 261132
THREAD 9: Host found at: www.sun.com --time: 264183
THREAD 2: Host found at: www.sun.com --time: 266447
THREAD 6: Host found at: www.sun.com --time: 266596
THREAD 8: Host found at: www.sun.com --time: 267192
THREAD 5: Host found at: www.sun.com --time: 268610
THREAD 4: Host found at: www.sun.com --time: 269849
THREAD 1: Host found at: www.sun.com --time: 280978
THREAD 7: Host found at: www.sun.com --time: 272589
THREAD 10: Host found at: www.sun.com --time: 273162
THREAD 3: Host found at: 129.42.16.99 --time: 13657
Thread THREAD 3 DONE
THREAD 4: Host found at: 129.42.16.99 --time: 4123
THREAD 2: Host found at: 129.42.16.99 --time: 9439
THREAD 5: Host found at: 129.42.16.99 --time: 6681
THREAD 8: Host found at: 129.42.16.99 --time: 7655
THREAD 6: Host found at: 129.42.16.99 --time: 8627
THREAD 9: Host found at: 129.42.16.99 --time: 10586
Thread THREAD 4 DONE
Thread THREAD 2 DONE
Thread THREAD 5 DONE
Thread THREAD 8 DONE
Thread THREAD 6 DONE
Thread THREAD 9 DONE
no host at: 129.42.16.99
Thread THREAD 7 DONE
no host at: 129.42.16.99
no host at: 129.42.16.99
Thread THREAD 10 DONE
Thread THREAD 1 DONE
Usually the first run after I had compiled the class (!?) This isn't a thread safety problem.

Reflection objects and thread safety

Hi,
I believe that I saw that Field and Method objects are thread-safe (i.e., can safely have methods called against a single object instance concurrently from multiple threads), but am having trouble finding such a description in the JDK javadocs static that fact.
I'm assuming that all thread-specific 'state' would be managed by the Object target passed to methods like invoke()/get()/set() and not on the actual Field and Method objects themselves. Ideally, i'd like to only have to look up fields and methods only once reflectively, and thereafter just use the same reflection object instances to access their target objects at runtime as a performance optimizations - possibly in different threads and at the same time - without having to pay the cost of looking it up again. I should be able to do that providing Method.invoke() is thread safe. Otherwise, i'd probably be forced to call Class.getMethod() to get a new Method object to use against each object instance, which would be more costly both from a memory standpoint (more Method objects) and a lookup-cost perspective.
Given that lots of existing performance-critical enterprise infrastructure code, such as OR database APIs, IoC frameworks and J2EE containers use reflection to decouple the generic code from any app specific code (from a compile time perspective) as an alternative to code generation, it's surprising that there's no obvious statement about thread safety in these classes. If I look at the source code for Method, it appears to be thread safe, but I can only get so far with this analysis, as the critical code in Method appears to be implemented using a class named 'sun.reflect.MethodAccessor', whose source I don't have access to.
I know it's possible to invoke a method against multiple objects by calling Method.invoke() against each of the target objects in question. However, there's no mention as to whether it's safe to use a single Method object instance to invoke a method against multiple target object instances at the same time (i.e., from different threads running in parallel). This would fail, for instance, if the Method object had data members that were used to communicate information between internal calls without any synchronization, as the values might be used by one thread while another was changing them.
Just to clarify (as i've seen some confusion in other forum discussions on this topic):
I completely understand that the thread safety of a target object's method (read, small 'm') is entirely dependent upon it's implementation and not the mechanism by which it's invoked - i.e., whether a method is invoked by an explicit compiled-in call against an instance of the target object in some Java source file, or indirectly via Method object-based reflection, is immaterial the the method's thread safety.
What i'm asking about is the thread safety of the Method.invoke() call itself (read, big 'M'). Same question wrt Field.get()/.set() as well. These calls should be thread-safe if they're stateless wrt the Method and Field object instances that they are invoked against.

In general, if a Java API is silent about multi-threading, it is intended to be thread-safe. See the javadoc for HashMap for an example of an explicit warning.
It is true that Java code can have bugs that show up only on unusual implementations of the Java memory model, such as relaxed memory model machines. Most (if not all) implementations of the JDK have been deployed principally on platforms with strong memory models. (Perhaps not coincidentally, those are also the machines that have market share.) There are even bugs found occasionally in the JDK core, so draw your own conclusions about the bug-tail of our software stack on systems with relaxed memory models!
One of the more likely bugs to run into on highly optimized systems is failure of timely initialization of non-final fields in objects which are shared in an unsynchronized manner. See http://www.cs.umd.edu/~pugh/java/memoryModel/jsr-133-faq.html#finalRight and related pages. JDK core programmers (at Sun, to my personal knowledge) take care not to write code with such bugs, but application programmers might.
And, yes, caching your own Method objects is a good idea, if only because their lookup is generally cumbersome and slow. If you are very performance sensitive, you'll end up generating bytecode "shim" between your callers and the desired target methods. I expect that the http://openjdk.java.net/projects/mlvm/ (an openjdk project we are just starting) will provide some relief for this; stay tuned.
Finally, since Method objects have no state to speak of (except their "accessible" bit, which is an ahead-of-time configuration), it would be really, really surprising if they could create a race condition of some sort. If you expect race conditions in formally stateless data structures, you are certifiably paranoid. (A normal state on some platforms, hopefully not on Java.)
For more information about method calls, including reflective methods, see my blog post: http://blogs.sun.com/jrose/entry/anatomy_of_a_call_site
Best wishes...

Thread Safety : Marking arguments of static method as final

Similar Messages

Maybe you are looking for