标签分类
技术文章
当前位置:主页 > 计算机编程 > java > java同步之如何写一个锁Lock

java写一个锁Lock的步骤方法

  • 发布时间:
  • 作者:码农之家原创
  • 点击:52

java同步之如何写一个锁Lock

这篇文章主要知识点是关于java同步锁,java锁,java同步之如何写一个锁Lock,Java锁机制Lock用法示例 的内容,如果大家想对相关知识点有系统深入的学习,可以参阅以下电子书

JavaScript核心技术开发解密
  • 类型:JavaScript大小:68.4 MB格式:PDF出版:电子工业出版社作者:阳波
立即下载

更多相关的学习资源可以参阅 程序设计电子书Java电子书、等栏目。

问题

(1)自己动手写一个锁需要哪些知识?

(2)自己动手写一个锁到底有多简单?

(3)自己能不能写出来一个完美的锁?

简介

本篇文章的目标一是自己动手写一个锁,这个锁的功能很简单,能进行正常的加锁、解锁操作。

本篇文章的目标二是通过自己动手写一个锁,能更好地理解后面章节将要学习的AQS及各种同步器实现的原理。

分析

自己动手写一个锁需要准备些什么呢?

首先,在上一章学习synchronized的时候我们说过它的实现原理是更改对象头中的MarkWord,标记为已加锁或未加锁。

但是,我们自己是无法修改对象头信息的,那么我们可不可以用一个变量来代替呢?

比如,这个变量的值为1的时候就说明已加锁,变量值为0的时候就说明未加锁,我觉得可行。

其次,我们要保证多个线程对上面我们定义的变量的争用是可控的,所谓可控即同时只能有一个线程把它的值修改为1,且当它的值为1的时候其它线程不能再修改它的值,这种是不是就是典型的CAS操作,所以我们需要使用Unsafe这个类来做CAS操作。

然后,我们知道在多线程的环境下,多个线程对同一个锁的争用肯定只有一个能成功,那么,其它的线程就要排队,所以我们还需要一个队列。

最后,这些线程排队的时候干嘛呢?它们不能再继续执行自己的程序,那就只能阻塞了,阻塞完了当轮到这个线程的时候还要唤醒,所以我们还需要Unsfae这个类来阻塞(park)和唤醒(unpark)线程。

基于以上四点,我们需要的神器大致有:一个变量、一个队列、执行CAS/park/unpark的Unsafe类。

大概的流程图如下图所示:

java同步之如何写一个锁Lock

关于Unsafe类的相关讲解请参考之前发的文章:

java Unsafe详细解析

 

解决

一个变量

这个变量只支持同时只有一个线程能把它修改为1,所以它修改完了一定要让其它线程可见,因此,这个变量需要使用volatile来修饰。

private volatile int state;

CAS

这个变量的修改必须是原子操作,所以我们需要CAS更新它,我们这里使用Unsafe来直接CAS更新int类型的state。

当然,这个变量如果直接使用AtomicInteger也是可以的,不过,既然我们学习了更底层的Unsafe类那就应该用(浪)起来。

private boolean compareAndSetState(int expect, int update) {
 return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
}

一个队列

队列的实现有很多,数组、链表都可以,我们这里采用链表,毕竟链表实现队列相对简单一些,不用考虑扩容等问题。

这个队列的操作很有特点:

放元素的时候都是放到尾部,且可能是多个线程一起放,所以对尾部的操作要CAS更新;

唤醒一个元素的时候从头部开始,但同时只有一个线程在操作,即获得了锁的那个线程,所以对头部的操作不需要CAS去更新。

private static class Node {
 // 存储的元素为线程
 Thread thread;
 // 前一个节点(可以没有,但实现起来很困难)
 Node prev;
 // 后一个节点
 Node next;

 public Node() {
 }

