Java并发编程——锁

最新推荐文章于 2022-12-31 12:30:09 发布
最新推荐文章于 2022-12-31 12:30:09 发布
阅读量113 收藏
点赞数
分类专栏： Java JUC 文章标签： java 并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43344930/article/details/111355345
版权
Java 同时被 2 个专栏收录
4 篇文章 0 订阅
订阅专栏
JUC
4 篇文章 0 订阅
订阅专栏

锁

一、Lock锁

Lock是一个接口，有三个实现类，可重入锁是最常用的一个实现类。
image-20200704005756165
image-20200704005922037
image-20200704010331358

  • 公平锁：多个线程按照申请锁的顺序去获得锁，线程会直接进入队列去排队，永远都是队列的第一位才能得到锁。
    • 优点：所有的线程都能得到资源，不会饿死在队列中。
    • 缺点：吞吐量会下降很多，队列里面除了第一个线程，其他的线程都会阻塞，cpu唤醒阻塞线程的开销会很大。
public class Lock1 {
    public static void main(String[] args) {
        Ticket1 ticket = new Ticket1();
        new Thread(()->{
            for(int i=0;i<40;i++)
                ticket.sale();
        }).start();
        new Thread(()->{
            for(int i=0;i<40;i++)
                ticket.sale();
        }).start();
        new Thread(()->{
            for(int i=0;i<40;i++)
                ticket.sale();
        }).start();
    }
    static class Ticket1{
        private int ticket = 30;
        Lock lock = new ReentrantLock(false);
        //业务逻辑
        private void sale(){
            //加锁
            lock.lock();
            try {
                if(ticket>0)
                    System.out.println(Thread.currentThread().getName()+"购买了一张票,"+"卖出了第"+(30-(--ticket))+"张票，还剩"+ticket+"张票");
            }catch (Exception e){

            }finally {
                //无论如何都会释放锁
                lock.unlock();
            }
        }
    }
}

Thread-0购买了一张票,卖出了第1张票，还剩29张票
Thread-0购买了一张票,卖出了第2张票，还剩28张票
Thread-1购买了一张票,卖出了第3张票，还剩27张票
Thread-2购买了一张票,卖出了第4张票，还剩26张票
Thread-0购买了一张票,卖出了第5张票，还剩25张票
Thread-1购买了一张票,卖出了第6张票，还剩24张票
Thread-2购买了一张票,卖出了第7张票，还剩23张票
Thread-0购买了一张票,卖出了第8张票，还剩22张票
Thread-1购买了一张票,卖出了第9张票，还剩21张票
Thread-2购买了一张票,卖出了第10张票，还剩20张票
Thread-0购买了一张票,卖出了第11张票，还剩19张票
Thread-1购买了一张票,卖出了第12张票，还剩18张票
Thread-2购买了一张票,卖出了第13张票，还剩17张票
Thread-0购买了一张票,卖出了第14张票，还剩16张票
Thread-1购买了一张票,卖出了第15张票，还剩15张票
Thread-2购买了一张票,卖出了第16张票，还剩14张票
Thread-0购买了一张票,卖出了第17张票，还剩13张票
Thread-1购买了一张票,卖出了第18张票，还剩12张票
Thread-2购买了一张票,卖出了第19张票，还剩11张票
Thread-0购买了一张票,卖出了第20张票，还剩10张票
Thread-1购买了一张票,卖出了第21张票，还剩9张票
Thread-2购买了一张票,卖出了第22张票，还剩8张票
Thread-0购买了一张票,卖出了第23张票，还剩7张票
Thread-1购买了一张票,卖出了第24张票，还剩6张票
Thread-2购买了一张票,卖出了第25张票，还剩5张票
Thread-0购买了一张票,卖出了第26张票，还剩4张票
Thread-1购买了一张票,卖出了第27张票，还剩3张票
Thread-2购买了一张票,卖出了第28张票，还剩2张票
Thread-0购买了一张票,卖出了第29张票，还剩1张票
Thread-1购买了一张票,卖出了第30张票，还剩0张票
  • 非公平锁：多个线程去获取锁的时候，会直接去尝试获取，获取不到，再去进入等待队列，如果能获取到，就直接获取到锁。
    • 优点：可以减少CPU唤醒线程的开销，整体的吞吐效率会高点，CPU也不必取唤醒所有线程，会减少唤起线程的数量。
    • 缺点：你们可能也发现了，这样可能导致队列中间的线程一直获取不到锁或者长时间获取不到锁，导致饿死。
