对JUC的学习和理解（一）：Lock、生产者和消费者问题、虚假唤醒、多线程8锁

最新推荐文章于 2022-04-28 21:51:09 发布
最新推荐文章于 2022-04-28 21:51:09 发布
阅读量291 收藏 2
点赞数 1
分类专栏： Java J.U.C
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41430914/article/details/106596771
版权
Java 同时被 2 个专栏收录
14 篇文章 0 订阅
订阅专栏
J.U.C
7 篇文章 0 订阅
订阅专栏

目录

什么是JUC？

通过写售票代码回顾Synchronized和认识Lock

Synchronized

Lock

synchorized与Lock锁的区别

Synochorized的生产者和消费者问题

虚假唤醒问题

Lock中的生产者和消费者问题

深入理解Java锁

什么是JUC？

在Java 5.0时提供了 java.lang.concurrent 这个包，这个包简称JUC包，提供了一些处理并发编程下的一些工具类。

通过写售票代码回顾Synchronized和认识Lock

售票这段代码在学习多线程的时候是必定绕不开的一环，多个线程同时去争抢票这个资源。

那么我们再写写这个卖票的代码，思路核心是多线程操作同一资源类，资源类是单独的，没有任何附属操作，它就只有属性和方法。

Synchronized

资源类 Ticket

/**
 * 资源类 Ticket
 */
class Ticket2 {
    private int ticket = 30;
    public  void sale() {
            if (ticket>0){
                System.out.println(Thread.currentThread().getName() + "售出第" + ticket-- + "张票" + "还剩" + ticket + "张票");
            }
    }
}

线程类：使用了匿名内部类来减少了代码量

    public static void main(String[] args) {
        Ticket2 ticket = new Ticket2();
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 40; i++) {
                    ticket.sale();
                }
            }
        }, "A").start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 40; i++) {
                    ticket.sale();
                }            }
        }, "B").start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 40; i++) {
                    ticket.sale();
                }            }
        }, "C").start();
    }

但推荐使用Lambda表达式，看起来更加简洁。

    public static void main(String[] args) {
        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();
    }

目前为止，代码是线程不安全的，要想实现线程同步，初学的时候使用的是Sychorized，同步代码块或者方法，在资源类的方法上加上synchronize即可，这就是一个普通的线程同步方法。

    public synchronized void sale() {
            if (ticket>0){
                System.out.println(Thread.currentThread().getName() + "售出第" + ticket-- + "张票" + "还剩" + ticket + "张票");
            }
    }

学习J.U.C，就是学习java.util.concurrent包下的一些工具类来解决并发的问题。

接下来使用Lock类来解决线程安全问题。

Lock

Java 1.8中的Lock接口的三个实现类。

我们现在使用的是RenntrantLock，它需要显示的加锁和解锁，并需要与trycatch一起使用。

  • 实例化Reentrantlock
  • lock.lock(加锁)
  • lock.unlock(解锁)

这样，就使用了Lock来实现了线程安全。

/**
 * 资源类 Ticket
 */
class Ticket2 {
    private int ticket = 30;
    // 实例化ReentrantLock
     ReentrantLock lock = new ReentrantLock();
        public void sale() {
            // 开启锁
            lock.lock();
        try {
            if (ticket>0){
                System.out.println(Thread.currentThread().getName() + "售出第" + ticket-- + "张票" + "还剩" + ticket + "张票");
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 关闭锁
            lock.unlock();
        }
    }
}

synchorized与Lock锁的区别

