Java中的锁

已于 2024-05-15 20:21:25 修改
阅读量856 收藏 19
点赞数 23
分类专栏： JUC 文章标签： java 开发语言 锁
于 2024-05-15 20:20:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/stduyc/article/details/138920527
版权

内容借鉴于

https://blog.csdn.net/weixin_44630656/article/details/115375659

https://blog.csdn.net/F15217283411/article/details/122752255

目录

公平锁和非公平锁

可重入锁

自旋锁

 互斥锁

线程8锁问题

1. 对象实例（4个）

2. 对象实例和类对象混合（4个）

总结

公平锁和非公平锁

公平锁：

是指多个线程按照申请锁的顺序来获取锁，类似于排队买饭，先来后到，先来先服务，就是公平的，也就是队列。

非公平锁：

是指多个线程获取锁的顺序，并不是按照申请锁的顺序，有可能后申请的线程比先申请的线程优先获取锁，具体来说就是：一个后进来的线程尝试获取锁会和阻塞队列中的队头线程一起竞争，如果竞争失败，才进入阻塞队列，竞争成功，这个后进来的线程就直接获取到了锁资源。在高并发环境下，有可能造成优先级翻转，或者饥饿的线程（也就是某个线程一直得不到锁）。

公平锁和非公平锁的创建

并发包中ReentrantLock的创建可以指定构造函数的boolean类型来得到公平锁或者非公平锁，默认是非公平锁，synchronized也是非公平锁。

/**
* 创建一个可重入锁，true 表示公平锁，false 表示非公平锁。默认非公平锁
*/
Lock lock = new ReentrantLock(true);

一般情况下，非公平锁的性能要好于公平锁的性能。

可重入锁

可重入锁也叫做递归锁）

指的是同一线程外层函数获得锁之后，内层递归函数仍然能获取该锁的代码，在同一个线程在外层方法获取锁的时候，在进入内层方法会自动获取锁。

也即是说，线程可以进入任何一个它已经拥有的锁所同步着的代码块。

ReentrantLock/synchronized就是一个典型的可重入锁。

可重入锁最大的作用是避免死锁。

Synchronized可重入锁演示程序：

class Phone {

    //这里的synchronized 锁对象锁的是当前类，也就是说在同一个通过new出来的Phone类型的变量中，他的锁对象都是相同的。所以这里可以进行锁的重入。

    public synchronized void sendSMS() throws Exception{
        System.out.println(Thread.currentThread().getName() + "\t invoked sendSMS()");

        // 在同步方法中，调用另外一个同步方法
        sendEmail();
    }


    public synchronized void sendEmail() throws Exception{
        System.out.println(Thread.currentThread().getId() + "\t invoked sendEmail()");
    }
}

public class SynchronizedReentrantLockDemo {

	public static void main(String[] args) {

        Phone phone = new Phone();

        // 两个线程操作资源列
        new Thread(() -> {
            try {
                phone.sendSMS();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "t1").start();

        new Thread(() -> {
            try {
                phone.sendSMS();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "t2").start();
	}

}

执行结果：

t1	 invoked sendSMS()
11	 invoked sendEmail()
t2	 invoked sendSMS()
12	 invoked sendEmail()

ReentrantLock可重入锁演示程序：

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

class Phone2 implements Runnable{

    Lock lock = new ReentrantLock();

    /**
     * set进去的时候，就加锁，调用get方法的时候，访问另外一个加锁的set方法
     */
    public void getLock() {
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "\t get Lock");
            setLock();
        } finally {
            lock.unlock();
        }
    }

    public void setLock() {
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "\t set Lock");
        } finally {
            lock.unlock();
        }
    }

    @Override
    public void run() {
        getLock();
    }
}

public class ReentrantLockDemo {


    public static void main(String[] args) {
        Phone2 phone = new Phone2();

        /**
         * 因为Phone实现了Runnable接口
         */
        Thread t3 = new Thread(phone, "t3");
        Thread t4 = new Thread(phone, "t4");
        t3.start();
        t4.start();
    }
}

执行结果：

t3	 get Lock
t3	 set Lock
t4	 get Lock	
t4	 set Lock

自旋锁

自旋锁：是指尝试获取锁的线程不会立即阻塞，而是采用循环的方式去尝试获取锁，这样的好处是减少线程上下文切换的消耗（用户态和内核态之间的切换），缺点是循环会消耗CPU。

手写自旋锁

通过CAS操作完成自旋锁，A线程先进来调用myLock方法自己持有锁5秒，B随后进来发现当前有线程持有锁，不是null，所以只能通过自旋等待，直到A释放锁后B随后抢到

