Скачать или смотреть Understanding ClassName::new VS new ClassName() in JAVA

Explore the differences between `ClassName::new` and `new ClassName()` in Java, including their implications in multithreading and practical usage with examples.
---
This video is based on the question https://stackoverflow.com/q/62421410/ asked by the user '李重辰' ( https://stackoverflow.com/u/10253280/ ) and on the answer https://stackoverflow.com/a/62425218/ provided by the user 'DuncG' ( https://stackoverflow.com/u/4712734/ ) at 'Stack Overflow' website. Thanks to these great users and Stackexchange community for their contributions.

Visit these links for original content and any more details, such as alternate solutions, latest updates/developments on topic, comments, revision history etc. For example, the original title of the Question was: "ClassName::new" VS "new ClassName()" in JAVA

Also, Content (except music) licensed under CC BY-SA https://meta.stackexchange.com/help/l...
The original Question post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license, and the original Answer post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license.

If anything seems off to you, please feel free to write me at vlogize [AT] gmail [DOT] com.
---
Understanding ClassName::new VS new ClassName() in JAVA

Java offers multiple ways to create new instances of a class, and two of the most common methods are ClassName::new and new ClassName(). While they may seem similar at first glance, these two approaches can lead to different behaviors, particularly in a multithreading context. In this guide, we will dive into the distinctions between these methods, exemplified through a practical coding scenario.

The Scenario: Creating Threads

When we create threads in Java, we often need to provide a Runnable to define the task that the thread will execute. Let’s explore two ways to create instances of MyRunnableThread in a thread factory situation by looking at the code provided earlier.

Code Snippet Overview

Here’s a brief overview of the classes involved:

UserThreadFactory: A factory for creating threads, which prepends a custom name to each thread.

MyRunnableThread: Implements Runnable, encapsulating the logic that will run in the thread.

CreateThreadByThreadFactory: The main class where we create multiple threads using the UserThreadFactory.

[[See Video to Reveal this Text or Code Snippet]]

Understanding the Two Ways

1. The First Way: new MyRunnableThread()

When we call new MyRunnableThread(), we are creating a new instance of MyRunnableThread for each thread that is being initiated. This means:

Separate Instances: Each thread gets its own object.

Constructor Calls: The constructor of MyRunnableThread is invoked every time, leading to multiple constructor calls.

Output Explanation:

In the output, a unique hash code is printed for each thread instance, showing that different instances of MyRunnableThread are created:

[[See Video to Reveal this Text or Code Snippet]]

2. The Second Way: () -> new MyRunnableThread()

In this approach, we are using a lambda expression to create a new MyRunnableThread, but the key aspect here is how the object's run() method is not automatically called:

Shared Instance: Because the lambda returns an instance of MyRunnableThread, if this instance isn't stored or called properly, every thread may reference the same object, leading to uniform behaviors.

Constructor Call: The constructor will only be called when we explicitly create an instance and invoke its methods.

A Critical Difference

The main difference is subtle but crucial:

In the first example, a new instance is constructed and passed to the thread.

In the second case, the Runnable function inside the lambda does not call the run() method unless you specify that to happen by appending .run(). Thus, the message indicating that the constructor was called appears only ONCE.

Correcting the Second Way:

To ensure that each thread has a unique instance, you need to change the second way to run the instance alongside the lambda:

[[See Video to Reveal this Text or Code Snippet]]

Conclusion

Understanding the difference between ClassName::new and new ClassName() is vital for developing efficient multithreaded applications in Java. The first creates unique instances that allow threads to run independently, while the second requires careful attention to object management to prevent shared state issues.

By mastering these distinctions, Java developers can ensure that their applications are both robust and efficient. Happy coding!