JUC——Day01

最新推荐文章于 2022-02-18 17:31:12 发布
最新推荐文章于 2022-02-18 17:31:12 发布
阅读量225 收藏
点赞数
文章标签： 多线程 并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44289860/article/details/107589088
版权

JUC Day01

文章总结自B站狂神说Java

JUC 是 java.util.concurrent以及下面的atomic和locks包的简称。称为并发编程，面试高频问。

1. 概念

1.1 进程与线程

进程是一个程序运行的集合，一个进程可以包含多个线程，至少包含一个线程，线程是进程最小的运行单位。在Java中最少包含两个线程：main、GC线程。
Java并不是真的可以开启线程，只能调用本地底层的C++方法，Java无法直接操作硬件设备。

1.2 并发与并行

并发为多个线程操作同一个资源，并行为多个线程同时执行（必须为多核CPU）。并发编程的本质是充分利用CPU的资源。

1.3 多线程状态

  1. NEW ： 新生状态
  2. RUNABLE ：运行状态
  3. BLOCKED：阻塞状态
  4. WATING ：等待状态，死死的等待
  5. TIMED_WATING ：超时等待
  6. TERMINATED ：终止状态

1.3 wait 和 sleep

wait来自Object类；sleep来自Thread类；
wait会释放锁；sleep不会释放锁；
wait必须在同步代码块中使用；Sleep可以在任何地方使用；
wait不需要捕获异常；sleep必须捕获异常。

2.LOCK 锁

线程是一个单独的资源类，没有任何的附属操作

创建Lock对象：
在创建对象时可以传递参数来指定是否为公平锁：不穿参数默认为false：非公平锁：根据CPU来决定运行顺序；传递参数为true：公平锁：先来后到，等先来的线程运行完毕之后再运行后面的线程。

    Lock lock = new ReentrantLock(false);

加锁：
把需要家锁的代码放在try/catch代码块中，使用finally释放锁。

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

    }

2.1传统的Synchronized与Lock的区别：

  1. Synchornnized 是内置的Java关键字，Lock是一个关键字;
  2. Synchorniezd 无法判断锁的状态，Lock可以判断锁的状态;
  3. Synchornized 会自动的释放锁，Lock必须要手动释放锁，如果不释放有可能会出现死锁问题。
  4. Synchornized 如果线程A阻塞线程B就会一直等待线程A释放锁；Lock可以使用tryLock方法去尝试获取锁。
  5. Synchornized是可重入锁，不可以中断的，非公平的；Lcok 可重入锁，判断锁状态，自己设置公平或者非公平。
  6. Synchornized 适合锁少量的代码同步问题，Lock适合大量的锁同步代码。

2.2 LOCK锁的消费者与生产者问题

lock相较于synchornized 的notifyAll方法变成了Condition对象的singalAll方法；wait变成了await方法。除去上述的区别外Condition还新增了对线程执行顺序控制的方法，对线程的精准通知唤醒。

juc解决生产者消费者问题

/**
 * @date 2020/7/26 13:28
 * juc 解决生产者消费者问题
 */
public class ProductAndCustomerJUC {

    public static void main(String[] args) {
        DataA dataA = new DataA();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    dataA.inc();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    dataA.dec();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"B").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    dataA.inc();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"C").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    dataA.dec();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"D").start();
    }
}
class DataA{
    private int num = 0;

//    锁对象
    Lock lock = new ReentrantLock();

//    获取condition对象用来执行 await 和 signalAll 方法
    Condition condition = lock.newCondition();

    /**
     * 加 1 方法
     * @throws InterruptedException
     */
    public void inc() throws InterruptedException {
        try {
            lock.lock();
            while (num != 0){
//            相当于 synchronized 的 wait 方法。
                condition.await();
            }

            num++;
            System.out.println(Thread.currentThread().getName()+"=>"+num);

//        通知其它线程 相当于 synchronized 的 notifyAll 方法
            condition.signalAll();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }

    /**
     * 减 1 方法
     * @throws InterruptedException
     */
    public void dec() throws InterruptedException {
        try {
            lock.lock();
            while (num == 0){
//            相当于 synchronized 的 wait 方法。
                condition.await();
            }
            num--;
            System.out.println(Thread.currentThread().getName()+"=>"+num);
//        通知其它线程 相当于 synchronized 的 notifyAll 方法
            condition.signalAll();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }

}

Condition 对线程的精准通知唤醒


/**
 * @date 2020/7/26 13:28
 * condition 对象精确唤醒线程
 */
public class ProductAndCustomerJUC02 {

    public static void main(String[] args) {
        DataB dataB = new DataB();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                dataB.printA();
            }
        },"A").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                dataB.printB();
            }
        },"B").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                dataB.printC();
            }
        },"C").start();
    }
}

