Synchronized static method -is there a problem?

Hi.
I'm facing a problem. I have a common java class that is used by many applications. Class is in a jar file and is in server's shared library. And every applications in the server used it.
Methods are declared static but not synchronized static. Class itself is not static. I have found that sometimes right after server is restarted and applications are using this class, method return values are mixed up or method behaviour is strange. I havent able to repeat this problem when testing with just one application.
Is the problem static method and when using under one classloader (in shared lib) probelm occurs? So if i declare it static synchronized, does that solve my problem?

Ok. But is it still risk to use static classes or
static methods/fields in class that are shared with
multiple applications ie. in servers shared library?That's a big fat YES.
I suspect that you might benefit from investing a couple of hours in the "concurrency" tutorial
http://java.sun.com/docs/books/tutorial/essential/concurrency/

Similar Messages

Synchronized static method???

Hi!
What does it means "synchronized static" method? What object in this case has a lock monitor?
class MyClass {
public synchronized static someMethod() {
}Is it the equivalent to:
synchronized ( MyClass.class ) {
Anton

The JVM creates a Class object when the class is loaded (When it is used for the first time) the
JVM creates one instance of Class for each class that is loaded, thus a class itself has a moniter
which a thread can gain ownership of.

Static methods in Session Beans problem

Can a Stateful Session Bean have a static method?
public static String foo();
I tried to add a static method to a Stateful Session bean but had two problems:
When I tried to add the static modifier to the Remote interface:
static String foo();
I got the following error message:
Error(12,17): modifier static not allowed here
When I tried to compile code calling this function :
MyClass.foo();
I got this message:
Error(795,42): non-static method getNewSuffix(java.lang.String) cannot be referenced from a static context
Even though a static method was compiled in this class. I assume it can't find the static modifier in the Remote interface which wasn't allowed. Are static methods allowed in EJB's at all?

dear friend,
1) Interfaces may not contain static functions!
2) EJBs doesnt support static methods !
Maybe you should go and learn more about Java and EJB's ?

Synchronized Static & Non Satatic methods

