Cava - A New Concurrency Model for Java
Authors
Damborg, Birthe ; Hansen, Anders Mørk
Term
4. term
Education
Publication year
2007
Abstract
Mange moderne programmer skal afvikle flere opgaver samtidigt for at udnytte flerkernede CPU’er. Java har allerede støtte for samtidighed, men modellen har svagheder som brudt indkapsling og arvsanomali. Dette projekt udviklede en ny samtidighedsmodel til Java, kaldet Cava. Målet var, at Cava skulle passe til den objektorienterede tilgang, være udtryksfuld, begrænse risikoen for fejl (fault restriction) og være enkel. For at vurdere, hvor godt modellen opfylder disse mål, blev der udviklet en vurderingsmetode, der tildeler en numerisk score baseret på spørgsmål under hvert designkriterium. Cava bygger videre på Java, men fjerner metoderne wait, notify og notifyAll samt nøgleordet synchronized. Tråde er stadig det grundlæggende element, men ikke-deterministisk adfærd opstår kun, når man aktivt vælger det. Alle variabler er trådlokale, medmindre de markeres som delte med den nye shared-modifikator. Adgang til delte variabler skal ske i metoder eller blokke, der er markeret med det nye transaction-nøgleord. Disse anvender software-transaktionel hukommelse (STM), som gør det muligt at rulle ændringer tilbage ved konflikter. Transaktionsstatus for metoder bevares ved arv. Cava introducerer også en gate-konstruktion til at sende beskeder mellem tråde: or-gates videresender en besked til én tråd, mens and-gates videresender til flere tråde. Som del af projektet blev der lavet en eksperimentel implementering ved at ændre Suns Java-kompiler til en Cava-kompiler og ved at bygge et Cava Runtime System. Strategien var at genbruge Java-kompileren, så de genererede class-filer kan køre på en standard JVM, når Cava Runtime System angives. Implementeringen gjorde det muligt at skrive og teste Cava-programmer og blev brugt på klassiske samtidighedsopgaver som en lock, Dining Philosophers, Santa Claus Problem og en parallel version af Quicksort. I sammenligningen opnåede Cava en bedre samlet score end Java, især på integration med den objektorienterede tilgang og på fejlbegrænsning. Udtryksfuldhed var uafgjort, mens enkelhed scorede lidt lavere end Java. Da Cava endnu er et stykke fra maksimumscoren, peger projektet også på mulige områder for fremtidigt arbejde og relateret forskning.
Many modern programs need to run tasks at the same time to use multicore CPUs effectively. Java already supports concurrency, but its current model has weaknesses such as broken encapsulation and the inheritance anomaly. This project proposes a new concurrency model for Java, called Cava. The model was designed to align with object-oriented principles, be expressive, provide fault restriction (limiting error-prone behavior), and remain simple. To evaluate how well these goals were met—and whether the model offers stronger support than Java for modeling concurrent problems and introducing parallelism—a scoring method was developed that assigns a numerical value based on questions for each design criterion. Cava builds on Java but removes the wait, notify, and notifyAll methods along with the synchronized keyword. Threads remain the fundamental construct, but non-deterministic behavior appears only when explicitly chosen, making interactions less unpredictable. By default, variables are thread-local unless marked as shared with a new shared modifier. Access to shared variables must occur inside methods or blocks marked with a new transaction keyword. These use Software Transactional Memory (STM), which groups changes and can roll them back when conflicts occur. The transactional status of methods is preserved through inheritance. Cava also introduces a gate construct for sending messages between threads: or-gates forward a message to a single thread, and and-gates forward a message to multiple threads. An experimental implementation was created by modifying Sun’s Java compiler into a Cava compiler and building a Cava Runtime System. The strategy reused the Java compiler so that generated class files run on a standard JVM when the Cava Runtime System is provided. This enabled writing and testing Cava programs on classic concurrency problems, including a lock, Dining Philosophers, the Santa Claus Problem, and a parallel version of Quicksort. In comparison, Cava achieved a higher overall score than Java, mainly due to better integration with the object-oriented paradigm and stronger fault restriction. Expressiveness was tied, while simplicity scored slightly worse than Java. As Cava is still far from the maximum score, the project outlines potential future work and related research.
[This abstract was generated with the help of AI]
Documents