Java——锁的实现

最新推荐文章于 2024-04-07 23:08:05 发布
最新推荐文章于 2024-04-07 23:08:05 发布
阅读量205 收藏
点赞数
分类专栏： Java 文章标签： java 经验分享
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fate_destiny/article/details/105691030
版权

紧接上篇的知识点Java——锁，讨论各种锁的具体实现方法。

1 synchronized关键字

对象锁
/**
 * 为非公平锁
 * 对象锁也叫方法锁，是针对一个对象实例的，它只在该对象的某个内存位置声明一个标识该对象是否拥有锁，
 * 所有它只会锁住当前的对象，而并不会对其他对象实例的锁产生任何影响，不同对象访问同一个被synchronized修饰的方法的时候不会阻塞,
 * 创建一个类,synchronized修饰普通方法,即为对象锁,那么这个时候,多个线程访问同一个对象实例的这个方法时,是会同步的,并且只有一个线程执行完,另一个线程才会执行。
 *
 *
 * synchronized修饰的代码块传入this也属于对象锁
 * 应用:减小锁粒度,第二种形式就比较好,比如A线程调用一个同步方法需要很长时间,那么B就要等待很长时间,这个时候可以将必须同步的代码使用synchronized代码块
 */

public class ObjectLockDemo {
    private synchronized void method1(){
        try {
            System.out.println(Thread.currentThread().getName());
            Thread.sleep(4000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    //synchronized修饰为同步方法,如果先调用method1,则4秒后才会调用method2
    //如果不用synchronized修饰,则可以直接异步调用,没有影响
    private void method2(){
        System.out.println(Thread.currentThread().getName());
    }

    private void doLongTimeTask(){
        try{
            System.out.println("当前线程开始："+Thread.currentThread().getName()+"，正在执行一个较长时间的业务操作，其内容不需要同步");
            Thread.sleep(10000);
            synchronized (this){
                System.out.println("当前线程："+Thread.currentThread().getName()+"，执行同步代码块，对其同步变量进行性操作");
                Thread.sleep(1000);
            }
            System.out.println("当前线程结束："+Thread.currentThread().getName()+"，执行完毕");
        }catch (Exception e){
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        //创建一个对象
        ObjectLockDemo myObject=new ObjectLockDemo();
        //多个实例对象不会同步对象锁
        ObjectLockDemo myObject2=new ObjectLockDemo();

        Thread t1=new Thread (new Runnable() {
            @Override
            public void run() {
                myObject.method1();
            }
        },"t1");
        Thread t2=new Thread (new Runnable() {
            @Override
            public void run() {
                myObject.method1();
            }
        },"t2");
        t1.start();
        t2.start();
        Thread t3=new Thread(new Runnable() {
            @Override
            public void run() {
                myObject.doLongTimeTask();
            }
        },"t3");
        Thread t4=new Thread(new Runnable() {
            @Override
            public void run() {
                myObject.doLongTimeTask();
            }
        },"t4");
        t3.start();
        t4.start();
    }
}
类锁
/**
 * 为非公平锁
 *类锁实际上就是这个类的对象的对象锁，也就是说每个类都是一个java.lang.Class对象，类锁就是这个类的类对象锁。
 * 类锁的三个获取方式
 * 1、synchronized (xxx.class) {}
 * 2、synchronized (Class.forName("xxx")) {...}
 * 3、public static synchronized void method(){...}，即修饰静态方法
 * 这个时候无论线程调用的是多少个对象实例的方法,都会同步
 */

public class ClassLockDemo {

    public static synchronized void method1(){
        try{
            System.out.println(Thread.currentThread().getName());
            Thread.sleep(4000);
            System.out.println("method1方法执行完毕");
        }catch (Exception e){
            e.printStackTrace();
        }
    }

    public void method2(){
        System.out.println("method2");
    }

    public static void main(String[] args) {
        //创建一个对象
        ClassLockDemo myObject1=new ClassLockDemo();
        //多个实例方法均会同步类锁
        ClassLockDemo myObject2=new ClassLockDemo();

        Thread t1=new Thread (() -> myObject1.method1(),"t1");
        Thread t2=new Thread (new Runnable() {
            @Override
            public void run() {
                myObject2.method1();
            }
        },"t2");
        t1.start();
        t2.start();
    }
}

2 接口锁

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

/**
 * lock锁默认为非公平锁，ReentrantLock类有构造法方法设置为公平锁或非公平锁，具体为ReentrantLock(boolean)
 * Lock接口有6个方法
 * 1、void lock() 获取锁
 * 2、void lockInterruptibly() 如果当前线程未被中断，则获取锁
 * 3、Condition new Condition() 返回绑定到此Lock实例的新Condition实例
 * 4、boolean tryLock() 仅在调用时锁为空闲状态才获取该锁
 * 5、boolean tryLock(long time,TimeUnit unit) 如果锁在给定的等待事件内空闲，并且当前线程未被中断，则获取锁
 * 6、void unlock() 释放锁
 *
 * 与synchronized关键字对比，Lock接口的使用要注意一下几点：
 * 1、synchronized是Java语言的关键字，因此是内置特性，Lock不是Java语言内置的，Lock是一个接口，通过实现类可以实现同步访问。
 * 2、synchronized是在JVM层面上实现的，不但可以通过一些监控工具监控synchronized的锁定，而且在代码执行时出现异常，JVM会自动释放锁定，
 *      但是使用Lock则不行，lock是通过代码实现的，要保证锁定一定会被释放，就必须将unLock()放到finally{}中
 * 3、在资源竞争不是很激烈的情况下，Synchronized的性能要优于ReetrantLock，但是在资源竞争很激烈的情况下，Synchronized的性能会下降几十倍，
 *      但是ReetrantLock的性能能维持常态。
 */


public class LockDemo {

    private Lock lock = new ReentrantLock();

    public void method1() {
        lock.lock();
        try {
            System.out.println("线程 " + Thread.currentThread().getName() + " method1开始执行");
            Thread.sleep(10000);
            System.out.println("线程 " + Thread.currentThread().getName() + " method1开始结束");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
            System.out.println("线程 " + Thread.currentThread().getName() + " 释放线程锁");
        }
    }

    public static void main(String[] args) {
        //创建一个对象
        LockDemo myObject1 = new LockDemo();
        //多个实例方法均会同步类锁
        LockDemo myObject2 = new LockDemo();

        Thread t1 = new Thread(() -> myObject1.method1(), "t1");
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                myObject1.method1();
            }
        }, "t2");
        t1.start();
        t2.start();
    }
}
自适应锁
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicReference;

public class CustomizedSpinningLock {

