What is "Thread Safe"?
I have heard a lot of folks talking about a class that is "Thread Safe".
I am assuming that this means the obect can be accessed by more than one thread at a time. I do not know what the concept really means in practice.
My question is, how can I tell if something is thread safe, what do I need to look out for?
Basically you're looking to avoid unwanted behavior by simultaneous access. Here are a couple examples I've seen:
Assuming myID is a class variable...
public void assignID(Client currentClient) {
myID = (some new random value)
currentClient.ID = myID;
In the above example, what happens if two threads access the method at the same time? The first one starts, assigning a value to the myID variable. Then the second one starts, assigning a value to myID AGAIN. Then when both clients assign their currentClients, they'll both end up with the same ID. To avoid a code block being accessed by two clients simultaneously, use the "synchronized" keyword.
Here's another one. Assume you have a Hashtable:
Enumerator myEnum = myHashtable.keys()
while (myEnum.hasMoreElements()) {
Object myKey = myEnum.nextElement();
myHashtable.remove(myKey);
This should not work in Java (and I know it doesn't in C# which I'm currrently being forced to use at work) because you're iterating through the keys of a Hashtable. But while you're trying to go linearly from key to key, you're also removing elements of the Hashtable. You're trying to operate on the object twice and the object doesn't allow it.
There are a couple ideas. I wrote a database pool once and had to synchronize methods so two clients didn't try to execute a query through the same Connection, etc.
Michael Bishop
Similar Messages
-
hello all,
please help me by answering these questions?
singleton patterns calls for creation of a single class that can be shared between classes. since one class has been created
Can singletons be used in a multithreaded environment? is singleton thread safe?
Are threading problems a consequence of the pattern or programming language?
thank you very much,
HiruHi,
Before explaining whether a singleton is thread safe
e i want to explaing what is thread safe here
When multiple threads execute a single instance of a
program and therefore share memory, multiple threads
could possibly be attempting to read and write to the
same place in memory.If we have a multithreaded
program, we will have multiple threads processing the
same instance.What happens when Thread-A examines
instance variable x? Notice how Thread-B has just
incremented instance variable x. The problem here is
Thread-A has written to the instance variable x and
is not expecting that value to change unless Thread-A
explicitly does so. Unfortunately Thread-B is
thinking the same thing regarding itself; the only
problem is they share the same variable.
First method to make a program threadsafe-: Avoidance
To ensure we have our own unique variable instance
for each thread, we simply move the declaration of
the variable from within the class to within the
method using it. We have now changed our variable
from an instance variable to a local variable. The
difference is that, for each call to the method, a
new variable is created; therefore, each thread has
its own variable. Before, when the variable was an
instance variable, the variable was shared for all
threads processing that class instance. The following
thread-safe code has a subtle, yet important,
difference.
second defense:Partial synchronization
Thread synchronization is an important technique to
know, but not one you want to throw at a solution
unless required. Anytime you synchronize blocks of
code, you introduce bottlenecks into your system.
When you synchronize a code block, you tell the JVM
that only one thread may be within this synchronized
block of code at a given moment. If we run a
multithreaded application and a thread runs into a
synchronized code block being executed by another
thread, the second thread must wait until the first
thread exits that block.
It is important to accurately identify which code
block truly needs to be synchronized and to
synchronize as little as possible. In our example, we
assume that making our instance variable a local
variable is not an option.
Third Defence:--Whole synchronization
Here u should implement an interface which make the
whole class a thread safe on or synchronized
Thre views are made by Phillip Bridgham, M.S., is a
technologist for Comtech Integrated Systems.I'm
inspired by this and posting the same hereWas there a point in all of that? The posted Singleton is thread-safe. Furthermore, some of that was misleading. A local variable is only duplicated if the method is synchronized, a premise I did not see established. Also, it is misleading to say that only one Thread can be in a synchronized block of code at any time because the same block may be using different monitors at runtime, in which case two threads could be in the same block of code at the same time.
private Object lock;
public void doSomething() {
lock = new Object();
synchronized(lock) {
// Do something.
}It is not guaranteed that only one Thread can enter that synchronized block because every Thread that calls doSomething() will end up synchronizing on another monitor.
This is a trivial example and obviously something no competent developer would do, but it illustrates that the statement assumes premises that I have not seen established. It would be more accurate to say that only one Thread can enter a synchronized block so long as it uses the same monitor.
It's also not noted in the discussion of local variables vs instance variables that what he says only applies to primitives. When it comes to actual Objects, just because the variable holding the reference is unique to each Thread does not make use of it thread-safe if it points to an Object to which references are held elsewhere. -
If I implement SingleThreadedModel in a servelt which are all thread safe?
Request object, response object, instance variables,class variables( by the by can i have class variables in a Servlet ? how/where it will be used?)If you use SingleThreadModel, everything will be thread safe, because you are spawning one instance of the servlet, for every request. This WILL NOT scale well if you have many users at once.
With regard to what is thread safe in a normal servlet, I believe
request
response
session
variables local to functions
NOT safe:-
class variables - these will be shared by multiple instances. -
What does it mean to be "thread safe"?
What does it mean to be "thread safe"?
I am working with a team on a project here at work. Someone here suggested that we build all of our screens during the initialization of the application to save time later. During the use of the application, the screens would then be made visible or invisible.
One of the objections to that idea was that the swing components (many of which we use) are not thread safe. Can anyone tell me what the relevance of that is?
ThanksTo understand why Swing is not thread safe you have to understand a little bit of history, and a little bit of how swing actually works. The history(short version) is that it is nearly impossible to make a GUI toolkit thread safe. X is thread safe(well, sorta) and it's a really big mess. So to keep things simple(and fast) Swing was developed with an event model. The swing components themselves are not thread safe, but if you always change them with an event on the event queue, you will never have a problem. Basically, there is a Thread always running with any GUI program. It's called the awt event handler. When ever an event happens, it goes on an event queue and the event handler picks them off one by one and tells the correct components about it. If you have code that you want to manipulate swing components, and you are not ON the awt thread(inside a listener trail) you must use this code.
SwingUtilities.invokeLater( new Runnable() {
public void run() {
// code to manipulate swing component here
});This method puts the defined runnable object on the event queue for the awt thread to deal with. This way changes to the components happen in order, in a thread safe way. -
Thread safe - what's that mean?
Hello,
I'm new to Java technology and I constantly read the Java forum as one way to learn from other's experience. What's that mean by "thread safe" as I often saw it in the forum and what's the difference between "thread" and "process"?
Thanks in advance.
wg97I'm new to Java technology and I constantly read the
Java forum as one way to learn from other's
experience. What's that mean by "thread safe" as I
often saw it in the forum and what's the difference
between "thread" and "process"?I'll answer the second question first. The difference between thread and process depends on context. Generally in Java programming threads are well defined and processes are more general. A thread is a set of executing instructions in the VM that can execute "concurrently" with other sets of executing instructions. An appliction always contains at least one thread often called the 'main' thread. The main thread can spawn other threads so an application can have multiple concurrent sets of executing instructions. Thread-safe methods are those that enforce rules about how objects can access them i.e. they make sure that two threads are not performing actions on a single object at the same time that can result in errors. This is done in Java using the synchronized keyword. -
What does, "swing is not thread safe." mean?
can anyone explain what that means in detail?
[Google can|http://letmegooglethatforyou.com/?q=swing+is+not+thread+safe+tutorial]
For better response, you may wish to ask a specific question that's answerable without having to write a book chapter. -
Swing isn't thread safe, what about AWT?
Since Swing isn't really thread safe what does that mean for AWT? Is AWT thread safe? Also if it is doesn't that mean one should use AWT over Swing since AWT is thread safe?
Trizi wrote:
jverd wrote:
Trizi wrote:
[http://forum.java.sun.com/thread.jspa?threadID=5282846&tstart=0|http://forum.java.sun.com/thread.jspa?threadID=5282846&tstart=0]
There ya go duffy the hom^oYou say that is if being gay were a bad thing. So, besides being an obnoxious fuckhead, you're also a homophobic troglodyte? Man your fiancee must be a real winner to have picked you. My guess is that she's either a sheep, a blow-up doll, or someone you've got bound and gagged in your basement.Now from what everyone is saying that I don't have anything original...
You don't either, too much "Silence of the Lambs" maybe?Dude, try speaking English.
By the way, I am sure if I was a troglodyte I would be in a museum, also I have homosexual friends, sorry not homophobic, I just found a good ting to his name and figured I'd exploit it.. Just like I'm exploiting your pathetic intelligence.You really need help if you think the above makes any sense or any point. -
Is Persistence context thread safe? nop
In my code, i have a servlet , 2 stateless session beans:
in the servlet, i use jndi to find a stateless bean (A) and invoke a method methodA in A:
(Stateless bean A):
@EJB
StatelessBeanB beanB;
methodA(obj) {
beanB.save(obj);
(Stateless bean B, where container inject a persistence context):
@PersistenceContext private EntityManager em;
save(obj) {
em.persist(obj);
it is said entity manager is not thread safe, so it should not be an instance variable. But in the code above, the variable "em" is an instance variable of stateless bean B, Does it make sense to put it there using pc annotation? is it then thread safe when it is injected (manager) by container?
since i think B is a stateless session bean, so each request will share the instance variable of B class which is not a thread safe way.
So , could you please give me any guide on this problem? make me clear.
any is appreciated. thank you
and what if i change stateless bean B to
(Stateless bean B, where container inject a persistence context):
@PersistenceUnit private EntityManagerFactory emf;
save(obj) {
em = emf.creatEntityManager()
//begin tran
em.persist(obj);
// commit tran
//close em
the problem is i have several stateless beans like B, if each one has a emf injected, is there any problem ?Hi Jacky,
An EntityManager object is not thread-safe. However, that's not a problem when accessing an EntityManager from EJB bean instance state. The EJB container guarantees that no more than one thread has access to a particular bean instance at any given time. In the case of stateless session beans, the container uses as many distinct bean instances as there are concurrent requests.
Storing an EntityManager object in servlet instance state would be a problem, since in the servlet programming model any number of concurrent threads share the same servlet instance.
--ken -
Thread-safe design pattern for encapsulating Collections?
Hi,
This must be a common problem, but I just can't get my head around it.
Bascially I'm reading in data from a process, and creating/updating data structuers from this data. I've got a whloe bunch of APTProperty objects (each with a name/value) stored in a sychronized HashMap encapsulated by a class called APTProperties. It has methods such as:
addProperty(APTProperty) // puts to hashmap
getProperty(String name) // retreives from hashmap
I also want clients to be able to iterate through all the APTProperties, in a thread safe manner . ie. they aren't responsible for sychronizing on the Map before getting the iterator. (See Collections.synchronizedMap() API docs).
Is there any way of doing this?
Or should I just have a method called
Iterator propertyIterator() which returns the corresponding iterator of the HashMap (but then I can't really make it thread safe).
I'd rather not make the internal HashMap visible to calling clients, if possible, 'cause I don't want people tinkering with it, if you know what I mean.
Hope this makes sense.
KeithIn that case, I think you need to provide your own locking mechanism.
public class APTProperties {
the add, get and remove methods call lock(), executes its own logic, then call unlock()
//your locking mechanism
private Thread owner; //dont need to be volatile due to synchronized access
public synchronized void lock() {
while(owner != null) {
wait();
th = Thread.currentThread();
public synzhronized void unlock() {
if(owner == currentThread()){
owner = null;
notifyAll();
}else {
throw new IllegalMonitorStateException("Thread: "+ Thread.currentThread() + "does not own the lock");
Now you dont gain a lot from this code, since a client has to use it as
objAPTProperties.lock();
Iterator ite = objAPTProperties.propertyIterator();
... do whatever needed
objAPTProperties.unlock();
But if you know how the iterator will be used, you can make the client unaware of the locking mechanism. Lets say, your clients will always go upto the end thru the iterator. In that case, you can use a decorator iterator to handle the locking
public class APTProperties {
public Iterator getThreadSafePropertyIterator() {
private class ThreadSafeIterator implements Iterator {
private iterator itr;
private boolean locked;
private boolean doneIterating;
public ThreadSafeIterator(Iterator itr){
this.itr = itr;
public boolean hasNext() {
return doneIterating ? false : itr.hasNext();
public Object next() {
lockAsNecessary();
Object obj = itr.next();
unlockAsNecessary();
return obj;
public void remove() {
lockAsNecessary();
itr.remove();
unlockAsNecessary();
private void lockAsNecessary() {
if(!locked) {
lock();
locked = true;
private void unlcokAsNecessary() {
if(!hasNext()) {
unlock();
doneIterating = true;
}//APTProperties ends
The code is right out of my head, so it may have some logic problem, but the basic idea should work. -
Thread-safe alternative to XmlValue
Hi,
I'm using bdb xml in an application which visualizes 3d data stored in xml. When I load the data, it will be written into the db and I#m using XPath as query language. This works quite good, but as I'm using multiple threads within my application, I can't use XmlValues for referencing into the database, because they are not thread-safe. But I need to store at least some of those references to get quick access to some data, or to run a new query, based on a result node from an earlier query, later from another thread. Those referenced nodes will change during runtime, so indices won't help. So what can I do or did I miss something?
Thanks
BjoernBjoern,
You may have to explain a bit more, especially the part about "referenced nodes will change during runtime." XmlValue objects that reference nodes are only guaranteed valid until the either (1) the XmlResults object containing them has been deleted or (2) the transaction in which they were retrieved ends. There are exceptions but those are the general rules.
The interfaces, XmlValue::getNodeHandle() and XmlContainer::getNode() exist to allow an application to store a string value that can be later resolved quickly back into an XmlValue. This works well unless the referenced node has been removed. It may be the answer you are looking for.
Regards,
George -
Hi,
I'm new to Java programming and I've read through the forums and the numerous technical documents Sun has provided on how to make a GUI thread-safe. With what I've been able to understand, I created some template classes to handle the proper creation of JFrames, so I don't have to worry about playing with threads all the time. (I am operating under the assumption that invokeLater should handle the creation of all frames, not just the first window of the application).
Since I'm not completely confident I've grasped the point, I was wondering if someone could look at this code to see if I've got the right idea. Your help would be much appreciated.
Test.java
import frames.*;
public class Test
public static void main(String args[])
FrameOptions frameOpts = new FrameOptions("Options Window", 300, 400, true);
frames\FrameOptions.java
package frames;
public class FrameOptions extends FrameTemplate
public FrameOptions(String title, int width, int height, final boolean visible)
super(title, width, height);
javax.swing.SwingUtilities.invokeLater ( new Runnable()
public void run()
createAndShow(visible);
public void createAndShow(boolean visible)
//Add all Swing components here.
finishCreateAndShow(visible);
frames\FrameTemplate.java
package frames;
import java.awt.Dimension;
import javax.swing.JFrame;
public class FrameTemplate extends JFrame
public FrameTemplate(String title)
super(title);
public FrameTemplate(String title, int width, int height)
super(title);
doSize(width, height);
private void doSize(int width, int height)
Dimension d = new Dimension(width, height);
setMinimumSize(d);
setPreferredSize(d);
protected void finishCreateAndShow(boolean visible)
pack();
setVisible(visible);
}OK, makes sense now.
For anyone else who may be new and wondering about this, this can be summed up as follows.
Summary 1:
If you create new frames from things such as menu events, you do not need to use invokeLater. Events are automatically done in the GUI thread/event dispatching thread. But if you're spawning these things from main() (or anything else not running in the EDT), you do.
If you're ever unsure of which thread a block of code is running in, just drop a System.out.println(javax.swing.SwingUtilities.isEventDispatchThread()); into it.
Summary 2:
Don't use those classes I wrote. They're rather pointless unless you're spawning all of your frames from main, which I suspect most people would not be doing.
Thanks for the clarification.
public static void main(String args[])
is run in a separate thread (separate from the GUi
i thread). So if you need to do painting or other
swing stuff from inside the main method, just use an
invoke later. If you create a new frame from the GUI
thread, you don't need to invoke later. Only if you
do it from the main method (or some other non-GUI
thread). Hope that helps -
I have a question regarding the semantice of servlets. Consider you are calling a method
public StringmodifyAddress(){......}in the service method of the servlet. Now considering that a servlet could be sericing multiple requests would this method be technically thread safe? If not what could we do to make it safe.
cheersOk let me rephrase and provide a little more details. Sorry I messed up the question the first time
private String email;
public void doPost(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException
User user = new User;
String address = user.modifyAddress(email);
}Now in the class User
public String modifyAddress(String email)
//writes the email address to a database
}Now I feel since user is a variable local to the service method it is thread safe, but a coworker feels that since email is a member variable it would not be thread safe. Please advise it seems that he might be correct. -
Hi,
I want to create a thread safe singleton class. But dont want to use the synchronized method or block. One way i could think of was initializing the object in static block. This way the instance will be created only once. But what if instance becomes null after some time. How will it get initialized again. Can anyone help me in creating a thread safe singleton class.
Also i would really really appreciate if some one can point me to a good tutorial on design patters, I searched on google.. Found many.. But not finding any of them satisfying.
Thankstschodt wrote:
Balu_ch wrote:
kilyas wrote:
Look into the use of volatile instead of synchronized, however the cost of using volatile is comparable to that of synchronizingCan you please explain in detail Google can.
Google ( [java volatile vs synchronized|http://www.google.com/search?q=java+volatile+vs+synchronized] ).
Hi, I think we need to use both (volatile and synchronized). Can some please explain how "volatile" alone can be used to ensure thread safe singleton? Below is the code taken from wikipedia
public class Singleton {
// volatile is needed so that multiple thread can reconcile the instance
// semantics for volatile changed in Java 5.
private volatile static Singleton singleton;
private Singleton()
// synchronized keyword has been removed from here
public static Singleton getSingleton(){
// needed because once there is singleton available no need to acquire
// monitor again & again as it is costly
if(singleton==null) {
synchronized(Singleton.class){
// this is needed if two threads are waiting at the monitor at the
// time when singleton was getting instantiated
if(singleton==null)
singleton= new Singleton();
return singleton;
} -
Thread safe RMI.
My RMI server provides clients with the ability to CRUD data but in order to manage concurrency I did the following.
1stly I would like to understand correctly the issues of RMI server objects....
It is my understanding that RMI server can cater for eg 100 clients by spawning 100 threads at random for each client. This process is not managed (thread wise) and the result is that 20 clients wishing to update record A can do so at will? Various steps can be taken from what I gather...
a) Synchronise (expensive)
b) implement a lock manager.
The step I have taken is include a lock manager and I have ensured that all locking an unlocking occur in a singleton server object that manages all sensitive data CRUD operations. Now I use a lock manager but I would like to know what happens if for eg the 1st RMI client dies and has its thread blocking
all other threads from locking the same record? Does the thread die with the client or is there a counter measure for this? The obvious answer that comes to mind is Object.wait() inside the lock manager?
The reason I ask was that because all of the locking occurs in a single method call in the Network
Server's JVM, so is there a need to worry about the RMI connection dying during the middle the locking operation.
Edited by: Yucca on May 23, 2009 8:14 PM/*
* @(#)LockManager.java
* Version 1.0.0
* 27/03/2009
import java.util.HashMap;
import java.util.Map;
import java.util.logging.Logger;
import java.util.ResourceBundle;
class LockManager {
* The <code>Map</code> containing all the record number keys of currently
* locked records that pair with the cookie value assigned to them when they
* are initially locked.
private static Map<Integer, Long> currentlyLockedMap =
new HashMap<Integer, Long>();
private static final Logger LOG = Logger.getLogger("project.db");
* Locks a record so that it can only be updated or deleted by this client.
* Returned value is a <code>long</code> that is the cookie value that must
* be used when the record is unlocked, updated, or deleted.
* If the specified record is already locked by a different client, then the
* current thread gives up the CPU and consumes no CPU cycles until the
* record is unlocked.
* @param recNo the assigned primary key of the record
* to be locked for an operation.
* @param data a <code>Data</code> instance used to
* check if the record exists before
* attempting the lock operation.
* @return A <code>long</code> containing the
* cookie value that must be used when the
* record is unlocked.
* @throws RecordNotFoundException if specified record does not exist or if
* specified record is marked as deleted
* in the database file.
long lock(int recNo, DB data) throws RecordNotFoundException {
LOG.entering(this.getClass().getName(), "lock", recNo);
synchronized (currentlyLockedMap) {
try {
while (currentlyLockedMap.containsKey(recNo)
&& currentlyLockedMap.get(recNo)
!= Thread.currentThread().getId()) {
currentlyLockedMap.wait();
// Check if record exists.
data.read(recNo);
long cookie = Thread.currentThread().getId();
currentlyLockedMap.put(recNo, cookie);
LOG.fine("Thread " + Thread.currentThread().getName()
+ "got Lock for " + recNo);
LOG.fine("Locked record count = " + currentlyLockedMap.size());
LOG.exiting(this.getClass().getName(), "lock", true);
return cookie;
} catch (InterruptedException ie) {
throw new SystemException("Unable to lock", ie);
* Releases the lock on a record. The cookie must be the cookie returned
* when the record was locked.
* @param recNo the assigned primary key of the record
* to be unlocked after an operation.
* @param cookie the cookie returned when the record was
* locked.
* @throws RecordNotFoundException if specified record does not exist or if
* specified record is marked as deleted
* in the database file.
* @throws SecurityException if the record is locked with a cookie
* other than cookie.
void unlock(int recNo, long cookie) throws RecordNotFoundException,
SecurityException {
LOG.entering(this.getClass().getName(), "unlock",
new Object[] { recNo, cookie });
synchronized (currentlyLockedMap) {
checkLock(recNo, cookie);
currentlyLockedMap.remove(recNo);
LOG.fine("released lock for " + recNo);
currentlyLockedMap.notifyAll();
LOG.exiting(this.getClass().getName(), "unlock");
* Checks if the given record is locked before doing any modification or
* unlocking for the record.
* <p/>
* Checks the <code>Map</code> of record number keys and cookie values
* to see if it contains the given record number.
* @param recNo the assigned primary key of the record
* to be checked if it is locked.
* @param lockCookie the cookie returned when the record was
* initially locked.
* @throws SecurityException if no lock exists for the record or if
* the record has been locked with a
* different cookie.
void checkLock(int recNo, long lockCookie) throws SecurityException {
LOG.entering(this.getClass().getName(), "checkLock",
new Object[] { recNo, lockCookie });
// Check if record has been locked
if (!currentlyLockedMap.containsKey(recNo)) {
throw new SecurityException(ResourceBundle.getBundle(
"resources.ErrorMessageBundle").getString(
"lockNotAppliedKey"));
// Check if record has been locked by different cookie.
if (currentlyLockedMap.get(recNo) != lockCookie) {
throw new SecurityException(ResourceBundle.getBundle(
"resources.ErrorMessageBundle").getString(
"notLockOwnerKey"));
LOG.exiting(this.getClass().getName(), "checkLock");
}Edited by: Yucca on May 23, 2009 8:16 PM
Edited by: Yucca on May 23, 2009 8:18 PMIt is my understanding that RMI server can cater for eg 100 clients by spawning 100 threads at random for each client.No. It spawns a new thread for every new connection. At the client end, RMI makes a new connection for every call unless it can find an idle connection to the same host that is less than 15 seconds old. So if the client is doing concurrent calls there will be concurrent threads at the server for that client.
This process is not managed (thread wise)'Managed' meaning what?
the result is that 20 clients wishing to update record A can do so at will?The result is that an RMI server is not thread safe unless you make it so.
a) Synchronise (expensive)Compared to a database update the cost of synchronization is trivial.
b) implement a lock manager. The database should already have one of those, and so does java.util.concurrent. Don't write your own. Personally I would just syncrhonize around the database calls.
what happens if for eg the 1st RMI client dies and has its thread(a) the client doesn't have a thread, see above. The call has a thread.
(b) at the server, the call will execute, regardless of the state of the client, until it is time to write the result back to the client, at which point the write will encounter an IOException of some description and the thread will exit.
blocking all other threads from locking the same record?That can't happen unless you foul up your concurrency management.
Does the thread die with the clientIt dies with the call.
is there a need to worry about the RMI connection dying during the middle the locking operation.The server JVM won't notice until it is time to write the call result back, see above. -
Thread safe logging class, using final and static
Hi,
I'm looking through a logging class (which writes entries to a text file and so on) written by someone else, and I'm trying to determine whether it's thread-safe...
Essentially the class looks like this:
public final class Logger {
private static FileOutputStream fout;
private static PrinterWriter pout;
private static final long MaxLength = 100000;
static {
/* basically checks size of logfile, if bigger than 100k, then copy it as bak, and start again */
public void write(String msg) {
/* write entry into log file */
public void writeWithTimeStamp(string msg) {
/* write entry with time stamp into log file */
Now, I could be wrong, but I don't think that the class is thread-safe is it? in order to be thread-safe, I would have to use synchronized before write() and writeWithTimeStamp(), right?
My confusion arises from the use of the keyword "final" at the top of the class. This class isn't being inherited (or rather, there's no reason for the class not to be inheritable)... so what is it's purpose, if there is one?!
And my other question concerns the static block. But I need to describe the current setup first: The Logger class is being use by a file server. File server basically sits there, accepts socket connections from the outside, and takes text files and output them into a local directory. When a new socket connection is created, a new thread is created. As it stands right now, each thread instantiates its own Logger object which seems weird! Bringing me to my question which was, if each thread instantiates its own Logger object, the static block is only ran ONCE, regardless of how many threads (and therefore Logger objects) are created, right??
And wouldn't it be a better idea to simply create only ONE Logger object and pass it by reference to all newly created threads as they are needed so that all threads access the same and only Logger object? (and therefore utilize sychronization)
Thanks!In JDK 1.4, there are already classes written that do all of that work. Check out the docs for the java.util.logging package. Specifically, check out FileHandler (which can rotate log files if they are greater than a specified size) and LogRecord (which is a standardized way to store logging entries). I believe the class is threadsafe, it doesn't say it isn't. Try it and see. If not, you can easily make a threadsafe wrapper for it (or any class for that matter).
The online documentation is at:
http://java.sun.com/j2se/1.4/docs/api/index.html
If you are curious, the simplest way to make any class threadsafe, if you don't want to or are not able to modify the class code itself is to define another class that calls methods of the original class, but that is synchronized.
Example:
// NonThreadSafe.java
public class NonThreadSafe {
public NonThreadSafe (String s) {
// Constructor
public void SomeMethod (int param) {
// Do some important stuff here...
public int AnotherMethod (boolean param) {
// Do some more important stuff here...
// ThreadSafeWrapper.java
public class ThreadSafeWrapper {
protected NonThreadSafe nts;
public ThreadSafeWrapper (String s) {
nts = new NonThreadSafe(s);
public synchronized void SomeMethod (int param) {
nts.SomeMethod(param);
public synchronized int AnotherMethod (boolean param) {
return nts.AnotherMethod(param);
public NonThreadSafe GetNonThreadSafe () {
return nts;
};Unfortunately, ThreadSafeWrapper isn't derived from NonThreadSafe, so you are somewhat limited in what you can do with it compared to what you could do with NonThreadSafe. AFAIK, you can't override unsynchronized methods with synchronized ones.
Another thing you could do is just write a method that writes to your logging class, and synchronize just that method. For example:
// ThreadSafeLogger.java
public class ThreadSafeLogger {
public static synchronized void LogMessage (MyLogger log, String msg) {
log.writeString(msg);
// In another thread, far, far away:
ThreadSafeLogger.LogMessage(theLog, "Blah");
...Hope that helps.
Jason Cipriani
[email protected]
[email protected]
Maybe you are looking for
-
ERROR while using SOAP adapter with SMTP protocol
Hi, The error i get is, SOAP: error occured: java.io.IOException: server not responding OK to MAIL FROM; 454 5.7.3 Client does not have permission to submit mail to this server. Please given your suggestions on the same....... Also do provide more in
-
When I click on some links, it does not open them. It use to work just fine. I have tried everything to help this situation. Many people are complaining about firefox 4. Maybe this is a bug.
-
How to get itunes on my iphone
I have a 5S and want to use it instead of my ipod for Nike+. I can't seem to get my itunes to work - only a couple of songs are there and can't see my playlists from itunes.
-
Is there a way to combine "contains" and "Startswith"? Or a better way???
I have a script that looks for reserved words in a list of words. It works but it's slow and I think there has got to be a better and faster way. I was thinking of how to combine the use of the -contains and $string.StartsWith but haven't had any l
-
Im creating a video presentation for my community colleges Graphics / Multimedia Department. Ive used FCE very little so im still a novice. I create some text in LiveType and made a video clip of it. In FCE i imported the text and the Lower Third it