JUC并发编程

最新推荐文章于 2023-07-10 16:45:52 发布
最新推荐文章于 2023-07-10 16:45:52 发布
阅读量78 收藏
点赞数
文章标签： 并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/satandyg/article/details/113609363
版权

JUC并发编程

目录

1. 什么是JUC

	源码+官方文档 
	java.util.concurrent 
	java.util.concurrent.atomic 
	java.util.concurrent.locks

业务：普通的线程代码 Thread
Runnable没有返回值，效率相比Callable相对较低

2.线程和进程

线程，进程，如果不能用一句话说出来的技术，不扎实！

进程：一个程序。QQ.exe  Music.exe 程序的集合
一个进程往往可以包含对个线程，至少包含一个。

Java默认有几个线程？2个 main 和GC

线程：开了一个进程QQ，发送消息（线程负责）
对于Java而言：Thread Runnable  Callable

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 */
            }
        }
    }
//native 修饰是C++写的本地方法，java不能调硬件方面的，因为是运行在虚拟机上的。    
private native void start0();

native 修饰是C++写的本地方法，java不能调硬件方面的，因为是运行在虚拟机上的。

并发与并行的区别

  • 1、并发（Concurrent）：指两个或多个事件在同一时间间隔内发生，即交替做不同事的能力，多线程是并发的一种形式。例如垃圾回收时，用户线程与垃圾收集线程同时执行（但不一定是并行的，可能会交替执行），用户程序在继续运行，而垃圾收集程序运行于另一个CPU上。

  • 2、并行（Parallel）：指两个或者多个事件在同一时刻发生，即同时做不同事的能力。例如垃圾回收时，多条垃圾收集线程并行工作，但此时用户线程仍然处于等待状态。

package com.zbk.demo01;

public class Test1 {
    public static void main(String[] args) {
        //获取CPU的核数
        //CPU 密集型, IO 密集型
        System.out.println(Runtime.getRuntime().availableProcessors());
    }
}

并发编程的本质:充分利用CPU的资源

线程有几个状态

public enum State {
       //新生
        NEW,

       //运行
        RUNNABLE,

       //阻塞
        BLOCKED,

        //等待  死死的等
        WAITING,

        //超时等待
        TIMED_WAITING,

       //终止
        TERMINATED;
    }

wait与sleep区别

  1. 来自不同的类
    wait => Object
    sleep => Thread
  2. 关于锁的释放
    wait会释放锁
    sleep不会释放锁
  3. 使用的范围是不同的
    wait 必须在同步代码快中
    sleep 可以在任何地方睡

3. Lock锁(重点)

synchronized

package com.zbk.demo01;

//基本的卖票例子

/**
 * 真正的多线程开发,公司中的开发
 * 线程就是一个单独的资源类,没有任何的附属操作
 * 1.属性,方法
 */
public class SaleTicketDemo01 {
    public static void main(String[] args) {
        //并发:  多线程操作同一个资源类
        Ticket ticket = new Ticket();
        new Thread(() -> {
            for (int i = 1; i <= 30; i++) {
                ticket.sale();
            }
        }, "A").start();
        new Thread(() -> {
            for (int i = 1; i <= 30; i++) {
                ticket.sale();
            }
        }, "B").start();
        new Thread(() -> {
            for (int i = 1; i <= 30; i++) {
                ticket.sale();
            }
        }, "C").start();

    }
}

//资源类 OOP
class Ticket {
    //属性 方法
    private int number = 20;

    //卖票的方式
    //synchronized   本质:队列 锁
    public synchronized void sale() {
        if (number > 0) {
            number--;
            System.out.println("剩余:" + number);
        }
    }
}

Lock 接口

所有已知实现类： 
ReentrantLock， 可重入锁(常用)
ReentrantReadWriteLock.ReadLock    读锁
ReentrantReadWriteLock.WriteLock    写锁

package com.zbk.demo01;

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

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

//lock三步曲
//1.new ReentrantLock();
//2.lock();//加锁
//3.finally  => unlock();//解锁
class Ticket2 {
    //属性 方法
    private int number = 20;

