JUC系列（一） 多线程基础复习

最新推荐文章于 2023-01-13 12:15:22 发布
最新推荐文章于 2023-01-13 12:15:22 发布
阅读量435 收藏
点赞数
分类专栏： JUC 冷环渊的全栈学习 文章标签： java 面试 JUC 多线程 并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/doomwatcher/article/details/127116663
版权

什么是JUC

问：如何学习JUC？

答： 源码 + Java帮助文档 面试高频，

juc 其实就是 Java.util 包下的线程分类的工具

image-20220301194131214

以往学习的线程只是：

			我们使用的普通的线程代码 Thread，==Runnable== 等其实回顾JavaSE的线程知识我们可以发现，

其实我们学习线程基础的时候，也是有用到concurrent包下的东西

比如 Runnable 和 Callable ,Callable 就是我们concurrent 包下的

还有就是 Lock

image-20220301194541263

线程与进程

线程、进程、如何来解释

进程 ： 一个程序 如 QQ.exe Music.exe 程序的集合

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

Java 默认是开启两个线程 main GC

线程： 开了一个进程 比如： typora 写字，自动保存（线程负责的）

对于Java 而言创建线程我们学习到的方法有三种 ： Thread , Runnable , Callable

PS ：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 */
            }
        }
    }

	// 本地方法 调用底层的 C++ Java本身不能直接操作硬件
    private native void start0();

并发，并行

我们要学习并发编程，首先要了解 ： 并发和并行是什么

并发（多线程操作同一资源）

  • CPU一核，模拟出来多条线程，天下武功，唯快不破，快速交替。

并行（多个程序一起走）

  • CPU 多核，多个线程同时执行；如果需要提高性能 ： 线程池

查看一下自己的cpu核数

image-20220301201453940

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

所有的公司都很看重，就是效率，比如裁员：一个厉害的可以大于两个不再那么厉害的甚至更多

比如： 做事情的速度 高手：1s，一般人： 10s 肯定是 1s 的更加的之前也更加的有效率；

做到人员（减少），但是技术力却提高了

线程有几个状态

通过Thread 源码里的枚举类：State 中的属性可以看出来

线程有六个状态

    public e
num State {
        //新的线程
        NEW,
        //运行中
        RUNNABLE,
        // 阻塞
        BLOCKED,
        //等待，一直等
        WAITING,
        //等待一段时间就不等了
        TIMED_WAITING,
        // 终止线程
        TERMINATED;
    }

wait/sleep的区别

1、他们来自不同的类

wait => object

sleep => Thread

2、关于锁的释放

wait会释放锁，sleep不会释放锁

抽象理解 ： sleep 睡着了没办法释放， wait 是等待，有人需要的释放

wait必须在同步代码块中使用，得有需要等的人

sleep可以在任何地方使用

3、是否需要捕获异常

wait 不需要捕获异常

sleep 需要捕获异常

Lock锁

传统 Synchronized

传统火车票案例

/**
 * @projectName: JUC
 * @package: Thread
 * @className: SaleTicketDemo
 * @author: 冷环渊 doomwatcher
 * @description: TODO
 * @date: 2022/3/1 20:28
 * @version: 1.0
 */
public class SaleTicketDemo {
    /**
     * 真正的多线程开发 公司中的需要降低耦合性
     * 线程就是一个单独的资源类，没有任何附属的操作
     * 1、 属性。方法
     * */
    public static void main(String[] args) {
        //并发: 多线程操作同一个资源类,把资源丢入线程
        Ticket ticket = new Ticket();
        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 Ticket {
    //属性 方法
    private int number = 50;

    //    买票的方式
    public synchronized void sale() {
        if (number > 0) {
            System.out.println(Thread.currentThread().getName() + "卖出了" + (number--) + "票,剩余" + number);
        }
    }
}

Lock接口

image-20220301204107904

常用的一些实现类

image-20220301204151242

image-20220301204430613

公平锁 : 十分公平,可以先来后到 比如 前一个线程要执行30s 后面的 需要3s 后者必须等待前者执行完

非公平锁 : 十分不公平,可以根据条件来插队

如何用Lock来编写火车票Demo

  1. new ReentrantLock();
  2. Lock.lock(); 解锁
  3. 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 适合锁大量的同步代码

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

生产者和消费者问题

生产者和消费者问题:Synchronized 版

面试高频 ： 单例模式，排序算法，生产者和消费者 死锁

package ProduceAndconsum;

/**
 * @projectName: JUC
 * @package: ProduceAndconsum
 * @className: A
 * @author: 冷环渊 doomwatcher
 * @description: TODO
 * @date: 2022/3/1 21:08
 * @version: 1.0
 */
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();
    }
}

