萌新必入！手把手教你玩转Synchronized锁和Lock锁！

最新推荐文章于 2023-04-16 20:03:43 发布
最新推荐文章于 2023-04-16 20:03:43 发布
阅读量3w 收藏 26
点赞数 18
分类专栏： Java 文章标签： java synchronized lock 锁 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46263782/article/details/119826566
版权

文章目录

声明

1）该文章部分内容整理自网上的资料，如不小心侵犯了大家的权益，还望海涵，并联系博主删除。

2）博主是萌新上路，文中如有不当之处，请各位大佬指出，共同进步，谢谢。
 

前言

这是一篇关于 Synchronized 锁和 Lock 锁的超详细的万字博文，博文中列举了大量的例子用于理解，相信深度阅读本博文后，玩转 Synchronized 锁和 Lock 锁轻轻松松，有手就行！
 

Synchronized锁

synchronized 锁，传统的队列锁；

  1. sychronized 的作用：

    在并发编程中会存在线程安全问题，主要原因是存在共享数据和多线程共同操作共享数据。关键字 sychronized 可以保证在同一时刻只有一个线程可以执行某个方法或某个代码块（临界区），同时 synchronized 可以保证一个线程的变化可见。

    只有共享资源读写访问才需要同步化，如果不是共享资源就没有必要同步。
     

  2. 三种应用方式：

  • 修饰实例方法，对当前实例进行加锁，进入同步代码前需获得当前实例的锁；

  • 修饰静态方法，对类对象加锁，要先获得当前类对象的锁；

  • 修饰代码块，指定加锁对象，对给定对象加锁，要先获得给定对象的锁；

    2.1 同步方法（静态方法、实例方法）：

    用 sychronized 修饰的方法就叫做同步方法，保证 A 线程执行该方法的时候，其他线程只能在方法外等着。

    synchronized public void doWorlk(){
     ...
}

    对于非静态类方法，同步锁就是 this(实例对象)；

    对于静态类方法，同步锁是当前方法所在类的字节码对象（类对象）；

    2.2 同步代码块：

    syschronized(同步锁){
  ....
}

    同步锁：在任何时候最多只能有一个线程有同步锁，其他线程只能在代码块外等着。

    为保证每个线程都能正常执行原子操作，Java 引入了线程同步机制。Java 程序运行可以使用任何对象作为同步监听对象，但一般把当前并发访问的共同资源作为同步监听对象。
     

  1. 举例子：

    package com.idiot.demo1;

public class Test1 {
    public static void main(String[] args) throws InterruptedException {
        // 并发：多线程操作同一个资源类,
        Ticket ticket = new Ticket();
        // @FunctionalInterface 函数式接口
        new Thread(() -> {
            for (int i = 1; i < 20; i++) {
                //把资源类丢入线程
                ticket.sale();
            }
        }, "A").start();
        new Thread(() -> {
            for (int i = 1; i < 20; i++) {
                ticket.sale();
            }
        }, "B").start();
        new Thread(() -> {
            for (int i = 1; i < 20; i++) {
                ticket.sale();
            }
        }, "C").start();
    }
}

class Ticket {
    //共卖30张票
    private int number = 30;

    // 卖票的方式
    public synchronized void sale() {
        if (number > 0) {
            System.out.println(Thread.currentThread().getName() + "卖出了第" + (number--) + "票,剩余：" + number);
        }
    }
}

当多个线程同时对一个对象的一个方法进行操作，只有一个线程能够抢到锁。因为一个对象只有一把锁，一个线程获取了该对象的锁之后，其他线程无法获取该对象的锁，就不能访问该对象的其他 synchronized 实例方法，但是可以访问非 synchronized 修饰的方法。
 

Lock锁

Lock 锁是一个接口，其所有的实现类为

  • ReentrantLock (可重入锁)；
  • ReentrantReadWriteLock.ReadLock (可重入读写锁的读锁)；
  • ReentrantReadWriteLock.WriteLock (可重入读写锁的写锁)；

Lock 锁提供了比使用 synchronized 方法和语句可获得的更广泛的锁定操作。Lock 接口的实现允许锁在不同的作用范围内获取和释放，并允许以任何顺序获取和释放多个锁。随着灵活的增加，也带来了更多的责任。不使用块结构锁就失去了使用 synchronized 方法和语句时会出现的锁自动释放功能。在大多数情况下，应使用以下语句：

