Synchronization and locking mechanism of interfaces and abstract classes in Java

Synchronization mechanism of interfaces and abstract classes in Java: Interfaces and abstract classes cannot be instantiated and cannot have their own locks. Synchronized methods can be declared, which are similar to ordinary methods but modified using the synchronized keyword. When a synchronized method is called, the thread will acquire the lock of the method. Other threads calling the same method at the same time will be blocked until the lock is released. Practical case: The shared resource class SharedResource has two synchronization methods. Two threads access the resource concurrently. However, due to method synchronization, the thread must wait for access to the lock before modifying the value to ensure the correctness of the value and avoid concurrency problems.

Synchronization and locking mechanism of interfaces and abstract classes in Java

Introduction

Synchronization is a mechanism to ensure safe access to shared resources by multiple threads. In Java, you can use locks to achieve synchronization. A lock is an object that, when a thread requests a lock, blocks other threads from accessing the resource until the lock is released.

Synchronization in interfaces and abstract classes

Interfaces and abstract classes cannot be instantiated, so they cannot have their own locks. However, they can declare synchronized methods, which are very similar to normal methods but modified using the synchronized keyword.

public interface SynchronizedInterface {

    synchronized void synchronizedMethod();

}

public abstract class SynchronizedAbstractClass {

    synchronized void synchronizedMethod();

}

When a thread calls a synchronized method, it acquires the method's lock. If another thread tries to call the same method at the same time, it will be blocked until the lock is released.

Practical case

Consider a shared resource class SharedResource, which has two synchronization methods: increment and decrement.

public class SharedResource {

    private int value = 0;

    public synchronized void increment() {
        value++;
    }

    public synchronized void decrement() {
        value--;
    }

}

Now, we have two threads Thread1 and Thread2, which access SharedResource concurrently.

public class Thread1 implements Runnable {

    private SharedResource sharedResource;

    @Override
    public void run() {
        for (int i = 0; i < 100000; i++) {
            sharedResource.increment();
        }
    }

}

public class Thread2 implements Runnable {

    private SharedResource sharedResource;

    @Override
    public void run() {
        for (int i = 0; i < 100000; i++) {
            sharedResource.decrement();
        }
    }

}

public class Main {

    public static void main(String[] args) {
        SharedResource sharedResource = new SharedResource();

        Thread1 thread1 = new Thread1();
        Thread2 thread2 = new Thread2();

        thread1.start();
        thread2.start();

        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Final value: " + sharedResource.value);
    }

}

In this case, two threads call the increment and decrement methods in parallel, but since these methods are synchronized, each thread is modifyingvalue Must wait for access to the lock before. This ensures that the value of value is always correct and no concurrency issues arise.

The above is the detailed content of Synchronization and locking mechanism of interfaces and abstract classes in Java. For more information, please follow other related articles on the PHP Chinese website!