//数字 资源类
// 1、 判断等待，通知
class Data {
    private int number = 0;

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

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

但是，写出来这个简单的模型 面试官还是会挑的出毛病来，问题出在那？

问题，现在我们是两个线程 ，我们加到四个线程 A,B,C,D 现在还是安全的吗？答案是肯定的不是

虚假唤醒问题：我们增加到四个线程输出的时候就会发现一些问题来，输出不再是0101了

image-20220301212425229

image-20220301212149214

这里如何解决呢？ 将 if 换成 while循环

修改之后根据官方文档的解释之后，将if改编成while

image-20220301212605922

输出就又回到了正常

package ProduceAndconsum;

/**
 * @projectName: JUC
 * @package: ProduceAndconsum
 * @className: A
 * @author: 冷环渊 doomwatcher
 * @description: TODO
 * @date: 2022/3/1 21:08
 * @version: 1.0
 */
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();
        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();
    }
}

//数字 资源类
// 1、 判断等待，通知
class Data {
    private int number = 0;

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

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

生产者和消费者问题: JUC版

在新的学习中 synchronized 有 Lock 替换

那么 wait 和 notify谁来替换呢？

image-20220301212829262

通过 Lock来找到 Condition

image-20220301213020385

image-20220301213059259

package ProduceAndconsum;

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

/**
 * @projectName: JUC
 * @package: ProduceAndconsum
 * @className: B
 * @author: 冷环渊 doomwatcher
 * @description: TODO
 * @date: 2022/3/1 21:31
 * @version: 1.0
 */


public class B {
    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();
    }
}

//数字 资源类
// 1、 判断等待，通知
class Data2 {
    private int number = 0;
    Lock lock = new ReentrantLock();
    Condition condition = lock.newCondition();
    //等待
    //    condition.await();
    //唤醒全部
    //    condition.signalAll();

    //    +1
    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();
        }
    }

    //    -1
    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();
        }
    }
}

package ProduceAndconsum;

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

/**
 * @projectName: JUC
 * @package: ProduceAndconsum
 * @className: B
 * @author: 冷环渊 doomwatcher
 * @description: TODO
 * @date: 2022/3/1 21:31
 * @version: 1.0
 */


public class B {
    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();
    }
}

//数字 资源类
// 1、 判断等待，通知
class Data2 {
    private int number = 0;
    Lock lock = new ReentrantLock();
    Condition condition = lock.newCondition();
    //等待
    //    condition.await();
    //唤醒全部
    //    condition.signalAll();

    //    +1
    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();
        }
    }

    //    -1
    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

image-20220301214146773

我们更换完代码之后，可以正常输出但是还是混乱的，我们想要达到 A->B->C->D 这样输出，这个时候就引出了新的知识点

Conddition精准唤醒

package ProduceAndconsum;

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

/**
 * @projectName: JUC
 * @package: ProduceAndconsum
 * @className: B
 * @author: 冷环渊 doomwatcher
 * @description: TODO
 * @date: 2022/3/1 21:31
 * @version: 1.0
 */


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();
    }
}

//数字 资源类
// 1、 判断等待，通知
class Data3 {
    private int number = 1;
    Lock lock = new ReentrantLock();
    Condition condition = lock.newCondition();
    Condition condition1 = lock.newCondition();
    Condition condition2 = lock.newCondition();

