JUC并发学习（一）

最新推荐文章于 2024-06-13 19:05:17 发布
最新推荐文章于 2024-06-13 19:05:17 发布
阅读量175 收藏
点赞数
分类专栏： JUC学习 文章标签： 多线程 java 并发编程 面试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qaq1314520/article/details/109476636
版权

目录

         1.学习前的环境配置

2.开始学习

  1.线程与进程

  2.并发和并行

  3.线程有几个状态？

  4.wait和sleep的区别？

  5.生产者和消费者

synchronized版本

Lock版本

 Condition可以精准通知唤醒

  6.锁是什么？

八锁现象：锁的八个问题

  7.LOCK锁     

synchronized传统

LOCK接口

1.学习前的环境配置

Project Structure一般在idea的右上角；（自己找一下）

Setting配置

2.开始学习

  1.线程与进程

进程是一个程序启动时出现的，一个进程包含多个线程，至少包含一个线程。

java默认2个线程（mian 和GC）

  2.并发和并行

并发（多线程操作同一个线程）（单核cpu快速交替，模拟多个线程，cpu多核可以多线程）

public class test1 {
    public static void main(String[] args) {
        //获得cpu的核数
        System.out.println(Runtime.getRuntime().availableProcessors());
        //cpu密集型  io密集型
    }
}

并行（多个程序同时进行）

本质：充分利用CPU的资源

  3.线程有几个状态？

状态：6个：新生（NEW）——》运行（RUNABLE）——》阻塞（BLOCKED）——》等待(WAITING)——》

超时等待（TIME_WAITING）——》终止（TIRMINATED）

4.wait和sleep的区别？

  1. 来自不同的类（wait——object，sleep——Thread）。
  2. 锁的释放：wait会释放锁，sleep不会释放锁。
  3. 使用范围不同：wait必须在同步代码块中，sleep可以在任何地方。
  4. 捕获异常：wait不需要异常，sleep必须要捕获异常。

5.生产者和消费者

synchronized版本

/*
线程之间的交替问题：生产者与消费者
A:num+1——》B;num-1;
等待唤醒，通知唤醒。
 */
public class test4 {
    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 num=0;
    //increment 增加
    public synchronized void  increment() throws InterruptedException {
        if (num!=0){
            this.wait();
        }
        //业务
        num++;
        System.out.println(Thread.currentThread().getName()+"=>"+num);
        //通知其他线程
        this.notify();
    }
    //decrement 减少
    public synchronized void  decrement() throws InterruptedException {
        if (num==0){
            this.wait();
        }
        //业务
        num--;
        System.out.println(Thread.currentThread().getName()+"=>"+num);
        //通知其他线程
        this.notify();
    }
}

问题：A,B两个线程可以，但加入出C,D线程后无法进行，

分析错误：

使用if判断时，唤醒后线程从wait之后的代码执行，但不会重新判断if条件。

原因:线程可以被唤醒，而不会被通知，中断，超时，即所谓的虚假唤醒。一般的等待会出现在循环中。

解决方法：while（true）{wait（）；}将if换成while，当wait之后代码运行，唤醒后会继续判断while中的条件，不成立执行while下面的代码块，成立继续执行wait（）； 

class Data{
    private int num=0;
    //increment 增加
    public synchronized void  increment() throws InterruptedException {
        while (num!=0){
            this.wait();
        }
        //业务
        num++;
        System.out.println(Thread.currentThread().getName()+"=>"+num);
        //通知其他线程
        this.notify();
    }
    //decrement 减少
    public synchronized void  decrement() throws InterruptedException {
        while (num==0){
            this.wait();
        }
        //业务
        num--;
        System.out.println(Thread.currentThread().getName()+"=>"+num);
        //通知其他线程
        this.notify();
    }
}

 

 

Lock版本

package com.zyf.juc;

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

