groovy.transform.Synchronized Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of spotless-ext-greclipse Show documentation
Groovy Eclipse's formatter bundled for Spotless
The newest version!
/*
 * Copyright 2008-2010 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package groovy.transform;

import org.codehaus.groovy.transform.GroovyASTTransformationClass;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * Method annotation to make a method call synchronized for concurrency handling
 * with some useful baked-in conventions.
 * 
 * {@code @Synchronized} is a safer variant of the synchronized method modifier.
 * The annotation can only be used on static and instance methods. It operates similarly to
 * the synchronized keyword, but it locks on different objects. When used with
 * an instance method, the synchronized keyword locks on this, but the annotation
 * locks on a (by default automatically generated) field named $lock.
 * If the field does not exist, it is created for you. If you annotate a static method,
 * the annotation locks on a static field named $LOCK instead.
 * 

 * If you want, you can create these locks yourself.
 * The $lock and $LOCK fields will not be generated if you create
 * them yourself. You can also choose to lock on another field, by specifying its name as
 * parameter to the {@code @Synchronized} annotation. In this usage variant, the lock field
 * will not be created automatically, and you must explicitly create it yourself.
 * 

 * Rationale: Locking on this or your own class object can have unfortunate side-effects,
 * as other code not under your control can lock on these objects as well, which can
 * cause race conditions and other nasty threading-related bugs.
 * 

 * Example usage:
 * 
 * class SynchronizedExample {
 *   private final myLock = new Object()
 *
 *   {@code @}Synchronized
 *   static void greet() {
 *     println "world"
 *   }
 *
 *   {@code @}Synchronized
 *   int answerToEverything() {
 *     return 42
 *   }
 *
 *   {@code @}Synchronized("myLock")
 *   void foo() {
 *     println "bar"
 *   }
 * }
 * 
 * which becomes:
 *  * class SynchronizedExample {
 *   private static final $LOCK = new Object[0]
 *   private final $lock = new Object[0]
 *   private final myLock = new Object()
 *
 *   static void greet() {
 *     synchronized($LOCK) {
 *       println "world"
 *     }
 *   }
 *
 *   int answerToEverything() {
 *     synchronized($lock) {
 *       return 42
 *     }
 *   }
 *
 *   void foo() {
 *     synchronized(myLock) {
 *       println "bar"
 *     }
 *   }
 * }
 * 
 *
 * Credits: this annotation is inspired by the Project Lombok annotation of the
 * same name. The functionality has been kept similar to ease the learning
 * curve when swapping between these two tools.
 * 
 * Details: If $lock and/or $LOCK are auto-generated, the fields are initialized
 * with an empty Object[] array, and not just a new Object() as many snippets using
 * this pattern tend to use. This is because a new Object is NOT serializable, but
 * a 0-size array is. Therefore, using {@code @Synchronized} will not prevent your
 * object from being serialized.
 *
 * @author Paul King
 * @since 1.7.3
 */
@java.lang.annotation.Documented
@Retention(RetentionPolicy.SOURCE)
@Target({ElementType.METHOD})
@GroovyASTTransformationClass("org.codehaus.groovy.transform.SynchronizedASTTransformation")
public @interface Synchronized {
    /**
     * @return if a user specified lock object with the given name should be used
     */
    String value () default "";
}