  • Synchorized 是内置的Java关键字，Lock锁是一个java类
  • Synchorized 无法判断获取锁的状态，Lock可以判断是否获取到了锁
  • Synchorized 会自动释放锁，lock必须要手动释放锁，如果不手动释放锁，会导致死锁
  • 如果发生了某个线程阻塞，Synchorized会一直等待，Lock锁不一定会等待下去（通过lock.trylock去尝试获得锁）
  • Synchorized 可重入锁，不可以中断，是非公平锁；Lock可重入锁，可以判断锁，非公平（可以自己设置）
  • Synchorized 适合锁少量的代码同步问题，Lock适合锁大量的同步代码

解释一下可重入锁：

可重入就是说某个线程已经获得某个锁，可以再次获取锁而不会出现死锁

Synochorized的生产者和消费者问题

生产者和消费者问题用于理解线程之间的通讯，其思路是一个共同资源类被多线程操作并且交替执行。

如果不能理解如何写这种多线程操作并且交替执行的代码，先想想思路：

  • 资源类
    • 生产：判断等待-->业务(生产)-->通知其他线程
    • 消费：判断等待-->业务(消费)-->通知其他线程
  • 主方法
    • 创建线程并开启线程
/**
 * 生产者与消费者问题
 * 问题:现在两个线程,可以操作初始值为零的一个变量
 * 实现一个线程对该变量+1,一个线程对该变量-1
 * 实现10轮交替,变量初始值为0
 *
 *
 * 思路:高内聚低耦合的思路,线程操作资源类
 * --->    判断/业务/通知
 *
 * @author Claw
 * @date 2020/6/8 16:36.
 */
public class ConsumersAndProducers {
    public static void main(String[] args) {
        Product product = new Product();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                product.toProduct();
            }
        }, "A").start();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                product.toConsume();
            }
        }, "B").start();
    }
}

/**
 * 资源类
 */
class Product {

    private int product = 0;

    /**
     * 生产者
     */
    public synchronized void toProduct() {
        // 判断等待
        if (product !=0){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        // 业务操作
        product++;
        System.out.println(Thread.currentThread().getName()+"------->"+product);
        // 通知
        this.notifyAll();

    }

    /**
     * 消费者
     */
    public synchronized void toConsume() {
        // 判断等待
        if (product==0){
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        // 业务操作
        product--;
        System.out.println(Thread.currentThread().getName()+"------->"+product);
        // 通知
        this.notifyAll();
    }

结果：

A------->1
B------->0
A------->1
B------->0
A------->1
B------->0
A------->1
B------->0
A------->1
B------->0
A------->1
B------->0
A------->1
B------->0
A------->1
B------->0
A------->1
B------->0
A------->1
B------->0

这样看似没有什么问题，但如果有更多的线程进来，会导致一个问题，叫做虚假唤醒。

虚假唤醒问题

在主方法中新加两个线程

        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                product.toProduct();
            }
        }, "C").start();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                product.toConsume();
            }
        }, "D").start();

执行结果：在这里截取了结果异常的一段，可以看到出现了异常的数量2和3。

这是为什么呢？API里解释了线程也可以被唤醒，而不会被通知，中断或超时，这就是所谓的虚假唤醒，等待应该总是出现在循环之中。

在上面的代码中，条件判断使用了if而不是while，这导致了虚假唤醒。

多线程的交互必须用while

While的本质是循环+判断，线程被唤醒后，需要重新判断是否符合运行条件。

而if只判断了一次

看看这个错误的结果，为什么两个线程没有问题，而4个线程出现了问题？

A和C是生产者，B和D是消费者

当A线程生产完毕后，ABCD四个线程都准备操作product，理想情况下，生产一个消费一个是我们想要的模式，所以我们会想着生产线程完毕，消费的线程进来。但事实上不是如此，当A线程生产完毕后，进来的是生产者线程C，此时product为1，我们使用if作为条件判断，当product !=0时,条件判断为true，C线程执行到wait()处，开始等待，释放了锁。此时product仍然为1，ABD三条线程开始想操作product，现在进入方法的仍然是A，执行到wait()后开始等待。

然后A和C两个生产线程都进行等待了，剩下的线程只剩下消费者线程。此时product为1，消费线程消费完product，唤醒其他线程，因为和C两个线程已经等待许久，系统会优先让A和C先执行，此时product为0，但因为使用了if语句作为条件判断，已经不满足条件了，但if不会判断第二次，唤醒后的A和C两个线程同时进行了++，product由1变成2。

