基本代码中显示了读/写锁定与同步之间的区别

Question

In my homework I need to show the difference between read/write lock and 'synchronized' key word usage in code. I really don't know how to do it and what is the clear way to understand that difference. I also need to show the time difference between execution of the same task in both ways. Here is code that I tried (without synchronized though)

public class Main {

    public static void main(String[] args) {

        Number number = new Number(5);

        Thread t1 = new Thread(){
            public void run(){
                System.out.println(number.getData());
                number.changaData(10);
                System.out.println(number.getData());
            }};
            Thread t2 = new Thread(){
                public void run(){
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    System.out.println(number.getData());
                    number.changaData(20);
                    System.out.println(number.getData());
                }};

                t2.start();
                t1.start();
    }
}


public class Number {

    private final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
    private final Lock readLock = rwl.readLock();
    private final Lock writeLock = rwl.writeLock();
    int value;

    public Number(int value) {
        this.value = value;
    }

    public int getData() {
        readLock.lock();
        try {
            return value;
        }
        finally {
            readLock.unlock();
        }
    }

    public int changaData(int change) {
        writeLock.lock();
        try {
            value = change;
            return value;
        }
        finally {
            writeLock.unlock();
        }
    }
}

Answer 1

The difference between synchronized and read/write locks is such that when you are using synchronized it allows only one thread at a time to access. With read/write lock you can have many readers at the same time (given that there are no write locks already in) so you can get better concurrent performance under some cases, especially when having many reads here.

You should add many more threads that are accessing this object to test performance.

And you can simply count time between finishing and starting of operations to measure performance (in example - Long startTime = System.nanoTime();).

Read up here to see how to check whether thread has ended so you can measure execution time : How to know if other threads have finished?

---

edit to answer comment: Hey, my answer is a bit simplified (ok, very, as multithreading is hard) as I was writing this in between doing stuff, so, for now, I can link you with some other resources which provide more in-depth look.

• What does 'synchronized' mean?
• How do I write a correct micro-benchmark in Java? <- when writing performance tests it's good to be aware of this
• https://javarevisited.blogspot.com/2013/03/reentrantlock-example-in-java-synchronized-difference-vs-lock.html
• https://javarevisited.blogspot.com/2011/04/synchronization-in-java-synchronized.html

very simple example as per your existing class:

class Number {

    private int value;

    public Number(int value) {
        this.value = value;
    }

    public synchronized int getValue() {
        return value;
    }

    public synchronized int changeData(int change) {
        value = change;
        return value;
    }
}