    public void printA() {
        lock.lock();
        try {
            //    业务，判断 执行 通知
            while (number != 1) {
                //等待
                condition.await();
            }
            System.out.println(Thread.currentThread().getName() + "=>AAA");
            number = 2;
            condition1.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void printB() {
        lock.lock();
        try {
            //    业务，判断 执行 通知
            while (number != 2) {
                //等待
                condition1.await();
            }
            System.out.println(Thread.currentThread().getName() + "=>BBB");
            number = 3;
            condition2.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void printC() {
        lock.lock();
        try {
            //    业务，判断 执行 通知
            while (number != 3) {
                //等待
                condition2.await();
            }
            System.out.println(Thread.currentThread().getName() + "=>BBB");
            number = 1;
            condition.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

输出的结果就达到我们的预期了

image-20220301215538935

冷环渊
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
JUC代码演示 Java多线程并发
05-03
JUC代码演示 Java多线程并发 源于B站https://www.bilibili.com/video/BV1Kw411Z7dF/?p=32&spm_id_from=333.1007.top_right_bar_window_history.content.click课程自我项目记录。 适合有一定基础的朋友。
JUC并发编程
风吟Pro的博客
04-24 689
需要有一定的多线程基础，需要的小伙伴可以回到这个帖子来复习Java多线程 何为JUC？ java.util.concurrent包 回顾线程和进程的区别 进程：一个程序，QQ.exe Music.exe 程序的集合； 一个进程往往可以包含多个线程，至少包含一个！ Java默认有几个线程？ 2 个 mian、GC 线程：开了一个进程 Typora，写字，自动保存（线程负责的） 对于Java而言：Thread、Runnable、Callable Java 真的可以开启线程吗？ 开不了，因为底层调用还是jvm，
高并发JUC详解
weixin_48958124的博客
08-26 1978
多线程进阶之高并发编程
JUC精简版（快速复习使用）
TheAnnoyingDog的博客
12-05 522
JUC 什么是JUC? JUC是JDK提供的为解决线程问题的工具类，即java.util.concurrent的缩写。 1.线程与进程 首先我们需要明白的是进程 > 线程 (虽然并不严谨，但是可以这样认为) 用一句专业术语来描述他们之间的区别：进程是CPU资源分配的最小单位，线程是CPU调度的最小单位 知乎上一个匿名用户很好的比喻： 进程 一个进程就是CPU执行 ，是程序在执行过程当中CPU资源分配的最小单位，并且进程都有自己的地址空间，包含了运行态、就绪态、阻塞态、创建态、终止态五个状态。
Java 多线程
weixin_45833157的博客
09-16 1087
多线程 9.1 进程与线程 进程是程序的一次动态执行过程，从代码加载，执行到执行完毕的完整过程。 多线程是实现并发机制的一种有效手段。 多线程是指一个进程在执行过程中可产生多个更小的程序单元（线程），这些线程可同时存在，同时运行，而一个进程可能包括多个同时执行的线程。 9.2 Java中线程的实现 继承Thread类 class 类名称 extends Thread{ 属性...; 方法...; public void run(){ 线程主体 } } 为什么启动线程不能直接使用run()方法？ 答：线程的
多线程基础知识,常被面试官挂在嘴边的问题
qq_51033936的博客
09-20 138
本篇文章主要围绕为什么使用多线程,进程、线程、管程 (monitor 监视器),,多线程并行和并发的区别,synchronized 和 lock 的区别,线程实现方式,线程的生命周期,线程同步的这部分内容进行讲解, 感兴趣的大佬戳进来
JUC多线程学习个人笔记
07-08
JUC（Java Util Concurrent）是Java中用于并发编程的工具包，提供了一组接口和类，用于处理多线程和并发操作。JUC提供了一些常用的并发编程模式和工具，如线程池、并发集合、原子操作等。 JUC的主要特点包括： ...
多线程基础、JUC锁、同步容器、线程池
07-11
多线程基础、JUC锁、同步容器、线程池
thread.zip--狂神多线程+juc
03-18
B站狂神说Java的多线程基础篇+juc高级篇代码
JUC代码收集，java高并发多线程学习
03-31
JUC代码收集，java高并发多线程学习
多线程详解&JUC
weixin_45683550的博客
01-13 333
多线程解析，并发并行。线程创建，线程状态。线程通知等待。JUC。线程池
JUC并发编程——线程的基本方法使用
weixin_39555954的博客
12-18 437
目录 一、线程名称设置和获取 二、线程的sleep() 三、线程的interrupt 四、join() 五、yield() 六、wait(),notify(),notifyAll() 一、线程名称设置和获取 1、线程名称一般在线程启动前设置，但也允许为正在运行的线程设置名称。在实际开发中，在使用多线程开发时，一定要自定义线程名称，偏于查找日志。 2、线程允许使用同样的名字，但应该尽量避免。 3、如果线程没有命名，系统会自动为线程设置名称。例如Thread-0,Thread-1。在Spri
JUC学习笔记一：复习多线程操作资源类的方法
qq_31314141的博客
02-04 738
高内聚，低耦合 所谓高内聚，低耦合就是每个程序要实现的特定功能要尽量多的在自己的内部完成，对外部提供很少量的接口以便调用。 并行和并发 并行即多个任务在自己的分配的各自的资源上执行，即多个任务同时跑，互不冲突。 并发即多个任务在统一的一个资源内执行，多个任务会抢占同一资源，在cpu中体现为交替执行，并不能同时执行，但是cpu在多个线程中切换的速度会非常快，所以宏观上看似是同时的。 最大的区别体现在...
JUC系列1-基础知识
Kerwin_luo的博客
08-27 1058
JUC系列-基础知识线程启动代码示例继承Thread类实现Runnable接口利用FutureTask线程常用方法线程通知与等待wait方法notify方法生产者与消费者代码示例如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰...
JUC复习
qq_52999613的博客
04-25 141
JUC学习 文章目录JUC学习什么是JUC并发与并行线程锁Synchronized：是自动解锁。Lock：需要手动解锁线程间的通信Synchronized锁的通信Lock锁的通信解决线程不安全问题1.解决ArrayList线程不安全的方法2.解决Hashset线程不安全问题3.解决HashMap线程不安全问题多线程锁公平锁和非公平锁死锁JUC强大的辅助类CountDownLatch：作用减少计数CyclicBarrier：循环栅栏Semaphore：信号灯ReentrantReadWriteLock（读写锁
3万字长文带你复习JUC
qq_42605968的博客
03-20 201
在复习JUC之前，先搞明白什么情况下才能线程安全，也就是线程安全所具备的条件 原子性 有序性 可见性 那从上面这几个角度来考虑Synchronized和volatile的区别？ Synchronized可以保证原子性，有序性，可见性 volatile可以保证有序性和可见性，但是不能保证原子性 还有一种类是绝对安全的，它就是不可变类（immutable），它的不可变也就意味着不能进行写操作，...
高级JAVA知识图及JUC讲解（看懂学半年进大厂无压力）
DanielAntony的博客
09-06 4664
知识框架梳理 核心知识框架图         以前待过一个公司，然后公司领导特别nice，10几年的大厂经验，然后技术也特别扎实全面，我们从他那边学到很多东西， 但是他教给我们有价值的干货，还得属于2017年年终review时候的分享的学习方法，我们知道授人予鱼不如授人予渔，无可 置疑，get到学习的method比get到属性有价值得多。   其实，他教我们学习java的办法很简单，总结...
JUC复习大总结
放下键盘
09-08 166
1.什么是虚假唤醒？（某个线程不应该被唤醒） 比如线程A和B同时陷入阻塞，线程C执行notifyAll（），线程A、B都被唤醒，但线程A唤醒执行后的结果应该导致B依旧阻塞，但B没有循环判断，导致也被唤醒！！下面有图解 以生产者-消费者模型举例。。 class Goods{ public int number=0; //制作方法 public synchronized void made() throws InterruptedException { //判断
JUC知识点总结
Novice_guy的博客
03-26 343
JUC juc->java.util.concurrent:并发编程中的工具类 三个包：concurrent，atomic，locks 进程和线程 进程：后台运行的一个程序，是操作系统分配资源的基本单位 线程：进程内部使用进程分配到的资源的，实现的某些功能，就是线程。 并发和并行 并发：而并发是指两个或多个事件在同一时间间隔发生。 并行：并行是指两个或者多个事件在同一时刻发生。 ...
JUC 解决多线程原子性问题，具体怎么做的？给出代码示例，谢谢
最新发布
08-14
下面是一个使用JUC提供的原子类AtomicInteger来解决多线程原子性问题的示例代码： ```java import java.util.concurrent.atomic.AtomicInteger; public class AtomicityExample { private static AtomicInteger ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

冷环渊

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值