所以需要使用while作为条件判断。

Lock中的生产者和消费者问题

上面的synchorized来体会的生产者消费者的问题并不是对JUC学习的目的，而是回顾。

J.U.C中，Lock替代了synchronized方法和语句的使用，Condition替代了Object监视器方法的使用。

synchronized让线程通讯的方法是：wait(),notify(),notifyAll().

Condition的与此相对应的方法是：await(),sign(),signAll()

Condition是一种广义上的条件队列。他为线程提供了一种更为灵活的等待/通知模式，线程在调用await方法后执行挂起操作，直到线程等待的某个条件为真时才会被唤醒。Condition必须要配合锁一起使用，因为对共享状态变量的访问发生在多线程环境下。一个Condition的实例必须与一个Lock绑定，因此Condition一般都是作为Lock的内部实现。

参考:JAVA并发-Condition

所以使用Lock来实现线程同步和通讯中,生产者和消费者问题的代码是这样的：

/**
 * 资源类
 */
class Product2 {

    private int product = 0;
    // 实例化ReentrantLock
    private ReentrantLock lock = new ReentrantLock();
    // 实例化Condition
    private Condition condition = lock.newCondition();

    /**
     * 生产者
     */
    public synchronized void toProduct() {
        // 判断等待
        while (product !=0){
            try {
                condition.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        // 业务操作
        product++;
        System.out.println(Thread.currentThread().getName()+"------->"+product);
        // 通知
        condition.signalAll();
    }

    /**
     * 消费者
     */
    public synchronized void toConsume() {
        // 判断等待
        while (product==0){
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        // 业务操作
        product--;
        System.out.println(Thread.currentThread().getName()+"------->"+product);
        // 通知
        condition.signalAll();
    }
}

这样看来，与使用synchronize并没有什么优势的地方。

但Condition的强大之处是它可以为多个线程建立不同的Condition，让线程精准通讯，比如控制A线程执行完以后执行B，B执行完以后执行C。

/**
 * 需求:多线程之间按顺序调用,实现A-B-C
 * 三个线程启动,要求如下
 * <p>
 * AA打印3次,BB打印3次,CC打印3次
 * 循环3次
 *
 * @author Claw
 * @date 2020/6/9 3:14.
 */
public class DataShare {

    public static void main(String[] args) {
        ShareResources sr = new ShareResources();
        new Thread(() -> {
            for (int i = 0; i < 3; i++) {
                sr.printA();
            }
        }, "线程1").start();
        new Thread(() -> {
            for (int i = 0; i < 3; i++) {
                sr.printB();
            }
        }, "线程2").start();
        new Thread(() -> {
            for (int i = 0; i < 3; i++) {
                sr.printC();
            }
        }, "线程3").start();
    }
}

/**
 * 资源类
 */
class ShareResources {
    // 实例化ReentrantLock
    ReentrantLock lock = new ReentrantLock();
    // 实例化 Condition
    Condition c1 = lock.newCondition();
    Condition c2 = lock.newCondition();
    Condition c3 = lock.newCondition();
    /**
     * 标志位:A:1 B:2 C:3
     */
    private int number = 1;

    public void printA() {
        // 加锁
        lock.lock();
        // 判断等待
        try {
            while (number != 1) {
                c1.await();
            }
            // 业务
            for (int i = 0; i < 3; i++) {
                System.out.println(Thread.currentThread().getName() + "\t" + "AA");
            }
            // 设置标志位
            number = 2;
            // 通知
            c2.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void printB() {
        // 加锁
        lock.lock();
        try {
            while (number != 2) {
                // 判断等待
                c2.await();
            }
            for (int i = 0; i < 3; i++) {
                System.out.println(Thread.currentThread().getName() + "\t" + "BBB");
            }
            // 标志位更改
            number = 3;
            // 通知
            c3.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void printC() {
        // 加锁
        lock.lock();
        try {
            while (number != 3) {
                // 判断等待
                c3.await();
            }
            // 业务
            for (int i = 0; i < 3; i++) {
                System.out.println(Thread.currentThread().getName() + "\t" + "CCC");
            }
            // 标志位更改
            number = 1;
            // 通知
            c1.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

深入理解Java锁

请看这段代码：

public class SynchronizedTest {
    public static void main(String[] args) {
        Phone phone = new Phone();
        new Thread(() -> { phone.sendEmail(); }).start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(() -> { phone.sendMsg(); }).start();
    }
}

/**
 * 资源类
 */
class Phone {

    public synchronized void sendEmail() {
        System.out.println("发邮件");
    }
    public synchronized void sendMsg() {
        System.out.println("发短信");
    }
}
  • 标准访问，请问是先打印邮件还是短信？

结果：发邮件-->发短信

  • 暂停4秒在邮件方法，请问打邮件还是短信？

在sendEmail中让线程休眠4秒

    public synchronized void sendEmail() {
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发邮件");
    }

结果: 仍然为发邮件--->发短信

为什么?问题1和问题2是一样的

一个对象里面如果有多个synchronized方法，某一个时刻内，只要一个线程去调用其中一个synchronized方法了，其他线程只能等待，换句话说，某一个时刻内，其他线程都不能进入到当前对象的其他synchronized方法。

锁的是当前对象this（也就是资源类Phone），被锁定后，其他线程线程都不能进入到当前对象的其他的synchronized方法。

两个方法用的都是同一把锁，所以一次只能进入一个线程。

  • 新增普通SayHello方法，请问先打印邮件还是hello?
/**
 * 资源类
 */
class Phone {

    public synchronized void sendEmail() {
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发邮件");
    }
    public synchronized void sendMsg() {
        System.out.println("发短信");
    }
    // 增加一个普通方法
    public void hello(){
        System.out.println("hello");
    }
}

让线程去调用发邮件以及hello的方法

    public static void main(String[] args) {
        Phone phone = new Phone();
        new Thread(() -> { phone.sendEmail(); }).start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(() -> { phone.hello(); }).start();
    }

结果：

为什么？

因为普通方法与同步锁无关

  • 两部手机，请问先打印邮件还是短信?

再实例化一个Phone类，一个实例对象去调用发邮件，一个实例去调用发短信，那么结果是什么？

public class SynchronizedTest {
    public static void main(String[] args) {
        Phone phone = new Phone();
        Phone phone2 = new Phone();
        new Thread(() -> { phone.sendEmail(); }).start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(() -> { phone2.sendMsg(); }).start();
    }
}

/**
 * 资源类
 */
class Phone {

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

结果：

为什么？

因为是两个对象，不是再共用一把锁，不冲突也不影响。

  • 两个静态同步方法，同一部手机，请问先打印邮件还是短信?

将资源类的发邮件和发短信改为静态同步方法

public class SynchronizedTest {
    public static void main(String[] args) {
        Phone phone = new Phone();
        Phone phone2 = new Phone();
        new Thread(() -> { phone.sendEmail(); }).start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(() -> { phone.sendMsg(); }).start();
    }
}

/**
 * 资源类
 */
class Phone {

    public static synchronized void sendEmail() {
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发邮件");
    }
    public static synchronized void sendMsg() {
        System.out.println("发短信");
    }
    public void hello(){
        System.out.println("hello");
    }
}

结果：

为什么？

synchronized修饰的同步方法，锁的是当前对象this，而对于静态同步方法，锁的就是整个Person类

  • 两个静态同步方法，2部手机，请问先打印邮件还是短信?

如果是两个手机，执行结果如何？这个跟上面的方法是一个意思。静态同步方法锁的对象是当前类的Class对象，因此谁先拿到锁，谁先执行。

  • 1个静态同步方法，1个普通同步方法，同一部手机，请问先打印邮件还是短信?
    public static synchronized void sendEmail() {
       try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发邮件");
    }
    public  synchronized void sendMsg() {
        System.out.println("发短信");
    }

为什么？

静态同步方法和普通同步方法不是同一把锁，因此调用方法时不再需要等待。

  • 1个静态同步方法，1个普通同步方法，2部手机，请问先打印邮件还是短信?

为什么?

因为既不是同一把锁，也不是争抢同一资源，不会互相影响。

 

 

 

PuppyCoding
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JUC多线程学习个人笔记
07-08
锁机制：JUC提供了Lock接口和Condition接口，可以实现更细粒度的锁控制和线程的等待和唤醒机制。 并发工具类：JUC提供了一些并发编程的工具类，如Semaphore、CountDownLatch、CyclicBarrier等，可以实现线程间的协作...
多线程基础、JUC锁、同步容器、线程池
07-11
多线程基础、JUC锁、同步容器、线程池
Lock版生产者和消费者问题
LIAO_YUANLONG的博客
12-17 52
与Synchronized相比，Lock用的是condition.await( )；来等待其他线程，用condition.signalAll( ); 来唤醒全部线程。通过lock.newCondition();来拿到condition package com.liao.lesson1; import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.util.concurren
JUC并发编程-Lock锁
qq_50596778的博客
01-27 1440
Lock详解 简介 java.util.concurrent.locks包下常用的类与接口（lock是jdk 1.5后新增的） Lock和ReadWriteLock是两大锁的根接口： Lock代表实现类是ReentrantLock（可重入锁） ReadWriteLock（读写锁）的代表实现类是ReentrantReadWriteLock 同步实现原理 lock只能被一个线程获取,当一个线程执行lock.lock()后其他线程再尝试获取会进入lock对象中的等待队列,从而达到同步效果，ReenT
Synchronized和Lock的区别
热门推荐
qq_42481883的博客
03-30 1万+
1.synchronized是一个关键字而lock是一个接口（lock、lockInterruptibly、tryLock、unlock、newCondition）。 2.synchronized是隐式的加锁，lock是显示的加锁。 3.synchronized可以作用在方法和代码块上，而lock只能作用在代码块上。 synchronized作用在静态方法上锁的是当前类的class，作用在普通方法上锁的是当前类的对象。 在javap反编译成字节码后，synchronized关键字需要有一个代码块进入的点mo
什么是虚假唤醒？为什么会产生虚假唤醒？
weixin_45668482的博客
05-28 9011
最近B站学习狂神的JUC并发编程时，听到了虚假唤醒这个词，虽然狂神进行了代码的演示，但我还是不太理解为什么使用if判断包装wait方法会出现虚假唤醒，查找了网上很多大佬的博客终于理解了，这里分享一下虚假唤醒产生的原因。 什么是虚假唤醒？ 当一定的条件触发时会唤醒很多在阻塞态的线程，但只有部分的线程唤醒是有用的，其余线程的唤醒是多余的。 比如说卖货，如果本来没有货物，突然进了一件货物，这时所有的顾客都被通知了，但是只能一个人买，所以其他人都是无用的通知。 虚假唤醒演示 public class test {
虚假唤醒详解
horacen的博客
04-28 5260
虚假唤醒详解        接触过多线程编程的朋友们或多或少都听说过虚假唤醒这一术语，我在百度上看了很多相关的帖子，说的都不是很清楚，于是写下这篇文章，希望能对大家有些裨益。 虚假唤醒是什么        首先我们来谈谈虚假唤醒到底是什么。在这里我给出一个自己的定义，帮助大家去理解虚假唤醒 虚假唤醒是一种现象，它只会出现在多线程环境中，指的是在多线程环境下，多个线程等
juc多线程交替打印ABC、熟悉lock的唤醒机制
07-10
现场交替访问、等待和唤醒
多线程源码JUC以及多线程和高并发
01-22
多线程源码JUC以及多线程和高并发 https://blog.csdn.net/u011488009 主要是根据 https://blog.csdn.net/u011488009/category_9678616.html 专栏来讲解的源码，都可以作为高并发的学习，练手用，主要是看这个源码...
Java多线程和JUC.pdf
01-22
java多线程的一些知识与问题的总结
浅谈对JUC的理解
weixin_38650574的博客
09-01 549
文章目录JUC一、JUC简介二、多线程1.线程和进程2.多线程的优势3.线程安全3.1线程安全定义3.2 线程安全的解决方式3.3 什么是多线程之间的同步4.解决线程安全4.1使用同步代码4.2使用同步方法4.3使用Lock解决线程安全三、多线程的创建方式1.继承Thread类2.实现Runnable接口创建线程3.使用Callable和Future创建线程4.使用线程池四、JUC工具类1. ReentrantReadWriteLock2. CountDownLatch3. CyclicBarrier4.S
Java基础知识 廖雪峰教程笔记
change970401的博客
08-07 890
Java基础知识Java基础知识java简介名词解释运行Java程序Java基本数据类型模块包装类型记录类异常处理Java异常使用Commons Logging使用log4j反射动态代理泛型擦拭法extends & super集合使用List创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 Java基础知识 廖雪峰Java教程笔记。廖雪峰J
Java线程间通信-虚假唤醒
zhong_xj的博客
02-24 224
什么是虚假唤醒？ 虚假唤醒（spurious wakeup）是一个表象，即在多处理器的系统下发出wait的程序有可能在没有notify唤醒的情形下苏醒继续执行。 很难理解是吗？用一个代码示例来描述一下这种现象。 代码演示 public class Shop { private volatile int goodsCount; private final static int M...
生产者消费者——虚假唤醒
笔记
03-11 108
/* * 生产者和消费者案例 */ public class TestProductorAndConsumer { public static void main(String[] args) { Clerk clerk = new Clerk(); Productor pro = new Productor(clerk); Consumer cus = new Cons...
synchronized和lock的使用分析（优缺点对比详解）
小东升职记
11-17 5210
1.synchronized 加同步格式： synchronized(需要一个任意的对象(锁)){      代码块中放操作共享数据的代码。 } synchromized缺陷 synchronized是java中的一个关键字，也就是说是java语言的内置的特性。 如果一个代码块被synchronized修饰，当一个线程获取了对应的锁，并执行代码块时，其他线程只能一直等待，等待获取锁的...
线程的虚假唤醒
Spring boot自动配置的实现原理简述
10-26 244
所谓虚假唤醒字面意思理解就是线程在被唤醒后，线程执行等待的变量条件实际上仍然不满足，这种情况发生在两个以上的多线程生产者消费者问题中。 从一个实际的例子中来理解虚假唤醒，建立一个简单的消费者生产者模型，判断条件时共享资源number是否等于0，等于0时，生产者让其+1，不等于0时，消费者让其-1。 public class PretendNotify { public static vo...
JAVA学习笔记
huangjiajubeyond的博客
07-30 902
1.非守护线程：就是你手动创建的线程。 2.Thread类里面有一些属性，id，name，priority属性，优先级属性，是1-10，其中1是最小优先级，10是最大优先级，一般不要修改优先级，当然你也可以改。Status属性，表示线程的状态，一共有六个线程状态。new,runnable,blocked,waiting,time waiting,terminaed 3.
JUC 解决多线程原子性问题，具体怎么做的？给出代码示例，谢谢
最新发布
08-14
JUC（Java并发编程工具包）是Java提供的用于解决多线程并发问题的工具包，其中包含了很多用于处理线程安全的类和接口。 JUC中解决多线程原子性问题的方式主要是通过提供原子类来实现。原子类是一种可以单独访问和...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值