    /**
     * 持有锁的线程，null表示锁未被线程持有
     */
    private AtomicReference<Thread> ref = new AtomicReference<>();

    public void lock() {
        Thread currentThread = Thread.currentThread();
        while (!ref.compareAndSet(null, currentThread)) {
            //当ref为null的时候compareAndSet返回true，反之为false
            //通过循环不断的自旋判断锁是否被其他线程持有
        }
    }

    public void unLock() {
        Thread cur = Thread.currentThread();
        if (ref.get() != cur) {
            //exception ...
        }
        ref.set(null);
    }


}

public class TestLock {

    static int count = 0;

    public static void main(String[] args) throws Exception {
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        CountDownLatch countDownLatch = new CountDownLatch(100);
        CustomizedSpinningLock customizedSpinningLock = new CustomizedSpinningLock();
        for (int i = 0; i < 100; i++) {
            executorService.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        System.out.println("线程 " + Thread.currentThread().getName() + " 正在执行");
                        customizedSpinningLock.lock();
                        ++count;
                        //JDK1.6以后出现了自适应自旋锁，删除该语句可明显体现此特性
                        Thread.sleep(1000);
                        customizedSpinningLock.unLock();
                        countDownLatch.countDown();
                    }catch (Exception e){
                        e.printStackTrace();
                    }
                }
            });

        }
        countDownLatch.await();
        System.out.println(count);
        executorService.shutdown();
    }
}
ReadWriteLock接口
import java.util.Random;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * ReadWriteLock 接口只有两个方法：
 * 1、Lock readLock() 返回用于读取操作的锁，仅用于标记，属于共享锁
 * 2、Lock writeLock() 返回用于写入操作的锁，仅用于标记，属于排他锁
 *
 * 只要没有 writer，读取锁可以由多个 reader 线程同时保持，而写入锁是独占的。
 */