Lock l = ...;
     l.lock();//加锁
     try {
         // access the resource protected by this lock
     } finally {
         l.unlock();//解锁
     }

加锁和解锁出现在不同作用范围中是，需谨慎确保锁定是所执行的所有代码用 try-finall 或 try-catch 保护，以确保在必要时释放锁。

  • 公平锁： 十分公平，必须先来后到；
  • 非公平锁： 十分不公平，可以插队；(默认为非公平锁)
  • 可重入锁：如果锁具备可重入性，则称为可（可以）重（再次）入(进入同步域，即同步代码块/方法)锁(同步锁)。可重入就是指某个线程已经获得某个锁，可以再次获取相同的锁而不会出现死锁。
package com.idiot.demo1;

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

public class LockDemo {
    public static void main(String[] args) {
        final Ticket2 ticket = new Ticket2();

        new Thread(() -> {
            for (int i = 0; i < 40; i++) {
                ticket.sale();
            }
        }, "A").start();
        new Thread(() -> {
            for (int i = 0; i < 40; i++) {
                ticket.sale();
            }
        }, "B").start();
        new Thread(() -> {
            for (int i = 0; i < 40; i++) {
                ticket.sale();
            }
        }, "C").start();
    }
}
//lock三部曲
//1、    Lock lock=new ReentrantLock();
//2、    lock.lock() 加锁
//3、    finally=> 解锁：lock.unlock();
class Ticket2 {
    private int number = 30;

    // 创建锁
    Lock lock = new ReentrantLock();
    //卖票的方式
    public void sale() {
        lock.lock(); // 开启锁
        try {
            if (number > 0) {
                System.out.println(Thread.currentThread().getName() + "卖出了第" + (number--) + "张票剩余" + number + "张票");
            }
        }finally {
            lock.unlock(); // 关闭锁
        }

    }
}

 

Synchronized与Lock区别

1、Synchronized 内置的 Java 关键字；Lock 是一个 Java 类；

2、Synchronized 无法判断获取锁的状态；Lock 可以判断；

3、Synchronized 会自动释放锁；Lock 必须要手动加锁和手动释放锁，可能会遇到死锁；

4、Synchronized 线程1(获得锁->阻塞)、线程2(等待)；Lock 就不一定会一直等待下去，Lock 会有一个 trylock 去尝试获取锁，不会造成长久的等待；

5、Synchronized 是可重入锁，不可以中断的，非公平的；Lock，可重入的，可以判断锁，可以自己设置公平锁和非公平锁；

6、Synchronized 适合锁少量的代码同步问题，Lock 适合锁大量的同步代码；

 

生产者与消费者问题

面试题：单例模式，排序算法，生产者和消费者，死锁；

Synchronized

package com.idiot.demo1;

public class A {
    public static void main(String[] args) {
        Data data = new Data();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();


        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"B").start();
    }
}

// 判断等待，业务，通知
class Data { // 数字 资源类
    private int number = 0;

    //+1
    public synchronized void increment() throws InterruptedException {
        if (number != 0) {    //0
            // 等待
            this.wait();
        }
        number++;
        System.out.println(Thread.currentThread().getName() + "=>" + number);
        // 通知其他线程，我+1完毕了
        this.notifyAll();
    }

    //-1
    public synchronized void decrement() throws InterruptedException {
        if (number == 0) { // 1
            // 等待
            this.wait();
        }
        number--;
        System.out.println(Thread.currentThread().getName() + "=>" + number);
        // 通知其他线程，我-1完毕了
        this.notifyAll();
    }
}

思考：如果有A，B，C，D四个线程，会出现什么情况？

会出现虚假唤醒问题，即除了输出0,1，还会有其他输出；

尝试之后的运行结果：

只需要将 if 改为 while 即可：

package com.idiot.demo1;

public class A {
    public static void main(String[] args) {
        Data data = new Data();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();


        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"B").start();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"C").start();


        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"D").start();
    }
}

// 判断等待，业务，通知
class Data { // 数字 资源类
    private int number = 0;

    //+1
    public synchronized void increment() throws InterruptedException {
        while (number != 0) {    //0
            // 等待
            this.wait();
        }
        number++;
        System.out.println(Thread.currentThread().getName() + "=>" + number);
        // 通知其他线程，我+1完毕了
        this.notifyAll();
    }

