View Javadoc

1   /*
2    * Licensed to the Apache Software Foundation (ASF) under one or more
3    * contributor license agreements.  See the NOTICE file distributed with
4    * this work for additional information regarding copyright ownership.
5    * The ASF licenses this file to You under the Apache License, Version 2.0
6    * (the "License"); you may not use this file except in compliance with
7    * the License.  You may obtain a copy of the License at
8    *
9    *      http://www.apache.org/licenses/LICENSE-2.0
10   *
11   * Unless required by applicable law or agreed to in writing, software
12   * distributed under the License is distributed on an "AS IS" BASIS,
13   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14   * See the License for the specific language governing permissions and
15   * limitations under the License.
16   */
17  package org.apache.commons.math.stat.descriptive;
18  
19  /**
20   * Implementation of
21   * {@link org.apache.commons.math.stat.descriptive.DescriptiveStatistics} that
22   * is safe to use in a multithreaded environment.  Multiple threads can safely
23   * operate on a single instance without causing runtime exceptions due to race
24   * conditions.  In effect, this implementation makes modification and access
25   * methods atomic operations for a single instance.  That is to say, as one
26   * thread is computing a statistic from the instance, no other thread can modify
27   * the instance nor compute another statistic. 
28   *
29   * @since 1.2
30   * @version $Revision: 762087 $ $Date: 2009-04-05 10:20:18 -0400 (Sun, 05 Apr 2009) $
31   */
32  public class SynchronizedDescriptiveStatistics extends DescriptiveStatistics {
33  
34      /** Serialization UID */
35      private static final long serialVersionUID = 1L;
36  
37      /**
38       * Construct an instance with infinite window
39       */
40      public SynchronizedDescriptiveStatistics() {
41          this(INFINITE_WINDOW);
42      }
43  
44      /**
45       * Construct an instance with finite window
46       * @param window the finite window size.
47       */
48      public SynchronizedDescriptiveStatistics(int window) {
49          super(window);
50      }
51      
52      /**
53       * A copy constructor. Creates a deep-copy of the {@code original}.
54       * 
55       * @param original the {@code SynchronizedDescriptiveStatistics} instance to copy
56       */
57      public SynchronizedDescriptiveStatistics(SynchronizedDescriptiveStatistics original) {
58          copy(original, this);
59      }
60  
61      /**
62       * {@inheritDoc}
63       */
64      @Override
65      public synchronized void addValue(double v) {
66          super.addValue(v);
67      }
68  
69      /**
70       * {@inheritDoc}
71       */
72      @Override
73      public synchronized double apply(UnivariateStatistic stat) {
74          return super.apply(stat);
75      }
76  
77      /**
78       * {@inheritDoc}
79       */
80      @Override
81      public synchronized void clear() {
82          super.clear();
83      }
84  
85      /**
86       * {@inheritDoc}
87       */
88      @Override
89      public synchronized double getElement(int index) {
90          return super.getElement(index);
91      }
92  
93      /**
94       * {@inheritDoc}
95       */
96      @Override
97      public synchronized long getN() {
98          return super.getN();
99      }
100 
101     /** 
102      * {@inheritDoc}
103      */
104     @Override
105     public synchronized double getStandardDeviation() {
106         return super.getStandardDeviation();
107     }
108 
109     /**
110      * {@inheritDoc}
111      */
112     @Override
113     public synchronized double[] getValues() {
114         return super.getValues();
115     }
116 
117     /**
118      * {@inheritDoc}
119      */
120     @Override
121     public synchronized int getWindowSize() {
122         return super.getWindowSize();
123     }
124 
125     /**
126      * {@inheritDoc}
127      */
128     @Override
129     public synchronized void setWindowSize(int windowSize) {
130         super.setWindowSize(windowSize);
131     }
132 
133     /**
134      * {@inheritDoc}
135      */
136     @Override
137     public synchronized String toString() {
138         return super.toString();
139     }
140     
141     /**
142      * Returns a copy of this SynchronizedDescriptiveStatistics instance with the
143      * same internal state.
144      * 
145      * @return a copy of this
146      */
147     @Override
148     public synchronized SynchronizedDescriptiveStatistics copy() {
149         SynchronizedDescriptiveStatistics result = 
150             new SynchronizedDescriptiveStatistics();
151         copy(this, result);
152         return result; 
153     }
154      
155     /**
156      * Copies source to dest.
157      * <p>Neither source nor dest can be null.</p>
158      * <p>Acquires synchronization lock on source, then dest before copying.</p>
159      * 
160      * @param source SynchronizedDescriptiveStatistics to copy
161      * @param dest SynchronizedDescriptiveStatistics to copy to
162      * @throws NullPointerException if either source or dest is null
163      */
164     public static void copy(SynchronizedDescriptiveStatistics source,
165             SynchronizedDescriptiveStatistics dest) {
166         synchronized (source) {
167             synchronized (dest) {
168                 DescriptiveStatistics.copy(source, dest);
169             }
170         }
171     }
172 }