An example to understand how to use the synchronized keyword in Java

This article brings you relevant knowledge about java, which mainly introduces issues related to the synchronized keyword, including using synchronization methods, using synchronization statements or blocks, and what is synchronization , why synchronization is needed, let’s take a look at it, I hope it will be helpful to everyone.

Recommended study: "java video tutorial"

In daily development, the synchronized keyword is often encountered, do you know synchronized How to use it? This article will introduce it to you.

We have two ways to use synchronization:

• Use synchronization method
• Use synchronization statement or block

Use synchronization method

To make a method synchronized, just add the synchronized keyword to its declaration:

public class SynchronizedDemo {

    private int i = 0;

    public synchronized void add() {
        i++;
    }

    public synchronized void del() {
        i--;
    }

    public synchronized int getValue() {
        return i;
    }
}

As the above code shows, there are three synchronized methods:

• add()
• del()
• getValue()

Each method will only be called on the same object at the same time Once, for example, when a thread calls add(), other threads will be blocked until the first thread finishes processing the add() method.

Use synchronized statements or blocks

    public void del(int value){

        synchronized(this){
            this.i -= value;
        }
    }

In the above code, synchronized is added before a {} code, which represents a synchronized code block.

The above are two ways to use the synchronized keyword. Let’s briefly introduce the concepts related to synchronization.

What is synchronization?

Synchronization is a process that controls multiple threads' access to any shared resource to avoid inconsistent results. The main purpose of using synchronization is to avoid inconsistent behavior of threads and prevent thread interference.

You can use the synchronized keyword in java to achieve synchronization effects. synchronized can only be applied to methods and blocks, not variables and classes.

Why do we need to synchronize?

First let’s look at a piece of code:

public class SynchronizedDemo {

    int i;

    public void increment() {
        i++;
    }

    public static void main(String[] args) {
        SynchronizedDemo synchronizedDemo = new SynchronizedDemo();
        synchronizedDemo.increment();
        System.out.println("计算值为：" + synchronizedDemo.i);
    }
}

The calculated value will be increased by 1 whenever the increment() method is called:

Call 2 times will add 2, 3 times will add 3, 4 times will add 4:

public class SynchronizedDemo {

    int i;

    public void increment() {
        i++;
    }

    public static void main(String[] args) {
        SynchronizedDemo synchronizedDemo = new SynchronizedDemo();
        synchronizedDemo.increment();
        synchronizedDemo.increment();
        synchronizedDemo.increment();
        synchronizedDemo.increment();
        System.out.println("计算值为：" + synchronizedDemo.i);
    }
}

Now let’s expand the above example and create a thread Call the increment() method 10 times:

public class SynchronizedDemo {

    int i;

    public void increment() {
        i++;
    }

    public static void main(String[] args) {
        SynchronizedDemo synchronizedDemo = new SynchronizedDemo();
        Thread thread = new Thread(() -> {
            for (int i = 1; i <= 10; i++) {
                synchronizedDemo.increment();
            }
        });
        thread.start();
        try {
            thread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("计算值为：" + synchronizedDemo.i);
    }
}

The calculated result at this time is as we expected, the result is 10.

This is a single thread Everything is so beautiful, but is it really the case? What would it look like if it were a multi-threaded environment?

Let’s demonstrate the multi-threading situation!

public class SynchronizedDemo {

    int i;

    public void increment() {
        i++;
    }

    public static void main(String[] args) {
        SynchronizedDemo synchronizedDemo = new SynchronizedDemo();

        Thread thread1 = new Thread(() -> {
            for (int i = 1; i <= 1000; i++) {
                synchronizedDemo.increment();
            }
        });

        Thread thread2 = new Thread(() -> {
            for (int i = 1; i <= 1000; i++) {
                synchronizedDemo.increment();
            }
        });

        thread1.start();
        thread2.start();
        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("计算值为：" + synchronizedDemo.i);
    }
}

As shown in the above code, we created two threads thread1 and thread2, and each thread called increment() 1000 times. In theory, the final printed value should be 2000, because thread1 calls increment () After 1000 times, the value will become 1000. After thread2 calls increment() 1000 times, the value will become 2000.

Let’s execute it and see the result:

The result is different from what we thought. It is less than 2000. Let’s execute it again:

The result is still less than 2000.

Why is this? ?

Because multi-threading supports parallel processing, it is always possible for two threads to get the value of the counter at the same time, and therefore both get the same counter value, so in this case, instead of incrementing the counter value twice , only increased once.

So, how to avoid this situation?

Use synchronized keyword to solve this problem.

We only need to add synchronized to the increment() method:

public class SynchronizedDemo {

    int i;

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

    public static void main(String[] args) {
        SynchronizedDemo synchronizedDemo = new SynchronizedDemo();

        Thread thread1 = new Thread(() -> {
            for (int i = 1; i <= 1000; i++) {
                synchronizedDemo.increment();
            }
        });

        Thread thread2 = new Thread(() -> {
            for (int i = 1; i <= 1000; i++) {
                synchronizedDemo.increment();
            }
        });

        thread1.start();
        thread2.start();
        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("计算值为：" + synchronizedDemo.i);
    }
}

Let’s execute it again at this time:

As you can see, the value is 2000.

We increase the number of calculations to 10,000 times:

public class SynchronizedDemo {

    int i;

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

    public static void main(String[] args) {
        SynchronizedDemo synchronizedDemo = new SynchronizedDemo();

        Thread thread1 = new Thread(() -> {
            for (int i = 1; i <= 10000; i++) {
                synchronizedDemo.increment();
            }
        });

        Thread thread2 = new Thread(() -> {
            for (int i = 1; i <= 10000; i++) {
                synchronizedDemo.increment();
            }
        });

        thread1.start();
        thread2.start();
        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("计算值为：" + synchronizedDemo.i);
    }
}

The execution result is:

Okay It can be seen that a little synchronized solves this problem so easily.

The principle behind this is that when thread 1 executes the increment() method, because it is synchronized, this method will be automatically locked. At this time, only thread 1 has this lock, and other threads can only wait until thread 1 Release this lock so that thread 2 can participate in the call.

Similarly, when thread 2 calls increment(), thread 2 gets the lock, and thread 1 waits until thread 2 releases the lock. That's it, until the calculation is completed. During this process, there will be no A calculation error has occurred.

Summary

• The synchronized keyword is the only way to make a block or method synchronized.
• The synchronized keyword provides locking features that ensure that race conditions do not occur between threads. After being locked, the thread can only read data from main memory. After reading the data, it flushes the write operation before it can release the lock.
• The synchronized keyword also helps avoid reordering of program statements.

Recommended study: "java video tutorial"

The above is the detailed content of An example to understand how to use the synchronized keyword in Java. For more information, please follow other related articles on the PHP Chinese website!