package test;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;

/**
 * 手写一个自旋锁
 *
 * 循环比较获取直到成功为止，没有类似于wait的阻塞
 *
 * 通过CAS操作完成自旋锁，A线程先进来调用myLock方法自己持有锁5秒，B随后进来发现当前有线程持有锁，不是null，所以只能通过自旋等待，直到A释放锁后B随后抢到
 */
public class SpinLockDemo {

    // 现在的泛型装的是Thread，原子引用线程，配合CAS使用
    AtomicReference<Thread> atomicReference = new AtomicReference<>();

    public void myLock() {
        // 获取当前进来的线程
        Thread thread = Thread.currentThread();
        System.out.println(Thread.currentThread().getName() + "\t come in ");

        // 开始自旋，期望值是null，更新值是当前线程，如果是null，则更新为当前线程，否者自旋
        while(!atomicReference.compareAndSet(null, thread)) {
            System.out.println(Thread.currentThread().getName() + "在自旋等待");
        }
        System.out.println(Thread.currentThread().getName() + "\t 获取到了锁");
    }

    /**
     * 解锁
     */
    public void myUnLock() {

        // 获取当前进来的线程
        Thread thread = Thread.currentThread();

        // 自己用完了后，把atomicReference变成null
        atomicReference.compareAndSet(thread, null);

        System.out.println(Thread.currentThread().getName() + "\t invoked myUnlock()");
    }

    public static void main(String[] args) {

        SpinLockDemo spinLockDemo = new SpinLockDemo();

        // 启动t1线程，开始操作
        new Thread(() -> {
            // 开始占有锁
            spinLockDemo.myLock();
            try {
                Thread.sleep(1500);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            // 开始释放锁
            spinLockDemo.myUnLock();

        }, "t1").start();


        // 让main线程暂停1.5秒，使得t1线程，先执行
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 1秒后，启动t2线程，开始占用这个锁
        new Thread(() -> {
            // 开始占有锁
            spinLockDemo.myLock();
            // 开始释放锁
            spinLockDemo.myUnLock();

        }, "t2").start();

    }
}


t1	 come in 
t1	 获取到了锁
t2	 come in 
t2在自旋等待
t2在自旋等待
t2在自旋等待
。。。。。。
。。。。。。
。。。。。。
t1	 invoked myUnlock()
t2	 获取到了锁
t2	 invoked myUnlock()

 互斥锁

互斥锁（ReadWriteLock）：分为读锁和写锁

  • 独占锁：指该锁一次只能被一个线程所持有。对ReentrantLock和Synchronized而言都是独占锁
  • 共享锁：指该锁可被多个线程所持有。

多个线程同时读一个资源类没有任何问题，所以为了满足并发量，读取共享资源应该可以同时进行。但是，如果有一个线程想去写共享资源时，就不应该再有其它线程可以对该资源进行读或写。

对ReentrantReadWriteLock其读锁是共享锁，其写锁是独占锁。

读锁的共享锁可保证并发读是非常高效的。但是读写，写读，写写的过程是互斥的。

例子：

package com.lun.concurrency;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantReadWriteLock;

class MyCache2 {

    private volatile Map<String, Object> map = new HashMap<>();

    private ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();