public class Lock1 {
    public static void main(String[] args) {
        Ticket1 ticket = new Ticket1();
        new Thread(()->{
            for(int i=0;i<40;i++)
                ticket.sale();
        }).start();
        new Thread(()->{
            for(int i=0;i<40;i++)
                ticket.sale();
        }).start();
        new Thread(()->{
            for(int i=0;i<40;i++)
                ticket.sale();
        }).start();
    }
    static class Ticket1{
        private int ticket = 30;
        Lock lock = new ReentrantLock();
        //业务逻辑
        private void sale(){
            //加锁
            lock.lock();
            try {
                if(ticket>0)
                    System.out.println(Thread.currentThread().getName()+"购买了一张票,"+"卖出了第"+(30-(--ticket))+"张票，还剩"+ticket+"张票");
            }catch (Exception e){

            }finally {
                //无论如何都会释放锁
                lock.unlock();
            }

        }
    }
}

Thread-0购买了一张票,卖出了第1张票，还剩29张票
Thread-0购买了一张票,卖出了第2张票，还剩28张票
Thread-0购买了一张票,卖出了第3张票，还剩27张票
Thread-0购买了一张票,卖出了第4张票，还剩26张票
Thread-0购买了一张票,卖出了第5张票，还剩25张票
Thread-0购买了一张票,卖出了第6张票，还剩24张票
Thread-0购买了一张票,卖出了第7张票，还剩23张票
Thread-0购买了一张票,卖出了第8张票，还剩22张票
Thread-0购买了一张票,卖出了第9张票，还剩21张票
Thread-0购买了一张票,卖出了第10张票，还剩20张票
Thread-0购买了一张票,卖出了第11张票，还剩19张票
Thread-0购买了一张票,卖出了第12张票，还剩18张票
Thread-0购买了一张票,卖出了第13张票，还剩17张票
Thread-0购买了一张票,卖出了第14张票，还剩16张票
Thread-0购买了一张票,卖出了第15张票，还剩15张票
Thread-0购买了一张票,卖出了第16张票，还剩14张票
Thread-0购买了一张票,卖出了第17张票，还剩13张票
Thread-0购买了一张票,卖出了第18张票，还剩12张票
Thread-0购买了一张票,卖出了第19张票，还剩11张票
Thread-0购买了一张票,卖出了第20张票，还剩10张票
Thread-0购买了一张票,卖出了第21张票，还剩9张票
Thread-0购买了一张票,卖出了第22张票，还剩8张票
Thread-0购买了一张票,卖出了第23张票，还剩7张票
Thread-0购买了一张票,卖出了第24张票，还剩6张票
Thread-0购买了一张票,卖出了第25张票，还剩5张票
Thread-0购买了一张票,卖出了第26张票，还剩4张票
Thread-0购买了一张票,卖出了第27张票，还剩3张票
Thread-0购买了一张票,卖出了第28张票，还剩2张票
Thread-0购买了一张票,卖出了第29张票，还剩1张票
Thread-0购买了一张票,卖出了第30张票，还剩0张票

1.1 synchronized和Lock的区别

  • synchronized 是内置的Java关键字，Lock是一个Java类
  • synchronized无法判断锁的状态，Lock可以判断是否获取锁
  • synchronized会自动释放锁，lock必须手动释放锁，如果不释放锁，就会造成死锁
  • 有两个线程使用synchronized，线程1获得锁后阻塞，线程2会一直等待；Lock锁不一定会一直等待下去
  • synchronized 可重入锁，不可以中断，非公平； Lock，可重入锁，可中断，非公平（可以直接设置）
  • synchronized 适合锁少量的代码，Lock适合锁大量的代码

1.2 使用synchronized，如何判断锁的是谁

  • new this ，生成一个对象，锁的是具体的对象
  • static，锁的是Class，唯一的一个模板，无论生成多少个对象都是一个锁

synchronized修饰的同步方法，锁的对象是方法的调用者，即new出来的phone对象
两个方法是同一个锁，谁先拿到谁先执行，另外的线程阻塞

1、标准情况下，两个线程先打印哪个，结果先打印，发短信
2、发短信延迟2s，两个线程先打印哪一个，结果是先打印，发短信
public class Test1 {
    public static void main(String[] args) throws InterruptedException {
        Phone phone = new Phone();
        new Thread(()->{
            phone.sendSms();
        }).start();
        TimeUnit.SECONDS.sleep(1);
        new Thread(()->{
            phone.call();
        }).start();
    }
}
class Phone{
    public synchronized  void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    public synchronized void call(){
        System.out.println("打电话");
    }
}