 public Node(Thread thread, Node prev) {
 this.thread = thread;
 this.prev = prev;
 }
}
// 链表头
private volatile Node head;
// 链表尾
private volatile Node tail;
// 原子更新tail字段
private boolean compareAndSetTail(Node expect, Node update) {
 return unsafe.compareAndSwapObject(this, tailOffset, expect, update);
}

这个队列很简单,存储的元素是线程,需要有指向下一个待唤醒的节点,前一个节点可有可无,但是没有实现起来很困难,不信学完这篇文章你试试。

加锁

public void lock() {
 // 尝试更新state字段,更新成功说明占有了锁
 if (compareAndSetState(0, 1)) {
 return;
 }
 // 未更新成功则入队
 Node node = enqueue();
 Node prev = node.prev;
 // 再次尝试获取锁,需要检测上一个节点是不是head,按入队顺序加锁
 while (node.prev != head || !compareAndSetState(0, 1)) {
 // 未获取到锁,阻塞
 unsafe.park(false, 0L);
 }
 // 下面不需要原子更新,因为同时只有一个线程访问到这里
 // 获取到锁了且上一个节点是head
 // head后移一位
 head = node;
 // 清空当前节点的内容,协助GC
 node.thread = null;
 // 将上一个节点从链表中剔除,协助GC
 node.prev = null;
 prev.next = null;
}
// 入队
private Node enqueue() {
 while (true) {
 // 获取尾节点
 Node t = tail;
 // 构造新节点
 Node node = new Node(Thread.currentThread(), t);
 // 不断尝试原子更新尾节点
 if (compareAndSetTail(t, node)) {
 // 更新尾节点成功了,让原尾节点的next指针指向当前节点
 t.next = node;
 return node;
 }
 }
}

(1)尝试获取锁,成功了就直接返回;

(2)未获取到锁,就进入队列排队;

(3)入队之后,再次尝试获取锁;

(4)如果不成功,就阻塞;

(5)如果成功了,就把头节点后移一位,并清空当前节点的内容,且与上一个节点断绝关系;

(6)加锁结束;

解锁

// 解锁
public void unlock() {
 // 把state更新成0,这里不需要原子更新,因为同时只有一个线程访问到这里
 state = 0;
 // 下一个待唤醒的节点
 Node next = head.next;
 // 下一个节点不为空,就唤醒它
 if (next != null) {
 unsafe.unpark(next.thread);
 }
}

(1)把state改成0,这里不需要CAS更新,因为现在还在加锁中,只有一个线程去更新,在这句之后就释放了锁;

(2)如果有下一个节点就唤醒它;

(3)唤醒之后就会接着走上面lock()方法的while循环再去尝试获取锁;

(4)唤醒的线程不是百分之百能获取到锁的,因为这里state更新成0的时候就解锁了,之后可能就有线程去尝试加锁了。

测试

上面完整的锁的实现就完了,是不是很简单,但是它是不是真的可靠呢,敢不敢来试试?!

直接上测试代码:

private static int count = 0;

public static void main(String[] args) throws InterruptedException {
 MyLock lock = new MyLock();

 CountDownLatch countDownLatch = new CountDownLatch(1000);

 IntStream.range(0, 1000).forEach(i -> new Thread(() -> {
 lock.lock();

 try {
 IntStream.range(0, 10000).forEach(j -> {
 count++;
 });
 } finally {
 lock.unlock();
 }
// System.out.println(Thread.currentThread().getName());
 countDownLatch.countDown();
 }, "tt-" + i).start());

 countDownLatch.await();

 System.out.println(count);
}

运行这段代码的结果是总是打印出10000000(一千万),说明我们的锁是正确的、可靠的、完美的。

总结

(1)自己动手写一个锁需要做准备:一个变量、一个队列、Unsafe类。

(2)原子更新变量为1说明获得锁成功;

(3)原子更新变量为1失败说明获得锁失败,进入队列排队;

(4)更新队列尾节点的时候是多线程竞争的,所以要使用原子更新;

