I started studying python a couple of month ago, then I found Jython.
Do threads work properly in Jython, since it doesn't have a GIL? If so, can you suggest a good book on concurrency (threading)?
4 Answers
The best book I've encountered on multithreading is "Java Concurrency in Practice". It's very much concentrating on Java thread concurrency, and is both humbling and exciting when you start to understand the problems and the possibilities introduced by concurrency. The copy I bought a few years ago had some errata in the coding, though, which exacerbated an already brain-challenging subject: check out errata here: http://jcip.net/errata.html.
Although designed for Java developers wishing to venture into concurrency (which by the way includes anyone who's ever used a GUI interface of any kind), I'm sure the technical difficulties and subtleties outlined in the book apply to any implementation of concurrency.
By the way, I also love Jython and can confirm that anything concurrency-wise that you can do in Java you can apparently do in Jython. However, there is a caveat: concurrency can be for asynchronous programming (including GUI) and/or for performance. If for the latter you have a problem, in my opinion: Jython in my experience runs about 10 x slower than the equivalent Java program.
What this means is that your more demanding Jython modules will have to call something other than Jython for the number-crunching tasks. At the same time, Jython up to now* has not had Python's multiprocessing module, so inter-process communications are out, unless you venture into the dreaded territory of RMI. You're more of a man/woman than I if you take that option. But everything's OK: please refer to "The Definitive Guide to Jython" at http://www.jython.org ... chapter 19 is a sort of whistle-stop intro to concurrency, and chapter 10 is about integrating Java and Jython (hint: it's absurdly easy).
- interesting: a quick glimpse at the Jython site shows that, just 10 days ago, 17/05/12, version 2.7a1 was released... an "Alpha" release. This should contain the multiprocessing module, which came in with Python 2.6. Wd be interesting to check this: if so it presumably gives you the exciting option of linking Jython and CPython processes (update later: sadly it appears for the moment that this is not so - the module name "multiprocessing" was not recognised when I tried)...
PS a final word: most experts who know much more about these things than I say that Moore's law is being superseded in importtance by Amdahl's law, which in short means that the daunting challenge of programming stable and scalable true concurrent programs will be unavoidable in the future. Exactly how easy true (i.e. thread) concurrency can be made with the use of clever code analysis tools I can't say but investment in this subject and the fascinating, intellectual new disciplines of reasoning imposed by concurrency will probably pay off... if you like a challenge.
Comments
Yes, with Jython you've real multi-threading. Jython (JPython successor's) is an implementation of Python that runs in the JVM. One of the main differences between Jython and the original project is that the first doesn't have the GIL and implements a real multi-threading support based on the JVM's implementation.
I'd suggest you to take a look to this book and the OReilly's one.
Comments
I have tried it with an example.
Requirements:- You should have JDK 7 or above, from (https://www.oracle.com/in/java/technologies/javase-downloads.html)
- You should install the recent Jython version, from (https://www.jython.org/installation.html)
from rough import print_time
from datetime import datetime
"""
This is actually using python threading package.
One thing I came to know is that if we use the python threading module also,
internally Jython chnages it to Java thread and work.
"""
# from threading import Thread, InterruptedException
"""
This is the java threading module.
"""
from java.lang import Thread, InterruptedException
"""
Here you can call your module from the run method.
For passing arguments, you can use the constructor of the Cycle class.
"""
class Cycle(Thread):
def __init__(self,time1=1):
Thread.__init__(self)
# arguments for the run method
self.time1 = time1
def run(self):
try:
# Calling the required module with given arguments
print_time(self.time1)
except InterruptedException:
print("Exception")
if __name__ == '__main__':
print("start time:",datetime.now())
for i in range(100):
Cycle(i).start()
print("end time:",datetime.now())
Please find the full code in https://github.com/om12nayak/Jython_multithreading_demo
Comments
The initially confusing aspect may be that you can mix and match Java and Jython's concurrency mechanisms. But it all seems to work. The reasons are:
- Underneath Jython is the same old Java. All of its robust threading mechanisms and data structures aren't going to break even under the heavy Jython machinery.
- Jython's threads take Java threads as their chassis and add some superstructure to make them speak the Python threading API. (There is no better way to make porting threaded Python code easier.) But the essence of the two types of threads is similar. Except that with Jython threads
... there are no priorities, no thread groups, and threads cannot be destroyed, stopped, suspended, resumed, or interrupted. [1]
The Python idioms are probably a bit more convenient, because, for example, if you wish to do the equivalent of synchronized (some_object) { ... }, there is a small bit of fiddling required, which is likely to be less readable than using an RLock.
Do I need to use python multiprocessing or Java's threading? I'm sure it works just not sure which one you have to use since jython is a blend of both.cpythonfor the usual c version. The GIL is only a limitation of that one (admittedly dominant) dialect. Real concurrent threads work just fine under Jython, IronPython and so on (though as far as I know not a single one of them specifies their exact memory model, so that's problematic. I wouldn't want to presume the memory model of the host platform holds for the interpreter)