有两个对象之后，就是两个锁，发短信线程先执行，但是有延迟，然后打电话跟它不是同个锁，执行到它就打印

3、增加一个普通方法后，先执行发短信还是hello，结果是hello
4、两个对象，两个同步方法，先发短信还是打电话，结果是打电话
public class Test2 {
    public static void main(String[] args) throws InterruptedException {
        Phone2 phone = new Phone2();
        new Thread(()->{
            phone.sendSms();
        }).start();
        TimeUnit.SECONDS.sleep(1);
        new Thread(()->{
            phone.hello();
        }).start();
    }
	public static void main(String[] args) throws InterruptedException {
        Phone2 phone = new Phone2();
        Phone2 phone2 = new Phone2();
        new Thread(()->{
            phone.sendSms();
        }).start();
        TimeUnit.SECONDS.sleep(1);
        new Thread(()->{
            phone2.call();
        }).start();
    }
}

class Phone2{
    public synchronized  void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    public synchronized void call(){
        System.out.println("打电话");
    }

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

静态同步方法锁的Class模板，无论new多少个对象，它的模板都只有一个，也就是说都是同个锁

5、增加一个静态的同步方法，结果先发短信 
6、在5的基础上再new 一个对象phone2，调用phone2的打电话，结果先发短信
public class Test3 {
    public static void main(String[] args) throws InterruptedException {
        Phone3 phone = new Phone3();
        new Thread(()->{
            phone.sendSms();
        }).start();
        TimeUnit.SECONDS.sleep(1);
        new Thread(()->{
            phone.call();
        }).start();
        Phone3 phone2 = new Phone3();
        new Thread(()->{
            phone.sendSms();
        }).start();
        TimeUnit.SECONDS.sleep(1);
        new Thread(()->{
            phone2.call();
        }).start();
    }
}

class Phone3{
    //静态方法，类一加载就有了，只有唯一个Class模板
    //同步静态方法锁的Class
    public static synchronized  void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    public static synchronized void call(){
        System.out.println("打电话");
    }

}

两个对象的话，静态方法和普通同步方法的锁不是同一个，所以不会影响。

7、一个静态同步方法，一个普通同步方法，一个对象，结果是先打电话
8、一个静态同步方法，一个普通同步方法，两个对象，结果是先打电话
public class Test4 {
    public static void main(String[] args) throws InterruptedException {
        Phone4 phone = new Phone4();
        new Thread(()->{
            phone.sendSms();
        }).start();
        TimeUnit.SECONDS.sleep(1);
        new Thread(()->{
            phone.call();
        }).start();
        Phone4 phone2 = new Phone4();
        new Thread(()->{
            phone.sendSms();
        }).start();
        TimeUnit.SECONDS.sleep(1);
        new Thread(()->{
            phone2.call();
        }).start();
    }
}

class Phone4{
    //静态方法，类一加载就有了，只有唯一个Class模板
    //同步静态方法锁的Class
    public static synchronized  void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    public synchronized void call(){
        System.out.println("打电话");
    }

}

1.3 可重入锁

可重入锁指的是可重复可递归调用的锁，在外层使用锁之后，在内层仍然可以使用，并且不发生死锁（前提得是同一个对象或者class），这样的锁就叫做可重入锁。ReentrantLock和synchronized都是可重入锁，下面是一个用synchronized实现的例子：

public class Test {

    public synchronized void get(){
        System.out.println(Thread.currentThread().getName()+"get");
        set();
    }

    public synchronized void set(){
        System.out.println(Thread.currentThread().getName()+"set");
    }