(5)更新队列头节点的时候只有一个线程,不存在竞争,所以不需要使用原子更新;

(6)队列节点中的前一个节点prev的使用很巧妙,没有它将很难实现一个锁,只有写过的人才明白,不信你试试^^

彩蛋

(1)我们实现的锁支持可重入吗?

答:不可重入,因为我们每次只把state更新为1。如果要支持可重入也很简单,获取锁时检测锁是不是被当前线程占有着,如果是就把state的值加1,释放锁时每次减1即可,减为0时表示锁已释放。

(2)我们实现的锁是公平锁还是非公平锁?

答:非公平锁,因为获取锁的时候我们先尝试了一次,这里并不是严格的排队,所以是非公平锁。

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持码农之家。

Java锁机制Lock用法示例

本文实例讲述了Java锁机制Lock用法。分享给大家供大家参考,具体如下:

package com.expgiga.JUC;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
 * 一、用于解决多线程安全问题的方式:
 * 1.同步代码块 synchronized 隐式锁
 * 2.同步方法 synchronized 隐式锁
 * 3.同步锁Lock (jdk1.5以后) 显示锁
 * 注意:显示锁,需要通过lock()方式上锁,必须通过unlock()方式进行释放锁
 */
public class TestLock {
  public static void main(String[] args) {
    Ticket ticket = new Ticket();
    new Thread(ticket, "1号窗口").start();
    new Thread(ticket, "2号窗口").start();
    new Thread(ticket, "3号窗口").start();
  }
}
class Ticket implements Runnable {
  private int tick = 100;
  private Lock lock = new ReentrantLock();
  @Override
  public void run() {
    while (true) {
      lock.lock();
      try {
        if (tick > 0) {
          try {
            Thread.sleep(200);
          } catch (InterruptedException e) {
            e.printStackTrace();
          }
          System.out.println(Thread.currentThread().getName() + " 完成售票,余票为 " + --tick);
        }
      } finally {
        lock.unlock();
      }
    }
  }
}

运行结果:

