Java中多线程同步问题、生产者与消费者、守护线程和volatile关键字（附带相关面试题）

已于 2023-08-06 07:13:09 修改
阅读量230 收藏 1
点赞数
分类专栏： Java 文章标签： java 开发语言 算法
于 2023-07-24 16:20:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dogxixi/article/details/131889535
版权

1.多线程同步问题(关键字Synchronized)

问题：多线程访问同一个资源时候可能就会出现资源完整性的问题

所以引入关键字synchronized（同步）

  • synchronized关键字的作用机制是给对象加锁，并为每个线程提供了一个计数器，初始值为0。当第一个线程获得锁时，计数器变为1，其他线程被阻塞。当第一个线程执行完代码并释放锁时，计数器归零，意味着资源可用，所有被阻塞的线程将恢复执行。
  • 一个通俗的比喻是厕所的使用情况。假设只有一个厕所位置但有很多人需要使用。当第一个人进入厕所并锁上门时，其他人不得不在外面等待。当第一个人使用完毕并打开门锁时，表示厕所空闲可用，所有等待的人可以继续使用。

关于synchronized有两种用法

1.设置同步代码块

public void method() {
    synchronized (obj) {
        // 同步代码块
    }
}

意味着只有同步代码块内部的代码需要同步，其他操作无需同步

2.设置同步代码方法

public synchronized void method() {
    // 同步代码块
}

这个方法就是整个方法内的代码都是同步的

注意：在生产案例中不要随意使用同步方法，因为一旦同步，整个程序的运行效率就会非常低，比如10个学生想要去学校上厕所，那么最好的操作就是让10个学生一起先到学校再同步操作上厕所，而不是10个学生其中某一个去学校上完厕所，其他学生才去学校上厕所

关于同步案例：（多个售票员售卖固定数量的票）

在上一篇文章的代码中就实现到这一步

package Example1401;
 
 
class MyThread extends Thread{
//    设置只有100张票
    private int ticket = 100;
    @Override
    public void run() {
        while (ticket>0){
            try {
//                内部数字单位为毫秒 1000毫秒就是1秒
                Thread.sleep(1000);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"卖出第"+(ticket--)+"张票");
        }
    }
}
 
public class javaDemo {
    public static void main(String[] args) {
        MyThread m1 = new MyThread();
        MyThread m2 = new MyThread();
        MyThread m3 = new MyThread();
        m1.setName("售票员1");
        m2.setName("售票员2");
        m3.setName("售票员3");
        m1.start();
        m2.start();
        m3.start();
    }
}

这一步实现了售票员之间的售卖间隔，就不会一下子就把所有票卖光。

现在通过同步代码块方法实现同步：

package ExampleThread;

import java.util.Random;

class Mythread implements Runnable {
    private int ticket = 100;