    public static void main(String[] args) {
        Test test = new Test();
        for (int i = 0; i < 10; i++) {
        new Thread(()->{
            test.get();
        }).start();
        }
    }
}

输出结果，整个过程没有发生死锁

Thread-0get
Thread-0set
Thread-7get
Thread-7set
Thread-6get
Thread-6set
Thread-5get
Thread-5set
Thread-4get
Thread-4set
Thread-3get
Thread-3set
Thread-1get
Thread-1set
Thread-2get
Thread-2set
Thread-9get
Thread-9set
Thread-8get
Thread-8set

set()和get()同时输出了线程名称，表明即使递归使用synchronized也没有发生死锁，证明其是可重入的。

1.4 不可重入锁

不可重入锁，与可重入锁相反，不可递归调用，递归调用就发生死锁。下次自己尝试设计一个不可重入锁。

public class UnreentrantLock {
    private boolean isLocked = false;
    public synchronized void lock() throws InterruptedException{
        while(isLocked){
            wait();
        }
        isLocked = true;
    }
    public synchronized void unlock(){
        isLocked = false;
        notify();
    }
}

使用该锁

public class UnreentrantLockDemo {
    private UnreentrantLock lock = new UnreentrantLock();
    public void get() throws InterruptedException {
        lock.lock();
        System.out.println(Thread.currentThread().getName()+" get");
        set();
        lock.unlock();
    }

    public void set() throws InterruptedException {
        lock.lock();
        System.out.println(Thread.currentThread().getName()+"set");
        lock.unlock();
    }

