public class RecList {
  private double value;
  private RecList next;
  /** Crée une liste avec une valeur et une sous-liste. */
  public RecList(double value, RecList next) { 
    this.value = value;
    this.next = next;
  }
  /** Teste si cette liste contient la valeur x. Seul l'accès à la
      valeur courante nécessite d'être synchronisé. */
  public boolean contains(double x) { 
    synchronized (this) {
      if (value == x)
    return true;
    }
    // Accès au suivant sans synchronisation (structure constante)
    if (getNext()==null)
      return false;
    return getNext().contains(x);
  }
  /** Retourne la somme des éléments de la liste. Seuls les accès aux
      valeurs sont synchronisés. */
  public double sum() { 
    double sum = getValue();
    if (getNext()!=null) sum += getNext().sum();
    return sum;
  }
  /** Positionne la valeur de l'élément courant. Le type double nécessite
      de synchroniser. */
  public synchronized void setValue(double value) { this.value = value;}
  /** Retourne la valeur de l'élément courant. Idem. */
  public synchronized double getValue() { return value; }
  /** Retourne la sous-liste. L'accès à la référence est atomique
      et la structure est constante : pas de synchronisation. */
  public RecList getNext() { return next; }
}