Lock和Synchronized的不同

最新推荐文章于 2024-11-11 21:19:25 发布
最新推荐文章于 2024-11-11 21:19:25 发布
阅读量108 收藏
点赞数
分类专栏： 多线程 文章标签： java

  在 Java 中线程的状态可以分为：新建（New）,运行状态（Runnable）、阻塞状态（Blocked）、等待状态（Waiting）、结束状态（Terminated）。运行状态可以转为 阻塞状态或等待状态。

   在接收完基本概念后，我们看看显示锁（Lock）和内部锁（synchronized）有什么不同。

  1. Lock 支持更细粒度的同步控制
  2. Lock是无阻塞锁，synchronized 是阻塞锁。当线程A持有锁S，如果线程B也期望获取锁S,如果是显示锁则线程B进入等待状态，如果是内部锁则线程B进入阻塞状态
  3. Lock可以实现公平锁(默认是非公平锁，即使对公平锁而言，可轮询的tryLock仍然会插队)，synchronized 只能是非公平锁
  4. Lock 是代码级的，synchronized 是JVM级的。

      ReentrantLock实现了Lock接口，并提供了与Synchronized相同的互斥性和可见性。在获取ReentrantLock时，有着与进入同步代码块相同的内存语义，在释放ReentrantLock时同样有着与退出同步代码块相同的含义。此外还提供了一些其他的功能，包括定时的锁等待，可中断的锁等待等。

     与显示锁相比，内置锁容然具有很大的优势（性能在JAVA 6.0 后与显示锁旗鼓相当）。内置锁为大家所熟悉，代码简洁紧凑。所以在一些内置锁无法满足需求的情况下，ReentrantLock可以作为一种高级工具。当需要一些高级功能时才应该使用ReentrantLock,这些功能包括：可定时的、可轮询的与可中断的锁获取操作，公平队列以及非块锁。否则，还是优先考虑使用内置锁。因为 synchronized 是JVM的内置属性，在未来优化的可能性更高。

import java.util.Calendar;
import java.util.concurrent.TimeUnit;

/**
 *
 * @author zhangwei_david
 * @version $Id: Task.java, v 0.1 2014年10月23日 下午10:26:05 zhangwei_david Exp $
 */
public class Task {

    public void doSomething() {
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (Exception e) {

        }
        StringBuffer strBuffer = new StringBuffer();
        strBuffer.append("线程名称：" + Thread.currentThread().getName());
        strBuffer.append(", 执行时间 ：" + Calendar.getInstance().get(13) + "s");
        System.out.println(strBuffer.toString());
    }

}
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 *
 * @author zhangwei_david
 * @version $Id: TaskWithLock.java, v 0.1 2014年10月23日 下午10:29:47 zhangwei_david Exp $
 */
public class TaskWithLock extends Task implements Runnable {

    Lock lock = new ReentrantLock();

    /**
     * @see java.lang.Runnable#run()
     */
    public void run() {
        try {
            lock.lock();
            doSomething();
        } finally {
            lock.unlock();
        }
    }

}
/**
 *
 * @author zhangwei_david
 * @version $Id: TaskWithSync.java, v 0.1 2014年10月23日 下午10:31:33 zhangwei_david Exp $
 */
public class TaskWithSync extends Task implements Runnable {

    /**
     * @see java.lang.Runnable#run()
     */
    public void run() {
        synchronized ("A") {
            doSomething();
        }
    }

}

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

/**
 *
 * @author zhangwei_david
 * @version $Id: TaskTest.java, v 0.1 2014年10月23日 下午10:32:07 zhangwei_david Exp $
 */
public class TaskTest {
    public static void runTask(Class<? extends Runnable> clz) throws InterruptedException,
    InstantiationException,
    IllegalAccessException {
        ExecutorService es = Executors.newCachedThreadPool();
        System.out.println("*** 开始执行 " + clz.getSimpleName() + " 任务****");
        for (int i = 0; i < 3; i++) {
            es.submit(clz.newInstance());
        }
        TimeUnit.SECONDS.sleep(10);
        System.out.println("---------" + clz.getSimpleName() + "-----------任务执行完毕！\n\n");
        es.shutdown();
    }

    /**
     *
     * @param args
     * @throws Exception
     * @throws
     * @throws
     */
    public static void main(String[] args) throws Exception {
        runTask(TaskWithLock.class);

        runTask(TaskWithSync.class);
    }

}

 运行的结果是：

*** 开始执行 TaskWithLock 任务****
线程名称：pool-1-thread-3, 执行时间 ：24s
线程名称：pool-1-thread-2, 执行时间 ：24s
线程名称：pool-1-thread-1, 执行时间 ：24s
---------TaskWithLock-----------任务执行完毕！


