JUC-1

最新推荐文章于 2024-08-27 15:54:39 发布
最新推荐文章于 2024-08-27 15:54:39 发布
阅读量402 收藏
点赞数
文章标签： java java-ee 经验分享
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/niwad/article/details/124545991
版权

JUC

1.什么是JUC

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IdYmYlNV-1651493924824)(JUC.assets/image-20220502163559898.png)]

Java.util:java工具包

Runnable ：没有返回值.效率比calllable来看要低一点

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lq2Ko074-1651493924826)(JUC.assets/image-20220502164148520.png)]

InterfaceLock

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XhrEBkVG-1651493924826)(JUC.assets/image-20220502164214070.png)]

线程与进程

进程：程序的集合

一个进程可以包含多个线程，自少包含一个

java默认有两个线程，main、GC

线程：代码的集合

java线程：Thread、Runnable、callable

java真的可以开启线程嘛？不可以

最终是一个native方法，调用底层的C++，java无法直接操作硬件

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-C2V6dYuH-1651493924827)(JUC.assets/image-20220502165025736.png)]

并发、并行

并发：多线程操作同一个资源，间歇性

并行：多个线程一起走；线程池

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

并发的本质：充分利用cpu资源

2.多线程

线程几个状态

NEW,//新建
RUNNABLE,//运行
BLOCKED,//组塞
WAITING,//等待
TIMED_WAITING,//超时等待
TERMINATED;//终止

wait/sleep区别

来自不同类

wait=>Object

sleep=>Thread

锁的释放不一样

wait释放

sleep抱着锁睡觉不释放

使用范围不一样

wait要在同步代码块

sleep可以在任何地方

是否捕获异常

wait不需要

sleep一定要

3.LOCK锁

传统Synchronize

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rRhOlitG-1651493924827)(JUC.assets/image-20220502172232364.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eoVP8exY-1651493924828)(JUC.assets/image-20220502172352328.png)]

公平锁与非公平锁

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rNbtbplX-1651493924828)(JUC.assets/image-20220502182717222.png)]

公平锁：先来后到

非公平锁：可以插队

默认为非公平锁

Synchronize与LOCK区别

  1. Synchronize是内置的一个关键字，lock是一个java类
  2. Synchronize无法获取锁的状态，lock可以判断是否获取到了锁
  3. Synchronize会自动释放锁，lock必须要手动释放，如果不释放就成为了死锁
  4. Synchronize线程1（获得锁，阻塞）、线程2（等待，傻等）；lock不会一直等待下去

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SpjYx9x4-1651493924829)(JUC.assets/image-20220502184148914.png)]

锁是什么

生产者和消费者问题

package com.shiyi.produnctCons;

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

public class SaleTicketDemo02  {

  public static void main(String[] args) {
    final Ticket2 ticket = new Ticket2();

    new Thread(()->{
      for (int i = 0; i < 40; i++) {
        ticket.sale();
      }
    },"A").start();
    new Thread(()->{
      for (int i = 0; i < 40; i++) {
        ticket.sale();
      }
    },"B").start();
    new Thread(()->{
      for (int i = 0; i < 40; i++) {
        ticket.sale();
      }
    },"C").start();
  }
}
// 资源类 OOP 属性、方法
class Ticket2 {

  private int number = 30;
  Lock lock=new ReentrantLock();
  //卖票的方式
  public  void sale() {
    lock.lock();

    try {
      if (number > 0) {
        System.out.println(Thread.currentThread().getName() + "卖出了第" + (number--) + "张票剩余" + number + "张票");
      }
    } catch (Exception e) {
      e.printStackTrace();
    } finally {
      lock.unlock();
    }
  }
}

存在问题

package com.shiyi.produnctCons;

/*
线程之间的通信问题：生产者和消费者问题
线程交替执行 A B操作同一个变量 num=0 A让num+1，B让num-1;
 **/
public class ConsumeAndProduct {
  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();
  
  
    new Thread(() -> {
      for (int i = 0; i < 10; i++) {
        try {
          data.increment();
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
      }
    }, "C").start();
    new Thread(() -> {
      for (int i = 0; i < 10; i++) {
        try {
          data.decrement();
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
      }
    }, "D").start();
  }
}

class Data {
  private int num = 0;

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

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WXEMUudK-1651493924829)(JUC.assets/image-20220502191806639.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BCruekuq-1651493924830)(JUC.assets/image-20220502191813533.png)]

