Categories:
Audio (13)
Biotech (29)
Bytecode (36)
Database (77)
Framework (7)
Game (7)
General (507)
Graphics (53)
I/O (35)
IDE (2)
JAR Tools (101)
JavaBeans (21)
JDBC (121)
JDK (426)
JSP (20)
Logging (108)
Mail (58)
Messaging (8)
Network (84)
PDF (97)
Report (7)
Scripting (84)
Security (32)
Server (121)
Servlet (26)
SOAP (24)
Testing (54)
Web (15)
XML (309)
Collections:
Other Resources:
Apache Commons Lang v3 Source Code Files
Apache Commons Lang 3 is the 3rd version of Apache Commons Lang, which provides a host of helper utilities for the java.lang API.
Apache Commons Lang 3 Source Code files are provided in both binary packge (commons-lang3-3.12.0-bin.zip) and source package (commons-lang3-3.12.0-src.zip). You can download them at Apache Commons Lang Website.
Apache Commons Lang 3 Source Code has no dependencies and is compatible with Java 8 and newer versions. You can compile it to generate your own version of Apache Commons Lang 3 JAR file.
You can also browse the source code below:
✍: FYIcenter
⏎ org/apache/commons/lang3/concurrent/AtomicSafeInitializer.java
/* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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 org.apache.commons.lang3.concurrent; import java.util.concurrent.atomic.AtomicReference; /** * <p> * A specialized {@code ConcurrentInitializer} implementation which is similar * to {@link AtomicInitializer}, but ensures that the {@link #initialize()} * method is called only once. * </p> * <p> * As {@link AtomicInitializer} this class is based on atomic variables, so it * can create an object under concurrent access without synchronization. * However, it implements an additional check to guarantee that the * {@link #initialize()} method which actually creates the object cannot be * called multiple times. * </p> * <p> * Because of this additional check this implementation is slightly less * efficient than {@link AtomicInitializer}, but if the object creation in the * {@code initialize()} method is expensive or if multiple invocations of * {@code initialize()} are problematic, it is the better alternative. * </p> * <p> * From its semantics this class has the same properties as * {@link LazyInitializer}. It is a "save" implementation of the lazy * initializer pattern. Comparing both classes in terms of efficiency is * difficult because which one is faster depends on multiple factors. Because * {@code AtomicSafeInitializer} does not use synchronization at all it probably * outruns {@link LazyInitializer}, at least under low or moderate concurrent * access. Developers should run their own benchmarks on the expected target * platform to decide which implementation is suitable for their specific use * case. * </p> * * @since 3.0 * @param <T> the type of the object managed by this initializer class */ public abstract class AtomicSafeInitializer<T> implements ConcurrentInitializer<T> { /** A guard which ensures that initialize() is called only once. */ private final AtomicReference<AtomicSafeInitializer<T>> factory = new AtomicReference<>(); /** Holds the reference to the managed object. */ private final AtomicReference<T> reference = new AtomicReference<>(); /** * Gets (and initialize, if not initialized yet) the required object * * @return lazily initialized object * @throws ConcurrentException if the initialization of the object causes an * exception */ @Override public final T get() throws ConcurrentException { T result; while ((result = reference.get()) == null) { if (factory.compareAndSet(null, this)) { reference.set(initialize()); } } return result; } /** * Creates and initializes the object managed by this * {@code AtomicInitializer}. This method is called by {@link #get()} when * the managed object is not available yet. An implementation can focus on * the creation of the object. No synchronization is needed, as this is * already handled by {@code get()}. This method is guaranteed to be called * only once. * * @return the managed data object * @throws ConcurrentException if an error occurs during object creation */ protected abstract T initialize() throws ConcurrentException; }
⏎ org/apache/commons/lang3/concurrent/AtomicSafeInitializer.java
Or download all of them as a single archive file:
File name: commons-lang3-3.12.0-sources.jar File size: 651724 bytes Release date: 2020-01-22 Download
⇒ Download and Install commons-lang3-3.8.1-bin.zip
⇐ Download Apache Commons Lang v3 Source Package
2022-10-19, 150773👍, 3💬
Popular Posts:
What Is ojdbc5.jar for Oracle 11g R1? ojdbc5.jar for Oracle 11g R1 is the JAR files of ojdbc.jar, JD...
maven-compat-3.8.6.jar is the JAR file for Apache Maven 3.8.6 Compact module. The JAR file name may ...
Swingx is the SwingLabs Swing Component Extensions. JAR File Size and Download Location: File name: ...
How to download and install ojdbc7.jar for Oracle 12c R1? ojdbc8.jar for Oracle 12c R1 is a Java 7 a...
Apache Ant Source Code Files are inside the Apache Ant source package file like apache-ant-1.10.10-s...