*** 开始执行 TaskWithSync 任务****
线程名称：pool-2-thread-1, 执行时间 ：34s
线程名称：pool-2-thread-3, 执行时间 ：36s
线程名称：pool-2-thread-2, 执行时间 ：38s
---------TaskWithSync-----------任务执行完毕！

 从结果中可以发现Lock 没有生效，到底是什么呢？因为Lock 是代码级的锁，属于一个对象，定义一个私有的锁是不会起到同步的作用的。

 

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 *
 * @author zhangwei_david
 * @version $Id: TaskWithLock.java, v 0.1 2014年10月23日 下午10:29:47 zhangwei_david Exp $
 */
public class TaskWithLock extends Task implements Runnable {

    private static final TaskWithLock instance = new TaskWithLock();

    /**
     * Getter method for property <tt>instance</tt>.
     *
     * @return property value of instance
     */
    public static TaskWithLock getInstance() {
        return instance;
    }

    Lock lock = new ReentrantLock();

    /**
     * @see java.lang.Runnable#run()
     */
    public void run() {
        try {
            lock.lock();
            doSomething();
        } finally {
            lock.unlock();
        }
    }

}
/**
 *
 * @author zhangwei_david
 * @version $Id: TaskWithSync.java, v 0.1 2014年10月23日 下午10:31:33 zhangwei_david Exp $
 */
public class TaskWithSync extends Task implements Runnable {

    /**
     * @see java.lang.Runnable#run()
     */
    public void run() {
        synchronized ("A") {
            doSomething();
        }
    }

}

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

/**
 *
 * @author zhangwei_david
 * @version $Id: TaskTest.java, v 0.1 2014年10月23日 下午10:32:07 zhangwei_david Exp $
 */
public class TaskTest {
    public static void runTask(Runnable task) throws InterruptedException, InstantiationException,
    IllegalAccessException {
        ExecutorService es = Executors.newCachedThreadPool();
        System.out.println("*** 开始执行 " + task.getClass().getSimpleName() + " 任务****");
        for (int i = 0; i < 3; i++) {
            es.submit(task);
        }
        TimeUnit.SECONDS.sleep(10);
        System.out
        .println("---------" + task.getClass().getSimpleName() + "-----------任务执行完毕！\n\n");
        es.shutdown();
    }

    /**
     *
     * @param args
     * @throws Exception
     * @throws
     * @throws
     */
    public static void main(String[] args) throws Exception {
        runTask(TaskWithLock.getInstance());

        runTask(new TaskWithSync());
    }

}

 结果是：

*** 开始执行 TaskWithLock 任务****
线程名称：pool-1-thread-2, 执行时间 ：41s
线程名称：pool-1-thread-1, 执行时间 ：43s
线程名称：pool-1-thread-3, 执行时间 ：45s
---------TaskWithLock-----------任务执行完毕！


*** 开始执行 TaskWithSync 任务****
线程名称：pool-2-thread-2, 执行时间 ：51s
线程名称：pool-2-thread-3, 执行时间 ：53s
线程名称：pool-2-thread-1, 执行时间 ：55s
---------TaskWithSync-----------任务执行完毕！

 

 可以发现只有锁本身是共享的时候才可以进行代码的同步控制。

如果将Lock改成这样：

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 *
 * @author zhangwei_david
 * @version $Id: TaskWithLock.java, v 0.1 2014年10月23日 下午10:29:47 zhangwei_david Exp $
 */
public class TaskWithLock extends Task implements Runnable {

    private static final TaskWithLock instance = new TaskWithLock();

    /**
     * Getter method for property <tt>instance</tt>.
     *
     * @return property value of instance
     */
    public static TaskWithLock getInstance() {
        return instance;
    }

    Lock lock = new ReentrantLock(true);

    /**
     * @see java.lang.Runnable#run()
     */
    public void run() {
        try {
            lock.lock();
            doSomething();
        } finally {
            lock.unlock();
        }
    }

}

 运行的结果是：

*** 开始执行 TaskWithLock 任务****
线程名称：pool-1-thread-1, 执行时间 ：34s
线程名称：pool-1-thread-2, 执行时间 ：36s
线程名称：pool-1-thread-3, 执行时间 ：38s
---------TaskWithLock-----------任务执行完毕！