如何解决虚假唤醒问题，使用while进行判断

package com.shiyi.produnctCons;

/*
线程之间的通信问题：生产者和消费者问题
线程交替执行 A B操作同一个变量 num=0 A让num+1，B让num-1;
 **/
public class ConsumeAndProduct {
  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();
  
  
    new Thread(() -> {
      for (int i = 0; i < 10; i++) {
        try {
          data.increment();
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
      }
    }, "C").start();
    new Thread(() -> {
      for (int i = 0; i < 10; i++) {
        try {
          data.decrement();
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
      }
    }, "D").start();
  }
}

class Data {
  private int num = 0;

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

  // -1
  public synchronized void decrement() throws InterruptedException {
    // 判断等待
    while (num == 0) {
      this.wait();
    }
    num--;
    System.out.println(Thread.currentThread().getName() + "=>" + num);
    // 通知其他线程 -1 执行完毕
    this.notifyAll();
  }
}
十弌
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
juc-1(2).docx
03-29
1) 线程间的调用顺序不可预知，需要通过同步机制来控制。 2) 示例代码展示了两个线程交替对共享数据进行加减操作，使用 `synchronized` 关键字保证原子性和互斥访问，配合 `wait()` 和 `notifyAll()` 进行线程间的...
JUC-master
03-21
《JUC：Java并发编程的艺术》 在Java世界中，JUC（Java Util Concurrency）是并发编程的核心库，它提供了丰富的...通过深入学习JUC-master项目，我们可以更深入地理解Java并发编程的原理和实践，提升我们的编程技能。
heima-JUC-资料
04-25
1. **线程池**：Java通过`ExecutorService`和相关的实现（如`ThreadPoolExecutor`）提供了线程池的概念。线程池可以有效管理多个线程，避免频繁创建和销毁线程带来的开销，同时可以控制并发执行的任务数量，提高系统...
tuling-juc-final.zip
05-23
本项目"tuling-juc-final.zip"显然聚焦于Java并发编程的实践，通过一系列代码示例来演示和解释Java内存模型（JMM）、`synchronized`关键字以及`volatile`关键字的使用。下面我们将深入探讨这些核心概念。 Java内存...
个人学习-JUC-笔记
02-25
1. **并发基础** - **线程与进程**：线程是程序执行的最小单位，进程则是资源分配的基本单位。了解它们的区别与联系，是理解并发的基础。 - **同步与异步**：同步确保操作顺序，异步则强调并行处理。在Java中，...
阿里云服务器 篇七：服务器热备份/定时备份
生活在别处
08-24 732
Python 客户端用于百度云（个人云存储）百度云/百度网盘 Python 客户端。它主要用于在 Linux 环境下通过命令行操作百度云盘的 2TB 存储空间。是一个Github开源项目，这是一个百度云/百度网盘Python客户端。: 列出百度 PCS 中的 ‘remotepath’ 目录。: 从本地目录同步到远程目录。: 在百度云中创建一个目录。
启动Application 报错：no mapping for GET /（已解决）
qq_3512323979的博客
08-26 753
no mapping for GET /因为我使用的是框架嘛，然后生成了一个SpringBoot项目后，resources下面就会有一个static的类，用于存放静态资源类，后面我把静态资源放在里面，但是启动启动类后，报错一直匹配不到。： 正常的话，我们使用SpringBoot框架，他会给我们提供许多便利，包括静态资源的自动服务，默认的话，他会去。报这个错可能还有其他原因，我的是因为这个，大家可以根据日志信息一步步检查，肯定可以解决的！类并覆盖其方法时，就会失去静态资源的自动服务
开发多线程程序时，需要注意那些问题
OO_SEN的博客
08-23 1169
线程安全 竞态条件（Race Condition）：当多个线程同时访问和修改共享资源时，可能会出现竞态条件，导致不确定的行为。需要通过同步机制（如互斥锁、读写锁、原子操作）来保护共享资源。 死锁（Deadlock）：当两个或多个线程相互等待对方释放锁时，程序会陷入死锁状态。避免死锁的一些策略包括：避免嵌套锁、确保加锁顺序一致、使用超时机制等。 活锁（Livelock）：与死锁不同，活锁是指线程不断地尝试获取资源但总是失败，导致无法继续执行。避免频繁重试操作或使用退避算法可以减少活锁的发生。 优先级反转（P
笔记redis
风止的博客
08-22 1695
Redis（Remote Dictionary Server）是用C语言开发的一个基于的数据库。
linux上datax 安装以及使用
寂夜了无痕的博客
08-24 1508
linux上datax 安装以及使用
基于jenkins部署maven项目
静水深流
08-26 619
如上所示，构建后，我们处于项目的根目录之下，可以进行后续的操作，如启动target目录下的jar包、将jar包传输到需要部署的服务器上、打docker镜像bing上传等等，需要根据实际情况进行选择，而这些都可以在“Add post-build step”选项中进行选择。我们主要关注上述几个部分，在General部分，可以对项目进行一个简单的描述，源码管理部分，需要配置对应的源码url，如下图所示。如上所示，选择“构建一个maven项目”，如果没有改选项，则需要安装maven构建的插件，请参考之前的文章。
@Transactional中使用线程锁导致了锁失效与解决方案
liuruiaaa的博客
08-23 1036
@Transactional中使用线程锁导致了锁失效与解决方案
Java学习_18_Stream流
qq_41136689的博客
08-23 1460
博客仅记录个人学习进度和一些查缺补漏。学习内容：BV17F411T7Ao流的出现让数据处理从几十行代码缩减到一两行就能实现，简化了很多集合数组的操作。
JavaScript 错误 - Throw 和 Try to Catch的使用
逆风优雅的博客
08-23 372
trycatchthrow上面的代码 因为 try中 没有adddlert这个方法，或者这个方法有误，这时，代码会执行catch部分。JavaScript 实际上会创建带有两个属性的Error 对象name和message。
Java面试宝典-java基础02
最新发布
杜盟恩的博客
08-27 130
机器语言是一种指令集的体系，是最早出现的计算机语言。机器语言从属于硬件设备。不同的计算机设备有不同的机器语言．所以机器语言是一种面向机器的语言。计算机指令系统中的指令是由“0”和“1”两种符号组成的代码，并且能被机器直接理解执行，它们被称为机器指令。一个计算机的机器指令的集，就构成了该计算机的机器语言，即计算机可以直接接受、理解的语言。机器语言能利用机器指令精准地描述算法、且编程质量高、所占存储空间小，执行速度快。但是这种程序直观性很差，容易出错，阅读检查和修改调试非常困难。
Java 入门指南：Java IO 模型
Zachyy的博客
08-26 917
Java中的 IO（Input/Output）模型是管理计算机与外部设备（如磁盘、网络等）之间数据交换的重要机制。它定义了数据如何在应用程序和操作系统之间流动，以及如何处理这些流动过程中的阻塞、非阻塞、同步和异步等问题。Java中常见的IO模型包括 BIO（Blocking I/O，阻塞IO）、NIO（Non-Blocking I/O，非阻塞IO）、AIO（Asynchronous I/O，异步IO）等。
Java中自定义注解的使用
echola_mendes的博客
08-22 1238
以【记录操作日志】为例，一般在开发中为了记录用户操作，当系统出现问题时，可以追溯日志所提供详细的错误信息，帮助开发者快速定位问题的原因最简单的方法：在每个方法中增加日志信息打印代码，来记录操作日志，但是这样重复代码也很多，也不易扩展，而且易出错使用自定义注解就会方便很多，减少不必要的重复代码，减少非业务代码的侵入性，如果需要扩展操作用户的信息以及IP就会很方便，易于扩展和维护@interface在需要使用自定义注解的地方使用该注解@LogOperation("新增")// 方法实现。
Java中的深克隆与浅克隆
qq_42798343的博客
08-27 781
浅克隆：复制对象时不复制引用对象的内容，克隆对象和原对象共享引用对象。深克隆：复制对象时也复制引用对象的内容，克隆对象和原对象完全独立。实现深克隆的方式：重写clone()方法、使用序列化、使用第三方库（如Apache Commons Lang）、使用JSON序列化。了解深克隆和浅克隆的区别，并根据实际需要选择合适的克隆方式，可以帮助开发者更好地管理对象的复制和状态。希望这篇博客能够帮助你更好地理解Java中的深克隆和浅克隆！
第一讲__提炼
I am the light coursing in the soul of the moon.
08-26 646
定义：有static修饰的变量是类变量访问方式：类名.变量名注意：类变量只在类加载时加载一次。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值