JUC并发编程（一）: Lock锁+新版生产者消费者写法

最新推荐文章于 2022-08-19 15:05:39 发布
最新推荐文章于 2022-08-19 15:05:39 发布
阅读量355 收藏
点赞数
分类专栏： java基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Hi_alan/article/details/104323505
版权

1. 什么是JUC

JUC是Java.util.concurrent包的简称，是Java提供用来支持高并发的工具类。
在这里插入图片描述

2.进程和线程回顾

进程/线程是什么？

进程：正在运行的程序，资源分配的最小单位
线程：CPU调度的最小单位
一个进程可能包含多个线程，至少包含一个。Java main,GC线程。

并发/并行是什么？

并发：多线程操作一个资源类，快速交替过程。
并行：多核CPU，同时处理多个线程。

你吃饭，吃到一半，电话来了，3种情况
1.吃完再去接电话（单线程）
2.先接电话再吃（交替，并发）
3.边吃边接电话（并发）

一个CPU的电脑不能并发执行任务
并发编程的主要目的，充分利用CPU的资源，提高性能

线程的状态

线程的状态6种

public enum State {
 
    NEW,

    RUNNABLE,

    BLOCKED,

    WAITING, // 等待

    TIMED_WAITING, // 延时等待 

    TERMINATED; //
}

wait/sleep的区别

1.类
wait -> Object
sleep -> Thread, 谁调用的sleep方法就是谁睡觉！
例如：A调用了B的sleep方法，实际上就是A睡觉。

2.释放锁
sleep抱着锁睡觉
wait会释放锁

3.使用范围不同
wait、notify、notifyAll只能在同步方法中或者同步代码块中；
sleep可以在任意地方使用；

4.异常
sleep,必须捕获异常！
wait，不需要捕获异常！

3.Lock锁

传统的synchronized

package com.coding.demo01;

import java.util.TimerTask;

/**
 *线程  操作（调用资源类暴露的方法） 资源类
 */
public class SaleTicketTest1 {
    public static void main(String[] args) {

        // 资源类
        final SaleTicket saleTicket = new SaleTicket();

        new Thread(new Runnable() {
            public void run() {
                for (int i = 1; i < 40; i++) {
                    saleTicket.saleTicket();
                }
            }
        }, "A").start();

        new Thread(new Runnable() {
            public void run() {
                for (int i = 1; i < 40; i++) {
                    saleTicket.saleTicket();
                }
            }
        }, "B").start();

        new Thread(new Runnable() {
            public void run() {
                for (int i = 1; i < 40; i++) {
                    saleTicket.saleTicket();
                }
            }
        }, "C").start();

    }
}

// 属性，和方法  高内聚
class SaleTicket{ //资源类
    private int number = 30;

    // 卖票方法
    public synchronized void saleTicket(){
        if (number>0){
            System.out.println(Thread.currentThread().getName()+"卖出第"+ (number--) +"还剩下："+number+"张票");
        }
    }

}

使用juc.locks包下的类操作Lock锁+Lambda表达式
在这里插入图片描述

package com.coding.demo01;

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

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

        // 并发： 多线线程操作同一个资源类
        // 资源类
        SaleTicket2 saleTicket = new SaleTicket2();

        // lambda表达式、链式编程、流式计算！
        //  lambda表达式，() -> {} 自动推断类型

        // IDEA 一定要设置 JDK 版本为 1.8 版本
        new Thread(() -> {
            for (int i = 1; i < 40; i++) saleTicket.saleTicket();
        }, "A").start();

        new Thread(() -> {
            for (int i = 1; i < 40; i++) saleTicket.saleTicket();
        }, "B").start();

        new Thread(() -> {
            for (int i = 1; i < 40; i++) saleTicket.saleTicket();
        }, "C").start();

    }
}

// 属性，和方法  高内聚
class SaleTicket2 { //资源类
    private int number = 30;

    // 锁LOCK
    private Lock lock = new ReentrantLock(); // 可重入

