java 篇之Lock、ReentrantLock、synchronized

最新推荐文章于 2025-12-08 09:18:56 发布

转载最新推荐文章于 2025-12-08 09:18:56 发布 · 164 阅读

0 ·

CC 4.0 BY-SA版权

原文链接：https://my.oschina.net/chenping12/blog/1517563

文章标签：

#java

1、什么是锁

锁是java来保证线程安全的一种手段，当程序处于并发环境下运行的时候，共享数据没有及时刷新到主内存当中，造成其他线程读取到的是历史缓存数据，为了保证数据的正确性，java提供了锁的机制来

2、synchronized 和 ReentrantLock

ReentrantLock 是jdk 5 提供出来的一种高伸缩性的锁，synchronized 在jdk 6已经修改成和ReentrantLock 一样的内部算法，所有在性能问题上 synchronized 已经和ReentrantLock接近，但是ReentrantLock提供了更多操作锁的方法

2.1 synchronized

一般我们使用synchronized(obj) 方式来使用同步锁，记住，最好不要用synchronized(this)方式，这种方式存在一个问题，比如 A 先获取到锁，B本来是A无关联的类，但是由于使用这种方式（锁住当前对象），B必须等待A的锁先释放才可以获取到锁，性能低下

public class Test{

public void A(){

synchronized(this){

}

public void B(){

synchronized(this){

}

2.2 ReentrantLock

ReentrantLock 作为jdk 5 出来的一种新的锁的方式完全可以替代synchronized，ReentrantLock 有3中锁的方式，我们来一一对比下

package main.test.thead;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * Created by ping on 2017/8/20.
 */
public class LockTest {
    private static int count = 0;
    private static final CountDownLatch start = new CountDownLatch(1);
    private static final CountDownLatch end = new CountDownLatch(10);
    private static final Object obj = new Object();
    private static final ReentrantLock lock = new ReentrantLock();

    public static void main(String[] args) throws InterruptedException {
        for (int i =0 ;i < 100 ;i++){
            Thread thread = new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        start.await();

                        //task
                        //这里可以是 lock.lock(),lock.lockInterruptibly()
                        if(lock.tryLock(10L,TimeUnit.SECONDS)){
                            try {
                                System.out.println(count++);
                            }catch (Exception e){
                                e.printStackTrace();
                            }
                            finally {
                                lock.unlock();
                            }
                        }else{
                            System.out.println("获取锁失败...");
                        }


                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }finally {
                        end.countDown();
                    }
                }
            });
            thread.start();
        }
        start.countDown();
        end.await();
    }


}

1、lock.lock()方式，这种方式是阻塞的（没有获取到锁会一直等待，线程处于休眠状态），功能基本和synchronized一样

2、lock.tryLock()方式，这种方式如果没有获取到锁，立即放回false（不阻塞），执行接下来的业务逻辑，可以设置等待时间

上面两种方式都不会响应线程中断

3、lock.lockInterruptibly(),这种方式也是阻塞的，但是如果当前线程中断，那么线程会从休眠中唤醒来响应线程中端

转载于:https://my.oschina.net/chenping12/blog/1517563