public class ReadWriteLockDemo {

    //共享数据，只能有一个线程能写该数据，但可以有多个线程同时读该数据。
    private Object data = null;

    ReadWriteLock lock = new ReentrantReadWriteLock();

    // 读数据
    public void readMethod() {
        // 加读锁
        lock.readLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + " be ready to read data!");
            Thread.sleep(10000);
            System.out.println(Thread.currentThread().getName() + " have read data :" + data);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            // 释放读锁
            lock.readLock().unlock();
        }
    }

    // 写数据
    public void writeMethod(Object data) {
        // 加写锁
        lock.writeLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + " be ready to write data!");
            Thread.sleep(10000);
            this.data = data;
            System.out.println(Thread.currentThread().getName() + " have write data: " + data);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            // 释放写锁
            lock.writeLock().unlock();
        }
    }

    public static void main(String[] args) {
        ReadWriteLockDemo queue = new ReadWriteLockDemo();
        //启动1个读线程
        new Thread() {
            public void run() {
                while(true) {
                    queue.readMethod();
                }
            }

        }.start();
        //启动1个写线程
        new Thread() {
            public void run() {
                while(true) {
                    queue.writeMethod(new Random().nextInt(10000));
                }
            }
        }.start();
        //启动1个读线程
        new Thread() {
            public void run() {
                while(true) {
                    queue.readMethod();
                }
            }

        }.start();
    }
}

参考自：

新增：原子类的线程安全演示
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicInteger;

public class CASDemo {

    public void CASMethod(AtomicInteger atomicInteger) {
        System.out.println("线程 " + Thread.currentThread().getName() + " 原子类自增的数据为 " + atomicInteger.incrementAndGet());
    }

    public void NoCASMethod(int a) {
        a++;
        System.out.println("线程 " + Thread.currentThread().getName() + " 非原子类自增的数据为 " + a);
    }

    public static void main(String[] args) throws Exception {
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        CountDownLatch countDownLatch = new CountDownLatch(10);
        AtomicInteger atomicInteger = new AtomicInteger(0);
        int count = 0;
        CASDemo casDemo = new CASDemo();
        for (int i = 0; i < 10; i++) {
            executorService.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        System.out.println("线程 " + Thread.currentThread().getName() + " 正在执行");
                        casDemo.CASMethod(atomicInteger);
                        casDemo.NoCASMethod(count);
                        countDownLatch.countDown();
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            });
        }
        countDownLatch.await();
        executorService.shutdown();
    }
}

执行结果：

线程 pool-1-thread-1 正在执行
线程 pool-1-thread-1 原子类自增的数据为 1
线程 pool-1-thread-1 非原子类自增的数据为 1
线程 pool-1-thread-2 正在执行
线程 pool-1-thread-2 原子类自增的数据为 2
线程 pool-1-thread-2 非原子类自增的数据为 1
线程 pool-1-thread-3 正在执行
线程 pool-1-thread-3 原子类自增的数据为 3
线程 pool-1-thread-3 非原子类自增的数据为 1
线程 pool-1-thread-4 正在执行
线程 pool-1-thread-4 原子类自增的数据为 4
线程 pool-1-thread-4 非原子类自增的数据为 1
线程 pool-1-thread-5 正在执行
线程 pool-1-thread-5 原子类自增的数据为 5
线程 pool-1-thread-5 非原子类自增的数据为 1
线程 pool-1-thread-6 正在执行
线程 pool-1-thread-6 原子类自增的数据为 6
线程 pool-1-thread-6 非原子类自增的数据为 1
线程 pool-1-thread-7 正在执行
线程 pool-1-thread-7 原子类自增的数据为 7
线程 pool-1-thread-7 非原子类自增的数据为 1
线程 pool-1-thread-8 正在执行
线程 pool-1-thread-8 原子类自增的数据为 8
线程 pool-1-thread-8 非原子类自增的数据为 1
线程 pool-1-thread-9 正在执行
线程 pool-1-thread-9 原子类自增的数据为 9
线程 pool-1-thread-9 非原子类自增的数据为 1
线程 pool-1-thread-10 正在执行
线程 pool-1-thread-10 原子类自增的数据为 10
线程 pool-1-thread-10 非原子类自增的数据为 1

