JUC并发编程笔记1__JUC概述、虚假唤醒问题、JUC的生产者和消费者关系、8锁问题（对象锁、类锁区别）

已于 2022-10-11 08:46:47 修改
阅读量242 收藏 1
点赞数 1
分类专栏： JUC并发编程 文章标签： java
于 2022-09-13 11:38:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62866676/article/details/126823938
版权

目录

一、回顾

概念

线程的几个状态 

wait和sleep的区别

Synchronized 和 Lock的区别

二、虚假唤醒问题

举例synchronized下的生产者、消费者模式场景

三、JUC下的生产者、消费者关系

四、8锁问题（对象锁、类锁）

一、回顾

概念

JUC即并发编程，也是多线程的进阶版
主要涉及的三个类java.util.concurrent、 java.util.concurrent.automic、 java.util.concurrent.locks
注意java实际上是开启不了线程的，而是调用本地方法，底层是c++开启线程，java是运行在虚拟机上的，无法直接操作硬件

线程的几个状态 

new 新生
runnable 运行
blocked 阻塞
waiting 等待
timed_witing 超时等待
terminated 终止

wait和sleep的区别

  1. 来自不同的类，wait来自Object，sleep来自Thread
  2. 锁是否是否释放不同,wait会释放锁，sleep不会释放锁
  3. 使用范围不同，wait必须放在同步代码块中（与显示锁Lock对应）
  4. 是否需要异常捕获，wait不需要异常捕获，sleep需要异常捕获

Synchronized 和 Lock的区别

  1. Synchronized 是内置java 关键字，Lock是接口
  2. Synchronized 无法判断获取锁的状态，Lock可以判断是否获取到了锁
  3. Synchronized 会自动释放锁，Lock必须手动释放
  4. Synchronized 线程1获得锁，则其它线程会一直等待，Lock 锁下的线程就不一定会一直等
  5. Synchronized 是可重入锁，不可中断的，非公平，Lock 可重入锁，可以判断锁，非公平锁可以设置公平性
  6. Synchronized 适合对少量代码加锁，Lock 适合大量同步代码

二、虚假唤醒问题

举例synchronized下的生产者、消费者模式场景

  • 资源类的属性num 为 0，方法是 对num 加1 和 减1
  • 初始是两个线程使用wait()和notifyAll()进行通信，保证num为0时候+1，为1时-1
  • 线程A是对num进行10次的+1，线程B是对num进行10次的-1
  • 线程A执行+1的条件是if(num == 0) ,否则wait等待，执行完 +1 就 notifyAll 唤醒其他线程（此时只有B线程）；B线程同理
  • 结果可以发现两个线程间的通信 正常