public class test5 {
    public static void main(String[] args) {
        Data2 data=new Data2();
        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 Data2 {
    private int num = 0;

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


    //increment 增加
    public  void increment() throws InterruptedException {

        try {
            lock.lock();
            while (num != 0) {
                //await()等待
                condition.await();
            }
            //业务
            num++;
            System.out.println(Thread.currentThread().getName() + "=>" + num);
            //通知其他线程
            //signalAll()唤醒全部
            condition.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }

    }

    //decrement 减少
    public  void  decrement() throws InterruptedException {

        try {
            lock.lock();
            while (num == 0) {
                condition.await();
            }
            //业务
            num--;
            System.out.println(Thread.currentThread().getName() + "=>" + num);
            //通知其他线程
            condition.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }

    }
}

 Condition可以精准通知唤醒

例：A,B,C线程依次执行

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

public class test6 {
    public static void main(String[] args) {
        Data3 data3=new Data3();
        new Thread(()->{
            for (int i = 0; i <10 ; i++) {
                try {
                    data3.processA();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();
        new Thread(()->{
            for (int i = 0; i <10 ; i++) {
                try {
                    data3.processB();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"B").start();
        new Thread(()->{
            for (int i = 0; i <10 ; i++) {
                try {
                    data3.processC();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"C").start();
    }
}
class Data3{

    private Lock lock=new ReentrantLock();
    private Condition condition1=lock.newCondition();
    private Condition condition2=lock.newCondition();
    private Condition condition3=lock.newCondition();
    private int num=1;

    public  void processA() throws InterruptedException {
        try {
            lock.lock();
           while (num!=1){
               condition1.await();
           }
           System.out.println(Thread.currentThread().getName() + "=>" + "输出A");
           num=2;
           condition2.signal();

        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }

    }
    public  void processB() throws InterruptedException {
        try {
            lock.lock();
            while (num!=2){
                condition2.await();
            }
            System.out.println(Thread.currentThread().getName() + "=>" + "输出B");
            num=3;
            condition3.signal();
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }

    }
    public  void processC() throws InterruptedException {
        try {
            lock.lock();
            while (num!=3){
                condition3.await();
            }
            System.out.println(Thread.currentThread().getName() + "=>" + "输出C");
            num=1;
            condition1.signal();
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }

    }
}

 

6.锁是什么？

八锁现象：锁的八个问题

1.标准情况下，线程执行顺序  1.发信息2.打电话。

锁的第一个问题：标准情况下，线程顺序执行

import java.util.concurrent.TimeUnit;
//1.标准情况下，线程执行顺序  1.发信息2.打电话
public class test7 {
    public static void main(String[] args) {
        Phone phone=new Phone();
        new Thread(()->{
            phone.sendMes();
        },"A").start();
        //来个睡眠  java.util.concurrent.TimeUnit;用JUC包下的,不用sleep();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{
            phone.call();
        },"B").start();
    }
}
class Phone{
    public synchronized void sendMes(){
        System.out.println("发消息");
    }
    public synchronized void call(){
        System.out.println("打电话");
    }
}

2.sendMes的方法中加一个4秒延迟，结果：1.发信息2.打电话。

线程A，B都是用的Phone同一个锁，那就是谁先拿到锁就先执行谁。

package com.zyf.juc;

import java.util.concurrent.TimeUnit;
//2.sendMes的方法中加一个4秒延迟，结果：1.发信息2.打电话
public class test7 {
    public static void main(String[] args) {
        Phone phone=new Phone();
        new Thread(()->{
            phone.sendMes();
        },"A").start();
        //来个睡眠  java.util.concurrent.TimeUnit;用JUC包下的,不用sleep();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{
            phone.call();
        },"B").start();
    }
}
class Phone{
    public synchronized void sendMes(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发消息");
    }
    public synchronized void call(){
        System.out.println("打电话");
    }
}

 

3.新增普通方法：hello()，执行sendMes方法和hello方法 结果：先执行发短信，再执行hello。

普通方法，没有锁，不是同步方法，不受锁的影响。

import java.util.concurrent.TimeUnit;
//3.新增普通方法：hello()，执行sendMes方法和hello方法 结果：先执行发短信，再执行hello
//原因：hello是普通方法，没有锁，不是同步方法，不受锁的影响。
public class test2 {
    public static void main(String[] args) {
        Phone2 phone=new Phone2();
        new Thread(()->{
            phone.sendMes();
        },"A").start();
        //来个睡眠  java.util.concurrent.TimeUnit;用JUC包下的,不用sleep();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{
            phone.hello();
        },"B").start();

    }
}
class Phone2{
    public synchronized void sendMes(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发消息");
    }
    public synchronized void call(){
        System.out.println("打电话");
    }
    public void hello(){
        System.out.println("hello");
    }
}

 

4.两个对象Phone,两个同步方法，顺序：1.打电话2.发短信

两个不同的对象，两把锁，互不影响。

import java.util.concurrent.TimeUnit;
//4.两个对象Phone,两个同步方法，顺序：1.打电话2.发短信
//原因:两个不同的对象，两把锁，发短信方法内部有4秒延迟，call方法没有延迟。
public class test2 {
    public static void main(String[] args) {
        Phone2 phone1=new Phone2();
        Phone2 phone2=new Phone2();
        new Thread(()->{
            phone1.sendMes();
        },"A").start();
        //来个睡眠  java.util.concurrent.TimeUnit;用JUC包下的,不用sleep();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{
            phone2.call();
        },"B").start();

    }
}
class Phone2{
    public synchronized void sendMes(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发消息");
    }
    public synchronized void call(){
        System.out.println("打电话");
    }
    public void hello(){
        System.out.println("hello");
    }
}

 

5.增加两个静态同步方法，同一对象，执行顺序。

synchronized 锁的对象是方法调用者， static静态方法，类一加载就有了，锁的是Class了，不是同步方法了。

import java.util.concurrent.TimeUnit;
//5.增加两个静态同步方法，同一对象，执行顺序：
//原因：synchronized 锁的对象是方法调用者， static静态方法，类一加载就有了，锁的是Class了，不是同步方法了
public class test3 {
    public static void main(String[] args) {
        Phone3 phone=new Phone3();
        new Thread(()->{
            phone.sendMes();
        },"A").start();
        //来个睡眠  java.util.concurrent.TimeUnit;用JUC包下的,不用sleep();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{
            phone.call();
        },"B").start();
    }
}
class Phone3{
    public static synchronized void sendMes(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发消息");
    }
    public static synchronized void call(){
        System.out.println("打电话");
    }
}

6.两个对象，增加两个静态同步方法，执行顺序: 1.发信息 2.打电话。

static加入后锁的就是class了，而两个对象的class就只有一个，就是class模板。

//6.两个对象，增加两个静态同步方法，执行顺序: 1.发信息 2.打电话
//原因：static加入后锁的就是class了，而两个对象的class就只有一个。
public class test3 {
    public static void main(String[] args) {
        Phone3 phone1=new Phone3();
        Phone3 phone2=new Phone3();
        new Thread(()->{
            phone1.sendMes();
        },"A").start();
        //来个睡眠  java.util.concurrent.TimeUnit;用JUC包下的,不用sleep();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{
            phone2.call();
        },"B").start();
    }
}
class Phone3{
    public static synchronized void sendMes(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发消息");
    }
    public static synchronized void call(){
        System.out.println("打电话");
    }
}