Process finished with exit code 0
fate_destiny
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java锁实现
xiexie_lovely的博客
11-16 195
锁的对比 java中的锁一共有4种状态，级别从低到高分别是： 无锁状态 偏向锁 轻量级锁 重量级锁 锁只能升级，不能降级 偏向锁 顾名思义，为了让线程获得锁的代价更低，引入了偏向锁。 加锁 当一个线程访问同步块并且获取锁时，会在对象头和栈帧中的锁记录里存储锁偏向的线程id，这样，这个线程便获取了这个对象的偏向锁，之后这个线程进入和退出就不需要通过CAS操作，也就是原子操作，来进行加锁和解锁，只...
java 中锁实现
coding
05-17 1370
java中的锁机制
java中的锁及其实现
qq_34332313的博客
09-18 183
多个线程获取锁的顺序，不是安装先到先得的顺序，有可能后申请的线程比先申请的线程优先获取锁。优点：非公平锁的性能高于公平锁，缺点：有可能造成线程饥饿（某个线程很长一段时间获取不到锁）java中的非公平锁：synchronized是非公平锁，ReentrantLockt通过构造函数指定该锁是公平还是非公平的，默认是非公平的。读操作的时候，不能进行写操作。实现有关系型数据的行锁，表锁，读锁，写锁，都是在操作之前加锁，java中的synchronized和ReentrantLock都是独占锁和悲观锁思想的实现。
java锁的实现原理
qq_36761506的博客
08-14 369
锁的实现原理： 1.悲观锁和乐观锁： 1.1悲观锁： 概念：使用数据时，一定会认为有线程来修改数据，所以会加锁，确保其他线程不能访问和数据修改。 锁的实现：关键字synchronized,接口lock的实现类 适用场景：一般使用于写操作较多的，先加锁可以保证写操作时数据正确 1.2乐观锁： 概念：使用数据时不会有别的线程修改数据，所以不会添加锁，只是在更新数据的时候去判断之前有没有 别的线程更新了...
java 锁的实现原理图_JAVA之锁机制实现原理(简化版)
weixin_31885123的博客
02-16 350
并发编程离不开锁，然而每次遇到锁问题时都会谈锁色变，下面对锁实现作简单化描述，方便大家容易理解！一、绪论在JAVA中锁一共有四种状态：无锁状态、偏向锁状态、轻量级锁状态和重量级锁状态(按从低到高顺序，锁着竞争情况逐渐升级)JAVA中锁只能升级却不能降级，目的是为了提高获得锁和释放锁的效率。二、对象头的介绍在HopSpot虚拟机中，对象在内存存储中分为3部分：对象头(Header)、实例数据(Ins...
java并发编程——内存模型
02-24
并发——在操作系统中，是指一个时间段中有几个程序都处于已启动运行到运行完毕之间，且...在Java中，可以通过volatile，synchronized,锁等方式实现同步。本文主要介绍java的通信机制，刚介绍常见通信机制主要包括以下
Java——volatile关键字详解
12-21
这就确保了所有线程都能看到最新的值，从而实现了可见性。 **禁止指令重排序：** 在多核处理器环境下，为了提高性能，编译器和处理器可能会对指令进行重排序。然而，`volatile`关键字可以防止这种重排序，保证代码...
Java——JUC
12-29
- `AtomicInteger`、`AtomicLong`等原子类提供了一种在不使用锁的情况下实现线程安全的方式，通过底层的CAS（Compare and Swap）操作保证了原子性，适用于简单的原子更新操作。 5. **Future和Callable接口** - `...
java面试——zookeeper面试专题.zip
09-26
《Java面试——Zookeeper面试专题》 Zookeeper是Apache Hadoop项目下的一个分布式协调服务，它为分布式应用程序提供了高效且可靠的分布式同步、配置管理以及命名服务。在Java面试中，Zookeeper是一个重要的考察点，...
java面试——深圳-OPPO-Java高级.zip
09-26
- 分布式锁：Redis、Zookeeper实现的分布式锁机制。 - 分布式一致性：CAP理论，Paxos、Raft等一致性协议的理解。 这些知识点不仅涵盖了Java语言的核心特性，还涉及到高级编程和系统架构的诸多方面。面试时，面试...
JAVA中常见的锁和锁的实现
最新发布
galaxyou的博客
04-07 882
java中各种锁
Java并发编程（一）Java锁的实现原理
小刺猬喜歡獨角獸
06-07 7192
CPU级别：
java锁实现方式有哪些_5.Java中的锁的使用和实现介绍
weixin_34008968的博客
02-17 655
Java并发编程的艺术笔记目录Lock接口队列同步器重入锁读写锁LockSupport工具Condition接口小结Lock接口在Java SE 5之后，并发包中新增了Lock接口(以及相关实现类)用来实现锁功能，它提供了与synchronized关键字类似的同步功能，只是在使用时需要 显式 地获取和释放锁。虽然它缺少了(通过synchronized块或者方法所提供的)隐式获取释放锁的便捷性，但是...
Java中的锁
qq_40229166的博客
03-16 945
Java中锁分析：CAS 、synchronized
Java 中的锁
博客只为自己学习提升纪录所用，如有侵权或不妥之处，还请私信删除！加油
05-19 337
Java 中各种锁的概念
Java基础-锁
07-12 485
学习编程，避不开多线程开发，多线程提供了高效的同时，也带来了访问资源的同步和互斥。互斥是指在一个单位时间内，只有一个线程可以访问共享资源。而同步是指多个线程之间可以同时正确的访问共享资源。在Java中，如何保障资源在访问过程中的原子性，正确性，就出现了锁机制。而锁的应用也比较常见，比如文件，数据的读写，对于一些接口要求不能并发请求等。//一把锁i
Java锁详解
Jiansong_Shen的博客
02-19 1627
欢迎学习Java锁的新手查看
聊聊JAVA 中 13 种锁的实现方式
热门推荐
LoveSummer
08-08 2万+
最近有很多小伙伴给我留言，分布式系统时代，线程并发，资源抢占，慢慢变得很重要。那么常见的锁都有哪些？
Java 的锁 -- 具体的锁对象及其实现原理
十七的博客
11-28 2322
锁机制：用来保证在多线程并发情况下数据的一致性。 锁的作用点：操作一个对象或者调用一个方法前加锁，这样当其他线程也对该对象和方法进行访问时就需要获得锁，如果该锁被其他线程持有，那么该线程则进入阻塞队列等待获得锁。 Java 中，用作锁的对象有：synchronized、ReentrantLock、ReadWriteLock、volatile。 synchronized：同步锁。 ReentrantLock：可重入锁。 ReadWriteLock：读写锁。
Zookeeper：分布式系统中的协调神器——实现分布式锁详解
它基于Java实现，采用树形结构的数据模型，数据存储在内存中以实现高吞吐量和低延迟。以下是关于Zookeeper的关键知识点： 1. **Zookeeper简介**： Zookeeper是一个分布式服务，它扮演着协调者角色，通过维护一个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值