    Lock lock = new ReentrantLock();

    public  void sale() {
        lock.lock();//加锁
        try {
            if (number > 0) {
                number--;
                System.out.println("剩余:" + number);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();//解锁
        }
    }
}

在这里插入图片描述
公平锁:十分公平 可以先来后到
非公平锁:十分不公平, 可以插队(默认)

synchronized与Lock区别

  1. synchronized 内置的Java关键字, Lock是一个Java类
  2. synchronized 无法判断获取锁的状态,Lock可以判断是否获取了锁
  3. synchronized 会自动释放锁,Lock锁必须手动释放锁!如果不释放锁,可能发生死锁
  4. synchronized 线程1:(获得锁 ,阻塞)线程2:(等待,傻傻的等);Lock锁就不一定会等待下去(tryLock);
  5. synchronized 可重入锁,不可以中断,非公平;Lock 可重入锁,可以判断锁,非公平(可以自己设置)
  6. synchronized 适合锁少量的代码同步问题,Lock适合锁大量的同步代码

锁是什么,如何判断锁的是谁!

4.生产者和消费者问题

生产者和消费者问题 synchronized版

package com.zbk.pc;

/**
 * 线程之间的通信问题 : 生产者和消费者问题
 * 线程交替执行  Produce Consumer 操作同一个变量  num = 0
 * Produce num+1
 * Consumer num-1
 */
public class Syn {
    public static void main(String[] args) {
        Food food = new Food();
        new Thread(()->{for(int i=0;i<10;i++) {
            try {
                food.increment();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        },"生产者").start();

        new Thread(()->{for(int i=0;i<10;i++) {
            try {
                food.decrement();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        },"消费者").start();
    }

}
//判断等待 业务 通知
class Food {
    private int number = 0;

    public synchronized void increment() throws InterruptedException {
        if(number!=0){
            //等待
            this.wait();
        }
        number++;
        System.out.println(Thread.currentThread().getName()+"==>"+number);
        //通知其他线程,我+1完毕了
        this.notifyAll();
    }

    public synchronized void decrement() throws InterruptedException {
        if(number==0){
            //等待
            this.wait();
        }
        number--;
        System.out.println(Thread.currentThread().getName()+"==>"+number);
        //通知其他线程,我+1完毕了
        this.notifyAll();
    }
}


生产者==>1
消费者==>0
生产者==>1
消费者==>0
生产者==>1
消费者==>0
.........

问题存在,A B C D 等多个线程! 虚假唤醒

在这里插入图片描述
解决方法: if 改为 while

package com.zbk.pc;

/**
 * 线程之间的通信问题 : 生产者和消费者问题
 * 线程交替执行  Produce Consumer 操作同一个变量  num = 0
 * Produce num+1
 * Consumer num-1
 */
public class Syn {
    public static void main(String[] args) {
        Food food = new Food();
        new Thread(()->{for(int i=0;i<10;i++) {
            try {
                food.increment();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        },"A").start();

        new Thread(()->{for(int i=0;i<10;i++) {
            try {
                food.decrement();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        },"B").start();
        new Thread(()->{for(int i=0;i<10;i++) {
            try {
                food.decrement();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        },"C").start();
        new Thread(()->{for(int i=0;i<10;i++) {
            try {
                food.increment();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        },"D").start();
    }

}
//判断等待 业务 通知
class Food {
    private int number = 0;

    public synchronized void increment() throws InterruptedException {
        while(number!=0){
            //等待
            this.wait();
        }
        number++;
        System.out.println(Thread.currentThread().getName()+"==>"+number);
        //通知其他线程,我+1完毕了
        this.notifyAll();
    }

    public synchronized void decrement() throws InterruptedException {
        while(number==0){
            //等待
            this.wait();
        }
        number--;
        System.out.println(Thread.currentThread().getName()+"==>"+number);
        //通知其他线程,我+1完毕了
        this.notifyAll();
    }
}

生产者消费者问题 JUC版

在这里插入图片描述

package com.zbk.pc;

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

/**
 * 线程之间的通信问题 : 生产者和消费者问题
 * 线程交替执行  Produce Consumer 操作同一个变量  num = 0
 * Produce num+1
 * Consumer num-1
 */
public class LockPC {
    public static void main(String[] args) {
        Food1 food = new Food1();
        new Thread(()->{for(int i=0;i<10;i++) {
            try {
                food.increment();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        },"A").start();

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

}

//判断等待 业务 通知
class Food1 {
    private int number = 0;

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

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

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

Condition 精准的通知和唤醒线程

package com.zbk.pc;

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

/**
 * 线程之间的通信问题 : 生产者和消费者问题
 * 线程交替执行  Produce Consumer 操作同一个变量  num = 0
 * Produce num+1
 * Consumer num-1
 */
public class LockPC {
    public static void main(String[] args) {
        Food1 food = new Food1();
        new Thread(()->{for(int i=0;i<10;i++) {
            try {
                food.increment();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        },"A").start();

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

}

//判断等待 业务 通知
class Food1 {
    private int number = 0;

    final Lock lock = new ReentrantLock();
    final Condition produce  = lock.newCondition();
    final Condition consumer = lock.newCondition();



    public  void increment() throws InterruptedException {
        lock.lock();
        try {
            while(number!=0){
                //精准通知生产者等待
                produce.await();
            }
            number++;
            System.out.println(Thread.currentThread().getName()+"==>"+number);
            //精准唤醒消费者
            consumer.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public  void decrement() throws InterruptedException {
        lock.lock();
        try {
            while(number==0){
                //精准通知消费者等待
                consumer.await();
            }
            number--;
            System.out.println(Thread.currentThread().getName()+"==>"+number);
            //精准唤醒生产者
            produce.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

5. 8锁现象

如何判断锁的是谁!
深刻理解我们的锁

8锁问题

DYG.Satan
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
juc并发编程脑图以及相关示例代码
07-30
juc并发编程脑图以及相关示例代码
尚硅谷大厂必备技术之JUC并发编程基础视频 配套资料（自己根据视频整理课件，和代码）
09-23
【尚硅谷】大厂必备技术之JUC并发编程视频 配套资料，自己根据视频整理 pdf 课件，和代码 视频地址：...
JUC 并发编程
m0_53067943的博客
07-10 1025
主要对于juc的知识点总结
周阳老师JUC并发编程
qq_44300280的博客
11-16 5461
周阳老师JUC并发编程
JUC并发编程详解
yyhgo_的博客
12-13 478
JUC并发编程详解
JUC并发编程超详细详解篇
热门推荐
白大锅的博客，毕设WangLoveBai_999
12-15 7万+
文章目录前言一、JUC并发编程简介及准备1.1.本系列讲解思路1.2.知识储备1.3.用到的依赖1.4.logback.xml 配置二、进程与线程2.1.进程与线程2.1.1.进程2.1.2.线程2.1.3.对比2.2.并行与并发2.2.1.两者区别直观解释2.3.应用2.3.1. 应用之异步调用（案例1）2.3.2.应用之提高效率（案例1）三、Java 线程3.1.本节主讲内容3.2.创建和运行线程3.2.1.方法一，直接使用 Thread3.2.2.方法二，使用 Runnable 配合 Thread3.
JUC 并发编程学习笔记（总）
Java技术一点通
10-19 2304
JUC指的就是工具包的简称，里面的工具类可以很方便的实现多线程的开发。java.util工具包、包、分类。业务：普通的线程代码 Thread。Runnable没有返回值、效率相比Callable相对较低！
JUC并发编程面试题
weixin_45081813的博客
04-06 2519
文章目录1. 并行和并发有什么区别？2. 线程和进程的基本概念、线程的基本状态以及状态之间的关系？3.守护线程是什么？4.创建线程有哪几种方式？5. sleep() 和 wait() 有什么区别？6.线程的 run() 和 start() 有什么区别？7.创建线程池有哪几种方式？8.在 Java 程序中怎么保证多线程的运行安全？9.什么是死锁？怎么防止死锁？10.synchronized 和 volatile 的区别是什么？11.synchronized 和 Lock 有什么区别？12.synchroniz
JUC(并发编程)
abc98526的博客
04-17 1万+
1.什么是JUC? JUC是指javaUtil包中的三个操作线程的包! 2.线程进程和程序 程序(Program):是一个静态的概念，一般对应于操作系统中的一个可执行的文件 ，比如：我们要启动酷狗听音乐，则对应酷狗可执行程序。当我们双击酷狗，则加载 程序到内存中，开始执行该程序，于是产生了"进程". 进程:执行中的程序叫做进程(Process),是一个动态的概念。现代的操作系统都可以同时启动多个进程。比如:我们在用酷狗听音乐，也可以使用wps写文档，也可以同时用浏览器查看网页。可以通过
【JUC并发编程】
蛋饼吧的博客
06-19 969
JUC是Java Util Concurrent的缩写,是Java SE 5.0中新增的一个包,主要提供了在并发编程中使用的工具类和框架。JUC包含了许多用于多线程编程的工具类和接口,如锁、原子变量、线程池、阻塞队列等。这些工具类和接口可以帮助开发者更方便地进行多线程编程,从而提高程序的并发性能和可靠性。JUC包中的工具类和接口都是线程安全的,可以在多线程环境下安全地使用。它们的设计和实现都是基于并发编程的最佳实践和原则,可以有效地避免线程安全问题的发生。
juc并发编程学习笔记下(尚硅谷)
noob9527的博客
10-13 465
5 多线程锁 5.1锁的八个问题演示 class Phone { public static synchronized void sendSMS() throws Exception { //停留4秒 TimeUnit.SECONDS.sleep(4); System.out.println("------sendSMS"); } public synchronized void sendEmail() throw
Java后端开发，JUC并发编程Java后端开发，JUC并发编程
04-14
Java后端开发，JUC并发编程Java后端开发，JUC并发编程Java后端开发，JUC并发编程Java后端开发，JUC并发编程Java后端开发，JUC并发编程Java后端开发，JUC并发编程Java后端开发，JUC并发编程Java后端开发，JUC并发编程...
根据尚硅谷JUC并发编程（对标阿里P6-P7）视频自己整理的pdf文档
09-21
1、根据尚硅谷JUC并发编程（对标阿里P6-P7）视频自己整理的pdf文档 2、包含源码 视频地址：https://www.bilibili.com/video/BV1ar4y1x727/?p=1&vd_source=c634d163b940964d44747b4c3976117b 参考资料：...
JUC并发编程.rar
12-14
"JUC并发编程.rar"这个压缩包文件包含了关于并发编程的相关案例源码和详细讲解，旨在帮助初学者和经验丰富的开发者深入理解并发编程的核心概念和技术。 首先，让我们来看看并发编程的基本概念。并发是指在一段时间...
JUC并发编程与源码分析视频课.zip
12-16
《JUC并发编程与源码分析视频课》是一门深入探讨Java并发编程的课程，主要聚焦于Java Util Concurrency（JUC）库的使用和源码解析。JUC是Java平台提供的一组高级并发工具包，它极大地简化了多线程编程，并提供了更...
JUC并发编程视频教程
11-28
* 颠覆一些你以为"正确"的认知，纠正其它同类视频的错误* 100+ 张手绘图 & 流程图，帮助你形成正确的"多线程世界观"* 以知识点为主线、穿插讲解"应用"，"原理"和"多线程设计模式"，多维度学懂并发主讲内容第一章：...
JUC并发编程.md
01-28
### JUC并发编程知识点 #### 一、JUC并发编程简介 JUC（Java Util Concurrency）是Java标准库中的一个子包，提供了一系列高级并发工具类和接口，旨在简化多线程编程的复杂性。它包括了各种锁机制、线程池、信号量...
juc并发编程线程池
最新发布
06-18
线程池是并发编程中常用的一种机制，它允许您预先创建一组线程，并在需要执行任务时重用这些线程，从而提高性能和资源管理。 `Executors`类提供了一些预定义的线程池工厂方法，如`newFixedThreadPool()`, `...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值