001    /*
002     * Licensed to the Apache Software Foundation (ASF) under one or more
003     * contributor license agreements.  See the NOTICE file distributed with
004     * this work for additional information regarding copyright ownership.
005     * The ASF licenses this file to You under the Apache License, Version 2.0
006     * (the "License"); you may not use this file except in compliance with
007     * the License.  You may obtain a copy of the License at
008     *
009     *      http://www.apache.org/licenses/LICENSE-2.0
010     *
011     * Unless required by applicable law or agreed to in writing, software
012     * distributed under the License is distributed on an "AS IS" BASIS,
013     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014     * See the License for the specific language governing permissions and
015     * limitations under the License.
016     */
017    package org.apache.commons.math3.stat.descriptive;
018    
019    import org.apache.commons.math3.exception.MathIllegalStateException;
020    import org.apache.commons.math3.exception.NullArgumentException;
021    import org.apache.commons.math3.util.MathUtils;
022    
023    /**
024     * Implementation of
025     * {@link org.apache.commons.math3.stat.descriptive.SummaryStatistics} that
026     * is safe to use in a multithreaded environment.  Multiple threads can safely
027     * operate on a single instance without causing runtime exceptions due to race
028     * conditions.  In effect, this implementation makes modification and access
029     * methods atomic operations for a single instance.  That is to say, as one
030     * thread is computing a statistic from the instance, no other thread can modify
031     * the instance nor compute another statistic.
032     *
033     * @since 1.2
034     * @version $Id: SynchronizedSummaryStatistics.java 1416643 2012-12-03 19:37:14Z tn $
035     */
036    public class SynchronizedSummaryStatistics extends SummaryStatistics {
037    
038        /** Serialization UID */
039        private static final long serialVersionUID = 1909861009042253704L;
040    
041        /**
042         * Construct a SynchronizedSummaryStatistics instance
043         */
044        public SynchronizedSummaryStatistics() {
045            super();
046        }
047    
048        /**
049         * A copy constructor. Creates a deep-copy of the {@code original}.
050         *
051         * @param original the {@code SynchronizedSummaryStatistics} instance to copy
052         * @throws NullArgumentException if original is null
053         */
054        public SynchronizedSummaryStatistics(SynchronizedSummaryStatistics original)
055        throws NullArgumentException {
056            copy(original, this);
057        }
058    
059        /**
060         * {@inheritDoc}
061         */
062        @Override
063        public synchronized StatisticalSummary getSummary() {
064            return super.getSummary();
065        }
066    
067        /**
068         * {@inheritDoc}
069         */
070        @Override
071        public synchronized void addValue(double value) {
072            super.addValue(value);
073        }
074    
075        /**
076         * {@inheritDoc}
077         */
078        @Override
079        public synchronized long getN() {
080            return super.getN();
081        }
082    
083        /**
084         * {@inheritDoc}
085         */
086        @Override
087        public synchronized double getSum() {
088            return super.getSum();
089        }
090    
091        /**
092         * {@inheritDoc}
093         */
094        @Override
095        public synchronized double getSumsq() {
096            return super.getSumsq();
097        }
098    
099        /**
100         * {@inheritDoc}
101         */
102        @Override
103        public synchronized double getMean() {
104            return super.getMean();
105        }
106    
107        /**
108         * {@inheritDoc}
109         */
110        @Override
111        public synchronized double getStandardDeviation() {
112            return super.getStandardDeviation();
113        }
114    
115        /**
116         * {@inheritDoc}
117         */
118        @Override
119        public synchronized double getVariance() {
120            return super.getVariance();
121        }
122    
123        /**
124         * {@inheritDoc}
125         */
126        @Override
127        public synchronized double getPopulationVariance() {
128            return super.getPopulationVariance();
129        }
130    
131        /**
132         * {@inheritDoc}
133         */
134        @Override
135        public synchronized double getMax() {
136            return super.getMax();
137        }
138    
139        /**
140         * {@inheritDoc}
141         */
142        @Override
143        public synchronized double getMin() {
144            return super.getMin();
145        }
146    
147        /**
148         * {@inheritDoc}
149         */
150        @Override
151        public synchronized double getGeometricMean() {
152            return super.getGeometricMean();
153        }
154    
155        /**
156         * {@inheritDoc}
157         */
158        @Override
159        public synchronized String toString() {
160            return super.toString();
161        }
162    
163        /**
164         * {@inheritDoc}
165         */
166        @Override
167        public synchronized void clear() {
168            super.clear();
169        }
170    
171        /**
172         * {@inheritDoc}
173         */
174        @Override
175        public synchronized boolean equals(Object object) {
176            return super.equals(object);
177        }
178    
179        /**
180         * {@inheritDoc}
181         */
182        @Override
183        public synchronized int hashCode() {
184            return super.hashCode();
185        }
186    
187        /**
188         * {@inheritDoc}
189         */
190        @Override
191        public synchronized StorelessUnivariateStatistic getSumImpl() {
192            return super.getSumImpl();
193        }
194    
195        /**
196         * {@inheritDoc}
197         */
198        @Override
199        public synchronized void setSumImpl(StorelessUnivariateStatistic sumImpl)
200        throws MathIllegalStateException {
201            super.setSumImpl(sumImpl);
202        }
203    
204        /**
205         * {@inheritDoc}
206         */
207        @Override
208        public synchronized StorelessUnivariateStatistic getSumsqImpl() {
209            return super.getSumsqImpl();
210        }
211    
212        /**
213         * {@inheritDoc}
214         */
215        @Override
216        public synchronized void setSumsqImpl(StorelessUnivariateStatistic sumsqImpl)
217        throws MathIllegalStateException {
218            super.setSumsqImpl(sumsqImpl);
219        }
220    
221        /**
222         * {@inheritDoc}
223         */
224        @Override
225        public synchronized StorelessUnivariateStatistic getMinImpl() {
226            return super.getMinImpl();
227        }
228    
229        /**
230         * {@inheritDoc}
231         */
232        @Override
233        public synchronized void setMinImpl(StorelessUnivariateStatistic minImpl)
234        throws MathIllegalStateException {
235            super.setMinImpl(minImpl);
236        }
237    
238        /**
239         * {@inheritDoc}
240         */
241        @Override
242        public synchronized StorelessUnivariateStatistic getMaxImpl() {
243            return super.getMaxImpl();
244        }
245    
246        /**
247         * {@inheritDoc}
248         */
249        @Override
250        public synchronized void setMaxImpl(StorelessUnivariateStatistic maxImpl)
251        throws MathIllegalStateException {
252            super.setMaxImpl(maxImpl);
253        }
254    
255        /**
256         * {@inheritDoc}
257         */
258        @Override
259        public synchronized StorelessUnivariateStatistic getSumLogImpl() {
260            return super.getSumLogImpl();
261        }
262    
263        /**
264         * {@inheritDoc}
265         */
266        @Override
267        public synchronized void setSumLogImpl(StorelessUnivariateStatistic sumLogImpl)
268        throws MathIllegalStateException {
269            super.setSumLogImpl(sumLogImpl);
270        }
271    
272        /**
273         * {@inheritDoc}
274         */
275        @Override
276        public synchronized StorelessUnivariateStatistic getGeoMeanImpl() {
277            return super.getGeoMeanImpl();
278        }
279    
280        /**
281         * {@inheritDoc}
282         */
283        @Override
284        public synchronized void setGeoMeanImpl(StorelessUnivariateStatistic geoMeanImpl)
285        throws MathIllegalStateException {
286            super.setGeoMeanImpl(geoMeanImpl);
287        }
288    
289        /**
290         * {@inheritDoc}
291         */
292        @Override
293        public synchronized StorelessUnivariateStatistic getMeanImpl() {
294            return super.getMeanImpl();
295        }
296    
297        /**
298         * {@inheritDoc}
299         */
300        @Override
301        public synchronized void setMeanImpl(StorelessUnivariateStatistic meanImpl)
302        throws MathIllegalStateException {
303            super.setMeanImpl(meanImpl);
304        }
305    
306        /**
307         * {@inheritDoc}
308         */
309        @Override
310        public synchronized StorelessUnivariateStatistic getVarianceImpl() {
311            return super.getVarianceImpl();
312        }
313    
314        /**
315         * {@inheritDoc}
316         */
317        @Override
318        public synchronized void setVarianceImpl(StorelessUnivariateStatistic varianceImpl)
319        throws MathIllegalStateException {
320            super.setVarianceImpl(varianceImpl);
321        }
322    
323        /**
324         * Returns a copy of this SynchronizedSummaryStatistics instance with the
325         * same internal state.
326         *
327         * @return a copy of this
328         */
329        @Override
330        public synchronized SynchronizedSummaryStatistics copy() {
331            SynchronizedSummaryStatistics result =
332                new SynchronizedSummaryStatistics();
333            // No try-catch or advertised exception because arguments are guaranteed non-null
334            copy(this, result);
335            return result;
336        }
337    
338        /**
339         * Copies source to dest.
340         * <p>Neither source nor dest can be null.</p>
341         * <p>Acquires synchronization lock on source, then dest before copying.</p>
342         *
343         * @param source SynchronizedSummaryStatistics to copy
344         * @param dest SynchronizedSummaryStatistics to copy to
345         * @throws NullArgumentException if either source or dest is null
346         */
347        public static void copy(SynchronizedSummaryStatistics source,
348                                SynchronizedSummaryStatistics dest)
349            throws NullArgumentException {
350            MathUtils.checkNotNull(source);
351            MathUtils.checkNotNull(dest);
352            synchronized (source) {
353                synchronized (dest) {
354                    SummaryStatistics.copy(source, dest);
355                }
356            }
357        }
358    
359    }