    public static void main(String[] args) throws InterruptedException {
        UnreentrantLockDemo demo = new UnreentrantLockDemo();
        demo.get();
    }
}

当前线程执行get()方法首先获取lock，然后执行set()方法，进入set()方法后无法在获取锁而发生阻塞，必须先获取锁。这个例子证明该锁是不可重入的。

二、ReadWriteLock读写锁

image-20200718225214347

共享锁（读锁）
独占锁（写锁）
public class ReadWriteLockDemo {
    public static void main(String[] args) {
        MyCache myCache = new MyCache();
        for (int i = 1; i <=20 ; i++) {
            final int temp = i;
            if(i%2!=0){
                new Thread(()->{
                    myCache.put(temp+"",temp+"");
                }).start();
            }else {
                new Thread(()->{
                    myCache.get(temp-1+"");
                }).start();
            }
        }
    }
}
/**
 * 自定义缓存
 */
 class MyCache{
     private volatile Map<String,Object> map = new HashMap<>();
     private ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
     //写入，一次只能有一个线程
     public void put(String key,Object value){
         readWriteLock.writeLock().lock();
         try {
             System.out.println(Thread.currentThread().getName()+"写入"+key);
             map.put(key,value);
             System.out.println(Thread.currentThread().getName()+"写入Ok");
         } catch (Exception e) {
             e.printStackTrace();
         } finally {
             readWriteLock.writeLock().unlock();
         }
     }
     public void get(String key){
         readWriteLock.readLock().lock();
         try {
             System.out.println(Thread.currentThread().getName()+"读取"+key);
             System.out.println(Thread.currentThread().getName()+"读取到数据"+map.get(key));
         } catch (Exception e) {
             e.printStackTrace();
         } finally {
             readWriteLock.readLock().unlock();
         }

     }
}

结果：

Thread-0写入1
Thread-0写入Ok
Thread-2写入3
Thread-2写入Ok
Thread-3读取3
Thread-3读取到数据3
Thread-5读取5
Thread-1读取1
Thread-5读取到数据null
Thread-1读取到数据1
Thread-10写入11
Thread-10写入Ok
Thread-4写入5
Thread-4写入Ok
Thread-12写入13
Thread-12写入Ok
Thread-6写入7
Thread-6写入Ok
Thread-7读取7
Thread-7读取到数据7
Thread-16写入17
Thread-16写入Ok
Thread-8写入9
Thread-8写入Ok
Thread-19读取19
Thread-13读取13
Thread-11读取11
Thread-9读取9
Thread-11读取到数据11
Thread-13读取到数据13
Thread-19读取到数据null
Thread-9读取到数据9
Thread-14写入15
Thread-14写入Ok
Thread-15读取15
Thread-17读取17
Thread-15读取到数据15
Thread-17读取到数据17
Thread-18写入19
Thread-18写入Ok

PS：读的时候其实不加锁也能实现多个线程同时读，但是可能在读的时候会有线程写入，造成幻读，加了读锁之后则一次读的操作没有完成前，不能写入

YaDe.
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java并发编程：锁
rrq_0324的博客
12-02 893
1.1 Lock Lock接口的实现基本都是通过聚合了一个队列同步器AQS的子类来完成线程访问控制的。 package java.util.concurrent.locks; import java.util.concurrent.TimeUnit; public interface Lock { //调用该方法的当前线程将会获取锁 void lock(); //可中断的获取锁，即在锁的获取中可以中断当前线程 void lockInterruptibly() throws Inte
java并发编程-锁
大猩猩的博客
09-17 76
1.1悲观锁与乐观锁 数据库中引入的名词，但是并发包里引用了类似的思想。 悲观锁直对数据被外界袖肥保持保守态度。认为数据很容易被其他线程修改，所以修改前加锁。在整个数据处理过程中处于锁定状态。悲观锁的实现依靠数据库的锁机制，在对数据库记录修改之前进行加排它锁。如果获取锁失败，说明数据被其他线程修改，当前线程则等待或跑出异常。 乐观锁是相对于悲观锁来说，认为数据一般不会造成冲突，所以访问记录时不会加排它锁，而是在进行数据更新时，才会对数据进行冲突检测。 1.2公平锁与非公平锁 根据线程的抢占机制，锁
并发编程——java中的锁
Aguai229的博客
09-20 482
一篇文章让你明白Lock锁、重入锁、读写锁，还不快学习！
java并发编程锁机制
JacksonLinjunqin的博客
12-14 221
之前系列文章都在叙述java线程池的设计以及实现机制，没有涉及java并发编程的锁机制，这是因为锁机制与线程池是相对独立的内容，自成体系，可以把锁机制当做线程池的一个基础组件，想黑盒一样使用它。 可我们如何去设计这样的一个黑盒，这样的一把锁？首先我们先了解清楚我们对锁的基本需求。 程序需要用到锁，说明程序中有多个线程（进程）存在共同竞争的资源，这样的资源可以包括一个共享变量，共享文件等。就线程池来...
Java并发编程——锁（干货满满）
silseven的博客
10-12 341
锁synchronizedLock接口队列同步器可重入锁（ReentrantLock） 本文参考了 黑马JUC并发编程 Java并发编程的艺术 深入理解java虚拟机 synchronized 在讲锁之前，先回顾一下synchronized的知识 在java中，最基本的互斥同步就是synchronized关键字。这是一种块结构（Block Structured）的同步语法。其经过Javac编译后，会分别形成monitorenter和monitorexit两个字节码指令。两者都需要一个reference类型的
java并发编程——内存模型
02-24
并发——在操作系统中，是指一个时间段中有几个程序都处于已启动运行到运行完毕之间，且这几个程序都是在同一个处理机上运行，但任一个时刻点上只有一个程序在处理机上运行——源自百度百科在并发编程中，我们需要...
Java并发编程总结——慎用CAS详解
09-02
Java并发编程中，CAS（Compare and Swap，比较并交换）是一种无锁算法，常用于实现原子操作，它在多线程环境下提供了数据的一致性。然而，CAS并不是万能的，过度依赖或不当使用可能会导致问题。下面我们将深入探讨...
Java并发编程图册Java并发编程图册
最新发布
03-29
首先，我们需要理解Java并发编程的基础——线程。在Java中，通过`Thread`类或者实现`Runnable`接口来创建线程。线程是程序执行的最小单位，允许多个任务在同一时间内执行。通过线程，我们可以实现并行处理，提升程序...
java 并发编程实践
05-19
本篇文章将深入探讨Java并发编程的相关知识点，主要基于提供的两个文件——"Java并发编程实战（中文版）.pdf"和"Java Concurrency in Practice.pdf"。 1. **线程与并发** - **线程基础**：Java中的线程是并发执行...
Java并发编程系列——锁：synchronized
Tas的博客
03-31 196
锁是并发编程里保证数据线程安全的一个重要的工具。今天就来了解下，java里的锁。 如何实现一个高并发的计数器 我们首先来考虑一个问题，如何实现一个高并发的计数器。稍微了解过java的人应该立马能想到"synchronized"关键字。但是事实上，在Java里可以通过各种方式来实现线程安全的计数器。 这篇文字将会解锁以下几种方式，并详细的解锁每一种锁的机制。 synchronized Lock接口...
Java并发编程实战笔记 （四）锁
qq_31887989的博客
11-29 243
时，会尝试获取对象的锁，如果锁的计数器为 0 则表示锁可以被获取，获取后将锁计数器设为 1 也就是加 1。主要解决的是多个线程之间访问资源的同步性，可以保证被它修饰的方法或者代码块在任意时刻只能有一个线程执行。在java虚拟机中，锁获取的是对象监视器 monitor,在执行。指令后，将锁计数器设为 0，表明锁被释放，其他线程可以尝试获取锁。访问标志来辨别一个方法是否声明为同步方法，从而执行相应的同步调用。提供了一种无条件的、可轮询的、定时的以及可中断的锁获取操作。标识，该标识指明了该方法是一个同步方法。
Java并发编程学习四：锁
weixin_41402069的博客
07-29 350
Java并发编程学习系列
java并发编程--锁和并发的小总结
lewis
09-25 432
个人对锁和并发的理解，说错欢迎纠错更正线程安全 1 对象封闭（不做共享）1).该对象封闭在某个作用域内，如局部变量，其他线程无法访问 2).封闭在线程内，由某个线程独占,与上思路相同，不做对象共享ThreadLocal 的思想便是将对象封闭在线程上， ThreadLocal为每个使用该变量的线程提供独立的变量副本。 2 锁 向 对象 加锁 ，确保不会多个线程发生竞争。 3 对象本身
《Java并发编程的艺术》——什么是锁(一)
Luffyu的博客
01-03 165
一 什么是锁 锁，是用来控制多个线程访问共享资源的一种方式，一般来说，一个锁能够防止多个线程同时访问共享资源,（但是有些锁也可以允许多个线程的访问贡献资源，例如读写锁）。 在Java 1.5之前 只有靠 synchronized关键字来实现锁功能，但是在Java1.5之后，提供了和synchronized有着同样功能的Lock接口是实现锁。同时具有 锁获取和释放的可操作、可中断以及超时获取锁等...
Java并发编程12种锁的具体实现方式
weixin_47053123的博客
07-24 1474
Java12种锁的具体实现方式synchronized(常用)Locklock,unlocktrylockReadAndWriteLock(读写锁)Atomic(i++操作)LongAdder(Atomic的优化)CountdownLatch(门闩)Exchanger(线程交换数据)Locksupport（类似于lock）Phaser (过程中，锁部分线程)CyclicBarrier(循环栅栏)Semaphore(限流)Unsafe(操作内存实现线程安全-不推荐) synchronized(常用) 使用J
Java并发编程进阶——并发锁
行者无疆的博客
03-14 4165
1 JAVA 多线程锁介绍 1.1 悲观锁 定义：悲观锁指对数据被外界修改持保守态度，认为数据很容易就会被其他线程修改（很悲观），所以在数据被处理前先对数据进行加锁，并在整个数据处理过程中，使数据处于锁定状态。 悲观锁的实现：开发中常见的悲观锁实现往往依靠数据库提供的锁机制，即在数据库中，在对数据记录操作前给记录加排它锁。如果获取锁失败，则说明数据正在被其他线程修改，当前线程则等待或者抛出异常。如果获取锁成功，则对记录进行操作，然后提交事务后释放排它锁。 实例：Java 中的 synchronized 关键
Java多线程常用函数使用
qq_60567426的博客
12-31 759
这个题只用join就足够了，主线程想要执行最后的输出语句，就必须等待着子线程执行完，这就是join函数的魅力，一般的sleep函数主要用于让整个程序执行放慢，比如我做过那个C++炸弹人小游戏，我就用了sleep函数，就是为了避免电脑执行太快，敌人可以瞬间到达你的身边。2：join()函数，让使用该函数的线程执行完之后，整个程序才能继续往下执行。补充完代码后，点击测评，平台会对你编写的代码进行测试，当你的结果与预期输出一致时，即为通过。请仔细阅读右侧代码，根据方法内的提示，在。子线程计算结果为：5。
Java源码学习之并发编程-锁-Java中8种锁机制
weixin_37627646的博客
07-14 791
​ 在ReentrantLock中包含了公平锁和非公平锁两种锁。 如果你用默认的构造函数来创建ReentrantLock对象，默认的锁策略就是非公平的。 ​ 多个线程按照申请锁的顺序去获得锁，线程会直接进入队列去排队，永远都是队列的第一位才能得到锁。 优点：所有的线程都能得到资源，不会饿死在队列中。 缺点：吞吐量会下降很多，队列里面除了第一个线程，其他的线程都会阻塞，cpu唤醒阻塞线程的开销会很大。 公平锁图示： 图示1： ​ 咱们重新回到第一张图，就是线程1刚刚释放锁之后，线程2还没来得及重新加锁的那个状
ReentrantLock可重入锁
wang__wang666的博客
09-11 169
什么是可重入性：线程可以进入任何一个他已经拥有锁的对象所锁住的代码块。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值