JUC学习笔记一：锁，生产者和消费者问题

最新推荐文章于 2024-04-07 10:04:54 发布
最新推荐文章于 2024-04-07 10:04:54 发布
阅读量97 收藏
点赞数
分类专栏： JUC
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44815465/article/details/108743547
版权

笔记来源狂神说java

1.进程和线程

  • 进程：就是一个程序。
  • 进程包含多个线程，至少包含一个。
  • 线程：开了一个程序的进程中有用于不同功能的线程。
  • java默认开启了2个线程：main，GC
  • 对于Java而言有几种开启线程的方式：Thread，Runnable，Callable
  • Java不能开启线程：Java是运行在虚拟机上的，不可以操作硬件
public synchronized void start() {
        /**
         * This method is not invoked for the main method thread or "system"
         * group threads created/set up by the VM. Any new functionality added
         * to this method in the future may have to also be added to the VM.
         *
         * A zero status value corresponds to state "NEW".
         */
        if (threadStatus != 0)
            throw new IllegalThreadStateException();

        /* Notify the group that this thread is about to be started
         * so that it can be added to the group's list of threads
         * and the group's unstarted count can be decremented. */
        group.add(this);

        boolean started = false;
        try {
            start0();
            started = true;
        } finally {
            try {
                if (!started) {
                    group.threadStartFailed(this);
                }
            } catch (Throwable ignore) {
                /* do nothing. If start0 threw a Throwable then
                  it will be passed up the call stack */
            }
        }
    }

    private native void start0();

2.并发和并行

  • 并发：多个线程操作同一个资源（单核CPU，模拟出多个线程，快速交替占用CPU）
  • 并行：多个线程同时运行（多核CPU，可用线程池）

获取cpu核数：
在这里插入图片描述
并发编程的本质：充分利用cpu的资源。

3.线程有几个状态？

public enum State {
        /**
         * Thread state for a thread which has not yet started.
         */
        NEW, //新建  刚开始认识

        /**
         * Thread state for a runnable thread.  A thread in the runnable
         * state is executing in the Java virtual machine but it may
         * be waiting for other resources from the operating system
         * such as processor.
         */
        RUNNABLE, //运行  甜蜜期

        /**
         * Thread state for a thread blocked waiting for a monitor lock.
         * A thread in the blocked state is waiting for a monitor lock
         * to enter a synchronized block/method or
         * reenter a synchronized block/method after calling
         * {@link Object#wait() Object.wait}.
         */
        BLOCKED, //阻塞 他没有回来。

        /**
         * Thread state for a waiting thread.
         * A thread is in the waiting state due to calling one of the
         * following methods:
         * <ul>
         *   <li>{@link Object#wait() Object.wait} with no timeout</li>
         *   <li>{@link #join() Thread.join} with no timeout</li>
         *   <li>{@link LockSupport#park() LockSupport.park}</li>
         * </ul>
         *
         * <p>A thread in the waiting state is waiting for another thread to
         * perform a particular action.
         *
         * For example, a thread that has called {@code Object.wait()}
         * on an object is waiting for another thread to call
         * {@code Object.notify()} or {@code Object.notifyAll()} on
         * that object. A thread that has called {@code Thread.join()}
         * is waiting for a specified thread to terminate.
         */
        WAITING, //等待，死死的等。。。

        /**
         * Thread state for a waiting thread with a specified waiting time.
         * A thread is in the timed waiting state due to calling one of
         * the following methods with a specified positive waiting time:
         * <ul>
         *   <li>{@link #sleep Thread.sleep}</li>
         *   <li>{@link Object#wait(long) Object.wait} with timeout</li>
         *   <li>{@link #join(long) Thread.join} with timeout</li>
         *   <li>{@link LockSupport#parkNanos LockSupport.parkNanos}</li>
         *   <li>{@link LockSupport#parkUntil LockSupport.parkUntil}</li>
         * </ul>
         */
        TIMED_WAITING, //超时等待 等了好久还是没来

        /**
         * Thread state for a terminated thread.
         * The thread has completed execution.
         */
        TERMINATED;//终止，等不到了。。。
    }

4.wait和sleep的区别

1.来自不同的类

  • wait–> Object
  • sleep–>Thred

2.关于锁的释放

wait会释放锁
sleep不会释放锁，抱着锁睡了就不会懂得释放了。。。

3.使用的范围不同

  • wait必须在同步代码块中
  • sleep在什么地方都可以睡。。。

4.是否需要捕获异常

  • wait不需要捕获异常
  • sleep需要捕获异常

5.Lock锁（重点）

1.传统的synchronized

