Use immutable classes: We should always prefer the immutable class in multithreading programming because immutable classes make sure that values are not changed in the middle of an operation without using synchronized blocks. For example, in an immutable class, such as java.lang.String, any modification on String, such as adding something or converting into uppercase, always creates another string object, keeping the original object unbroken.

Use local variables: Always try to use local variables instead of an instance or class-level variables because local variables are never shared between threads.

Use thread pool: Thread pool can reuse previously created threads and eliminate the time of thread creation, which improves the performance of the application.

Use the synchronization utility: Here, we can use the synchronization utility instead of the wait and notify methods. The java.util.concurrent package provides better synchronization utilities, such as CycicBariier, CountDownLatch, Sempahore, and BlockingQueue. It is very easy to wait for five threads using CountDownLatch to complete its task instead of implementing the same utility using the wait and notify methods. It is also easier to implement the producer-consumer design with the help of BlockingQueue rather than the wait and notify methods.

Use concurrent collections instead of synchronized collection: Concurrent collections are implemented with the new locking mechanism provided by the Lock interface and designed in such a way that we can take advantage of the native concurrency construct provided by the underlying hardware and JVM. Concurrent collections give more scalability and performance than their synchronized counterparts. ConcurrentHashMap provides better performance than synchronized HashMap or Hashtable classes if there are many updates and fewer reads concurrently.

Minimize locking scope: We should always try to reduce the locking scope as much as possible because locking block will not be executed concurrently and it impacts the application's performance. We should always first try to use atomic and volatile variables to achieve our synchronization requirement if our requirement is not satisfied with them, and then we need to use the functionality provided by the Lock interface. We can also reduce the locking scope to use a synchronized block instead of the synchronized method.

Use Java Executor framework: It provides an abstraction layer on the Java threading framework and provides better control in terms of creating and executing threads in a multithreaded environment.