    public void put(String key, Object value) {

        // 创建一个写锁
        rwLock.writeLock().lock();

        try {

            System.out.println(Thread.currentThread().getName() + "\t 正在写入：" + key);

            try {
                // 模拟网络拥堵，延迟0.3秒
                TimeUnit.MILLISECONDS.sleep(300);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            map.put(key, value);

            System.out.println(Thread.currentThread().getName() + "\t 写入完成");

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 写锁 释放
            rwLock.writeLock().unlock();
        }
    }

    public void get(String key) {

        // 读锁
        rwLock.readLock().lock();
        try {

            System.out.println(Thread.currentThread().getName() + "\t 正在读取:");

            try {
                // 模拟网络拥堵，延迟0.3秒
                TimeUnit.MILLISECONDS.sleep(300);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            Object value = map.get(key);

            System.out.println(Thread.currentThread().getName() + "\t 读取完成：" + value);

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 读锁释放
            rwLock.readLock().unlock();
        }
    }

    public void clean() {
        map.clear();
    }


}

public class ReadWriteWithLockDemo {
    public static void main(String[] args) {

        MyCache2 myCache = new MyCache2();

        // 线程操作资源类，5个线程写
        for (int i = 1; i <= 5; i++) {
            // lambda表达式内部必须是final
            final int tempInt = i;
            new Thread(() -> {
                myCache.put(tempInt + "", tempInt +  "");
            }, String.valueOf(i)).start();
        }

        // 线程操作资源类， 5个线程读
        for (int i = 1; i <= 5; i++) {
            // lambda表达式内部必须是final
            final int tempInt = i;
            new Thread(() -> {
                myCache.get(tempInt + "");
            }, String.valueOf(i)).start();
        }
    }
}

结果：

1	 正在写入：1
1	 写入完成
2	 正在写入：2
2	 写入完成
3	 正在写入：3
3	 写入完成
5	 正在写入：5
5	 写入完成
4	 正在写入：4
4	 写入完成
2	 正在读取:
3	 正在读取:
1	 正在读取:
5	 正在读取:
4	 正在读取:
3	 读取完成：3
2	 读取完成：2
1	 读取完成：1
5	 读取完成：5
4	 读取完成：4

线程8锁问题

一、引入
synchronized不是锁住了方法，而是锁住了使用了该方法的类对象或者对象实例，比如：
1. 锁住对象实例：

class Test{
    public synchronized void test() {
    }
}
//等价于
class Test{
    public void test() {
        synchronized(this) {
        }
    }
}



2. 锁住类对象：

class Test{
    public synchronized static void test() {
    }
}
//等价于
class Test{
    public static void test() {
        synchronized(Test.class) {
        }
    }
}


线程八锁的重点：

  • 非静态方法的默认锁是this，静态方法的默认锁是class（一个进程中只有一个）
  • 某一时刻内，只能有一个线程有锁，无论几个方法
  • 同一个类对象中的静态方法和非静态方法上锁，即对象实例上锁和类对象上锁，之间不会冲突
  • 不同对象实例间非静态方法执行不会冲突，非静态方法属于实例
  • 不同对象实例间静态方法执行会冲突，静态方法属于类

1. 对象实例（4个）

情况1：输出12或21

@Slf4j
class Number{
    public synchronized void a() {
        log.debug("1");
    }
    public synchronized void b() {
    	log.debug("2");
    }
}

public static void main(String[] args) {
    Number n1 = new Number();
    new Thread(()->{ n1.a(); }).start();
    new Thread(()->{ n1.b(); }).start();
}

解释：
线程数：2个线程
锁对象：对象实例（n1）
两个线程是对同一个实例对象上锁，a()方法或b()方法谁都可能先执行，先执行的会上锁，后面线程得等前一个线程结束才可以执行，准确来说是同步，通俗讲是串行

情况2：1s后12，或 2 1s后 1

@Slf4j
class Number{
    public synchronized void a() {
        sleep(1);
        log.debug("1");
    }
    public synchronized void b() {
        log.debug("2");
    }
}

public static void main(String[] args) {
    Number n1 = new Number();
    new Thread(()->{ n1.a(); }).start();
    new Thread(()->{ n1.b(); }).start();
}

解释：
线程数：2个线程
锁：对象实例
两个线程是对同一个实例对象上锁，a()方法的sleep这个线程在运行中模拟有这么一段处理时间，a()方法或b()方法谁都可能先执行，先执行的会上锁，后面线程得等前一个线程结束才可以执行

情况3：3 1s 12 或 23 1s 1 或 32 1s 1

@Slf4j
class Number{
    public synchronized void a() {
        sleep(1);
        log.debug("1");
    }
    public synchronized void b() {
        log.debug("2");
    }
    public void c() {
        log.debug("3");
    }
}

public static void main(String[] args) {
    Number n1 = new Number();
    new Thread(()->{ n1.a(); }).start();
    new Thread(()->{ n1.b(); }).start();
    new Thread(()->{ n1.c(); }).start();
}

解释：
线程数：3个线程
锁：对象实例
a()方法和b()方法是对同一个实例对象上锁，两者不能并行运行，只能串行执行，c()方法没有锁，a()方法或b()运行时不影响c()方法并行运行，反过来c()方法运行a()和b()方法依旧可以运行，通过并行运行可以得出，最先输出的只能是2或3，因为a()方法可以先执行，但不会先输出1，如果对哪个方法先执行有疑虑，我可以告诉你，哪个方法都可以先执行，只是只能通过输出来看。

情况4：2 1s 后 1

@Slf4j
class Number{
    public synchronized void a() {
        sleep(1);
        log.debug("1");
    }
    public synchronized void b() {
        log.debug("2");
    }
}

public static void main(String[] args) {
    Number n1 = new Number();
    Number n2 = new Number();
    new Thread(()->{ n1.a(); }).start();
    new Thread(()->{ n2.b(); }).start();
}

解释：
线程数：2个线程
锁：对象实例
两个线程是对不同实例对象上锁，线程之间不会影响，可以并行执行，但b()方法比a()更早输出

2. 对象实例和类对象混合（4个）

情况1：2 1s 后 1

@Slf4j
class Number{
    public static synchronized void a() {
        sleep(1);
        log.debug("1");
    }
    public synchronized void b() {
    	log.debug("2");
    }
}

public static void main(String[] args) {
    Number n1 = new Number();
    new Thread(()->{ n1.a(); }).start();
    new Thread(()->{ n1.b(); }).start();
}

解释：
线程数：2个线程
锁：对象实例和类对象
引入那里我已经给大家补了，a()上的锁是类对象，b()方法上的锁是实例对象，即重点第三点，两者是独立执行，谁都不会阻塞，因此，b()方法输出比a()更快

情况2：1s 后12， 或 2 1s后 1

@Slf4j
class Number{
    public static synchronized void a() {
        sleep(1);
        log.debug("1");
    }
    public static synchronized void b() {
        log.debug("2");
    }
}
    
public static void main(String[] args) {
    Number n1 = new Number();
    new Thread(()->{ n1.a(); }).start();
    new Thread(()->{ n1.b(); }).start();
}

解释：
线程数：2个线程
锁：类对象
两个线程是对同一个类对象上锁，先执行的上锁，后面的阻塞，因此先执行第一个线程，第二个才可以执行，结果会出现两种

情况3：2 1s 后 1

@Slf4j
class Number{
    public static synchronized void a() {
        sleep(1);
        log.debug("1");
    }
    public synchronized void b() {
        log.debug("2");
    }
}

public static void main(String[] args) {
    Number n1 = new Number();
    Number n2 = new Number();
    new Thread(()->{ n1.a(); }).start();
    new Thread(()->{ n2.b(); }).start();
}

解释：
线程数：2个线程
锁：对象实例和类对象
两个线程执行的是不同对象的方法，非静态方法和静态方法（类和实例）、非静态方法和非静态方法（实例与实例，两个不同实例）之间不会冲突，可以并行运行，并行是相对于多核的，单核那叫时间片轮询执行，看起来也像是并行，不过是内核在做上下文切换，影响的是性能。

情况4：1s 后12， 或 2 1s后 1

@Slf4j
class Number{
    public static synchronized void a() {
        sleep(1);
        log.debug("1");
    }
    public static synchronized void b() {
        log.debug("2");
    }
}

public static void main(String[] args) {
    Number n1 = new Number();
    Number n2 = new Number();
    new Thread(()->{ n1.a(); }).start();
    new Thread(()->{ n2.b(); }).start();
}

解释：
线程数：2个线程
锁：类对象
与情况二类似，上锁的根本在于同一个类，对不同实例是没有关系的，所以这里也会有上锁，会发生阻塞。

总结

线程八锁，实际是总结出来也就是，上锁【类、实例】和线程执行方法【是否是同一个实例】的划分，而增加sleep是为了能够更好的展示效果，能够更好去理解线程。

一枚coin
关注
  • 23
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java中锁的分类
@龙猫的博客
04-12 3290
Java中锁的分类1、可重入锁/不可重入锁2、可中断锁3、公平锁/非公平锁4、独享锁（互斥锁）/共享锁（读写锁）5、乐观锁/悲观锁6、分段锁7、偏向锁/轻量级锁/重量级锁8、自旋锁 先来一段很常见的死锁代码： class Deadlock { public static String str1 = "str1"; public static String str2 = "str2"...
java中锁的四种状态
m0_69523172的博客
04-29 1862
四种状态 锁状态转换过程 锁的优缺点 参考文章 小结 [](()前言 ============================================================ 在多线程并发编程中Synchronized一直是元老级角色，很多人都会称它为重量级锁，但是随着 Java SE1.6 对 Synchronized 进行了各种优化之后，有些情况下它并不那么重了，本文详细介绍了 Java SE1.6 中为了减少获得锁和释放锁带来的性能消耗而引入的偏向锁和轻量级锁，..
java中锁的详解
清雨小竹
05-26 2393
因此，重量级锁的开销较大，可能会导致线程阻塞和性能下降。但是，由于重量级锁提供了最高的线程安全性，所以在需要确保数据完整性和一致性的情况下，重量级锁是非常有用的。但是，由于轻量级锁不是互斥的，所以如果多个线程同时尝试获取锁，则可能导致数据不一致的问题。可重入锁(Reentrant Lock):可重入锁允许同一个线程多次获取同一个锁，这意味着线程可以在执行完同步代码后再次获取该锁而不需要重新竞争。自旋锁(Spin Lock):自旋锁是一种基于忙等待的同步机制，它在获取锁时会一直循环等待，直到获取到锁为止。
java中锁的面试题
热门推荐
m0_52767002的博客
02-16 1万+
1. synchronized锁（悲观锁、同步锁） synchronized关键字：表示“同步”的。它可以对“多行代码”进行“同步”——将多行代码当成是一个完整的整体，一个线程如果进入到这个代码块中，会全部执行完毕，执行结束后，其它线程才会执行。这样可以保证这多行的代码作为完整的整体，被一个线程完整的执行完毕。 synchronized被称为“重量级的锁”方式，也是“悲观锁”——效率比较低。 1.1synchronized有几种使用方式： a).同步代码块【常用】 b).同步方法【常
Java中锁种类、实现方式
weixin_40482816的博客
03-08 4305
锁作为并发共享数据，保证一致性的工具，在JAVA平台有多种实现。如 synchronized 和 ReentrantLock（并发包中的锁类）等 。 1、锁涉及的几个重要概念 死锁 线程之间相互等着对方释放资源，而自己的资源又不释放给别人，这种情况就是死锁。所以，只要其中一线程释放了资源，死锁就会被解除。 重入锁 重入锁指的是，一个线程在拥有了当前资源的锁之后，可以再次拿到该锁而不被阻塞。在后面会讲到synchronized的重入锁原理。 自旋锁 自旋锁指的是，线程在没有获得锁时，不是被直接挂起，而
java中的锁机制
jh_554的博客
07-27 2855
java中的锁相关知识梳理笔记
Java中的锁升级
热爱编程的菜鸟
03-15 8693
关于锁升级的四种级别，即如何升级
JAVA中的各种锁机制
2201_75382167的博客
03-13 2103
JAVA中的各种锁机制
java中的锁面试题
libaowenBlog的博客
06-18 9693
synchronized 锁升级原理：在锁对象的对象头里面有一个 threadid 字段，在第一次访问的时候 threadid 为空，jvm 让其持有偏向锁，并将 threadid 设置为其线程 id，再次进入的时候会先判断 threadid 是否与其线程 id 一致，如果一致则可以直接使用此对象，如果不一致，则升级偏向锁为轻量级锁，通过自旋循环一定次数来获取锁，执行一定次数之后，如果还没有正常获取到要使用的对象，此时就会把锁从轻量级升级为重量级锁，此过程就构成了 synchronized 锁的升级。锁的升
面试题——Java中的锁
Q_P777的博客
05-21 2990
文章目录1、synchronized 关键字是怎么用的？1.1 构造方法可以使用 synchronized 关键字修饰么？1.2 使用 String 作为锁对象，会有什么问题？1.3 synchronized 的底层原理有了解吗？1.4 还使用过其他锁吗？2、volatile 有什么作用？2.1 原理是什么？2.2 和 synchronized 有什么区别？3. 写一个单例模式 1、synchronized 关键字是怎么用的？ synchronized 关键字解决的是多个线程之间访问资源的同步性，sync
浅谈对java中锁的理解
08-31
本文主要讲述java中锁的相关知识。具有很好的参考价值，下面跟着小编一起来看下吧
java并发锁面试知识
03-21
java中的乐观锁与悲观锁，synchronized与ReentrantLock重入锁的说明与比较
JAVA中锁概及运用.doc
09-30
JAVA中锁概及运用.doc
java 中锁的性能提高办法
08-31
主要介绍了java 中锁的性能提高办法的相关资料,需要的朋友可以参考下
java中锁知识的整理,文件是.xmind思维导图
最新发布
10-04
适合已经学过锁这方面知识的小伙伴进行学习,思维导图对各种锁进行了详细整理总结，采用思维导图的方式更加方便大伙们学习并记忆。
彻底理解Java中的各种锁.pdf
06-18
java各种锁机制
java中redis锁的封装
05-04
语言：java 内容：封装好的redis锁 使用场景： 1.并发情况下 2.对某个字段状态的处理 3.支付回调，重复收到回调数据 使用方法： Object result = redisLockTemplate.execute("REDIS:LOCK:" + id, 1, TimeUnit....
改善Java中锁的性能
12-22
　我们努力为自己的产品所遇到的问题思考解决办法，但在这篇文章中我将给大家分享几种常用的技术，包括分离锁、并行数据结构、保护数据而非代码、缩小锁的作用范围，这几种技术可以使我们不使用任何工具来检测死锁...
Java中锁的实现和内存语义浅析
08-26
主要给大家介绍了关于Java中锁的实现和内存语义的相关资料，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值