*** 开始执行 TaskWithSync 任务****
线程名称：pool-2-thread-1, 执行时间 ：44s
线程名称：pool-2-thread-3, 执行时间 ：46s
线程名称：pool-2-thread-2, 执行时间 ：48s
---------TaskWithSync-----------任务执行完毕！

 我们可以发现Lock的锁是公平的，而synchronized 是非公平的。（公平是指JVM优先选择等待时间最长的线程持有锁，非公平是指随机选择）

      在激烈竞争的情况下，非公平锁的性能远远高于公平锁，原因是：恢复一个被挂起的线程与该线程真正开始运行之间存在着验证的延迟。 如： 线程B请求线程A持有的锁，由于锁已经被A持有B被挂起，A释放锁，C请求锁；如果是非公平的锁，此时C可以持有锁，线程B被唤醒，B唤醒时C已经释放锁，B正好可以持有锁。公平锁，就必须等待B释放,C 才可以获取锁。

 

Synchronized 重入(Reentrant)

             当某个线程请求一个由其他线程持有的锁时，发出的请求的线程就会阻塞。然而，由于内置锁（Intrinsic Lock）是可重入的，因此如果该线程试图获取一个已经由他持有锁，那么这个请求就会成功。重入意味着获取锁的操作粒度是一个线程而不是调用。

 

/**
 *
 * @author zhangwei_david
 * @version $Id: Parent.java, v 0.1 2015年2月4日 下午5:28:43 zhangwei_david Exp $
 */
public class Parent {
    public synchronized void doParent() {
        System.out.println("父类获取锁，进入同步代码块");
    }
}

 

/**
 *
 * @author zhangwei_david
 * @version $Id: Child.java, v 0.1 2015年2月4日 下午5:30:11 zhangwei_david Exp $
 */
public class Child extends Parent {

    public synchronized void doChild() {
        System.out.println("子类获取锁，进入同步代码块");
        super.doParent();

    }
}

 测试类：

/**
 *
 * @author zhangwei_david
 * @version $Id: Client.java, v 0.1 2015年2月4日 下午5:31:31 zhangwei_david Exp $
 */
public class Client {

    public static void main(String[] args) {
        Child child = new Child();
        child.doChild();
    }
}

 结果是：

子类获取锁，进入同步代码块
父类获取锁，进入同步代码块

 