7.send是static的同步方法，call是普通的同步方法，一个对象，执行顺序：1.打电话 2.发信息。

send方法锁的是class类模板，call锁的是方法，不是同一个锁，所以call无需等待send。

import java.util.concurrent.TimeUnit;
//7.send是static的同步方法，call是普通的同步方法，一个对象，执行顺序：1.打电话 2.发信息
//原因:send方法锁的是class类模板，call锁的是方法，不是同一个锁，所以call无需等待send
public class test4 {
    public static void main(String[] args) {
        Phone4 phone=new Phone4();
        new Thread(()->{
            phone.sendMes();
        },"A").start();
        //来个睡眠  java.util.concurrent.TimeUnit;用JUC包下的,不用sleep();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{
            phone.call();
        },"B").start();
    }
}
class Phone4{
    public static synchronized void sendMes(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发消息");
    }
    public  synchronized void call(){
        System.out.println("打电话");
    }
}

 

8.send是static的同步方法，call是普通的同步方法，两个对象，执行顺序：1.打电话 2.发信息。

send方法锁的是class类模板，call锁的是方法，不是同一个锁，所以call无需等待send。

//8.send是static的同步方法，call是普通的同步方法，两个对象，执行顺序：1.打电话 2.发信息
//原因:send方法锁的是class类模板，call锁的是方法，不是同一个锁，所以call无需等待send
public class test4 {
    public static void main(String[] args) {
        Phone4 phone1=new Phone4();
        Phone4 phone2=new Phone4();
        new Thread(()->{
            phone1.sendMes();
        },"A").start();
        //来个睡眠  java.util.concurrent.TimeUnit;用JUC包下的,不用sleep();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{
            phone2.call();
        },"B").start();
    }
}
class Phone4{
    public static synchronized void sendMes(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发消息");
    }
    public  synchronized void call(){
        System.out.println("打电话");
    }
}

 

7.LOCK锁     

synchronized传统

没有加synchronized的时候