1号窗口 完成售票,余票为 99
2号窗口 完成售票,余票为 98
2号窗口 完成售票,余票为 97
2号窗口 完成售票,余票为 96
2号窗口 完成售票,余票为 95
3号窗口 完成售票,余票为 94
1号窗口 完成售票,余票为 93
1号窗口 完成售票,余票为 92
1号窗口 完成售票,余票为 91
1号窗口 完成售票,余票为 90
1号窗口 完成售票,余票为 89
1号窗口 完成售票,余票为 88
1号窗口 完成售票,余票为 87
1号窗口 完成售票,余票为 86
2号窗口 完成售票,余票为 85
3号窗口 完成售票,余票为 84
1号窗口 完成售票,余票为 83
2号窗口 完成售票,余票为 82
3号窗口 完成售票,余票为 81
1号窗口 完成售票,余票为 80
1号窗口 完成售票,余票为 79
1号窗口 完成售票,余票为 78
1号窗口 完成售票,余票为 77
1号窗口 完成售票,余票为 76
1号窗口 完成售票,余票为 75
1号窗口 完成售票,余票为 74
1号窗口 完成售票,余票为 73
1号窗口 完成售票,余票为 72
2号窗口 完成售票,余票为 71
2号窗口 完成售票,余票为 70
2号窗口 完成售票,余票为 69
2号窗口 完成售票,余票为 68
3号窗口 完成售票,余票为 67
1号窗口 完成售票,余票为 66
1号窗口 完成售票,余票为 65
1号窗口 完成售票,余票为 64
1号窗口 完成售票,余票为 63
1号窗口 完成售票,余票为 62
1号窗口 完成售票,余票为 61
2号窗口 完成售票,余票为 60
2号窗口 完成售票,余票为 59
3号窗口 完成售票,余票为 58
3号窗口 完成售票,余票为 57
1号窗口 完成售票,余票为 56
1号窗口 完成售票,余票为 55
2号窗口 完成售票,余票为 54
2号窗口 完成售票,余票为 53
2号窗口 完成售票,余票为 52
3号窗口 完成售票,余票为 51
1号窗口 完成售票,余票为 50
1号窗口 完成售票,余票为 49
1号窗口 完成售票,余票为 48
1号窗口 完成售票,余票为 47
1号窗口 完成售票,余票为 46
1号窗口 完成售票,余票为 45
2号窗口 完成售票,余票为 44
3号窗口 完成售票,余票为 43
3号窗口 完成售票,余票为 42
3号窗口 完成售票,余票为 41
3号窗口 完成售票,余票为 40
3号窗口 完成售票,余票为 39
1号窗口 完成售票,余票为 38
2号窗口 完成售票,余票为 37
2号窗口 完成售票,余票为 36
2号窗口 完成售票,余票为 35
2号窗口 完成售票,余票为 34
2号窗口 完成售票,余票为 33
2号窗口 完成售票,余票为 32
2号窗口 完成售票,余票为 31
3号窗口 完成售票,余票为 30
1号窗口 完成售票,余票为 29
1号窗口 完成售票,余票为 28
1号窗口 完成售票,余票为 27
1号窗口 完成售票,余票为 26
1号窗口 完成售票,余票为 25
1号窗口 完成售票,余票为 24
1号窗口 完成售票,余票为 23
1号窗口 完成售票,余票为 22
1号窗口 完成售票,余票为 21
1号窗口 完成售票,余票为 20
1号窗口 完成售票,余票为 19
1号窗口 完成售票,余票为 18
1号窗口 完成售票,余票为 17
1号窗口 完成售票,余票为 16
1号窗口 完成售票,余票为 15
2号窗口 完成售票,余票为 14
2号窗口 完成售票,余票为 13
2号窗口 完成售票,余票为 12
3号窗口 完成售票,余票为 11
3号窗口 完成售票,余票为 10
3号窗口 完成售票,余票为 9
1号窗口 完成售票,余票为 8
1号窗口 完成售票,余票为 7
1号窗口 完成售票,余票为 6
1号窗口 完成售票,余票为 5
2号窗口 完成售票,余票为 4
3号窗口 完成售票,余票为 3
1号窗口 完成售票,余票为 2
2号窗口 完成售票,余票为 1
2号窗口 完成售票,余票为 0

更多java相关内容感兴趣的读者可查看本站专题:《Java进程与线程操作技巧总结》、《Java数据结构与算法教程》、《Java操作DOM节点技巧总结》、《Java文件与目录操作技巧汇总》和《Java缓存操作技巧汇总》

希望本文所述对大家java程序设计有所帮助。

以上就是本次给大家分享的全部知识点内容总结,大家还可以在下方相关文章里找到spring+springmvc+mybatis整合注、 解决axios.interceptors.respon、 详解vue axios封装请求状态、 等java文章进一步学习,感谢大家的阅读和支持。

上一篇:java对synchronized的优化知识点总结

下一篇:Java应聘中到底啥是分布式系统开发经验

展开 +

收起 -

学习笔记
网友NO.348620

Java中的显示锁ReentrantLock使用与原理详解