    // 卖票方法
    public void saleTicket() {
        lock.lock(); // 加锁
        try {
            // 业务代码
            if (number > 0) {
                System.out.println(Thread.currentThread().getName() + "卖出第" + (number--) + "还剩下：" + number + "张票");
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock(); // 解锁
        }

    }

}

synchronized和lock区别（自动档 手动挡）

1.synchronized关键字，Java内置的。lock是一个Java类
2.synchronized无法判断是否获取锁，lock可以判断是否获得锁
3.synchronized锁会自动释放！lock需要手动在finally释放锁，如果不释放锁，就会死锁。
4.synchronized线程1阻塞 线程2永久等待下去。lock可以lock.tryLock();//尝试获取锁，如果获取不到锁，可以结束等待
5.synchronizd可重入，不可中断，非公平得，Lock锁，可重入、可以判断、可以公平！

可重入：一个房子如果只有一个大门，只要拿到大门的钥匙，就可以进入卧室，厨房，厕所，不需要额外再获取钥匙。

公平：排队，必须先来后到！
非公平：可以插队~

4.生产者和消费者

线程间得通信、无法通信，调度线程

生产者和消费者synchronized版

package com.coding.demo02;

/**
 * 题目：现在两个线程，操作一个初始值为0的变量
 *       一个线程 + 1， 一个线程 -1。判断什么时候+1，什么时候-1
 *       交替10 次
 *   生产者消费者模式：判断  干活  通知
 */
public class A {

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

