Synchronization in Respect to Multithreading in Java

2025 年 3 月 28 日 | 阅读 6 分钟

在 Java 多线程中，同步 确保多个线程对共享资源的受控访问，以防止数据不一致。同步的主要目标是避免线程干扰和内存可见性问题。

同步方法

Java 中的同步方法一次只允许一个线程访问。当执行一个同步方法时，调用线程会获取对对象（实例方法）或类（静态方法）的锁。在持有锁的线程释放锁之前，它会阻止其他线程在该对象或类上运行同步方法。

语法

public synchronized void synchronizedMethod() {
    // synchronized code
} 

文件名：SynchronizationDemo.java

class BankAccount {
    // Instance variable to hold the account balance
    private int balance = 1000;
    // Synchronized Method to withdraw money from the account
    // It ensures that only one thread can execute this Method at a time on the same BankAccount object
    public synchronized void withdraw(int amount) {
        // Check if the balance is sufficient for the withdrawal
        if (balance >= amount) {
            // Deduct the withdrawal amount from the balance
            balance -= amount;
            // Print the successful withdrawal message and the remaining balance
            System.out.println("Withdrawal successful. Remaining balance: " + balance);
        } else {
            // If funds are insufficient, print a failure message
            System.out.println("Insufficient funds. Withdrawal failed.");
        }
    }
}
public class SynchronizationDemo {
    public static void main(String[] args) {
        // Create a new BankAccount object with an initial balance of 1000
        BankAccount account = new BankAccount();
        // Create a thread to withdraw 700 units of money from the account
        Thread t1 = new Thread(() -> account.withdraw(700));
        // Create another thread to withdraw 500 units of money from the account
        Thread t2 = new Thread(() -> account.withdraw(500));
        // Start the first thread
        t1.start();
        // Start the second thread
        t2.start();
    }
}   

输出

 
Withdrawal successful. Remaining balance: 300
Insufficient funds. Withdrawal failed.

同步代码块

在 Java 中，同步块用于同步特定的代码块，而不是整个方法。它允许更精细地管理哪些代码段是同步的，从而减小了锁的范围，并可能提高性能。

语法

synchronized (object) {
    // synchronized code
}   

示例

文件名：Synchronized BlockDemo.java

class Counter {
    // Instance variable to hold the count value
    private int count = 0;
    // Lock object used for synchronization
    private final Object lock = new Object();  
    //Method to increment the count
    public void increment() {
        // Only this block of code is synchronized using the lock object
        synchronized (lock) {
            count++;  // Increment the count by 1
        }
    }
    //Method to return the current value of the count
    public int getCount() {
        return count;  // Return the current count value
    }
}
public class SynchronizedBlockDemo {
    public static void main(String[] args) {
        // Create a new Counter object
        Counter counter = new Counter();
        // Create a thread that increments the count 1000 times
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();  // Call the increment method
            }
        });
        // Create another thread that increments the count 1000 times
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();  // Call the increment method
            }
        });
        // Start the first thread
        t1.start();
        // Start the second thread
        t2.start();
        try {
            // Wait for the first thread to finish execution
            t1.join();
            // Wait for the second thread to finish execution
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();  // Handle any InterruptedException that may occur
        }
        // Print the final count value, which should be 2000 if synchronization works correctly
        System.out.println("Count: " + counter.getCount());
    }
}   

输出

 
Count: 2000

静态同步

静态同步是指同步 Java 中的静态方法或块。如果一个静态方法或块是同步的，那么锁与类对象相关联，而不是与任何特定的类实例相关联。它确保对于某个特定的类，无论有多少个类实例，一次只有一个线程可以运行同步的静态方法或块。

语法

public static synchronized void synchronizedStaticMethod() {
    // synchronized code
}   

文件名：StaticSynchronization.java