public class test2 {
    //线程就是一个单独的资源类，没有任何附属的操作
    public static void main(String[] args) {
        Ticket ticket=new Ticket();
        new Thread(()->{
            for (int i = 0; i <30 ; i++) {
                ticket.sell();
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();

        new Thread(()->{
            for (int i = 0; i <30 ; i++) {
                ticket.sell();
            }
        },"B").start();
        new Thread(()->{
            for (int i = 0; i <30 ; i++) {
                ticket.sell();
            }
        },"C").start();
    }
}
//资源类
class  Ticket{
    //属性、方法
    private int number=20;

    public void sell(){
        if (number>0){
            System.out.println(Thread.currentThread().getName()+"卖出:"+(number--)+"张");
        }
    }
}

加了synchronized：

class  Ticket{
    //属性、方法
    private int number=20;

    public synchronized void sell(){
        if (number>0){
            System.out.println(Thread.currentThread().getName()+"卖出:"+(number--)+"张");
        }
    }
}

LOCK接口

公平锁：先来后到（）

非公平锁：可以插队（默认）

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

public class test3 {
    public static void main(String[] args) {
        Ticket ticket=new Ticket();
        new Thread(()->{
            for (int i = 0; i <30 ; i++) {
                ticket.sell();
            }
        },"A").start();

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

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

    }

}
class  Ticket2{
    //属性、方法
    private int number=20;

    Lock lock=new ReentrantLock();


    public  void sell(){
        //加锁
        lock.lock();
        //尝试锁
        lock.tryLock();
        try {
            //业务
            if (number>0){
                System.out.println(Thread.currentThread().getName()+"卖出:"+(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锁不一定会等待下去。

5.synchronized可重入锁，不可以中断，非公平，Lock可重入锁，可判断锁，非公平。

6.synchronized适合锁少量代码同步问题，Lock锁适合锁大量的同步代码。

 

qaq1314520
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
高级技术之 JUC 高并发编程
wa_ka_ka的博客
08-25 783
1，什么是 JUC 1.1 JUC简介 JUC 就是java.util.concurrent 工具包的简称，这一个专门用来处理线程的工具包，JDK1.5开始出现 1.2 进程与线程 **进程（Process）：**是系统进行资源分配和调度的基本单位，比如QQ启动就是一个进程。 **线程（Thread）：**是操作系统能够进行运算调度的最小单位，是程序执行的最小单位，它被包含在进程中，比如QQ中的各个功能，都是不同的线程。 1.3 线程的状态 在Thread类中枚举了线程的6种状态; pu
JUC 并发进阶学习（一）
weixin_44593504的博客
12-30 331
并发进阶学习
【JUC并发编程】
蛋饼吧的博客
06-19 962
JUC是Java Util Concurrent的缩写,是Java SE 5.0中新增的一个包,主要提供了在并发编程中使用的工具类和框架。JUC包含了许多用于多线程编程的工具类和接口,如锁、原子变量、线程池、阻塞队列等。这些工具类和接口可以帮助开发者更方便地进行多线程编程,从而提高程序的并发性能和可靠性。JUC包中的工具类和接口都是线程安全的,可以在多线程环境下安全地使用。它们的设计和实现都是基于并发编程的最佳实践和原则,可以有效地避免线程安全问题的发生。
学习JUC高并发编程这一篇就够了（上篇）
Laptoy的博客
03-22 580
Lock，线程安全，八锁，多线程锁，线程通信详解
多线程进阶——JUC并发
最新发布
zhaozhao_1的博客
06-13 968
JUC是Java中的三个包，java.util.concurrent，业务：普通的线程代码 Thread 调用Runnable没有返回值，效率较Callable低，所以企业中Runnable使用少，大多情况下使用Callable。
JUC(并发编程)
热门推荐
abc98526的博客
04-17 1万+
1.什么是JUC? JUC是指javaUtil包中的三个操作线程的包! 2.线程进程和程序 程序(Program):是一个静态的概念，一般对应于操作系统中的一个可执行的文件 ，比如：我们要启动酷狗听音乐，则对应酷狗可执行程序。当我们双击酷狗，则加载 程序到内存中，开始执行该程序，于是产生了"进程". 进程:执行中的程序叫做进程(Process),是一个动态的概念。现代的操作系统都可以同时启动多个进程。比如:我们在用酷狗听音乐，也可以使用wps写文档，也可以同时用浏览器查看网页。可以通过
JUC --java高并发总结（上）
心藏_的博客
10-18 145
1.什么是 JUC JUC就是 java.util 下的工具包、包、分类等。 普通的线程代码： Thread Runnable 没有返回值、效率相比入 Callable 相对较低！ Callable 有返回值！ 2.线程和进程 进程：一个程序，QQ.exe Music.exe 程序的集合； 一个进程往往可以包含多个线程，至少包含一个！ Java默认有2个线程？ mian、GC 线程：开了一个进程 Typora，写字，自动保存（线程负责的） 对于Java而言提供了：Thread、Runnable、
JUC并发编程学习
xu_jin_shan的博客
07-10 409
JUC并发编程学习 JUC概述 Lock接口 线程间通信 线程间定制化通信 集合的线程安全 多线程锁 Callable接口 JUC强大的辅助类 ReentrantReadWriteLock读写锁 BlockingQueue阻塞队列 ThreadPool线程池 Fork/Join分支合并框架 CompleteableFuture异步调用...
JUC并发编程.rar
12-14
总之，"JUC并发编程.rar"是一个宝贵的资源，它涵盖了Java并发编程的关键方面，无论你是想提升你的并发编程技能，还是在面临并发问题时寻找解决方案，这个资料都将大有裨益。通过深入学习和实践，你将能够更好地理解...
JUC并发编程.md
01-28
JUC并发编程学习笔记，狂神说
JUC代码收集，java高并发多线程学习
03-31
本资源"JUC代码收集，java高并发多线程学习"显然是一个专注于探讨和学习JUC库的资料包。 JUC库包含多个子包，如`concurrent`, `atomic`, `locks`等，每个子包都有其特定的功能和用途： 1. **concurrent**：这是JUC...
JUC并发编程与源码分析视频课.zip
12-16
《JUC并发编程与源码分析视频课》是一门深入探讨Java并发编程的课程，主要聚焦于Java Util Concurrency（JUC）库的使用和源码解析。JUC是Java平台提供的一组高级并发工具包，它极大地简化了多线程编程，并提供了更...
JUC并发编程学习笔记(硅谷)
07-23
"JUC并发编程学习笔记(硅谷)"很可能包含了关于Java并发工具集（Java Util Concurrency, JUC）的深入理解和实战经验。JUC是Java标准库提供的一套强大的并发处理工具，它极大地简化了多线程编程，提高了程序的可读性...
【并发编程】JUC并发编程（彻底搞懂JUC）
DreamSun的博客
03-29 6279
JUC实际上就是我们对于jdk中java.util .concurrent 工具包的简称，其结构如下：这个包下都是Java处理线程相关的类，自jdk1.5后出现。目的就是为了更好的支持高并发任务。让开发者进行多线程编程时减少竞争条件和死锁的问题！JUC主要是指JDK8中java.util.concurrent里提供的一系列线程并发工具，但是线程并发的问题远不止几个工具这么简单。要学习工具使用，更要能深入理解工具的原理以及处理线程并发问题的思路。
JUC 并发编程
m0_53067943的博客
07-10 999
主要对于juc的知识点总结
JUC 常用 4 大并发工具类详解
天行健，君子以自强不息；地势坤，君子以厚德载物。
06-28 809
什么是 JUC?JUC 就是 java.util.concurrent 包,这个包俗称 JUC,里面都是解决并发问题的一些东西,该包的位置位于 java 下面的 rt.jar 包下面JUC 中 4 大常用并发工具类CountDownLatchCyclicBarrierSemaphoreExChangerCountDownLatchCountDownLatch,俗称闭锁,作用是类似加强版的 Join...
JUC并发编程，看这一篇就够了
一个沉迷Java，无法自拔的Coder
07-25 6283
数万字长文，搭配代码，带你学习JUC并发编程；看了狂神的课程以及自己做的笔记
JUC常用4大并发工具类详解
sinat_31583645的博客
07-19 551
首先这个第一个参数也是 Int 类型的,传入的是执行线程的个数,这个数量和 CountDownLatch 不一样,这个数量是需要和线程数量吻合的,CountDownLatch 则不一样,CountDownLatch 可以大于等于,而 CyclicBarrier 只能等于,然后是第二个参数,第二个参数是 barrierAction,这个参数是当屏障开放后,执行的任务线程,如果当屏障开放后需要执行什么任务,可以写在这个线程中。通过返回结果就可以很直接的看到业务线程是在初始化线程完全跑完之后,才开始执行的。
"Java-JUC-多线程 进阶：遇见狂神说的JUC并发编程进阶版概要
Java-JUC-多线程进阶是一门关于Java并发编程的课程，来源于B站的《遇见狂神...通过学习这门课程，可以帮助开发者更好地理解并发编程的原理和技术，并且掌握相关的工具和模式，从而实现更高效、安全和正确的多线程程序。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值