public class Test1 {

    public static void main(String[] args) {
        //并发：多线程操作同一个资源类
        Ticket ticket = new Ticket(); //线程资源类
        //()->{}

        //将线程资源类丢进线程中
        new Thread(() -> {
            for (int i = 0; i < 30; i++) {
                ticket.sale();
            }
        }, "A").start();

        new Thread(() -> {
            for (int i = 0; i < 30; i++) {
                ticket.sale();
            }
        }, "B").start();

        new Thread(() -> {
            for (int i = 0; i < 30; i++) {
                ticket.sale();
            }
        }, "C").start();
    }
}

//线程应该是一个独立的资源类，没有其他附属的操作，降低耦合性
class Ticket {
    private int num = 50;

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

2.lock接口

查看文档说明
在这里插入图片描述

在这里插入图片描述
构造方法：
在这里插入图片描述
java默认的是非公平锁

  1. 非公平锁：进程之间可以互相抢占
  2. 公平锁：进程之间不可以互相抢占
public class Test2 {

    public static void main(String[] args) {
        Ticket2 ticket = new Ticket2();
//        //()->{}
        new Thread(() -> {
            for (int i = 0; i < 30; i++) ticket.sale();
        }, "A").start();
        new Thread(() -> {
            for (int i = 0; i < 30; i++) ticket.sale();
        }, "B").start();
        new Thread(() -> {
            for (int i = 0; i < 30; i++) ticket.sale();
        }, "C").start();
    }
}

class Ticket2 {
    private int num = 50;
    //锁对象
    Lock lock = new ReentrantLock();

    public synchronized void sale() {
        //加锁
        lock.lock();
        try {
            //业务
            if (num > 0) {
                System.out.println(Thread.currentThread().getName() + "还剩" + (num--) + "张票");
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //释放锁
            lock.unlock();
        }

    }
}

3.synchronized 和lock的区别

  1. synchronized 是java内置的关键字，lock是一个类
  2. synchronized 无法判断获取锁的状态，lock可以判断是否获取到了锁
  3. Synchronized 会自动释放锁，lock 必须要手动释放锁！如果不释放锁，死锁
  4. Synchronized 线程 1（获得锁，阻塞）、线程2（等待，傻傻的等）；Lock锁就不一定会等待下去；
  5. Synchronized 可重入锁，不可以中断的，非公平；Lock ，可重入锁，可以 判断锁，非公平（可以自己设置）；
  6. Synchronized 适合锁少量的代码同步问题，Lock 适合锁大量的同步代码！

6.生产者和消费者问题

synchronized版本

/**
 * 线程之间的通信问题：生产者和消费者的问题！ 等待唤醒<---->通知唤醒
 * 线程交替执行 A  B 操作同一个变量   直到num==0
 *
 * A：num+1
 * B：num-1
 */
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();
    }
}

问题存在：虚假唤醒

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();
                }
            }
        },"D").start();
        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 四个线程同时去操作，那么就会出现虚假唤醒的情况。
原因是方法中只有一次的判断num==0的操作，而此时有多个线程在操作num。
在这里插入图片描述
解决办法：可以将if改为while
在这里插入图片描述

JUC版本

在这里插入图片描述
通过lock找到Condition
在这里插入图片描述
代码

public class B {
    public static void main(String[] args) {
        Data2 data = new Data2();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data.increment();
            }
        },"A").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data.increment();
            }
        },"B").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data.increment();
            }
        },"C").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data.decrement();
            }
        },"D").start();
    }

}

class Data2 {
    private int number = 10;
    Lock lock = new ReentrantLock();
    Condition condition = lock.newCondition();

    //+1
    public void increment() {
        lock.lock();
        try {
            while (number == 0) {
                condition.await();
            }
            number++;
            System.out.println(Thread.currentThread().getName() + "=>" + number);
            // 通知其他线程，我+1完毕了
            condition.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }

    }