        new Thread(()->{
            for (int i = 1; i <= 10; i++) {
                try {
                    data.increment();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        },"A").start();

        new Thread(()->{
            for (int i = 1; i <= 10; i++) {
                try {
                    data.decrement();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        },"B").start();

    }

}


// 资源类  属性，方法
class Data{
    private int num = 0;

    // +1
    public synchronized void increment() throws Exception{
        //判断
        if (num!=0){
            this.wait();
        }
        // 干活
        num++;
        System.out.println(Thread.currentThread().getName()+"\t"+num);
        // 通知
        this.notifyAll();
    }

    // -1
    public synchronized void decrement() throws Exception{
        // 判断
        if (num==0){
            this.wait();
        }
        // 干活
        num--;
        System.out.println(Thread.currentThread().getName()+"\t"+num);
        // 通知
        this.notifyAll();
    }

}

问题升级：防止虚假唤醒，4个线程，两个加，两个减

在这里插入图片描述

package com.coding.demo02;

public class A {

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

        new Thread(()->{
            for (int i = 1; i <= 10; i++) {
                try {
                    data.increment();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        },"A").start();

        new Thread(()->{
            for (int i = 1; i <= 10; i++) {
                try {
                    data.decrement();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        },"B").start();

        new Thread(()->{
            for (int i = 1; i <= 10; i++) {
                try {
                    data.increment();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        },"C").start();

        new Thread(()->{
            for (int i = 1; i <= 10; i++) {
                try {
                    data.decrement();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        },"D").start();

    }

}


// 资源类  属性，方法
class Data{
    private int num = 0;

    // +1
    public synchronized void increment() throws Exception{
        //判断  if 只判断了一次，  0  1  0   1   
        while (num!=0){    
            this.wait();
        }
        // 干活
        num++; 
        System.out.println(Thread.currentThread().getName()+"\t"+num);
        // 通知
        this.notifyAll();
    }

    // -1
    public synchronized void decrement() throws Exception{
        // 判断
        while (num==0){
            this.wait(); //0
        }
        // 干活
        num--;
        System.out.println(Thread.currentThread().getName()+"\t"+num);
        // 通知
        this.notifyAll();
    }

}

传统的，JUC！

新版生产者和消费者写法

在这里插入图片描述
任何一个新技术的出现，一定不仅仅是换了个马甲在这里插入图片描述

package com.coding.demo02;

import sun.awt.SunHints;

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

// lock版生产者消费者
public class B {


    public static void main(String[] args) {
        // 新版
        Data2 data = new Data2();

        new Thread(()->{
            for (int i = 1; i <= 10; i++) {
                try {
                    data.increment();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        },"A").start();

        new Thread(()->{
            for (int i = 1; i <= 10; i++) {
                try {
                    data.decrement();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        },"B").start();

        new Thread(()->{
            for (int i = 1; i <= 10; i++) {
                try {
                    data.increment();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        },"C").start();

        new Thread(()->{
            for (int i = 1; i <= 10; i++) {
                try {
                    data.decrement();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        },"D").start();

    }

}

// 资源类  属性，方法
class Data2{
    private int num = 0;
    // 定义锁
    Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();

    // +1
    public void increment() throws Exception{

        // 加锁
        lock.lock();

        try {
            //判断
            while (num!=0){
                condition.await(); //等待
            }
            // 干活
            num++;
            System.out.println(Thread.currentThread().getName()+"\t"+num);
            // 通知
            condition.signalAll();

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

    // -1
    public void decrement() throws Exception{


        // 加锁
        lock.lock();
        try {
            // 判断
            while (num==0){
                condition.await(); //等待
            }
            // 干活
            num--;
            System.out.println(Thread.currentThread().getName()+"\t"+num);
            // 通知
            condition.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            // 解锁
            lock.unlock();
        }
    }

}

精确通知顺序访问 Condition

在这里插入图片描述

package com.coding.demo02;

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

/**
 *  多个线程启动  A -- B -- C
 *  三个线程依次打印
 *  A  5次
 *  B  10次
 *  C  15次
 *  依次循环
 *
 *  精确通知线程消费
 */
public class C {

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

        // 线程操作资源类
        new Thread(()->{
            for (int i = 1; i <= 10; i++) {
                data.print5();
            }
        },"A").start();

        new Thread(()->{
            for (int i = 1; i <= 10; i++) {
                data.print10();
            }
        },"B").start();

        new Thread(()->{
            for (int i = 1; i <= 10; i++) {
                data.print15();
            }
        },"C").start();

    }

}


// 资源类  属性，方法
class Data3{
    private int num = 1; // A1   B2   C3
    // 定义锁
    Lock lock = new ReentrantLock();
    private Condition condition1 = lock.newCondition(); //3个判断，交替执行 A--B--C--A
    private Condition condition2 = lock.newCondition(); //3个判断，交替执行 A--B--C--A
    private Condition condition3 = lock.newCondition(); //3个判断，交替执行 A--B--C--A

    // 3个方法、作业，合3为1
    // +1
    public void print5(){
        // 加锁
        lock.lock();
        try {
            //判断
            while (num!=1){
                condition1.await(); //等待
            }
            // 干活
            for (int i = 1; i <=5 ; i++) {
                System.out.println(Thread.currentThread().getName()+"\t"+i);
            }

            // 第一个线程通知第二个线程，第二个线程通知第三个....  计数器
            num=2;
            // 通知第二个线程干活,指定谁干活
            condition2.signal();

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

    public void print10() {
        // 加锁
        lock.lock();
        try {
            //判断
            while (num!=2){
                condition2.await(); //等待
            }
            // 干活
            for (int i = 1; i <=10 ; i++) {
                System.out.println(Thread.currentThread().getName()+"\t"+i);
            }
            // 第一个线程通知第二个线程，第二个线程通知第三个....  计数器
            num=3;
            // 通知第二个线程干活,指定谁干活
            condition3.signal();

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

    public void print15() {
        // 加锁
        lock.lock();
        try {
            //判断
            while (num!=3){
                condition3.await(); //等待
            }
            // 干活 = 业务代码
            for (int i = 1; i <=15 ; i++) {
                System.out.println(Thread.currentThread().getName()+"\t"+i);
            }

            num=1;
            condition1.signal();

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


}
代码魔法师Sunny
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java——聊聊JUC中的锁（synchronized & Lock & ReentrantLock）
java_lujj的博客
09-12 329
这篇文章是关于锁的，是入门级别的文章，后续还会有更深入、更底层的JUC，我会慢慢更新的。。。
艾编程coding老师：JUC 并发编程 + 底层原理.pdf
03-26
JUC就是java.util .concurrent工具包的简称。这是一个处理线程的工具包，JDK 1.5开始出现的。下面一起来看看它怎么使用。
JUC回顾之-ArrayBlockingQueue底层实现和原理
aodaidi6752的博客
10-24 205
ArrayBlockingQueue的原理和底层实现的数据结构： ArrayBlockingQueue是数组实现的线程安全的有界的阻塞队列，可以按照FIFO（先进先出）原则对元素进行排序。 线程安全是指，ArrayBlockingQueue内部通过“互斥锁”保护竞争资源，实现了多线程对竞争资源的互斥访问。而有界，则是指ArrayBlockingQueue对应的数组是有界限的。 ...
详解JUC之锁——Lock与AQS（02）
腹黑大壁花
05-11 1631
前言在详解JUC之锁——概述（01）中我对JUC中的锁进行了概述，下面我就介绍一下它们的根基Lock接口和AQS类Lock看名字就知道Lock接口就是JUC中锁的顶级接口，支持语义不同的锁规则，比如说公平锁和非公平锁，独占锁（也可以叫互斥锁）和共享锁等。它最主要的两个方法就是lock()和unlock()，一看就知道是获取锁和释放锁。还有一个比较有趣的方法是boolean tryLock(long
JUC与锁——精华篇
weixin_50545075的博客
08-19 208
Java的juc包与锁
JUC并发编程——锁
weixin_39555954的博客
12-30 588
锁
尚硅谷大厂必备技术之JUC并发编程基础视频 配套资料（自己根据视频整理课件，和代码）
09-23
【尚硅谷】大厂必备技术之JUC并发编程视频 配套资料，自己根据视频整理 pdf 课件，和代码 视频地址：...
JUC并发编程视频教程
11-28
* 颠覆一些你以为"正确"的认知，纠正其它同类视频的错误* 100+ 张手绘图 & 流程图，帮助你形成正确的"多线程世界观"* 以知识点为主线、穿插讲解"应用"，"原理"和"多线程设计模式"，多维度学懂并发主讲内容第一章：...
Java后端开发，JUC并发编程Java后端开发，JUC并发编程
最新发布
04-14
Java后端开发，JUC并发编程Java后端开发，JUC并发编程Java后端开发，JUC并发编程Java后端开发，JUC并发编程Java后端开发，JUC并发编程Java后端开发，JUC并发编程Java后端开发，JUC并发编程Java后端开发，JUC并发编程...
juc并发编程脑图以及相关示例代码
07-30
juc并发编程脑图以及相关示例代码
JUC相关知识和底层实现原理分析.jpg
09-02
JUC底层实现原理分析，结构多线程更加贯彻同步知识
JUC —— Lock锁
weixin_46540606的博客
02-07 341
真正的多线程(公司)开发，不会去创建一个类，用该类去继承Thread类或实现Runnable接口，线程就是一个单独的资源类，没有任何附属的操作！ Synchronized传统锁 public class SynchronizedTest { public static void main(String[] args) { //创建资源类 Ticket ticket = new Ticket(); //函数式接口使用lambda表达式 n
JUC下的锁
qq_51263139的博客
05-03 472
在java.util.concurrent.* JUC包，现代写Java并发编程使用这个包下提供的工具。 java.util.concurrent.locks
JUC核心底层实现分析
qq_31142237的博客
09-02 113
java juc底层核心实现分析
JUC之各种锁
Y_Ace的博客
04-15 572
公平锁和非公平锁 回头看一下之前的一个多线程买票案例 public class LockSaleTicket { public static void main(String[] args) { LockTicket lockTicket = new LockTicket(); new Thread(()->{ for (int i = 0; i < 20; i++) { lockTicket.sal
jdk源码解析(juc)的锁-java中的锁ReetrentLock
牧码人博客@luckyhe.com
12-04 564
《jdk源码解析(juc)的锁-java中的锁ReetrentLock》首发橙寂博客转发请加此提示 jdk源码解析(juc)的锁-java中的锁ReetrentLock Lock接口 Lock接口出现之前，java是通过synchronized关键字实现的锁功能，javase5之后，并发包新增了Lock接口 Lock使用方式，和分布式锁的构造很像。 Lock lock = new Reentran...
并发编程系列（八）—初识JUC锁和AQS
牧码心
04-26 421
大家好，牧码心今天给大家推荐一篇并发编程系列（八）—初识JUC锁和AQS的文章，希望对你有所帮助。内容如下: - 概要 - JUC锁框架 - AQS概要 - AQS方法 - AQS原理
JUC并发编程——线程池介绍和底层实现
万里顾一程的博客
09-20 157
文章目录JUC并发编程——线程池底层实现1、线程池介绍2、线程池的简单使用3、线程池底层实现3.1、三大方法源码分析3.2、七大参数3.3、四大拒绝策略4、自定义创建线程池 JUC并发编程——线程池底层实现 1、线程池介绍 池化技术 池化技术是一种很常见的编程技巧，在请求量大时能明显优化应用性能，降低系统频繁建连的资源开销。我们日常工作中常见的有数据库连接池、线程池、对象池等，它们的特点都是将 “昂贵的”、“费时的” 的资源维护在一个特定的 “池子” 中，规定其最小连接数、最大连接数、阻塞队列等配置，方
JUC之 底层核心AQS
world6的博客
07-23 816
AQS，AbstractQueuedSynchronizer，即队列同步器。它是构建锁或者其他同步组件的基础框架（如ReentrantLock、ReentrantReadWriteLock、Semaphore等）   AQS使用一个int类型的成员变量state来表示同步状态，当state&gt;0时表示已经获取了锁，当state = 0时表示释放了锁。它提供了三个方法（getState()、...
狂神说java-juc并发编程
09-23
JUC是Java中用于处理并发编程的三个包之一，它包含了一系列的并发工具类和线程安全的集合类。其中，java.util.concurrent.atomic包提供了一些原子性操作的类，可以保证线程安全地对变量进行操作；java.util....

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值