陈脩
关注
专栏目录
Lock与Synchronized的区别
2301_82243816的博客
04-19 848
大型分布式系统犹如一个生命，系统中各个服务犹如骨骼，其中的数据犹如血液，而Kafka犹如经络，串联整个系统。这份Kafka源码笔记通过大量的设计图展示、代码分析、示例分享，把Kafka的实现脉络展示在读者面前，帮助读者更好地研读Kafka代码。麻烦帮忙转发一下这篇文章+关注我《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！33%;" />大型分布式系统犹如一个生命，系统中各个服务犹如骨骼，其中的数据犹如血液，而Kafka犹如经络，串联整个系统。
java的lock和synchronized的区别.docx
09-18
lock 和 synchronized 都是锁的意思，但是它们有不同的实现机制和应用场景。lock 提供了更加灵活和高效的锁机制，可以满足不同场景下的需求，而 synchronized 则是 Java 中的关键字，具有语言的内置性。
Lock与synchronized是不一样的
你是我的天晴
11-17 1030
很多编码者都会说，Lock类和synchronized关键字用在代码块的并发性和内存上时语义 是一样的，都是保持代码块同时只有一个线程具有执行权。这样的说法只对了一半，我们以一个任务提交给多个线程运行为例，来看看使用显式锁（Lock类）和内部锁（synchronized 关键字）有什么不同。首先定义一个任务： class Task{ public void doSomething(){ t
JAVA应届生必备面试题--Lock锁和synchronized锁的区别
m0_58174511的博客
12-02 446
JAVA应届生必备面试题--Lock锁和synchronized锁的区别
Synchronized与lock锁区别
xc_blog
09-02 1万+
1、synchronized是java关键字，他是jvm层面； lock是接口（相应的实现比如ReentrantLock)； 2、synchronized无法获取到锁的状态， lock可以获取到锁的状态； 3、synchronized是自动锁，如果代码执行完毕或发生异常， 他会自动释放锁的资源， lock手动锁，需要人工进行调用unlock方法进行释放锁的资源， 一般都是放在finally； 如果不释放会发生死锁； 4、synchronized如果线程a获取到锁的资源，发生阻塞，线程b会一直等待， 而
Synchronized和Lock的区别
热门推荐
qq_42481883的博客
03-30 1万+
1.synchronized是一个关键字而lock是一个接口（lock、lockInterruptibly、tryLock、unlock、newCondition）。 2.synchronized是隐式的加锁，lock是显示的加锁。 3.synchronized可以作用在方法和代码块上，而lock只能作用在代码块上。 synchronized作用在静态方法上锁的是当前类的class，作用在普通方法上锁的是当前类的对象。 在javap反编译成字节码后，synchronized关键字需要有一个代码块进入的点mo
Synchronized锁和Lock锁的区别
Morning Sunshine的IT技术博客
01-07 1万+
面试必问之synchronized与Lock的区别及底层实现 一共8大区别； 区别1：Synchronized 是Java的一个关键字， 而Lock是java.util.concurrent.Locks 包下的一个接口； 区别2：Synchronized 使用过后，会自动释放锁， 而Lock需要手动上锁、手动释放锁。（在 finally 块中） 区别3：Lock提供了更多的实现方法，而且 可响...
Lock和Synchronized区别
渣渣
07-17 6220
https://blog.csdn.net/zhangcanyan/article/details/80284586 一、synchronized和lock的用法区别 synchronized：在需要同步的对象中加入此控制，synchronized可以加在方法上，也可以加在特定代码块中，括号中表示需要锁的对象。lock：需要显示指定起始位置和终止位置。一般使用ReentrantLock类做为锁，多个线程中必须要使用一个ReentrantLock类做为对象才能保证锁的生效。且在加锁和解锁处需要通过lock
synchronized 和Lock区别
kv110的专栏
08-31 1964
原文不知道网址，这是转发的转发 https://blog.csdn.net/hefenglian/article/details/82383569 如有问题，请告诉我 0、synchronized实现原理 Java中每一个对象都可以作为锁，这是synchronized实现同步的基础： 普通同步方法，锁是当前实例对象 静态同步方法，锁是当前类的class对象 同步方法块，锁...
Synchronized 和 Lock 的区别和使用场景
01-20
本文将深入探讨两种主要的锁机制：`synchronized`关键字和`Lock`接口，以及它们各自的特点、应用场景和使用方式。 一、Synchronized `synchronized`是Java中的一个内置关键字，用于提供线程安全。它的主要作用是...
lock锁，lock锁和synchronized的对比
11-19
lock锁，lock锁和synchronized的对比 # Lock锁 JDK5.0后Java提供了一种更加强大的线程同步机制。一种显式定义同步锁对象来实现锁，提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问...
简单了解synchronized和lock的区别
08-25
了解synchronized和lock的区别 synchronized是Java语言...在Java中，synchronized和lock都是用于实现线程同步的机制，但它们有不同的实现机制和性能特点。在选择使用哪种机制时，需要考虑到具体的应用场景和性能要求。
Lock与Synchronized区别
weixin_41010294的博客
03-16 6270
先说结论,后面详解 synchronized是关键字,Lock是接口; synchronized是隐式的加锁,lock是显式的加锁; synchronized可以作用于方法上,lock只能作用于方法块; synchronized底层采用的是objectMonitor,lock采用的AQS; synchronized是阻塞式加锁,lock是非阻塞式加锁支持可中断式加锁,支持超时时间的加锁; synchronized在进行加锁解锁时,只有一个同步队列和一个等待队列, lock有一个同步队
并发编程之Lock及其实现类
博客
05-28 893
1
日常bug记录，easyexcel导入报错convert data ... to class java.math.BigDecimal error
mm
11-11 98
排查发现实体类中有BigDecimal属性，然而数据中这个属性为null，进行转换时报错。在实体类上加上自定义转换器。解决方法：自定义转换器类。
SpringBoot 实现图片加水印
最新发布
心猿意码
11-11 214
通过上述步骤，我们可以在SpringBoot项目中实现一个简单的图片加水印功能。当然，实际应用中可能需要更复杂的水印处理，比如水印图片、调整水印位置等，可以根据需求进行相应的扩展和优化。
刷题---顺序表算法题
weixin_63997543的博客
11-11 253
顺序算法题----力扣刷题
JAVA-01-变量
LJH_laura_li的博客
11-08 462
在方法、构造函数或块内部定义的变量。
基于 SpringBoot 实现QQ邮箱验证码注册功能
2301_79201049的博客
11-06 671
找到并开通以下的邮件协议服务，而且服务开启也较为简单，需要我们发送一个短信到指定的号码，开启后平台会提供一个授权码，一定要记住这个授权码，发邮件的时候需要这个。host 是根据服务主机区分，网易邮箱是 smtp.163.com, qq邮箱是 smtp.qq.com。其中的 username 是你第一步中操作的邮箱账号，nickname 是接收者收到邮件中显示的发件人。发送邮件的核心依赖是 mail ，由于该项目还涉及其他依赖就全都导进来了。（1）首先打开QQ邮箱，点击设置并来到账号页面。
lock和synchronized
06-01
lock和synchronized都是Java中用于实现线程同步的机制。 synchronized是Java内置的关键字，用于实现同步方法和同步代码块，可以保证在多线程环境下，同一时间只有一个线程访问共享资源，避免了多个线程同时访问共享...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值