SoFunction
Updated on 2025-05-13

Several common methods of Java multithreaded synchronization

What are the methods of Java multithreading synchronization?

1. Use synchronized keywords

synchronizedIt is the most basic synchronization method provided by Java. It can be used to modify methods or code blocks to ensure that only one thread can execute the synchronized code part at the same time.

(1) Synchronization method

Mark the entire method as a synchronous method to ensure that only one thread can execute the method at the same time.

public synchronized void method() {
    // Thread-safe operation}
  • If the synchronization method is an instance method, the lock is the current instance object (this）。
  • If the synchronization method is a static method, the lock is a class object (Class）。

(2) Synchronize code block

By synchronizing code blocks, specifying a specific lock object to control the scope of synchronization, thereby improving performance.

public void method() {
    synchronized (this) {
        // Thread-safe operation    }
}

This means locking the current instance object, and you can use different lock objects as needed.

2. Use ReentrantLock

ReentrantLock is a lock implementation in the package, providing more flexible and powerful functions than synchronized, such as reentrant, fairness, response to interrupts, etc. Control the acquisition and release of locks by explicitly calling lock() and unlock().

import ;
 
public class LockExample {
    private final ReentrantLock lock = new ReentrantLock();
 
    public void method() {
        ();
        try {
            // Thread-safe operation        } finally {
            ();
        }
    }
}

characteristic:

  • Reentrability: The same thread can obtain locks multiple times.
  • Fairness: A fair lock can be selected (acquisition locks in the order of request).
  • Interrupt response: Support response thread interrupts.

3. Use ReadWriteLock

ReadWriteLockyesAn interface in the package is divided intoReentrantReadWriteLockImplementation class. It provides a read-write lock mechanism, where multiple threads are allowed to read at the same time, but write operations are mutually exclusive, ensuring efficient read operations and avoiding write operations conflicts.

import ;
 
public class ReadWriteLockExample {
    private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
 
    public void readMethod() {
        ().lock();
        try {
            // Thread-safe read operation        } finally {
            ().unlock();
        }
    }
 
    public void writeMethod() {
        ().lock();
        try {
            // Thread-safe write operation        } finally {
            ().unlock();
        }
    }
}

characteristic:

  • Read lock: Multiple threads can obtain read locks at the same time, as long as no write locks are occupied.
  • Write lock: Write lock is exclusive. When one thread acquires a write lock, other threads cannot obtain read locks or write locks at the same time.

4. Use the volatile keyword

volatileKeywords are used to ensure that the thread's modification of a variable is immediately visible to other threads.volatileThe visibility of variables is guaranteed, but the atomicity cannot be guaranteed.

private volatile boolean flag = false;
  • Visibility: Make sure the threads are correctvolatileModification of variables is immediately visible to other threads.
  • Atomicity is not guaranteed: For compound operations (such asi++），volatileAtomicity cannot be guaranteed.

5. Use the Atomic class

The package provides some atomic operation classes, such asAtomicInteger、AtomicBooleanetc., suitable for handling simple numerical operations. They provide atomic operations through the CAS (Compare and Exchange) mechanism, avoiding the use of locks.

import ;
 
public class AtomicExample {
    private final AtomicInteger count = new AtomicInteger(0);
 
    public void increment() {
        ();
    }
 
    public int getCount() {
        return ();
    }
}
  • Atomicity: These classes ensure thread safety through the underlying CAS operation.
  • Lockless mechanism: Avoid the performance overhead of traditional locks.

6. Use Semaphore

SemaphoreIt is a synchronization tool used to control the number of threads that access specific resources simultaneously. It can set a semaphore count to control the number of threads that can access certain resources.

import ;
 
public class SemaphoreExample {
    private final Semaphore semaphore = new Semaphore(3); // Maximum 3 threads are allowed 
    public void accessResource() {
        try {
            ();
            // Perform resource access operations        } catch (InterruptedException e) {
            ();
        } finally {
            ();
        }
    }
}
  • Controlling concurrency count: Control the number of concurrent threads through semaphores.
  • Applicable scenarios: Used to restrict concurrent access to certain shared resources, such as database connection pools, etc.

7. Use CountDownLatch

CountDownLatchIt is a synchronization tool that allows one or more threads to wait until other threads complete a set of operations before continuing to execute. It is usually used to start the main thread or other threads after a group of threads completes the task.

import ;
 
public class CountDownLatchExample {
    private final CountDownLatch latch = new CountDownLatch(3); // Wait for 3 threads to complete 
    public void task() {
        try {
            // Perform certain operations        } finally {
            (); // The operation is completed, the count is reduced by one        }
    }
 
    public void mainTask() throws InterruptedException {
        (); // Wait for all threads to complete        ("All tasks are finished!");
    }
}

8. Use CyclicBarrier

CyclicBarrierIt is a synchronization tool that allows a group of threads to wait for each other until all threads reach a common barrier point before continuing to execute. It is suitable for scenarios where multi-threaded parallel execution is required.

import ;
 
public class CyclicBarrierExample {
    private final CyclicBarrier barrier = new CyclicBarrier(3, new Runnable() {
        @Override
        public void run() {
            ("All threads reached the barrier, continue execution.");
        }
    });
 
    public void task() throws InterruptedException {
        (); // Wait for all threads to reach the barrier        // Execute tasks    }
}

Summarize

Java provides a variety of synchronization mechanisms to ensure thread safety in a multi-threaded environment. The specific method used depends on the actual application scenario:

  • synchronized: Simple and easy to use, but low performance.
  • ReentrantLock: Provides more flexible lock control.
  • ReadWriteLock: Suitable for scenarios where more reads, less writes.
  • volatile: Used to ensure the visibility of variables, but not suitable for compound operations.
  • AtomicClass: Suitable for simple atomic operations, avoiding the use of locks.
  • Semaphore: Controls the number of concurrent threads.
  • CountDownLatchandCyclicBarrier: used for inter-thread coordination and synchronization.

These methods can help us achieve thread-safe and efficient concurrent control in different scenarios.

The above are the detailed contents of several common methods of Java multithreading synchronization. For more information about Java multithreading synchronization methods, please pay attention to my other related articles!