1. Language overview
JR is a programming language especially created to solve concurrent programming problems. This language is an overview of Java who add to this last the main paradigms of concurrent programming. Moreover JR make easier the concepts still implemented in Java like process or semaphores. There is also several extensions for JR to add more functionalities like monitors and Conditional Critical Region (CCR). JR is the implementation of the SR language for Java.
JR makes nothing else than add a layer over Java. Once we use the JR compiler, the JR source files are transformed in Java files and are executed by the virtual machine like any other Java class.
JR is often used as a school support to learn concurrent programming.
In this article, we will see the bases of the programmation with JR.
The presented version is the one of June 2009, the version 2.00602 who are based on Java 6.0.
This article need that you’ve installed the JR environment on your system. An article is available here for the installation under Windows.
In this article, we will especially focus on the apports of the JR language for the concurrent programming. We will not see the the integrality of the language. JR has other benefits than make easier concurrent programming, but we will not see that in this article. Moreover, all the aspects of concurrent programming in JR will not be treated here.
2. Hello World
Like all other languages, we must start with a simple Hello World. Thus we’ll create a file Hello.jr. Nothing special here, it’s pure Java :
public class Hello { public static void main(String[] args){ System.out.println("Hello World"); } }
Then we can compile it :
jrc Hello.jr
This will create a jrGen folder containing Java files. The result of a JR compilation is always a set of Java files corresponding to the translation of the JR files.
To launch your JR program, use the jr command followed by the name of the main class (class containing the main method) :
jr Hello
That will display :
Hello World
The jr command will also launch the compilation of Java files. This compilation will be done every time. If you want to make only the launch of compiled files, you can use the jrrun command.
Like said in introduction, the JR language extends the Java language. So, you can code in Java with JR. Thus an Hello World is only Java.
3. Processes
The first thing to see is the declaration of processes. This is done in an easier way than in Java. No need to instanciate some objects, this is done in a declarative way and JR make the rest.
For the declaration of process, JR introduce a new keyword process who enable to declare a process. Here is the simplest declaration of a process :
process Hello { System.out.println("Processus"); }
Like you can see it, it’s easier than in Java. And better, no need to launch it, you just have to instanciate the class. A process can also be declared static. This times, it will not be launched at the instanciation of the class but at the resolution of the class by the virtual machine. By example, we can rewrite an HelloWorld in that way :
public class HelloProcess { static process Hello { System.out.println("Hello World"); } public static void main(String[] args){} }
who display exactly the same thing as the first version of the Hello World. At the difference that our display is made from a thread.
Moreover, JR enable to declare a big set of threads in a declaration with the following syntax :
static process Hello((int id = 0; id < n; id++)){}
This will declare n threads. The syntax is the same as the for loop. Let’s declare 25 threads Hello World :
public class HelloProcess { static process Hello((int id = 0; id < 25; id++)){ System.out.println("Hello World from thread " + id); } public static void main(String[] args){} }
When we launch that, we could have the following result :
Hello World from thread 2 Hello World from thread 24 Hello World from thread 11 Hello World from thread 22 Hello World from thread 0 Hello World from thread 4 Hello World from thread 6 Hello World from thread 8 Hello World from thread 10 Hello World from thread 12 Hello World from thread 14 Hello World from thread 16 Hello World from thread 18 Hello World from thread 20 Hello World from thread 23 Hello World from thread 21 Hello World from thread 19 Hello World from thread 17 Hello World from thread 15 Hello World from thread 13 Hello World from thread 9 Hello World from thread 7 Hello World from thread 5 Hello World from thread 3 Hello World from thread 1
Like you can see, if you launch several times the program, the display is not same and the message commes in an order completely different order at each launch. Nothing can guarantee the order of the threads launches and still less the order of the execution of the instructions and you must not count on it.
It’s the basis of the concurrent programming. You cannot predict the order of the instructions in the different threads.