package synchronized_productor_consumer;

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

        Data data = new Data();

        // 线程A,进行加1
        new Thread(()->{
            try {
                // 10 次操作
                for (int i = 0; i < 10; i++) {
                    data.increment();
                }

            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"线程A").start();

        // 线程B,进行减1
        new Thread(()->{
            try {

                for (int i = 0; i < 10; i++) {
                    data.decrement();
                }

            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"线程B").start();

    }
}


/**
 * 待操作的Data资源类，需要解耦
 */

class Data{
    private int num = 0;

    public synchronized void increment() throws InterruptedException {
        if(num != 0){
            // 等待
            this.wait();
        }
        System.out.println(Thread.currentThread().getName() + "=> " + num);
        num ++;
        this.notifyAll();
    }

    public synchronized void decrement() throws InterruptedException {
        if(num == 0){
            // 等待
            this.wait();
        }
        System.out.println(Thread.currentThread().getName() + "=> " + num);
        num --;

        this.notifyAll();
    }


}

输出：
线程A=> 0
线程B=> 1
线程A=> 0
线程B=> 1
线程A=> 0
线程B=> 1
线程A=> 0
线程B=> 1
线程A=> 0
线程B=> 1
线程A=> 0
线程B=> 1
线程A=> 0
线程B=> 1
线程A=> 0
线程B=> 1
线程A=> 0
线程B=> 1
线程A=> 0
线程B=> 1

现在是A一个线程做 + 1，B一个线程做 - 1，如果是多个线程呢？


package synchronized_productor_consumer;

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

        Data data = new Data();

        // 线程A,进行加1
        new Thread(()->{
            try {
                // 10 次操作
                for (int i = 0; i < 10; i++) {
                    data.increment();
                }

            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"线程A").start();

        // 线程B,进行减1
        new Thread(()->{
            try {

                for (int i = 0; i < 10; i++) {
                    data.decrement();
                }

            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"线程B").start();

        // 线程A,进行加1
        new Thread(()->{
            try {
                // 10 次操作
                for (int i = 0; i < 10; i++) {
                    data.increment();
                }

            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"线程C").start();

        // 线程B,进行减1
        new Thread(()->{
            try {

                for (int i = 0; i < 10; i++) {
                    data.decrement();
                }

            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"线程D").start();

    }
}


/**
 * 待操作的Data资源类，需要解耦
 */

class Data{
    private int num = 0;

    public synchronized void increment() throws InterruptedException {
        if(num != 0){
            // 等待
            this.wait();
        }
        System.out.println(Thread.currentThread().getName() + "=> " + num);
        num ++;
        this.notifyAll();
    }

    public synchronized void decrement() throws InterruptedException {
        if(num == 0){
            // 等待
            this.wait();
        }
        System.out.println(Thread.currentThread().getName() + "=> " + num);
        num --;

        this.notifyAll();
    }


}


输出：
线程A=> 0
线程D=> 1
线程C=> 0
线程B=> 1
线程C=> 0
线程B=> 1
线程C=> 0
线程B=> 1
线程C=> 0
线程B=> 1
线程C=> 0
线程B=> 1
线程C=> 0
线程B=> 1
线程C=> 0
线程B=> 1
线程C=> 0
线程B=> 1
线程C=> 0
线程B=> 1
线程C=> 0
线程B=> 1
线程D=> 0
线程D=> -1
线程D=> -2
线程D=> -3
线程D=> -4
线程D=> -5
线程D=> -6
线程D=> -7
线程D=> -8
线程A=> -9


虚假唤醒问题分析

结果出现问题的原因：在于资源类内部的if判断，因为if判断只进行一次，造成多个线程之间的虚假唤醒问题，就是指有可能当A线程进入在if代码块中调用wait()方法后，A线程会处于阻塞状态，wait()方法还会释放当前A线程获取到的锁，此时有可能C线程获取到Cpu时间片，进入if代码块，调用wait()方法处于阻塞状态并释放锁，当其他线程重新唤醒A、C线程以后，A、C线程都会从if代码块中跳出来，执行num + 1的操作
解决办法：就是将资源类内部 if 判断换成 while 即可，这样每次线程都会先进行一次条件判断，避免虚假唤醒问题

三、JUC下的生产者、消费者关系

Lock下的线程通信

  • Condition接口取代了Object监视器方法（wait、notify、notifyAll）使用自己的方法完成线程间通信
  • 使用lock对象的newCondition()方法可以获得condition对象，该对象有一个await()等待方法和singalAll()唤醒全部线程方法
  • 同时Condition支持精准的通知、唤醒线程（使线程按照顺序执行）

场景举栗

package lock_productor_consumer;

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

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

        Data data = new Data();

        // 线程A,进行加1
        new Thread(()->{
            try {
                // 10 次操作
                for (int i = 0; i < 10; i++) {
                    data.increment();
                }

            } catch (Exception e) {
                e.printStackTrace();
            }
        },"线程A").start();

        // 线程B,进行减1
        new Thread(()->{
            try {

                for (int i = 0; i < 10; i++) {
                    data.decrement();
                }

            } catch (Exception e) {
                e.printStackTrace();
            }
        },"线程B").start();

        // 线程A,进行加1
        new Thread(()->{
            try {
                // 10 次操作
                for (int i = 0; i < 10; i++) {
                    data.increment();
                }

            } catch (Exception e) {
                e.printStackTrace();
            }
        },"线程C").start();

        // 线程B,进行减1
        new Thread(()->{
            try {

                for (int i = 0; i < 10; i++) {
                    data.decrement();
                }

            } catch (Exception e) {
                e.printStackTrace();
            }
        },"线程D").start();

    }
}


/**
 * 待操作的Data资源类，需要解耦
 */

class Data{
    private int num = 0;

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

    public  void increment()  {

        // 加锁
        lock.lock();

        try {
            while(num != 0){
                // 等待
                condition.await();


            }
            System.out.println(Thread.currentThread().getName() + "=> " + num);
            num ++;
            // 唤醒
            condition.signalAll();

        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            // 解锁
            lock.unlock();
        }


    }

    public  void decrement()  {
        // 加锁
        lock.lock();

        try {
            while(num == 0){
                // 等待
               condition.await();
            }
            System.out.println(Thread.currentThread().getName() + "=> " + num);
            num --;
            // 唤醒
            condition.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            // 解锁
            lock.unlock();
        }


    }


}
输出：
线程A=> 0
线程B=> 1
线程A=> 0
线程B=> 1
线程A=> 0
线程B=> 1
线程A=> 0
线程B=> 1
线程A=> 0
线程B=> 1
线程A=> 0
线程B=> 1
线程A=> 0
线程B=> 1
线程A=> 0
线程B=> 1
线程A=> 0
线程B=> 1
线程A=> 0
线程B=> 1
线程C=> 0
线程D=> 1
线程C=> 0
线程D=> 1
线程C=> 0
线程D=> 1
线程C=> 0
线程D=> 1
线程C=> 0
线程D=> 1
线程C=> 0
线程D=> 1
线程C=> 0
线程D=> 1
线程C=> 0
线程D=> 1
线程C=> 0
线程D=> 1
线程C=> 0
线程D=> 1

Condition控制线程间精准通信

场景如三个线程顺序执行：
A线程先执行，使达到B线程的执行条件，唤醒B线程，A线程处于等待状态；
B线程接着执行，使达到C线程的执行条件，唤醒C线程，B线程处于等待状态；
C线程接着执行，使达到A线程的执行条件，唤醒A线程，C线程处于等待状态；
…
实现原理是condition对象可以设置多个，每个对象可以和线程绑定一块。一个condition对象服务一个线程，因为加锁了，所以其他线程正在等待，而有执行条件的线程会接到通知从 判断--->等待--->执行--->通知

package study_condition;

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

public class Demo {

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

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

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

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

    }
}

class Data {
    private Lock lock = new ReentrantLock();
    private Condition condition1 = lock.newCondition();
    private Condition condition2 = lock.newCondition();
    private Condition condition3 = lock.newCondition();
    private int num = 1;

    public void A(){
        lock.lock();

        try {
            while(num != 1){
                // 等待
                condition1.await();
            }
            System.out.println(Thread.currentThread().getName() + "=> A 方法" );
            num  = 2;

            // 唤醒执行方法B的线程
            condition2.signal();

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }


    }
    public void B(){
        lock.lock();

        try {
            while(num != 2){
                // 等待
                condition2.await();
            }
            System.out.println(Thread.currentThread().getName() + "=> B 方法" );
            num  = 3;

            // 唤醒执行方法B的线程
            condition3.signal();

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }


    }
    public void C(){
        lock.lock();

        try {
            while(num != 3){
                // 等待
                condition3.await();
            }
            System.out.println(Thread.currentThread().getName() + "=> C 方法" );
            num  = 1;

            // 唤醒执行方法B的线程
            condition1.signal();

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }


    }

}

输出：

1线程=> A 方法
2线程=> B 方法
3线程=> C 方法
1线程=> A 方法
2线程=> B 方法
3线程=> C 方法
1线程=> A 方法
2线程=> B 方法
3线程=> C 方法
1线程=> A 方法
2线程=> B 方法
3线程=> C 方法
1线程=> A 方法
2线程=> B 方法
3线程=> C 方法
1线程=> A 方法
2线程=> B 方法
3线程=> C 方法
1线程=> A 方法
2线程=> B 方法
3线程=> C 方法
1线程=> A 方法
2线程=> B 方法
3线程=> C 方法
1线程=> A 方法
2线程=> B 方法
3线程=> C 方法
1线程=> A 方法
2线程=> B 方法
3线程=> C 方法

四、8锁问题（对象锁、类锁）

初始场景:

  • Phone资源类有 void sendMessage() 、void call()两个方法
  • main方法开启 多线程场景 进行测试，8种情况可以提出8个锁问题，即8锁问题
  • JUC下线程sleep方法：TimeUnit.SECONDS.sleep(1) -- 线程睡眠1s

1.创建一个Phone实例多线程调用两个方法，问哪一个先执行？ 

package eight_locks;

import java.util.concurrent.TimeUnit;

public class Demo1 {


    public static void main(String[] args) {

        Phone p = new Phone();

        // 发短信
        new Thread(()->{
            p.sendMessage();
        }).start();

        // JUC下的线程延时方法
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 打电话
        new Thread(()->{
            p.call();
        }).start();

    }
}


class Phone {

    public synchronized void sendMessage(){
        System.out.println("发短信");
    }

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

输出:
发短信
打电话

结果分析:

  • 第一个线程与第二个线程之间因为有睡眠，所以第一个线程肯定先拿到cpu的时间片，先执行方法
  • 因为synchronized关键字 是对 该Phone资源类的对象 上锁，因此哪个线程先拿到对象锁，就先执行
  • 因此第一个线程先拿到锁，所以先执行

 2.创建一个Phone实例多线程调用两个方法，其中第一个线程调用的方法中加延迟，问哪一个先执行？

package eight_locks;

import java.util.concurrent.TimeUnit;

public class Demo1 {


    public static void main(String[] args) {

        Phone p = new Phone();

        // 发短信
        new Thread(()->{
            p.sendMessage();
        }).start();

        // JUC下的线程延时方法
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 打电话
        new Thread(()->{
            p.call();
        }).start();

    }
}


class Phone {

    public synchronized void sendMessage(){
        // JUC下的线程延时方法
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

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

输出:
发短信
打电话

结果分析

  • synchronized修饰普通方法锁住的是方法的调用者，也就是Phone资源类的对象实例
  • 因为是第一个线程先拿到 Phone资源类 的锁对象，所以第一个输出的还是发短信

3.创建一个Phone实例多线程调用两个方法，其中一个是普通方法，而且该线程位置靠后，问哪一个先执行？ 

package eight_locks;

import java.util.concurrent.TimeUnit;

public class Demo3 {


    public static void main(String[] args) {

        Phone3 p = new Phone3();

        // 发短信
        new Thread(()->{
            p.sendMessage();
        }).start();

        // JUC下的线程延时方法
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 打电话
        new Thread(()->{
            p.watchMovie();
        }).start();

    }
}


class Phone3 {

    public synchronized void sendMessage(){
        // JUC下的线程延时方法
        try {
            TimeUnit.SECONDS.sleep(3); 
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("发短信");
    }

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

    public void watchMovie(){
        System.out.println("看电影");
    }
}

输出:
看电影
发短信

结果分析

  • watchMovie()为普通方法，不受 锁 的影响，即使第一个线程获取到了Phone资源类的对象锁，到第二个线程执行的时候，照样可以去执行普通方法
  • 因为 sendMessage()方法体中有延迟语句，因此会后输出

4.创建两个Phone实例多线程调用两个方法，问哪一个先执行？ 

import java.util.concurrent.TimeUnit;

public class Demo4 {


    public static void main(String[] args) {

        Phone4 one = new Phone4();
        Phone4 two = new Phone4();

        // 发短信
        new Thread(()->{
            one.sendMessage();
        }).start();

        // JUC下的线程延时方法
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 打电话
        new Thread(()->{
            two.call();
        }).start();

    }
}


class Phone4 {

    public synchronized void sendMessage(){
        
        // JUC下的线程延时方法
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("发短信");
    }

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


}

输出:
打电话
发短信

结果分析

  • 因为synchronized锁住的是调用方法的对象，上面Phone资源类有两个不同的象，所以一、二两个线程调用方法互不影响
  • 之所以，打电话 先输出，是因为 发短信方法中进行了睡眠

5.创建一个Phone实例多线程调用两个方法，两个方法都有static修饰，问哪一个先执行？ 

import java.util.concurrent.TimeUnit;

public class Demo5 {


    public static void main(String[] args) {

        Phone5 one = new Phone5();


        // 发短信
        new Thread(()->{
            one.sendMessage();
        }).start();

        // JUC下的线程延时方法
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 打电话
        new Thread(()->{
            one.call();
        }).start();

    }
}


class Phone5 {

    public synchronized static void sendMessage(){
        // JUC下的线程延时方法
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("发短信");
    }

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


}

输出:
发短信
打电话

问题分析

  • 加上static关键字之后，两个方法都变为静态方法。
  • 发短信 在前面的原因是 synchronized 加 静态方法 锁的是 Class ，Phone5.Class只有单个。因此第二个线程需要 等待第一个线程释放Class锁才能执行。

6.创建两个Phone实例多线程调用两个方法，两个方法都有static修饰，问哪一个先执行？ 

import java.util.concurrent.TimeUnit;

public class Demo6 {


    public static void main(String[] args) {

        Phone6 one = new Phone6();
        Phone6 two = new Phone6();


        // 发短信
        new Thread(()->{
            one.sendMessage();
        }).start();

        // JUC下的线程延时方法
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 打电话
        new Thread(()->{
            two.call();
        }).start();

    }
}


class Phone6 {

    public synchronized static void sendMessage(){
        // JUC下的线程延时方法
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("发短信");
    }

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


}

输出:
发短信
打电话

结果分析

  • 两个对象的Class只有一个Phone6.Class
  • synchronized 加 静态方法 锁的是 Class

7.创建一个Phone实例多线程调用两个方法，其中一个有static修饰，问哪一个先执行？ 

import java.util.concurrent.TimeUnit;

public class Demo7 {


    public static void main(String[] args) {

        Phone7 one = new Phone7();



        // 发短信
        new Thread(()->{
            one.sendMessage();
        }).start();

        // JUC下的线程延时方法
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 打电话
        new Thread(()->{
            one.call();
        }).start();

    }
}


class Phone7 {

    public synchronized static void sendMessage(){
        // JUC下的线程延时方法
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("发短信");
    }

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


}

输出:
打电话
发短信

结果分析

  • 打电话 先输出的原因是 Phone7 实例 和 Phone7.Class 分别被锁，一个是对象锁，一个是类锁，所以第二个线程照样可以去调用打电话的方法，两个线程之间并无影响
  • 打电话先执行主要是因为在发短信的方法中有线程延迟
  • 再次 证明 synchronized 锁的是 类实例即对象 、synchronized 加 静态方法 锁的是 Class

 8.创建两个Phone实例多线程调用两个方法，其中一个有static修饰，问哪一个先执行？

package eight_locks;

import java.util.concurrent.TimeUnit;

public class Demo7 {


    public static void main(String[] args) {

        Phone8 one = new Phone8();
        Phone8 two = new Phone8();



        // 发短信
        new Thread(()->{
            one.sendMessage();
        }).start();

        // JUC下的线程延时方法
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 打电话
        new Thread(()->{
            two.call();
        }).start();

    }
}


class Phone7 {

    public synchronized static void sendMessage(){
        // JUC下的线程延时方法
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("发短信");
    }

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


}

输出:
打电话
发短信

结果分析

  • 原理同7，两个线程分别锁的是 Phone8.Class 和 Phone8实例，因为线程延迟，打电话 才会优先输出。
Mr_代码先生
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
尚硅谷大厂必备技术之JUC并发编程基础视频 配套资料（自己根据视频整理课件，和代码）
09-23
【尚硅谷】大厂必备技术之JUC并发编程视频 配套资料，自己根据视频整理 pdf 课件，和代码 视频地址：...
深入理解JUC的8锁现象
qq_51447436的博客
04-15 7991
深入理解JUC的8锁现象
JUC-八锁现象
菜鸟程序员的成长之路
11-21 1400
JUC 八锁现象 Java并发编程
JUC并发编程——8锁现象（基于狂神说的学习笔记）
whale_cat的博客
10-12 136
static 则表名该方法与Class同步产生，因此，static是在Class对象中的，如果synchronized锁锁住了static方法，则表明锁住了整个Class对象，而因为Class对象唯一（所有的实例对象都通过Class对象创建的）因此，无论后续创建了多少个实例对象资源，最终只要某一线程持有住某一静态同步方法的锁，则其他静态同步方法一律无法使用。8个锁的问题，两两分组，问题，答案，代码皆在下面代码块中，如有问题后续补充。普通同步锁实例，静态同步锁模板，即使再多实例在，静态之间统一管。
【JUC中的 “8锁现象” 】 —— 每天一点小知识
仰望天空，妳我亦是行人.
06-12 525
💧8锁现象指的是在多线程环境下，当多个线程同时对同一个对象的不同锁进行操作时，可能导致性能下降的现象。每个对象都有一个与之关联的监视器锁......
【JUC基础】07. wait()，notify()虚假唤醒
有一只柴犬的专栏
04-09 431
wait()，notify()虚假唤醒
根据尚硅谷JUC并发编程（对标阿里P6-P7）视频自己整理的pdf文档
09-21
1、根据尚硅谷JUC并发编程（对标阿里P6-P7）视频自己整理的pdf文档 2、包含源码 视频地址：https://www.bilibili.com/video/BV1ar4y1x727/?p=1&vd_source=c634d163b940964d44747b4c3976117b 参考资料：...
JUC并发编程视频教程
11-28
* 颠覆一些你以为"正确"的认知，纠正其它同类视频的错误* 100+ 张手绘图 & 流程图，帮助你形成正确的"多线程世界观"* 以知识点为主线、穿插讲解"应用"，"原理"和"多线程设计模式"，多维度学懂并发主讲内容第一章：...
最全的并发编程JUC 笔记 Typora 版
10-03
JUC 笔记 基于JDK 17
juc并发编程脑图以及相关示例代码
07-30
juc并发编程脑图以及相关示例代码
什么是虚假唤醒？为什么会产生虚假唤醒？
最新发布
The best are water的博客
03-15 516
当一定的条件触发时会唤醒很多在阻塞态的线程，但只有部分的线程唤醒是有用的，其余线程的唤醒是多余的。比如说卖货，如果本来没有货物，突然进了一件货物，这时所有的顾客都被通知了，但是只能一个人买，所以其他人都是无用的通知。
【JUC并发编程】关于锁和虚拟唤醒问题
b1ngsha的博客
04-11 147
假设当前有4个线程分别为A，B，C，D，其中A、C线程是生产者，B、D线程是消费者。多线程环境下，有多个线程执行了wait()方法，需要其他线程执行notify()或者notifyAll()方法去唤醒它们，假如多个线程都被唤醒了，但是只有其中一部分是有用的唤醒操作，其余的唤醒都是无用功；而在Lock中，会分情况而定，Lock中有尝试获取锁的方法，如果尝试获取到锁，则不用一直等待。，其中出现了2、3这样的值，显然不符合预期，出现了num重复++的问题，即是虚假唤醒的问题。如果线程A发生阻塞，则线程B会。
JUC-第七篇 : JUC线程 生产者消费者案例-虚假唤醒
程序员果果的博客
11-04 188
以下是一个案例，有一个店员，负责进货和卖货。进货生产，卖货消费。 当商品超过10件，生产等待，消费继续，当少于0件，消费等待，消费继续。一、演示的代码package co...
【JUC】生产者消费者问题（包含虚假唤醒问题）
Elephant_King的博客
12-30 285
参考文章 【操作系统】生产者消费者问题_liushall-CSDN博客_生产者消费者问题操作系统 概念 生产者消费者问题（英语：Producer-consumer problem），也称有限缓冲问题（英语：Bounded-bufferproblem），是一个多线程同步问题的经典案例。 可以理解为肯德基买炸鸡， 生产者就相当于肯德基的后厨，生产炸鸡并放到前台 消费者就相当于顾客，从前台获得炸鸡 有限的缓冲区就相当于前台的保温柜里...
Juc03_多线程中的虚假唤醒的产生、问题分析、解决方案
qq_46265096的博客
12-09 408
(一个卖面的面馆，有一个做面的厨师和一个吃面的食客，需要保证，厨师做一碗面，食客吃一碗面，不能一次性多做几碗面，更不能没有面的时候吃面；按照上述操作，进行十轮做面吃面的操作)②. 代码展示(两个线程不会出现虚假唤醒问题，三个或多个线程才会出现)
JUC(十二)-线程中断相关问题(LockSupport,sleep,InterruptException)
~奇思妙想的王多鱼的博客
05-11 496
JUC 线程中断相关内容总结
JUC 经典线程八锁
weixin_44311939的博客
06-05 236
Demo代码 public class Lock8 { public static void main(String[] args) { Phone phone = new Phone(); Phone phone1 = new Phone(); new Thread(() -> { phone.sendEmail(); }, "AA").start(); try {
JUC学习笔记（二）：八锁现象
m0_56343209的博客
12-16 723
八锁现象主要是指 八种锁的情况，掌握了这八种情况我们以后碰到锁就能明白锁锁的是谁了 在了解八锁之前，我们需要先了解什么是锁： 锁是一种将资源私有化的的方式，在java中就是让某个类、变量、方法在同一个时刻只能被一个线程使用，保证数据的安全性，只要当使用锁的线程释放了这个锁，其它线程才能获取使用。 （1）让两个方法都加上同步锁 package com.lai.lock8; import java.util.concurrent.TimeUnit; /** * @author l...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值