考虑一个场景,轮流打印0-100以内的技术和偶数。通过使用 synchronize 的 wait,notify机制就可以实现,核心思路如下: 使用两个线程,一个打印奇数,一个打印偶数。这两个线程会共享一个数据,数据每次自增,当打印奇数的线程发现当前要打印的数字不是奇数时,执行等待,否则打印奇数,并将数字自增1,对于打印偶数的线程也是如此 //打印奇数的线程private static class OldRunner implements Runnable{ private MyNumber n; public OldRunner(MyNumber n) { this.n = n; } public void run() { while (true){ n.waitToOld(); //等待数据变成奇数 System.out.println("old:" + n.getVal()); n.increase(); if (n.getVal()98){ break; } } }}//打印偶数的线程private static class EvenRunner implements Runnable{ private MyNumber n; public EvenRunner(MyNumber n) { this.n = n; } public void run() { while (true){ n.waitToEven(); //等待数据变成偶数 System.out.println("even:"+n.getVal()); n.increase(); if (n.getVal()99){ break; } } }} 共享的数据如下 private static class MyNumber{ private int val; public MyNumber(int val) { this.val = val; } public int getVal() { return val; } public synchronized void increase(){ val++; notify(); //数据变了,唤醒另外的线程 } public synchronized void waitToOld(){ while ((val % 2)==0){ try { System.out.println("i am "+Thread.currentThread().getName()+" ,but now is even:"+val+",so wait"); wait(); //只要是偶数,一直等……

网友NO.223788

Java并发系列之ReentrantLock源码分析

在Java5.0之前,协调对共享对象的访问可以使用的机制只有synchronized和volatile。我们知道synchronized关键字实现了内置锁,而volatile关键字保证了多线程的内存可见性。在大多数情况下,这些机制都能很好地完成工作,但却无法实现一些更高级的功能,例如,无法中断一个正在等待获取锁的线程,无法实现限定时间的获取锁机制,无法实现非阻塞结构的加锁规则等。而这些更灵活的加锁机制通常都能够提供更好的活跃性或性能。因此,在Java5.0中增加了一种新的机制:ReentrantLock。ReentrantLock类实现了Lock接口,并提供了与synchronized相同的互斥性和内存可见性,它的底层是通过AQS来实现多线程同步的。与内置锁相比ReentrantLock不仅提供了更丰富的加锁机制,而且在性能上也不逊色于内置锁(在以前的版本中甚至优于内置锁)。说了ReentrantLock这么多的优点,那么下面我们就来揭开它的源码看看它的具体实现。 1.synchronized关键字的介绍 Java提供了内置锁来支持多线程的同步,JVM根据synchronized关键字来标识同步代码块,当线程进入同步代码块时会自动获取锁,退出同步代码块时会自动释放锁,一个线程获得锁后其他线程将会被阻塞。每个Java对象都可以用做一个实现同步的锁,synchronized关键字可以用来修饰对象方法,静态方法和代码块,当修饰……

网友NO.736547

Java源码解析阻塞队列ArrayBlockingQueue功能简介

本文基于jdk1.8进行分析。 阻塞队列是java开发时常用的一个数据结构。首先看一下阻塞队列的作用是什么。阻塞队列的作用,从源码中类的注释中来了解,是最清晰准确的。 ArrayBlockingQueue是一个用数组实现的有界阻塞队列。提供FIFO的功能。队列头上的元素是在队列中呆了最长时间的元素,队列尾上的元素是在队列中呆了时间最短的元素。新元素会插入在队列尾部,从队列获取元素时会从队列头上获取。 这是一个传统的有界队列,在这个有界队列里,一个固定大小的数组用来保存生产者产生的元素和消费者获取的元素。一旦创建,大小不可改变。往已满的队列中尝试添加元素,会阻塞操作。从空的队列中获取元素,也会阻塞操作。 这个类为等待中的生产着和消费者线程排序提供可选的公平策略。默认情况下,顺序是没有保证的。但是,一个用fairness=true创建的队列可以保证FIFO特性。公平性通常会降低吞吐量,但是可以减少易变性并避免饥饿。 /** * A bounded {@linkplain BlockingQueue blocking queue} backed by an * array. This queue orders elements FIFO (first-in-first-out). The * emhead/em of the queue is that element that has been on the * queue the longest time. The emtail/em of the queue is that * element that has been on the queue the shortest time. New elements * are inserted at the tail of the queue, a……

<
1
>

Copyright 2018-2019 xz577.com 码农之家

版权责任说明