    @Override
    public void run() {
        while (true) {
//           当没买完票则开始卖票
//                实现同步
            synchronized (this) {
//                判断是否有票
                if (ticket > 0) {
                    try {
//                        设置随机售卖出去的时间间隔
                        Thread.sleep(1000);
//                        输出售卖信息
                        System.out.println(Thread.currentThread().getName() + "卖第" + ticket-- + "张票");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
            if (ticket <= 0) {
                System.out.println("票已经全部卖光了");
                break;
            }
//            线程礼让，让其他线程也有机会售出票
            Thread.yield();
        }
    }
}

public class test {
    public static void main(String[] args) {
        Mythread task = new Mythread();
        new Thread(task, "售票员A").start();
        new Thread(task, "售票员B").start();
        new Thread(task, "售票员C").start();

    }
}

由于票太多所以为了方便显示就改成5了

 

面试题： Synchronized 用过吗，其原理是什么？

（1）可重入性

synchronized的锁对象中有一个计数器（recursions变量）会记录线程获得几次锁；

    可重入的好处：
    可以避免死锁；
    可以让我们更好的封装代码；

synchronized是可重入锁，每部锁对象会有一个计数器记录线程获取几次锁，在执行完同步代码块时，计数器的数量会-1，直到计数器的数量为0，就释放这个锁。

（2）不可中断性

    一个线程获得锁后，另一个线程想要获得锁，必须处于阻塞或等待状态，如果第一个线程不释放锁，第二个线程会一直阻塞或等待，不可被中断；
    synchronized 属于不可被中断；
    Lock lock方法是不可中断的；
    Lock tryLock方法是可中断的；

 面试题：为什么说 Synchronized 是非公平锁？

当锁被释放后，任何一个线程都有机会竞争得到锁，这样做的目的是提高效率，但缺点是可能产生线程饥饿现象。

面试题：为什么说 Synchronized 是一个悲观锁？乐观锁的实现原理又是什么？什么是 CAS，它有什么特性？

Synchronized的并发策略是悲观的，不管是否产生竞争，任何数据的操作都必须加锁。

乐观锁的核心是CAS，CAS包括内存值、预期值、新值，只有当内存值等于预期值时，才会将内存值修改为新值。

2. Object线程的等待与唤醒方法

注意：

这些方法必须在同步块或同步方法中使用，因为它们会改变对象的内部锁状态。调用wait()方法将释放当前线程持有的对象锁，并使线程进入等待状态。而调用notify()或notifyAll()方法会唤醒等待在该对象上的线程，并将其重新放入可运行状态。

案例要求：设置一个图书类，一个图书管理员可以放图书的书名和作者，一个读者可以看图书的书名和作者

package Example;
class Book{
//    封装属性
    private String author;
    private String bookName;
//    设置获取属性
    public void setAuthor(String author) {
        this.author = author;
    }
    public void setBookName(String bookName) {
        this.bookName = bookName;
    }
    public String getAuthor() {
        return author;
    }
    public String getBookName() {
        return bookName;
    }
}
//图书管理员
class Bookmaneger implements  Runnable{
    Book book;
    Bookmaneger(Book book){
        this.book = book;
    }
    @Override
    public void run() {
        synchronized (this){
            for (int i =0;i<1000;i++){
                try {
//                    假设网络延迟
                    Thread.sleep(1000);
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
//                奇偶数时候设置不同图书
                if (i%2==0){
                    book.setAuthor("西游记");
                    book.setBookName("吴承恩");
                }
                else {
                    book.setAuthor("天龙八部");
                    book.setBookName("金庸");
                }
            }
        }
    }
}
//读者线程
class Reader implements Runnable{
    Book book;
    Reader(Book book){
        this.book = book;
    }
    @Override
    public void run() {
        while (true){
            synchronized (this){
//                读取图书信息
                try {
//                    假设网络延迟
                    Thread.sleep(1000);
                    System.out.println(book.getBookName()+"--->"+book.getAuthor());
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
            }
        }
    }
}
public class Library {
    public static void main(String[] args) {
//        公用同一图书对象book
        Book book = new Book();
        Bookmaneger manegerTask = new Bookmaneger(book);
        Reader readerTask = new Reader(book);
//        创建并运行读者和管理员的线程
        new Thread(manegerTask).start();
        new Thread(readerTask).start();
    }
}

 在网络延迟的情况下可能会出现问题：

1.数据不匹配（解决需要-》结果能够一一对应）

2.重复取同一个数据（解决需要--》每次都只取一次，只有更改后再取）

解决方法：

1.数据错乱，根本原因在于多线程下，图书管理员线程在设置图书信息到一半的时候，读者就读取图书信息造成图书信息错乱，解决方法很简单，只需要在book下将所有get和set方法设置为同步代码方法就可以解决数据错乱了

2.其原理也很简单就是因为同步代码块，所以在完成Manger在执行完set前不会执行get。Reader在执行完get前也不会执行set

package Example;
class Book{
//    封装属性
    private String author;
    private String bookName;
//    简化设置和获取属性
    public synchronized void  set(String author,String bookName) {
        this.bookName = bookName;
        this.author = author;
    }
    public String get() {
        return author +"----->"+ bookName;
    }
}
//图书管理员
class Bookmaneger implements  Runnable{
    Book book;
    Bookmaneger(Book book){
        this.book = book;
    }
    @Override
    public void run() {
        synchronized (this){
            for (int i =0;i<1000;i++){
                try {
//                    假设网络延迟
                    Thread.sleep(1000);
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
//                奇偶数时候设置不同图书
                if (i%2==0){
                    book.set("西游记","吴承恩");
                }
                else {
                    book.set("天龙八部","金庸");
                }
            }
        }
    }
}
//读者线程
class Reader implements Runnable{
    Book book;
    Reader(Book book){
        this.book = book;
    }
    @Override
    public void run() {
        while (true){
            synchronized (this){
//                读取图书信息
                try {
//                    假设网络延迟
                    Thread.sleep(1000);
                    System.out.println(book.get());
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
            }
        }
    }
}
public class Library {
    public static void main(String[] args) {
//        公用同一图书对象book
        Book book = new Book();
        Bookmaneger manegerTask = new Bookmaneger(book);
        Reader readerTask = new Reader(book);
//        创建并运行读者和管理员的线程
        new Thread(manegerTask).start();
        new Thread(readerTask).start();
    }
}

 

虽然解决了数据错乱的问题但是这样的数据出现有重复，我们的目标是需要西游记后输出天龙八部的交替输出。这就是最基础的生产者消费者模型了。

那么如何具体实现呢？就需要用到前面给的方法，等待唤醒机制，即wait();与notify（）;

其工作原理是设置一个标志位（资源量）当一个Reader读取时候就设置为true,maneger就是false并且进入沉睡。当Reader执行完任务后又将标志位设置为false 并让执行notify（）唤醒其他熟睡的线程

案例实现代码：

class  Book{
    private String author;
    private String bookName;
    boolean flag = false;
    int i = 0;

    public synchronized void BookManger(){
//        判断标志位
        if (flag==true){
//            此处如果存在书籍则管理员休息
            try {
                super.wait();
                Thread.sleep(1000);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
//            如果不存在工作管理员就需要进行给书加作者和名字
        }else {
            if (i%2==0){
                this.author = "吴承恩";
                this.bookName = "西游记";
            }else {
                this.author = "金庸";
                this.bookName = "天龙八部";
            }
//            执行完后设置标志位表示已经放好一本新的书了，并且唤醒其他线程
            i++;
            flag = true;
            super.notify();
        }
    }
    public synchronized void  Reader(){
//        判断如果没有书籍则休息
        if (flag==false){
            try {
                super.wait();
                Thread.sleep(1000);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
//            如果有书籍就输出书籍的信息
        }else {
            System.out.println(this.bookName+"----->"+this.author);
            flag = false;
            super.notify();
        }
    }
}
//读者线程
class Reader implements Runnable{
//    设置共同对象用以通信
    Book book;
    Reader(Book book){
        this.book = book;
    }
    @Override
    public void run() {
        while (true){
            book.Reader();
        }
    }
}
//管理员线程
class BookManger implements Runnable{
//    设置同一对象用以通信
    Book book;
    BookManger(Book book){
        this.book = book;
    }
//  线程调用对应方法
    @Override
    public void run() {

        while (true){
            book.BookManger();
        }
    }
}
public class ExampleThreadtest {
    public static void main(String[] args) {
//        创建共有对象book
        Book book = new Book();
        BookManger mangerTask = new BookManger(book);
        Reader readerTask = new Reader(book);
//        线程启动
        new Thread(mangerTask).start();
        new Thread(readerTask).start();
    }
}

面试题： Java 如何实现多线程之间的通讯和协作？

1.可以通过中断 和 共享变量的方式实现线程间的通讯和协作

比如说最经典的生产者-消费者模型：当队列满时，生产者需要等待队列有空间才能继续往里面放入商品，而在等待的期间内，生产者必须释放对临界资源（即队列）的占用权。因为生产者如果不释放对临界资源的占用权，那么消费者就无法消费队列中的商品，就不会让队列有空间，那么生产者就会一直无限等待下去。因此，一般情况下，当队列满时，会让生产者交出对临界资源的占用权，并进入挂起状态。然后等待消费者消费了商品，然后消费者通知生产者队列有空间了。同样地，当队列空时，消费者也必须等待，等待生产者通知它队列中有商品了。这种互相通信的过程就是线程间的协作。

Java中线程通信协作的最常见的两种方式：

1、syncrhoized加锁的线程的Object类的wait()/notify()/notifyAll()

2、ReentrantLock类加锁的线程的Condition类的await()/signal()/signalAll()

线程间直接的数据交换：

通过管道进行线程间通信：1）字节流；2）字符流

 3.模拟生产者与消费者

模拟生产者与消费者

通过上面一个案例应该就有对生产者消费者模型有初步了解，下面将举一个十分经典的消费者生产者模型让大家有更深层次的理解

案例目标：设计一个生产计算机类与一个搬运计算机类，要求是生产者生产一台计算机就要搬走一台计算机，如果没有新的计算机那么搬运工就要等待新的计算机产出，如果生产出的计算机没有被搬走就要等待搬运者将计算机搬走，最后搬运统计搬运走的电脑个数

案例代码:

package Test1402;
class Computer{
//    设置标志位
    private int flag = 0;
    private  int id=1;
    private int count = 0;
    
    //模拟生产函数
    public void produce(){
        synchronized (this){
            while (true){
                if (flag == 1){
                    try {
                        super.wait();
                        Thread.sleep(1000);
                    }catch (InterruptedException e){
                        e.printStackTrace();
                    }
                }
                System.out.println("生产电脑第"+id++);
                count++;
                flag = 1;
                super.notify();
            }
        }
    }
//    模拟搬运函数
    public  void  Carry(){
        synchronized (this){
            while (true){
                if (flag ==0){
                    try {
                        super.wait();
                        Thread.sleep(1000);
 
                    }catch (InterruptedException e){
                        e.printStackTrace();
                    }
                }
                System.out.println("搬运电脑"+(id+-1));
                flag = 0;
                super.notify();
            }
        }
    }
}
 
class Producer implements Runnable{
    Computer computer;
 
    Producer(Computer computer){
        this.computer = computer;
    }
    @Override
    public void run() {
 
        computer.produce();
    }
}
 
class Carryer implements  Runnable{
    Computer computer;
    Carryer(Computer computer){
        this.computer =computer;
    }
    @Override
    public void run() {
        try {
            Thread.sleep(1000);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        computer.Carry();
    }
}
 
public class javaDemo {
    public static void main(String[] args) {
        Computer computer = new Computer();
        new Thread(new Producer(computer)).start();
        new Thread(new Carryer(computer)).start();
    }
}

4.守护线程

一个进程的运行往往可能需要十分多的子进程辅助运行，比如聊天软件，主线程是软件的使用。而所有的聊天对象都是子线程可以分别接收消息。当软件关闭主线程时候即关闭软件使用时候，此时子线程的存在就没有了意义。就会自动关闭。这样的子线程就叫做守护线程

设置守护线程

Thread 对象.setDeamon(true/false);true-》开启守护线程,false-关闭守护线程

具体应用案例：

package Example1413;
public class javaDemo {
    public static void main(String[] args) {
//        主线程
        new Thread( ()->{
//            执行输出三次
        for (int i=0;i<3;i++){
            try {
                Thread.sleep(300);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+i);
        }
        },"userThread").start();

//        守护线程
        Thread daemon = new Thread(()->{
//            正常情况下应该执行输出10000次
            for (int i=0;i<10000;i++){
                try {
                    Thread.sleep(200);
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+i);
            }
        },"daemonThread");
//        设置守护模式
        daemon.setDaemon(true);
        daemon.start();
    }

}

 

5.volatile关键字

一般情况下比如之前的售票员售票其调用ticket时候是进行先复制其数据副本再通过加载-》使用-》赋值-》存储-》写入才对内存的数据ticket进行同步，就是线程操作的数据都只是原始数据的备份，在操作完成后再和原始数据进行替换。而volatile则不需要这些数据备份直接操作内存的原始数据

好处：volatile关键字可以直接对内存进行操作，就不需要同步数据了，所以可以减少程序运行的时间

使用案例代码：

package Example1414;

class sale implements Runnable{
    private volatile int ticket =100;

    @Override
    public void run() {
        synchronized (this){
            while (ticket>0){
                try {
                    Thread.sleep(100);
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"售卖出"+ticket--+"张票");
            }
        }
    }
}

public class javaDemo {
    public static void main(String[] args) {
        sale s = new sale();
        new Thread(s,"售票员A").start();
        new Thread(s,"售票员B").start();
        new Thread(s,"售票员C").start();
    }
}

*面试题：volatile 关键字的作用

对于可见性，Java 提供了 volatile 关键字来保证可见性和禁止指令重排。 volatile 提供 happens-before 的保证，确保一个线程的修改能对其他线程是可见的。当一个共享变量被 volatile 修饰时，它会保证修改的值会立即被更新到主存，当有其他线程需要读取时，它会去内存中读取新值。

从实践角度而言，volatile 的一个重要作用就是和 CAS 结合，保证了原子性，详细的可以参见 java.util.concurrent.atomic 包下的类，比如 AtomicInteger。

volatile 常用于多线程环境下的单次操作(单次读或者单次写)。

 *面试题：既然 volatile 能够保证线程间的变量可见性，是不是就意味着基于 volatile 变量的运算就是并发安全的？

volatile修饰的变量在各个线程的工作内存中不存在一致性的问题（在各个线程工作的内存中，volatile修饰的变量也会存在不一致的情况，但是由于每次使用之前都会先刷新主存中的数据到工作内存，执行引擎看不到不一致的情况，因此可以认为不存在不一致的问题），但是java的运算并非原子性的操作，导致volatile在并发下并非是线程安全的。

  *面试题：请谈谈 volatile 有什么特点，为什么它能保证变量对所有线程的可见性？

volatile只能作用于变量，保证了操作可见性和有序性，不保证原子性。

在Java的内存模型中分为主内存和工作内存，Java内存模型规定所有的变量存储在主内存中，每条线程都有自己的工作内存。

主内存和工作内存之间的交互分为8个原子操作：

    lock
    unlock
    read
    load
    assign
    use
    store
    write

volatile修饰的变量，只有对volatile进行assign操作，才可以load，只有load才可以use，，这样就保证了在工作内存操作volatile变量，都会同步到主内存中。

Alphamilk
关注
专栏目录
多线程生产者消费者问题详解-附面试题大全【精】
debugEDM的博客
07-29 731
多线程 生产者与消费者(线程通信) 实现生产者和消费者案例(一) public class Resource { //定义布尔类型的成员,标志位,指示线程该做什么 //false没有,需要生产, true需要消费 boolean flag = false; int count ;//包子的计数器 } public class Product implements Runnable { //创建资源对象 Resource r = new Resource(); public void r
Java实现同步机制（生产者消费者）
一个安静的程序员
07-31 592
Java实现线程的同步，可以通过synchronized，wait(), notitfy(), notifyAll()；假设一个线程（生产者）生产产品，一个线程（消费者）消费产品，其访问的资源时间都是随机的，这样就是生产者必须得产品（资源）消费完成之后才可以生产，而消费者必须在产品有的时候才可以消费，这就是必须对资源进行同步操作，对资源的使用部分的代码需要加入锁。 下列是我的实现方法： /**...
java实现同步_Java实现同步机制（生产者消费者）
weixin_29018815的博客
02-20 415
过多的线程同步可能会造成死锁 死锁通俗来讲就是两个或者两个以上线程，占用了对方下一步所需要的资源，多个线程僵持都无法结束任务的状态 生产者和消费者模式是一个多线程同步的经典案例 它利用信号灯来判断线程是否可以执行，可以避免线程的死锁问题 在javaJava实现线程的同步，可以通过synchronized，wait(), notitfy(), notifyAll()；假设一个线程(生产者)生产产品，...
JAVA同步-生产者与消费者实现 一
J-WH博客
04-16 552
生产者消费者模型：实现手段 用wait(),notifALL()实现; 问题描述：在一个餐馆里，有一个厨师（做食物），有一个伙计（端食物/消费）；                 食物为空时：伙计不能再端食物，此时通知厨师要做菜；                 食物不为空时： 厨师就不再做食物，通知伙计消费食物；//此处问题抽象：厨师每次只能做一样食物(只有一个盘子)，可以做多次； 食物类：cl...
多个线程共同调用一个方法造成数据错乱的问题
热门推荐
fenfenguai的专栏
03-09 1万+
最近在做一个小功能，具体逻辑是通过代码读取datahub数据并把获取到的数据产出成数据文件。因为数据量较大，所以考虑到使用多线程来运行。下面是主要代码 线程启动方法 public void start() throws Exception { String shardId = "0"; String name = "ThreadShardOne"; ...
java线程混乱错位_多线程之解决数据错位问题
weixin_36393674的博客
02-27 946
[在网上查了资料，说类的实例变量是多线程共享的。经过实验为什么不是呢？请看下面的代码 package test; public class ThreadDemo extends Thread{ private int i =class Message{private String title;private String content;public synchronized void...
热门Java面试多线程面试题问答Top50共17页.pdf
10-31
【标签】"热门Java面试多线程面试题问答" 指明了文档的主题，即Java多线程相关的面试问题和答案，这是一个经常在高级Java开发岗位面试中出现的话题。多线程是Java编程中的核心概念，涉及到系统性能、程序正确性和...
15个顶级Java多线程面试题（附答案）
08-31
Java多线程是Java编程中不可或缺的部分，尤其在面试中，这一领域的知识是评估程序员能力的重要标准。以下是一些关于Java多线程的面试重点： 1. **线程的顺序控制**：面试题中提到的T1、T2、T3线程顺序执行问题，...
Java 多线程编程面试集锦20道问题解答Java多线程编程高难度面试题及解析
06-14
Java 多线程编程是Java开发中的重要领域，特别是在高并发的应用场景下，对多线程的深入理解和熟练运用显得尤为关键。以下是一些关于Java多线程编程的知识点： 1. **线程安全**：在多线程环境中，线程安全意味着多个...
15个高级Java多线程面试题及回答
09-04
Java多线程是Java编程中不可或缺的部分，尤其在面试中，它是评估开发者能力的重要标准。以下是一些高级Java多线程面试题及其涉及的知识点： 1. **如何保证线程执行顺序？** - 使用`Thread.join()`方法可以使一个...
JMM---Volatile关键字
TIANJIAWEN的博客
04-13 531
JMM 即Java Memory Model 它定义了主存、工作内存抽象概念，底层对应着CPU寄存器、缓存、硬件内存、CPU指令优化等JMM体现在以下几个方面 ·原子性-保证指令不会受到线程上下文切换的影响 synchronized和Lock能够保证任一时刻只有一个线程执行该代码块，那么自然就不存在原子性问题了，从而保证了原子性。 ·可见性-保证指令不会受cpu缓存的影响 volatile关键字可.........
关于JAVA 中volatile使用的一些笔记
山河已无恙
12-08 626
太敏感的人会体谅到他人的痛苦，自然就无法轻易做到坦率。所谓的坦率，其实就是暴力。-----太宰治《候鸟》
Java多线程下生产者消费者问题的五种同步方法实现
ai-exception的博客
05-21 1874
本文目录： 文章目录概述`wait() / notify()`方法实现`await() / signal()`方法`BlockingQueue`阻塞队列方法`Semaphore`方法实现同步`PipedInputStream` / `PipedOutputStream` 概述 生产者消费者模式是通过一个容器来解决生产者和消费者的强耦合问题。 　　 生产者消费者模式的优点: 解耦 支持并发 支持忙...
java模拟生产者与消费者问题（线程同步）
hl17200178的专栏
10-04 7244
关于生产者与消费者的问题，百度百科上的定义是这样的：生产者消费者问题，也称有限缓冲问题，是一个多线程同步问题的经典案例。该问题描述了两个共享固定大小缓冲区的线程——即所谓的“生产者”和“消费者”——在实际运行时会发生的问题。生产者的主要作用是生成一定量的数据放到缓冲区中，然后重复此过程。与此同时，消费者也在缓冲区消耗这些数据。该问题的关键就是要保证生产者不会在缓冲区满时加入数据，消费者也不会在缓冲
java多线程同步：生产者与消费者问题
reality_jie的专栏
10-24 6868
消费者与生产者问题是线程同步里边一个很经典的问题。 用通俗的语言来描述：一群生产者不断的生产产品，并将产品放到一个容器里边；同时一群消费者不断从容器里边消费产品。 容器的容量是有限的。如果容器满了，生产者不能再往容器放产品，必须进入等待状态。等待产品被消费者拿走了，再往容器放产品。 同样，如果容器空了，消费者也必须进入等待状态。等待生产者往里边放产品，再将消费者唤醒。 下边我们来看看如何用
java并发--生产者消费者模型---volatile关键字
潇潇安宁的android学习
04-09 585
生产者消费者模型：系统中包含生产者和消费者两种角色，通过内存缓冲区进行通信。生产者生产消费者需要的产品，消费者把产品取出消费掉。 生产者===》 ====》消费者 生产者===》内存缓冲区（存放资源）====》消费者 生产者===》 ...
[自用，更新自day5]瑞吉外卖代码及笔记
最新发布
lapiii的博客
11-01 809
当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。Mybatis Plus公共字段自动填充，也就是在插入或者更新的时候为指定字段赋予指定的值，使用它的好处就是可以统一对这些字段进行处理，避免了重复代码。因为在分页查询的Dish的records(菜品记录中)，只有这个菜品所属的categoryId，但是我们需要分页的时候展示的是菜品名字。
基于vue框架的的汇生活家居商城的设计与实现bdjlq（程序+源码+数据库+调试部署+开发环境）系统界面在最后面。
h2345678的博客
10-29 1370
项目功能：商品分类,商品信息,用户。
JAVA 插入 JSON 对象到 PostgreSQL
qq_52143611的博客
10-30 862
在现代软件开发中，由于 JSON 数据的轻量和通用性，处理 JSON 数据已经变得无处不在。PostgreSQL凭借其对 JSON 的强大支持，为存储和查询 JSON 数据提供了出色的平台。为了将JSON数据保存到PostgreSQL数据库中，我们可以将JSON数据转换为PostgreSQL的JSONB类型数据，然后将其存储在数据库中。在Java中，我们可以使用JDBC或者基于ORM框架的方式来实现这一功能。
Java多线程并发面试必备：22题解析与思维导图
"Java多线程与并发编程是面试中的常见考点，本资料提供了22道高频面试题，并附带思维导图和答案解析，涵盖了多线程创建、线程控制及并发工具的使用等关键知识点。" 在Java编程中，多线程与并发是核心的性能优化和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Alphamilk

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

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

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

打赏作者

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

抵扣说明：

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

余额充值