    //-1
    public synchronized void decrement() throws InterruptedException {
        while (number == 0) { // 1
            // 等待
            this.wait();
        }
        number--;
        System.out.println(Thread.currentThread().getName() + "=>" + number);
        // 通知其他线程，我-1完毕了
        this.notifyAll();
    }
}


 

Lock

通过 Lock 找到 Condition：

package com.idiot.demo1;

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

public class B {
    public static void main(String[] args) {
        Data2 data = new Data2();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();


        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"B").start();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"C").start();


        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"D").start();
    }
}

// 判断等待，业务，通知
class Data2 { // 数字 资源类
    private int number = 0;

    Lock lock = new ReentrantLock();
    Condition condition = lock.newCondition();

    //condition.await();      等待
    //condition.signalAll();  唤醒全部
    //+1
    public void increment() throws InterruptedException {
        lock.lock();
        try {
            while (number != 0) {    //0
                condition.await();
            }
            number++;
            System.out.println(Thread.currentThread().getName() + "=>" + number);
            condition.signalAll();
        } catch (Exception e){
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    //-1
    public void decrement() throws InterruptedException {
        lock.lock();
        try {
            while (number == 0) {    //0
                condition.await();
            }
            number--;
            System.out.println(Thread.currentThread().getName() + "=>" + number);
            condition.signalAll();
        } catch (Exception e){
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

任何一个新的技术，绝对不是仅仅只是覆盖了原来的技术，更有优势和补充！Condition 精准的通知和唤醒线程；

可以从上面的运行截图中发现，A，B，C，D的输出是随机的，并不是我们想要的有序输出，这是就要使用 Condition 的精准通知和唤醒功能了；

package com.idiot.demo1;

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

public class C {
    public static void main(String[] args) {
        Data3 data = new Data3();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data.printA();
            }
        },"A").start();


        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data.printB();
            }
        },"B").start();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data.printC();
            }
        },"C").start();
    }
}

class Data3{ // 资源类 Lock
    private int number = 1; // 1A 2B 3C

    private Lock lock = new ReentrantLock();
    private Condition condition1 = lock.newCondition();
    private Condition condition2 = lock.newCondition();
    private Condition condition3 = lock.newCondition();