Is synchronized static method acquire lock ? I have wriietn a code in which i synchronized a static & non static(instance) method. but statc method call is not acquiring a lock.
If its not posible then there is a chance of corruption of static data.
plz inform me
my code is given below
public class TestThread{
     private static int i=0;
     public synchronized static void m1(){
          System.out.println("1 Static M1 \t");
          i++;
          try{Thread.sleep(10000);}
          catch(Exception e){e.printStackTrace();}
          System.out.println("2 Static M1 \t");
     public synchronized void m2(){
          System.out.println("1 Static M2 \t");
          i++;
          try{Thread.sleep(10000);}
          catch(Exception e){e.printStackTrace();}
          System.out.println("2 Static M2 \t");
     public static void main(String[] args){
          new Thread(){
               public void run(){
                    TestThread.m1();
          }.start();
     try{Thread.sleep(100);}
     catch(Exception e){e.printStackTrace();}
          new Thread(){
               public void run(){
                    new TestThread().m2();
          }.start();

Your example has two methods, both of which modify a static integer of the same class.
Both of your methods are synchronized - but - one is static and one isn't. A synchronized static method aquires the 'lock' of the class, where as a non-static method aquires the 'lock' of the object.
For this reason, your two method calls are locking on different objects and so they may be invoked by different threads executing at the 'same time'.
Just to clarify, you can see this:
class Test {
private static int i = 0;
public static synchronized modifyStatic() {
    ++i;
public synchronized modify() {
    ++i;
}As being this:
class Test {
private static int i = 0;
public static modifyStatic() {
    synchronized(Test.class) {
        ++i;
public modify() {
    synchronized(this) {
      ++i;
}So, as you can see from above, the two locks aquired are not the same.
Dave

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.

Single object referenced by static method

Hi,
I have a class, that I know in advance will only be instantiated ONE time. My problem is that I wish to address this object from elsewhere in the programme. I'm using:
class Client{
private static Client me = new Client();
public static Client getMe(){
return me;
....lots of non-static methods
Is there a better way of doing this (of course there is, but what??)

Wouldn't have a clue what GoF is, but yes, what you are describing is an honest-to-god, taught to students, pattern.
It is the accepted way of doing this, you aren't being dodgy (at least not yet).
Good luck,
Radish21

When a static method is accessed concurrently

When a static method is accessed by many objects symultaneously(concurrently),
What is happened in the static method.
Are the stacks for that method maded seperately and
each stack doesn't influence other stacks?
thank you in advance.

The static objects or methods concept is clear, one
instance for all objects.No. One instance for the class.
, and every
one know that, static methods is slower than
nonstatic, Since when? I've certainly never heard that before... Do you have a reference I can look at?
and this is as i thought because static
methods are syncronized by default.Absoloutely not!
All synchronization locks on an object. When you synchronize an instance method, it locks on the implicit "this"; When you synchronize a static method, it locks on the class's associated Class object.
So two synchronized static methods in the same class can not be called at the same time, but synchronized instance methods that access static variables can all access those variables at the same time and potentially cause threading problems. In this situation you can declare the static fields volatile or wrap synchronized blocks around all code that accesses them, and synchronize on the same object (perhaps the Class object associated with the current class would be appropriate, but that reallt depends on the rest of your design).

Static method vs synchronisation

Hi,
A fundamental query.
If i am declaring a method as static, can i also declare it as sunchronized? i.e. can i have something like
public static synchronized sss(){
xxx
If a method is static, there is only one instance in the memory. Correspondingly, only one client can execute it at a time. in which case it is automatically synchronized.
Pl correct my reasoning.
When do we have the requirement of having a static method, or probably a singleton??
Thanks,
Prashant Gupta

Hi,
A fundamental query.
If i am declaring a method as static, can i also declare it as sunchronized? i.e. can
i have something like
public static synchronized sss(){
xxx
}?Yes, static methods can be synchronized which means that when any thread is running within a synchronized static method of class C, no other thread may enter a static synchronized method of that class. In other words, the monitor acquired by a static synchronized method is the Class itself while the monitor acquired by a non-static synchronized method is the object refered to by 'this'.
If a method is static, there is only one instance in the memory. Correspondingly,
only one client can execute it at a time. in which case it is automatically synchronized.There is (in most circumstances) a single copy of the definition (bytecodes representing all methods - static or not - and static fields) of of a class. However, any number of threads may be executing within any section of code unles that code is guarded by a synchronized block or within a synchronized method. In that case, no two threads can enter (well, actually be runnable within - Object.wait() has special implications) a synchronized block monitored by the same object.
When do we have the requirement of having a static method, or
probably a singleton??Not sure what you are asking here. You define static methods when there is behavior you want to implement that does not need to have access to instance (non-static) fields or methods and which would never need to be overridden (for purposes of polymorphism) by derived classes.
Wen needing a singleton, you have a choice of defining a "true singleton" (i.e. a class with a private constructor, some sort of static getInstance() method, with the bulk of its methods anf fields are non-static) or defining a class whose methods are all static and whose fields are also all static. Singletons. Use the one that fits you needs the best.
Chuck

Static methods, what for?

What are static methods for? is there something that is not possible through methods associated with instances (non-static methods) ?

There are many examples of static mehods in the Java API. For example the Math or the System class. All methods in this classes are static. So you dont have to instantiate the system class. In fact it is even not possible to instantiate the System class. System is final and all Constructors are private.
Another use for static methods is the access to private static variables.

Question about synchronized static function.

Hi, everyone!
The synchronized statement often deals with an object (called monitor).
But a static function can be invoked without an object.
So if a static function is declared as static, what is the function of
static and synchronized here? Which lock it is using?
Can you give me a simple expplanation?
regards,
George

Hence try and avoid synchronizing static methods.
Try and use non static method if you are doing
multithreaded programming. That way you can have lockWell, I avoid static methods, not just when doing multithreading, but not for the reason you mention.
objects which allow non interfering methods to be
accessed in parallelThats easy to do with static methods anyway:
class Foo
static Object lock1 = new Object();
static Object lock2 = new Object();
static void method1()
synchronized( lock1 )
static void method2()
synchronized( lock2 )
}Maybe I just missunderstod you...

Interesting Qtion: Synchronize a static method

I know that a non-static method and a block can be synchronized.
Can anyone tell me as to what it means to synchronize a static method of a class and how/when is it used. I just tried compiling the code and it gives no compiler/syntactical errors.
it would be helpful if u could take up a simple class example.
Thanks,
Novice

Hi,
A good example for using synchronized static methods is the singleton pattern. E.g.
public class Singleton
private Singleton() {}
private static Singleton fgUniqueInstance;
public static synchronized Singleton getInstance()
    if (fgUniqueInstance==null) {
      fgUniqueInstance = new Singleton();
    return fgUniqueInstance;
}If you won't synchronize this class in a multi-threading environment, it could happen, that more than one instance is created.
Andre

Synchronized and static methods

I've got a doubt: is it possible to apply syncrhonized to a static method? I know that synchronized takes a lock on the current object, but in the case of a static method there could be no object.
So how can I synchronize a static method?
Thanks,
Luca

previous X POST(s) :
http://forum.java.sun.com/thread.jsp?forum=31&thread=411296
http://forum.java.sun.com/thread.jsp?forum=31&thread=411285
http://forum.java.sun.com/thread.jsp?forum=31&thread=390499
http://forum.java.sun.com/thread.jsp?forum=31&thread=374388
http://forum.java.sun.com/thread.jsp?forum=31&thread=325358
BOTTOM LINE : Search the forum b4 posting.
rgds.

Problem with calling dispose() from static method

I have one class, where I have this:
EditorWindow.disposeWindow();and class EditorWindow, where I have static method
protected static void disposeWindow() {
dispose();
}But, dispose() cant be called from static method. Is there any way to hide or close the EditorWindow window?

kaneeec wrote:
I dont have references of these windows, because it would be too difficult. They are created just by new Window().setVisible(true);It's not difficult:
Window w = new Window();
w.setVisible(true);Now you have a reference (w) to your window that you can later call dispose() on.
w.dispose();dispose() isn't a static method, so you have no choice but to call it on a specific instance.

Why there should not be many static methods.

Why a java class should not have many static methods.How is memory managed in case of static methods.
If a Utility class has static methods then we can use methods directly by class name but if we do not make the methods static then we can acess methods using object.How does it make the difference.I know that there remains a single copy of class variables/methods.But i want to know how class memory is managed and garbage collected.

shobhit123 wrote:
Why a java class should not have many static methods.How is memory managed in case of static methods.
If a Utility class has static methods then we can use methods directly by class name but if we do not make the methods static then we can acess methods using object.How does it make the difference.I know that there remains a single copy of class variables/methods.But i want to know how class memory is managed and garbage collected.The reason to discourage static methods is stylistic rather than technical. It encourages object oriented thinking.
Each loaded class is represented by a Class object, and associated with that it a block of memory for static fields. As with all such storage this block is, as viewed from code, rather like an array with one, or in the case of double or long values, two slots per field.
Because the class loader maintains a map from FQN to Class this storage is only released if the class loader that loaded it becomes unreachable, which happens only in situations like the un-deployment of a web application or EJB.
Local variables for static methods are allocated in a stack frame, just as with instance methods. There's really no significant difference there.

Synchronized on static methods

It's my understanding that the synchronized keyword attached to a method by default locks on this.
public synchronized void red () {
doStuff();
}is equivelant to:
public void red () {
synchronized (this) {
doStuff();
}But, what about synchronized on static methods? What is the synchronization object for static methods?
public synchronized static void blue () {
doStuff();
}is equivelant to what?

oh yeah! man! but you get what I mean, it syncs on theYes, we do, but the compiler doesnt...
Class object, I guess...Stop guessing...

Synchronized static method -is there a problem?

Similar Messages

Maybe you are looking for