class Counter {
    // A static variable to hold the count value, shared among all instances of the class
    private static int count = 0;
    // A synchronized static method to increment the count
    // It ensures that only one thread can execute this Method at a time for the Counter class
    public static synchronized void increment() {
        count++;  // Increment the count by 1
    }
    // A static method to return the current value of the count
    public static int getCount() {
        return count;  // Return the current count value
    }
}
public class StaticSynchronization {
    public static void main(String[] args) {
        // Create a new thread that increments the count 1000 times
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                Counter.increment();  // Call the synchronized increment method
            }
        });
        // Create another thread that increments the count 1000 times
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                Counter.increment();  // Call the synchronized increment method
            }
        });
        // Start both threads
        t1.start();
        t2.start();
        try {
            // Wait for both threads to finish execution
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();  // Handle any InterruptedException that may occur
        }
        // Print the final count value, which should be 2000 if the synchronization works correctly
        System.out.println("Count: " + Counter.getCount());
    }
}   

输出

 
Count: 2000

可重入同步

可重入同步允许线程多次进入同步块或方法而不会发生死锁。这得益于 Java 的可重入同步功能，该功能允许线程多次获取同一个锁。

文件名：ReentrantDemo.java

class ReentrantExample {
    // Synchronized Method, meaning only one thread can execute it at a time on the same object
    public synchronized void outerMethod() {
        System.out.println("In outer method");  // Print a message indicating entry into the outer method
        // Call another synchronized method within the same object
        innerMethod();  // It demonstrates reentrant synchronization, where the same thread can acquire the lock again
    }
    // Another synchronized method
    public synchronized void innerMethod() {
        System.out.println("In inner method");  // Print a message indicating entry into the inner method
    }
}
public class ReentrantDemo {
    public static void main(String[] args) {
        // Create an instance of ReentrantExample
        ReentrantExample example = new ReentrantExample();
        // Create a new thread that calls the outerMethod
        Thread t1 = new Thread(() -> {
            example.outerMethod();  // It will call outerMethod(), which in turn calls innerMethod()
        });
        // Start the thread, allowing it to execute the outerMethod
        t1.start();  // The thread will acquire the lock and proceed with the method execution
    }
}   

输出

 
In outer Method
In inner Method

使用 ReentrantLock 的示例

文件名：ReentrantDemo.java

import java.util.concurrent.locks.ReentrantLock;
class ReentrantExample {
    // Create a ReentrantLock instance
    private final ReentrantLock lock = new ReentrantLock();
    //Method that uses the lock for synchronization
    public void outerMethod() {
        lock.lock();  // Acquire the lock
        try {
            System.out.println("In outer method");  // Print a message indicating entry into the outer method
            innerMethod();  // Call another method that also uses the same lock
        } finally {
            lock.unlock();  // Release the lock to allow other threads to acquire it
        }
    }
    // Another method that uses the same lock for synchronization
    public void innerMethod() {
        lock.lock();  // Re-acquire the lock
        try {
            System.out.println("In inner method");  // Print a message indicating entry into the inner method
        } finally {
            lock.unlock();  // Release the lock to allow other threads to acquire it
        }
    }
}
public class ReentrantDemo {
    public static void main(String[] args) {
        // Create an instance of ReentrantExample
        ReentrantExample example = new ReentrantExample();
        // Create a new thread that calls the outerMethod
        Thread t1 = new Thread(() -> {
            example.outerMethod();  // It will call outerMethod(), which in turn calls innerMethod()
        });
        // Start the thread, allowing it to execute the outerMethod
        t1.start();  // The thread will acquire the lock and proceed with method execution
    }
}   

输出

 
In outer Method
In inner Method

下一主题Java 中如何避免空指针异常

Synchronization in Respect to Multithreading in Java

同步方法

同步代码块

静态同步

可重入同步

使用 ReentrantLock 的示例

联系信息

关注我们

教程

面试题

在线编译器

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

Java Conversion

Java Misc

Synchronization in Respect to Multithreading in Java

同步方法

同步代码块

静态同步

可重入同步

使用 ReentrantLock 的示例

相关帖子

Java 中洗牌数组

Java Logger

Java 中的 Atomic Boolean

Java 8 之后的接口 vs. 抽象类

Java 中捕获基类和派生类作为异常

Java 中的三元运算符

Java 中的 NullPointerException

A Java Runtime Environment JRE Or JDK Must Be Available

Stack vs Heap Java

最流行的 Java 后端工具

订阅 Tpoint Tech

联系信息

关注我们

教程

面试题

在线编译器