    //-1
    public void decrement()  {
        lock.lock();
        try{
            while (number == 0) { // 1
                // 等待
                condition.await();
            }
            number--;
            System.out.println(Thread.currentThread().getName() + "=>" + number);
            // 通知其他线程，我-1完毕了
            condition.signalAll();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
}

Condition实现精准唤醒：


/**
 * Condition 实现精准唤醒
 */
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 lock = new ReentrantLock();
    Condition condition1 = lock.newCondition();
    Condition condition2 = lock.newCondition();
    Condition condition3 = lock.newCondition();

    private int number = 1; // 1A 2B 3C

    //+1
    public void printB() {
        lock.lock();
        try {
            while (number !=1) {
                condition1.await();
            }
            System.out.println(Thread.currentThread().getName() + "=>" +"bbbbbbbbbbb");
            number=2;
            // 通知其他线程，我+1完毕了
            condition2.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }

    }

    //-1
    public void printA()  {
        lock.lock();
        try{
            while (number !=2) { // 1
                // 等待
                condition2.await();
            }
            number=3;
            System.out.println(Thread.currentThread().getName() + "=>" +"AAAAAAAAA");
            // 通知其他线程，我-1完毕了
            condition3.signalAll();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }

    public void printC()  {
        lock.lock();
        try{
            while (number !=3) { // 1
                // 等待
                condition3.await();
            }
            number=1;
            System.out.println(Thread.currentThread().getName() + "=>" +"CCCCCCC");
            // 通知其他线程，我-1完毕了
            condition1.signalAll();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
}

7.锁现象

  1. 一个对象，synchronized在方法中，锁的是调用者，几个方法用的是同一个锁，那么谁先占用锁，谁就先运行。
  2. 两个对象，synchronized在方法中，就有两个同步方法，谁先调用谁就先执行。
  3. 一个对象，方法都为静态方法，synchronized在方法中，这时候锁的是类模板，只有一个锁，谁先占用谁就先执行
  4. 两个对象，方法为静态方法，synchronized在方法中，也是有两个同步方法，谁先调用谁就先执行
小铭爱学习
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
linux网络编程之System V 信号量（三）：基于生产者-消费者模型实现先进先出的共享内存段
Meditation
06-15 6399
生产者消费者问题：该问题描述了两个共享固定大小缓冲区的进程——即所谓的“生产者”和“消费者”——在实际运行时会发生的问题。生产者的主要作用是生成一定量的数据放到缓冲区中，然后重复此过程。与此同时，消费者也在缓冲区消耗这些数据。该问题的关键就是要保证生产者不会在缓冲区满时加入数据，消费者也不会在缓冲区中空时消耗数据。 我们可以用信号量解决生产者消费者问题，如下图： 定义3个信号量，s
个人学习JUC代码笔记总集
07-27
这个压缩包文件“个人学习JUC代码笔记总集”显然是一个个人的学习资源，记录了对JUC组件的理解和应用实例，特别适合已经有一定Java基础，想要深入学习并发编程的开发者。 JUC的主要目标是简化并发编程，提高多线程...
生产者和消费者关于锁的案例
酷学Java
03-29 133
1. 老版案例 public class tets2 { public static void main(String[] args) { Data data = new Data(); new Thread(()->{for(int i = 0 ;i<10;i++) { try { dat...
使用三个锁解决生产者消费者问题
蒙牛真好的博客
12-22 333
//队列 public class Buffer { private Queue<String> queue; private int size = 10; // 消费者锁 private Object getLock = new Object(); // 生产者锁 private Object addLock = new Object(); private AtomicInteger count = new AtomicIntege
生产者消费者问题（多线程通信和同步锁）
小程同学
08-22 141
个人见解： 生产者-------------资源池-------------------消费者 生产者和消费者同时运行，分别对同一个资源池里的数据进行生产和消费操作，为了保证线程安全，我们需要用的锁机制。 同时在资源池为空时，消费者行为无法进行；同样，资源池满时，生产者行为无法进行，故需要线程通信，来协调双方的动作正常进行。 代码实现： ResourcePool.java public class ResourcePool { private int [] array=new int [3]
信号量 锁机制 处理生产者-消费者问题
whuzzy的博客
04-27 333
#include<iostream> #include<cstdlib>#include<Windows.h>//包含对window系统资源的一些操作函数包括窗口光标线程 using namespace std; const unsigned short SIZE_OF_BUFF = 10;//缓冲区的容量 int g_buffer[SIZE_OF_BU...
JUC学习笔记 .md
01-31
JUC学习笔记 .md
jvm-juc：jvm学习笔记
03-03
4. Lock接口：提供了比synchronized更细粒度的锁控制，如ReentrantLock、ReadWriteLock（读写锁）等，支持公平性和非公平性锁。 5. Concurrent Collections：并发集合，如ConcurrentHashMap、CopyOnWriteArrayList...
个人学习-JUC-笔记
02-25
本笔记主要围绕尚硅谷周阳老师的JUC课程展开，旨在帮助个人学习者深入理解和掌握Java并发编程的核心知识。 1. **并发基础** - **线程与进程**：线程是程序执行的最小单位，进程则是资源分配的基本单位。了解它们的...
【学习笔记】JUC基础基础程序
02-24
本学习笔记将深入探讨JUC的基础知识，帮助你理解和掌握Java并发编程的核心概念。 在Java中，多线程是实现并发的主要方式。一个线程是程序执行的一个流，多线程则意味着一个程序内可以同时执行多个线程。Java提供了...
System V共享内存与信号量综合应用之生产者与消费者问题解决
05-27
用System V共享内存与信号量综合应用之生产者与消费者问题解决的相关代码,几乎每句代码都有注释,方便阅读.
Qt--多线程间的互斥
cangnuan2978的博客
08-20 260
一.多线程间的互斥 临界资源--每次只允许一个线程进行访问的资源线程间的互斥--多个线程在同一个时刻需要访问临界资源QMute类是一把线程锁，保证线程间的互斥--利用线程锁能够保证临界资源的安全性QMutex中的关键成员函数void lock()--当锁空闲时，获取锁并继续执行；当锁被获取时，阻塞并等待释放void unlock()--释放锁(同一把锁的获取和释放必须在同一线程中成对出现 )A.生...
线程
Outsider_in的博客
12-10 311
并行与并发 并发：指的是两个或者多个事件(任务)在同一时间段内发生的。 并行：指的是两个或者多个事件(任务)在同一时刻发生(同时发生)。 图解如下： 线程与进程 进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个线程；进程也是程序的一次执行过程，是系统 运行程序的基本单位；系统运行一个程序就是一个进程从创建、运行到消亡的过程。 线程：线程是进程中的一个执行单元，负责当前进程中程序的运行，一个程序中至少有一个线程。一个进程可以有多个线程，这个应用程序也可以称之
生产者与消费者问题
qq_38718462的博客
06-06 851
三种方法简单实现生产者与消费者 方法一：使用wait()和notifyAll() /** * 使用wait()和notifyAll()简单实现生产者与消费者 */ public class Test1 { private static int count = 0;//记录当前剩余“产品”量 private static final int FULL = 10;//最大容量 private static Object obj = new Object(); public
Rhyme/Java多线程之生产者消费者问题(等待唤醒机制、虚假唤醒、锁机制)
RhymeChiang
02-02 372
Java多线程之生产者消费者问题(等待唤醒机制、虚假唤醒、锁机制) 本篇博客由浅入深，先从最基础的生产者消费者问题讲起，然后依次深入 普通的生产者消费者问题 首先我们有一个店员类，模拟进货和卖货操作，店里的商品数量最多为10个 注意这里我们给进货和卖货方法都加了synchronized的关键字 生产者线程，负责生产商品 消费者线程，负责消费商品 好，然后我们先看运
生产者和消费者模型
f2016913的博客
06-24 435
一:条件变量: 我们知道多线程访问时会出现冲突的问题,为了解决这个问题我们引入互斥锁的概念,即多个线程同时访问理解资源时,获得锁多线程可以完成”读-修改-写”操作,然后释放锁给其他线程.没有获得锁的线程只能挂起等待. 与互斥锁不同,条件变量时挂起等待而不是上锁,条件变量用来自动阻塞一个线程,直到某特殊情况的发生,通常条件变量和互斥锁同时使用. 原理:条件变量是利用线程间共享的全局变量进行同步的
C语言中的并发与同步机制：互斥锁、条件变量、信号量与生产者消费者问题（四）
weixin_56154577的博客
04-07 710
生产者消费者问题是并发编程中的经典同步问题，描述了这样一个场景：有两个或多个线程（生产者线程和消费者线程）共享一个固定大小的缓冲区（队列或环形缓冲区）。生产者线程负责生成数据项并放入缓冲区，消费者线程负责从缓冲区取出数据项并进行处理。生产者和消费者线程均以异步方式运行，且生产速度和消费速度可能不一致。
死锁机制以及生产者与消费者模式
qq_34780061的博客
09-12 1507
    java之所以能够一直矗立在各种编程语言之前，与它的多线程技术是密不可分的！   1.我们在使用多线程技术时，除了要保证他的效率，更要确保安全性，java的多线程技术为了确保其安全引入了锁（synchronized）的概念，给程序的安全带来了极大的保证  2.synchronized（锁）我简单的分为代码块锁和方法锁     这两个锁执行的内容是一样的，但是他们的锁对象不一样，代码...
JUC代码演示 Java多线程并发
最新发布
05-03
这个资源通过具体的代码实例，展示了Java多线程编程中的基础概念，包括如何使用用户线程和守护线程，以及如何利用JUC库中的同步机制（如`synchronized`和`Lock`）来处理并发场景中的数据一致性问题。这些知识对于有...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值