Re: Combining Java Reflection API with Java Annotation Types for
Thread Safety
pek wrote:
I know Java has an Annotation Type system that it can help me mark
various methods in a class for a particular purpose (such as a @Test
or @FixThis). So I was thinking, this could also work if every method
that inside the code a thread is initiated, I could Annotate it as
@ThreadCreator. Also, I could annotate a method that is being called
from a thread as @ThreadSafe (making sure of course that it is indeed
a thread-safe method). This is the first part.
Using annotations for static analysis? I would like to see how this
works out: I've been considering using some for moving some internal
precondition checks to pseudo-compile time.
The second part is to use Java Reflection API. I saw that I can use
this API to find what annotations a class uses and where. So I know I
could find out that a particular method in a class is annotated as
@ThreadCreator.
Now, combining this together, I was wondering if I could create a
"system" (I don't really know how to call it) that would take a class
that I give it, find which methods are annotated with @ThreadCreator,
invoke those methods, and see if the methods call other methods that
are not annotated as @ThreadSafe, in which case the "system" will warn
me that this should be @ThreadSafe.
Is this even possible? Is there any other solution to this? Is there
already an implementation of this?
I *think* the best way to proceed would be to use the annotation
processing tool. I have not used this tool at all (then again, my use of
annotations is rather limited at present), but it seems it would be far
easier than processing runtime loading components. Speaking from my
limited experience, processing annotations at runtime loading of classes
is a nightmare in terms of initial implementation.
As far other implementations, I know of none, but I would not be
surprised to see an existing implementation (soliciting help from any
resident concurrent programming gurus lurking about).
I also have reservations about your verification algorithm as stated,
but since I am not an expert in concurrent programming, and since it
appears to me that this is merely a conceptual-level design, I am sure
that you have already handled the objects of my fears, so I will not
mention them.
--
Beware of bugs in the above code; I have only proved it correct, not
tried it. -- Donald E. Knuth