class DataB{
    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();
    private Condition condition1 = lock.newCondition();
    private Condition condition2 = lock.newCondition();
    private int num =  1;


    public void printA(){
        lock.lock();
        try {
//          业务代码
            while (num != 1){
                condition.await();
            }
            System.out.println(Thread.currentThread().getName()+"-------------->printA");
            num = 2;
//            精准唤醒
            condition1.signalAll();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
    public void printB(){
        lock.lock();
        try {
//          业务代码
            while (num != 2){
                condition1.await();
            }
            System.out.println(Thread.currentThread().getName()+"----------------->printB");
            num = 3;
//            精准唤醒
            condition2.signalAll();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
    public void printC(){
        lock.lock();
        try {
//          业务代码
            while (num != 3){
                condition2.await();
            }
            System.out.println(Thread.currentThread().getName()+"-------------->printC");
            num = 1;
//            精准唤醒
            condition.signalAll();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }

}

2.2 锁的问题

  1. 没有锁的线程的运行顺序与调用顺序无关；
  2. 有锁的与休眠时间无关；
  3. synchornized锁的是调用方法的对象，也就是说如果一个对象调用两个方法，先拿到锁（先被调用就先拿到锁）的就先执行。
  4. 没有同步的方法不受锁的影响。
  5. 两个不同的对象调用同步的方法，不受对方锁的影响。
  6. 加了static标识符的方法锁的是全局唯一的class对象，即使是两个对象调用方法也是同把锁。
  7. 如果同时存在静态同步方法和普通同步方法，这个两个方法的锁的对象是不同的，所以不需要等待对方释放锁。

3. 不安全类

3.1 在并发下list并不安全

如果使用多个线程去往list中添加数据会java.util.ConcurrentModificationException异常，这个错误为并发修改异常。

public class ListDemo01 {
    public static void main(String[] args) {
        List<String> lists = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                lists.add(UUID.randomUUID().toString().substring(0,5));
                System.out.println(lists);
            },String.valueOf(i)).start();
        }
    }
}

解决方案：

  1. List<String> lists = new Vector<>();
  2. List<String> lists = Collections.synchronizedList(new ArrayList<>());
  3. List<String> lists = new CopyOnWriteArrayList<>();
    推荐使用第三个，实现原理是在读写分离，在写入时避免覆盖而造成的数据问题；相较于Vector而言它的add方法并不是使用的synchornized锁同步的方法，效率高。

3.2 在并发下set也不安全

在多线程共同像set添加内容时，set也会出现与list一样的异常List<String> lists = new CopyOnWriteArrayList<>();
解决方案：

  1. Set <String > strings = Collections.synchronizedSet(new HashSet<>());
  2. Set<String > set = new CopyOnWriteArraySet<>();

HashSet的底层就是HashMap。

3.3 Map也不是安全的

出现的问题与上面的set和list的问题一样，推荐的解决方案是：
Map<String,Sting> map = new ConncurrnetHashMap<>();

江海i
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java——JUC
12-29
Java并发编程是Java开发中的重要领域，而Java并发工具包（Java Concurrency Utility，简称JUC）则是Java标准库提供的一套强大而丰富的工具，它极大地简化了多线程环境下的编程工作。JUC主要包含在`java.util....
JUC基石——Unsafe类
12-21
《JUC基石——Unsafe类详解》 在Java并发编程领域，`Unsafe`类扮演着一个特殊的角色，尽管它被标记为“不安全”，但却是Java并发库（JUC）中的重要基石，尤其在高并发场景下，如`ConcurrentHashMap`、`Atomic`系列...
JUC——Day03
热门推荐
风间琉璃の博客
07-28 1万+
JUC Day03 文章总结自B站狂神说JAVA 1.ForkJoin 分支合并：并行执行任务来提高效率。把大任务划分成小任务来分来执行，将每个小任务得到的结果整合为最终结果。 特点： 工作窃取：不让执行完毕任务的线程等待，去帮助其它的线程执行任务。 demo： /** * @date 2020/7/28 7:54 * * 求和计算任务 */ public class ForkJoinDemo01 extends RecursiveTask<Long> { priv
JUC并发编程
qq_40357769的博客
08-15 79
JUC简介 java.util.concurrent在并发编程中使用的工具类 线程和进程 进程：一个程序，QQ.exe、Music.exe一个进程可以包含多个线程，至少包含一个！ JAVA程序默认有几个线程？两个 main 和GC线程 线程：一个线程只属于一个进程 并发和并行 并发：指的是CPU执行多个任务，但不会同一时间去完成 你吃饭吃到一半，电话来了，你停了下来接了电话，接完后继续吃饭，这说明你支持并发。 并行: 指的是CPU可以支持同一时间处理多个任务 你吃饭吃到一半，电话
初识JUC——day01&&lock接口&&线程间通信
weixin_45483328的博客
02-18 225
文章目录1. JUC简介1.1 进程与线程1.2 线程的状态1.3 wait/sleep的区别1.4并发与并行2. Lock接口2.1 Synchronized2.2 Lock接口2.3 Lock方法2.4 ReentrantLock2.5 ReadWriteLock2.6 比较synchronized和lock3.线程间通信3.1 使用synchronized3.2 使用lock4.线程间定制化通信参考资料 1. JUC简介 JUC是java.unti.concurrent包的简称，在Java中是处理线程
JUC学习——day01
ZLB_CSDN的博客
06-20 193
当一个条件满足时，很多线程都被唤醒了，但是只有其中部分是有用的唤醒，其它的唤醒都是无用功 1.比如说买货，如果商品本来没有货物，突然进了一件商品，这是所有的线程都被唤醒了 ，但是只能一个人买，所以其他人都是假唤醒，获取不到对象的锁
JUC——Day04
风间琉璃の博客
07-29 4882
JUC Day04 视频总结自B站狂神说JAVA 1.单例模式 只要是单例模式一定是构造器私有。 1.1 饿汉式 饿汉式单例模式最大的特点就是在程序运行时，会立即将所需要的全部对象创建完毕，会影响加载速度浪费资源。 /** * @date 2020/7/29 7:37 * hungry * 饿汉式单例模式 */ public class Demo01 { // 在程序执行时都会创建完毕，消耗资源过多。 private byte[] data1 = new byte[1024*10
JUC——Day02
风间琉璃の博客
07-27 160
JUC Day02 文章总结自B站狂神说JAVA 1.Callable 优点：可以有返回值，可以抛出异常。 代码测试： /** * @date 2020/7/27 8:04 * callable 测试 */ public class CallableDemo01 { public static void main(String[] args) throws ExecutionException, InterruptedException { // 启动callable
JUC学习——day02
ZLB_CSDN的博客
06-21 167
Condition Lock替换synchronized方法和语句的使用， Condition取代了对象监视器方法的使用。 一个Condition实例本质上绑定到一个锁。 要获得特定Condition实例的Condition实例，请使用其newCondition()方法。 例如，假设我们有一个有限的缓冲区，它支持put和take方法。 如果在一个空的缓冲区尝试一个take ，则线程将阻塞直到一个项目可用; 如果put试图在一个完整的缓冲区，那么线程将阻塞，直到空间变得可用。 我们希望在单独的等待集中等待
JUC学习——day03
ZLB_CSDN的博客
06-22 189
JUC学习——day03 目录： 文章目录JUC学习——day03**一、Vector和SynchronizedList**二、CopyOnWriteArrayList2.1 剖析为什么遍历时不用调用者显式加锁2.2 CopyOnWriteArrayList缺点三、COW(写时复制)3.1 什么是 COW？ List集合类（安全和不安全） 不安全：ArrayList （为了替代Vector，出现在Jdk1.2） 安全 ：Vector （出现在Jdk1.0）、 Collections.synchr
heima-JUC-资料
04-25
Java并发编程是Java Util Concurrency（JUC）库的核心内容，它为多线程环境提供了高效、安全且灵活的工具和API。JUC是Java 5及后续版本引入的一个重要特性，极大地提升了Java在多处理器和高并发环境下的性能表现。 ...
JUC思维导图.emmx
01-29
个人整理的JUC知识总结
udp分片报文pcap文件
07-18
udp分片报文pcap文件：64kudp大包分成每片658字节总计100片
计算机教学导案.doc
07-18
计算机
摩根：2024年大市前瞻.pdf
最新发布
07-18
摩根：2024年大市前瞻
计算机控制专业技术专题实习任务书温度控制.doc
07-18
计算机
计算机控制系统.doc
07-18
计算机
Java并发编程详解：JUC与面试必备知识
"这篇资源主要介绍了Java并发编程中的重要组件JUC，以及相关的并发编程概念，包括进程和线程的定义、线程的状态和相关方法如wait、notify、notifyAll等。" Java并发编程（JUC）是Java.util.concurrent包及其相关子...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值