    public void printA(){
        lock.lock();
        try {
            while (number!=1){
                condition1.await();
            }
            System.out.println(Thread.currentThread().getName()+"=>A");
            number = 2;
            condition2.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void printB(){
        lock.lock();
        try {
            while (number!=2){
                condition2.await();
            }
            System.out.println(Thread.currentThread().getName()+"=>B");
            number = 3;
            condition3.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void printC(){
        lock.lock();
        try {
            while (number!=3){
                condition3.await();
            }
            System.out.println(Thread.currentThread().getName()+"=>C");
            number = 1;
            condition1.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

 

8锁现象

深刻理解锁，判断锁的是谁；

可以把锁理解为上厕所，两个方法一把锁，就好比只有一个厕所，里面已经有人在上了，且把门锁了，那么另一个人只能在门外等里面的人上完解锁出来，才能进去上厕所；

8锁，就是关于锁的8个问题：

1、标准情况下，两个线程先打印“发短信”还是“打电话”？

package com.idiot.lock8;

public class Test1 {
    public static void main(String[] args) {
        Phone phone = new Phone();

        new Thread(()->{
            phone.send();
        },"A").start();

        try {
            TimeUnit.SECONDS.sleep(1); 
        } catch (InterruptedException e) { 
            e.printStackTrace(); 
        }
        
        new Thread(()->{
            phone.call();
        },"B").start();
    }

}

class Phone{

    //synchronized 锁的对象是方法的调用者
    //两个方法用的是同一个锁，谁先拿到谁先执行！
    public synchronized  void send(){
        System.out.println("发短信");
    }

    public synchronized  void call(){
        System.out.println("打电话");
    }
}

运行结果：毋庸置疑的是发短信先输出，因为 send() 方法先拿到 synchronized 锁，call() 方法只能等 send() 执行完之后释放锁了，才能得到 synchronized 锁；

发短信
打电话

 

 
2、如果将 send() 方法内部延迟四秒，两个线程先打印“发短信”还是“打电话”？

public synchronized  void send(){
    try {
        TimeUnit.SECONDS.sleep(4);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println("发短信");
}

运行结果：依然是发短信先输出，因为两个方法调用的是同一个对象，且 send() 方法先拿到 synchronized 锁，哪怕该方法内部睡眠了，也要等它执行完才能运行下一个线程，不会出现抢占的情况；

发短信
打电话

 

 
3、 增加了一个普通方法后，先执行“发短信”还是 “hello”？

package com.idiot.lock8;

import java.util.concurrent.TimeUnit;

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

        new Thread(()->{
            phone.send();
        },"A").start();

        try {
            TimeUnit.SECONDS.sleep(1); 
        } catch (InterruptedException e) { 
            e.printStackTrace(); 
        }
        
        new Thread(()->{
            phone.hello();
        },"B").start();
    }

}

class Phone2{

    //synchronized 锁的对象是方法的调用者
    public synchronized  void send(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

    //不是同步方法，不受锁的影响
    public void hello(){
        System.out.println("hello");
    }
}

运行结果：hello 先输出，因为 hello() 只是一个普通方法，不受 synchronized 锁的影响，send() 方法睡眠的时候，hello() 方法借机抢占 CPU 或者说 CPU 自行调度使其先执行；

hello
发短信

 

 
4、 两个对象，两个同步方法，先打印“发短信”还是“打电话”？

package com.idiot.lock8;

import java.util.concurrent.TimeUnit;

public class Test2 {
    public static void main(String[] args) {
        Phone2 phone1 = new Phone2();
        Phone2 phone2 = new Phone2();

        new Thread(()->{
            phone1.send();
        },"A").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(()->{
            phone2.call();
        },"B").start();
    }
}

class Phone2{

    //synchronized 锁的对象是方法的调用者
    public synchronized  void send(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

    public synchronized  void call(){
        System.out.println("打电话");
    }
}

运行结果：打电话先输出，因为是两个不同的对象，所以有两把 synchronized 锁，两把锁互不影响，send() 方法会睡眠4秒，因此“打电话”先输出；

打电话
发短信

 

 

5、增加两个静态的同步方法，只有一个对象，先打印“发短信”还是“打电话”？

package com.idiot.lock8;

import java.util.concurrent.TimeUnit;

public class Test3 {
    public static void main(String[] args) {
        Phone3 phone1 = new Phone3();

        new Thread(()->{
            phone1.send();
        },"A").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(()->{
            phone1.call();
        },"B").start();
    }
}

class Phone3{

    // static 静态方法,类一加载就有了,锁的是Class
    public static synchronized  void send(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

    public static synchronized  void call(){
        System.out.println("打电话");
    }
}

运行结果：发短信先输出，因为 static 静态方法在类加载的时候就有了，这意味着锁的不再是方法调用者了，而是 Class，因为是同一个对象，所以当 send() 方法获得 synchronized 锁之后，call() 方法只能等待；

发短信
打电话

 

 
6、增加两个静态的同步方法，有两个对象，先打印“发短信”还是“打电话”？

public static void main(String[] args) {
    Phone3 phone1 = new Phone3();
    Phone3 phone2 = new Phone3();

    new Thread(()->{
        phone1.send();
    },"A").start();

    try {
        TimeUnit.SECONDS.sleep(1);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }

    new Thread(()->{
        phone2.call();
    },"B").start();
}

运行结果：发短信先输出，在第五实验时已经得出结论，有 static 时，锁的是 Class，因此，虽然是两个对象，但他们是同一个 Class 模板生成的，所以共用同一把锁；

发短信
打电话

如果创建一个跟 Phone3 一模一样的 Phone4，

Phone3 phone1 = new Phone3();
Phone4 phone2 = new Phone4();

运行结果：打电话先输出，因为两个对象是两把锁，互不影响，send() 方法又内置睡眠函数，因此 call() 方法先执行完；

打电话
发短信

 

 

7、1个静态的同步方法，1个普通的同步方法 ，一个对象，先打印“发短信”还是“打电话”？

package com.idiot.lock8;

import java.util.concurrent.TimeUnit;

public class Test4 {
    public static void main(String[] args) {
        Phone4 phone1 = new Phone4();

        new Thread(()->{
            phone1.send();
        },"A").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(()->{
            phone1.call();
        },"B").start();
    }
}

class Phone4{

    // static 静态方法,类一加载就有了,锁的是Class
    public static synchronized  void send(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

    public synchronized  void call(){
        System.out.println("打电话");
    }
}

运行结果：打电话先输出，静态方法锁的是 Class，而普通方法锁的是方法的调用者，两者不是同一把锁，因此互不影响；

打电话
发短信

 

 
8、1个静态的同步方法，1个普通的同步方法 ，两个对象，先打印“发短信”还是“打电话”？

public static void main(String[] args) {
    Phone4 phone1 = new Phone4();
    Phone4 phone2 = new Phone4();

    new Thread(()->{
        phone1.send();
    },"A").start();

    try {
        TimeUnit.SECONDS.sleep(1);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }

    new Thread(()->{
        phone2.call();
    },"B").start();
}

运行结果：打电话先输出，在第七实验的时候，同一个对象的情况两者锁的都不是同一把锁，更何况两个对象呢；

打电话
发短信

 

后记

本博文到此就结束了，希望阅读本博文之余，也自己动手敲敲代码，加深印象和理解，要是能来个一键三连就更好啦！

本博文的参考视频，十分感谢狂神老师！

sid10t.
关注
  • 18
    点赞
  • 踩
  • 26
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 7
    评论
专栏目录
lock锁，lock锁和synchronized的对比
11-19
lock锁，lock锁和synchronized的对比 # Lock锁 JDK5.0后Java提供了一种更加强大的线程同步机制。一种显式定义同步锁对象来实现锁，提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问...
深入理解java内置锁(synchronized)和显式锁(ReentrantLock)
08-28
主要介绍了Java多线程之内置锁(synchronized)和显式锁(ReentrantLock)的深入理解新的和用法，具有一定参考价值，需要的朋友可以了解下。
Synchronized 和 Lock 的区别和使用场景
01-20
并发编程中，锁是经常需要用到的，今天我们一起来看下Java中的锁机制：synchronized和lock。 Synchronized 和 Lock的概念 Synchronized 是Java 并发编程中很重要的关键字，另外一个很重要的是 volatile。Syncronized 的目的是一次只允许一个线程进入由他修饰的代码段，从而允许他们进行自我保护。Synchronized 很像生活中的锁例子，进入由Synchronized 保护的代码区首先需要获取 Synchronized 这把锁，其他线程想要执行必须进行等待。Synchronized 锁住的代码区域执行完成后需要把锁归还，也就是释放锁，
synchronized和lock的使用分析（优缺点对比详解）
小东升职记
11-17 5216
1.synchronized 加同步格式： synchronized(需要一个任意的对象(锁)){      代码块中放操作共享数据的代码。 } synchromized缺陷 synchronized是java中的一个关键字，也就是说是java语言的内置的特性。 如果一个代码块被synchronized修饰，当一个线程获取了对应的锁，并执行代码块时，其他线程只能一直等待，等待获取锁的...
synchronized 和Lock的使用
lzq199528的博客
08-28 332
synchronized 和 Lock的区别 synchronized是java中的一个关键字，也就是说是Java语言内置的特性。 Lock不是Java语言内置的，Lock是一个接口。 Lock和synchronized有一点非常大的不同，采用synchronized不需要用户去手动释放锁，当synchronized方法或者synchronized代码块执行完之后，系统会自动让线程释放对锁的占用...
《消息队列高手课》如何正确使用锁保护共享数据，协调异步线程？
weixin_44399827的博客
05-18 626
在前几天的加餐文章中我讲到，JMQ 为了提升整个流程的处理性能，使用了一个“近乎无锁”的设计，这里面其实隐含着两个信息点。第一个是，在消息队列中，“锁”是一个必须要使用的技术。第二个是，使用锁其实会降低系统的性能。 那么，如何正确使用锁，又需要注意哪些事项呢？今天我们就来聊一聊这个问题。 我们知道，使用异步和并发的设计可以大幅提升程序的性能，但我们为此付出的代价是，程序比原来更加复杂了，多线程在并行执行的时候，带来了很多不确定性。特别是对于一些需要多个线程并发读写的共享数据，如果处理不好，很可能会产出不
怎么正确使用锁？
技术修行者
03-18 646
这篇文章主要关注分布式锁，包括加锁和解锁的过程，锁的用法，加锁带来的代价，对性能的影响以及如何避免死锁。
多线程锁syn\lock使用详解
qq_44691484的博客
04-16 2095
lock和synchronized相比，更能灵活的试算代码片段加锁例如：手把手的进行锁获取和释放，先获得锁A，然后再获取锁B，当获取锁B后释放锁A同时获取锁C，等等代码逻辑枷锁。
synchronized和lock的区别以及用法
a984171281的博客
08-05 4939
1.synchronized锁是什么？ 1）：synchronized是Java的一个关键字，它能够将代码块(方法)锁起来 2）：它是一个隐式锁，即：锁的持有与释放都是隐式的，我们无需干预 3）：synchronized是非公平锁，它无法保证等待的线程获取锁的顺序 4）：synchronized是一种互斥锁，一次只能允许一个线程进入被锁住的代码块 5）：synchronized是一种内置锁/监视器锁，Java中每个对象都有一个内置锁(监视器,也可以理解成锁标记)，而synchronized就是使用对象的内置
多线程 生产，消费 ProducerConsumerDemo
mhbsoft的博客
12-03 209
ProducerConsumerDemo.java /** * 资源类 */ class ShareData { private int number = 0; private Lock lock = new ReentrantLock(); private Condition condition = lock.newCondition(); public void increment() { lock.lock(); //加锁 //1
synchronized和lock使用示例
fang_18014899963的博客
11-03 302
synchronized synchronized 在方法上，所有这个类的加了 synchronized 的方法，在执行时，会获得一个该类的唯一的同步锁，当这个锁被占用时，其他的加了 synchronized 的方法就必须等待 当静态方法加上synchronized时，普通synchronized方法和静态synchronized方法多线程时并行执行互补干扰 注意synchronized锁住的是对象而不是代码 线程通知 1.判断，需要使用while循环判断 2.干活 3.通知其他线程 代码示例：
synchronized、Lock、ReadWriteLock（读写锁例子 CacheDemo）
weixin_34253539的博客
06-16 195
2019独角兽企业重金招聘Python工程师标准>>> ...
Java并发 synchronized锁住的内容解析
08-25
主要介绍了Java并发 synchronized锁住的内容解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
synchronized枷锁实例
07-05
基于Synchronized加锁的四个demo，主要反映类锁、对象锁、方法锁的使用方法。 并测试不同类型锁之间的有效关系。
狂神说JAVA-JUC并发编程（一）线程、生产者消费者、锁、synchronized、Lock
想握住此生辽阔
01-28 678
1
JUC学习From狂神
m0_53891873的博客
06-21 156
线程进程 进程 一个进程可包含多个线程，至少包含一个 java默认有两个线程，一个main 一个GC 线程：开了一个写字板的进程，写字，自动保存（线程负责） Java开启线程：Thread、 Runnable 、Callable Java真的可以开启线程吗？ 不行 /** * Causes this thread to begin execution; the Java Virtual Machine * calls the <code>run</code&gt
狂神说Java笔记——Java多线程 - 线程同步与死锁（队列和锁、synchronized、lock、线程通信）
Blue
10-27 265
目录一、线程同步1. 并发2. 队列和锁 一、线程同步多个线程操作同一个资源1. 并发同一个对象被多个线程同时操作2. 队列和锁在访问时加入锁机制synchronized,3.三大不安全案例代码1—不安全的取钱线程不安全的集合4.同步方法锁-买票5. 同步块锁CopyOnWriteArrayList二、死锁某一个同步块同时拥有 “两个以上对象的锁 时，就可能会发生“死锁”的问题synchronized产生死锁的四个必要条件synchronized与Lock的对比线程协作线程通信管程法4. 使用线程池
在 Java 中高效使用锁的技巧
while(!isStrong()) wait(); return new Myself(me.toBlank());
04-06 290
[size=large][b]简介[/b][/size] 锁（lock）作为用于保护临界区（critical section）的一种机制，被广泛应用在多线程程序中。无论是 Java 语言中的 synchronized 关键字，还是 java.util.concurrent 包中的 ReentrantLock，都是多线程应用开发人员手中强有力的工具。但是强大的工具通常是把双刃剑，过多...
Java锁机制，synchronized和lock详解。
记录开发日常笔记
08-16 6827
Java锁机制详解
synchronized锁和lock锁
最新发布
07-28
例如，使用lock锁可以实现尝试锁定、超时锁定等操作，而synchronized关键字只能进行简单的加锁和释放锁。 另外，lock锁可以与Condition类配合使用，实现线程间的通信，而synchronized关键字则不能。 总之，lock锁...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

sid10t.

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值