ReentrantLock与synchronized的区别

最新推荐文章于 2024-10-05 12:07:50 发布

.-残念-.

最新推荐文章于 2024-10-05 12:07:50 发布

阅读量62

点赞数

文章标签： java 开发语言

本文链接：https://blog.csdn.net/weixin_52617676/article/details/131794029

版权

文章对比了ReentrantLock和synchronized在多线程同步中的异同，指出ReentrantLock具有显示获取和释放锁、响应中断、可配置公平锁以及通过Condition支持多个条件等特点，而synchronized则是隐式同步并由JVM实现。

摘要由CSDN通过智能技术生成

1.ReentrantLock与synchronized的相同点

1.都是用来协调多线程对共享对象、变量的访问

2.都是可重入锁，同一线程可以多次获得同一个锁

3.都保证了可见性和互斥性

2.ReentrantLock与synchronized的不同点

1. ReentrantLock显示地获得，释放锁，synchronized隐式获得释放锁

2. ReentrantLock可响应中断，可轮回，synchronized是不可以响应中断的

3. ReentrantLock是API级别的，synchronized是JVM级别的

4. ReentrantLock可以实现公平锁

5. ReentrantLock通过Condition可以绑定多个条件

6. Lock是一个接口，而synchronized是java中的关键字，synchronized是内置的语言实现

public class Doem3 {
    public static void main(String[] args) throws NoSuchFieldException, InterruptedException {
        counter c1 = new counter();
        Thread t1 = new Thread(){
            @Override
            public void run() {
                c1.add();
            }
        };
        Thread t2 = new Thread(){
            @Override
            public void run() {
                c1.dec();
            }
        };
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(counter.count);
    }
}
class counter {
    public static int count = 0;

    private final ReentrantLock lock = new ReentrantLock();
    public void add(){
        for (int i = 0; i < 10000; i++) {
            lock.lock();
            try{
                counter.count+=1;
            }finally {
                lock.unlock();
            }
        }
    }

    public void dec(){
        for (int i = 0; i < 10000; i++) {
            lock.lock();
            try{
                counter.count-=1;
            }finally {
                lock.unlock();
            }
        }
    }

}

public class Demo4 {
    public static void main(String[] args) throws InterruptedException {
        Counter1 c1 = new Counter1();
        Thread t1 = new Thread(){
            @Override
            public void run() {
                c1.add();
            }
        };
        Thread t2 = new Thread(){
            @Override
            public void run() {
                c1.dec();
            }
        };
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(Counter1.count);
    }
}
class Counter1 {
    public static int count = 0;

    public synchronized void add(){
        for (int i = 0; i < 10000; i++) {
            Counter1.count+=1;
        }
    }

    public synchronized void dec(){
        for (int i = 0; i < 10000; i++) {
            Counter1.count-=1;
        }
    }

}