JUC编程——（二）（深入理解锁—8锁现象，集合类不安全，走进Callable，常用辅助类（CountDownLatch，CyclicBarrier，Semaphore））

最新推荐文章于 2025-03-24 21:03:06 发布
原创 最新推荐文章于 2025-03-24 21:03:06 发布 · 339 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#并发编程

本文深入探讨Java并发编程中的锁机制，包括同步方法、静态同步方法的锁对象区别，以及集合类的安全性问题，如CopyOnWriteArrayList、CopyOnWriteArraySet、ConcurrentHashMap的使用。同时介绍了Callable接口的异步通信特性，以及CountDownLatch、CyclicBarrier、Semaphore等并发辅助类的作用和原理。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

一、深入理解锁

1、第一组
package com.JUC编程.代码;
import java.util.concurrent.TimeUnit;
/*
* 1.标准情况下,输出:  1/发短信 2/打电话
* 2.sendmsg延迟4秒,输出:  1/发短信 2/打电话
* */
public class MyDemo8 {
    public static void main(String[] args)  {
        demo demo = new demo();
        new Thread(()->{
                demo.sendmsg();
        },"A").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{
            demo.call();
        },"B").start();
    }
}
class demo{
    public synchronized void sendmsg()  {
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发消息");
    }
    public synchronized void call(){
        System.out.println("打电话");
    }
}
分析

上面的代码中synchronized 锁的对象是方法的调用者，而调用者只有一个， 所以两个方法用的是同一把锁，谁先拿到先执行。

2、第二组
package com.JUC编程.代码;
import java.util.concurrent.TimeUnit;
/*
* 3.加一个普通方法 输出:1/发视频 2/发消息
* 4.两个对象，两个同步方法 输出:1/打电话 2/发消息
* */
public class MyDemo9 {
    public static void main(String[] args)  {
        demo1 demo1 = new demo1();
        demo1 demo2 = new demo1();
        new Thread(()->{
            demo1.sendmsg();
        },"A").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{
            demo2.call();
        },"B").start();
    }
}
class demo1{
    public synchronized void sendmsg()  {
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发消息");
    }
    public synchronized void call(){
        System.out.println("打电话");
    }
    public void video(){
        System.out.println("发视频");
    }
}
分析

（1）普通方法不是同步方法，不收锁的影响。
（2）创建了两个对象，有两个调用者，所以有两把锁，所以按照时间先后来执行。

3、第三组
package com.JUC编程.代码;

import java.util.concurrent.TimeUnit;
/*
 * 5.两个静态同步方法,一个对象,输出:1/发消息 2/打电话
 * 6.两个静态同步方法,两个对象,输出:1/发消息 2/打电话
 * */
public class MyDemo10 {
    public static void main(String[] args)  {
        demo2 demo1 = new demo2();
        demo2 demo2 = new demo2();
        new Thread(()->{
            demo1.sendmsg();
        },"A").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{
            demo2.call();
        },"B").start();
    }
}
class demo2{
    public static synchronized void sendmsg()  {
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发消息");
    }
    public static synchronized void call(){
        System.out.println("打电话");
    }
}
分析

此时，synchronized锁的不再是个对象，而是类，我们知道对象可以有多个，但类只有一个，所以无论有几个对象，可以说都是同一把锁。

4、第四组
package com.JUC编程.代码;
import java.util.concurrent.TimeUnit;
/*
* 1、一个静态同步方法，一个同步方法，一个对象。输出:1/打电话 2/发消息
* 2、一个静态同步方法，一个同步方法，两个对象。输出:1/打电话 2/发消息
* */
public class MyDemo11 {
    public static void main(String[] args)  {
        demo3 demo1 = new demo3();
        demo3 demo2 = new demo3();
        new Thread(()->{
            demo1.sendmsg();
        },"A").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{
            demo2.call();
        },"B").start();
    }
}
class demo3{
    public static synchronized void sendmsg()  {
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发消息");
    }
    public  synchronized void call(){
        System.out.println("打电话");
    }
}
分析

两个锁锁的东西不一样，一个是方法调用者，一个是类。

二、集合类不安全

在这里插入图片描述

1、CopyOnWriteArrayList
package com.JUC编程.集合类不安全;
import java.util.*;
//java.util.ConcurrentModificationException 并发修改异常
public class MyDemo {
    public static void main(String[] args) {
       List<String> list = new ArrayList<>();
        /* 1.使用 List<String> list = new Vector<>();
         * 2.使用集合工具类Collections.synchronizedList(list)进行转换
        * 3.List<String> list = new CopyOnWriteArrayList<>();
        * CoCopyOnWriteArrayList<>()使用lock锁实现的比synchronized的效率高
        * */
        for (int i = 1; i <= 100; i++) {
            //产生随机字符串添加进集合中
            new Thread(()->{
                list.add(UUID.randomUUID().toString().substring(0,5));
                System.out.println(list);
            },String.valueOf(i)).start();
        }
    }
}
2、 CopyOnWriteArraySet
package com.JUC编程.集合类不安全;
import java.util.Collections;
import java.util.HashSet;
import java.util.Set;
import java.util.UUID;
import java.util.concurrent.CopyOnWriteArraySet;
public class MyDemo1 {
    public static void main(String[] args) {
        Set<String> set = new HashSet<>();
        /*
        * 1.使用Set<String> set1 = Collections.synchronizedSet(set);
        * 2. Set<String> set1 = new CopyOnWriteArraySet<>();
        * */
        for (int i = 0; i < 100; i++) {
            new Thread(()->{
                set.add(UUID.randomUUID().toString().substring(0,5));
                System.out.println(set);
            }).start();
        }
    }
}
hashset的底层是什么？
public HashSet() {
     map = new HashMap<>();
 }
 public boolean add(E e) {
        return map.put(e, PRESENT)==null;
 }
 private static final Object PRESENT = new Object();
3、ConurrentHashMap
package com.JUC编程.集合类不安全;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;
public class MyDemo2 {
    public static void main(String[] args) {
       // HashMap<String, String> hashMap = new HashMap<>();
        ConcurrentHashMap<String, String> hashMap = new ConcurrentHashMap<>();
        for (int i = 0; i < 30; i++) {
            new Thread(()->{
                String substring = UUID.randomUUID().toString().substring(0, 5);
                String name = Thread.currentThread().getName();
                hashMap.put(name,substring);
                System.out.println(hashMap);
            },String.valueOf(i)).start();
        }
    }
}

三、Callable

在这里插入图片描述

package com.JUC编程.代码;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
public class Demo1 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        MyThread myThread = new MyThread();
        FutureTask<String> Task = new FutureTask<String>(myThread);
        new Thread(Task,"A").start();
        new Thread(Task,"B").start();
        //只会输出一个call()
        String s = Task.get();//会有阻塞 可以用异步通信来解决
    }
}
class MyThread implements Callable<String> {
    @Override
    public String call() throws Exception {
        System.out.println("call()");
        return "123";
    }
}

注意：
1、当call方法中是一个非常耗时的操作，主线程就会另开辟一个新的线程去执行这个，并不会影响主线程的执行。（异步通信）所以get()的调用一般都放在代码后边。

2、缓存现象，使用两个线程去执行同一个FutureTask，只会有一个结果。

四、常用辅助类

1、CountDownLatch

在这里插入图片描述

package com.JUC编程.代码;
import java.util.concurrent.CountDownLatch;
//减法计数器
public class CountDownLatchDemo {
    public static void main(String[] args) throws InterruptedException {
        //等待所有线程执行完 计数器归0 用于必须要执行的任务
        CountDownLatch countDownLatch = new CountDownLatch(6);
        for (int i = 1; i <=6; i++) {
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"走了");
                countDownLatch.countDown();
            }).start();
        }
        countDownLatch.await();//等待计数器归0  然后向下执行
        System.out.println("关门");
    }
}
2、CyclicBarrier

在这里插入图片描述

package com.JUC编程.代码;import org.omg.PortableServer.THREAD_POLICY_ID;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
//加法计数器
public class CyclicBarrierDemo {
    public static void main(String[] args) {
        CyclicBarrier cyclicBarrier = new CyclicBarrier(7,()->{
            System.out.println("神龙召唤成功");
        });
        for (int i = 1; i <=7; i++) {
            final int temp=i;
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"集齐第"+temp+"颗龙珠");
                try {
                    cyclicBarrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}
3、Semaphore

在这里插入图片描述

package com.JUC编程.代码;
import jdk.internal.org.objectweb.asm.tree.FieldInsnNode;
import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;
public class SemaphoreDemo {
    public static void main(String[] args) {
        //线程数量 停车位
        Semaphore semaphore = new Semaphore(3);
        for (int i = 1; i <=6; i++) {
            new Thread(()->{
                try {
                    semaphore.acquire();
                    System.out.println(Thread.currentThread().getName()+"得到车位");
                    TimeUnit.SECONDS.sleep(2);
                    System.out.println(Thread.currentThread().getName()+"失去车位");
                } catch (InterruptedException e) {
                }finally {
                    semaphore.release();//释放
                }
            },String.valueOf(i)).start();
        }
    }
}

原理：

  • acquire()：获得，如果已经满了，就等待，等待被释放。
  • release()：释放，会将当前的信号量释放，然后唤醒等待的线程。
    作用：
  • 多个共享资源互斥的使用。
  • 并发限流，控制最大的线程数。
Java JUC详解：深入理解并发编程工具包
suqieer的博客
04-24 2349
java.util.concurrent：核心并发工具类，如ExecutorService、Semaphore、CountDownLatch等。java.util.concurrent.atomic：原子变量类，如AtomicInteger、AtomicLong、AtomicReference等。java.util.concurrent.locks：锁和同步器类，如ReentrantLock、ReadWriteLock、Condition等。
跟南桑学JUC第三节课（8锁）
ZN175623的博客
10-10 150
>关于8锁的问题 >list的线程安全问题和解决措施
8锁现象
qq_40826814的博客
04-21 127
5. 8锁现象 如何判断锁的是谁！锁到底锁的是谁？ 锁会锁住：对象、Class 深刻理解我们的锁 问题1 两个同步方法，先执行发短信还是打电话 public class dome01 { public static void main(String[] args) { Phone phone = new Phone(); new Thread(() -> { phone.sendMs(); }).start(); TimeUnit
8锁 现象
DaDaguai001的博客
07-01 444
以下都是为了更好的解释锁。 1 标准访问，先打印邮件还是先发送短信 解释 ：这个是不能确定的，线程的调度与cpu有关，所以不能确定。 class Phone//Phone.java ---> Phone.class Class.forName() { public synchronized void sendEmail() throws Exception{ //TimeUnit.SECONDS.sleep(3);//新的写法 //Threa..
JUC线程锁框架
12-31
Java并发编程是Java平台的重要特性...通过深入学习和实践JUC线程锁框架，开发者可以更好地解决并发问题，提高程序的并发性能和稳定性。理解并掌握这些组件的原理和使用方式，对于编写高效、可靠的多线程代码至关重要。
Java并发编程技巧与JUC工具类深入解析
第三，JUC中的锁框架提供了多种锁实现，包括可重入锁(ReentrantLock)、读写锁(ReadWriteLock)以及锁工具类如Semaphore、CountDownLatch和CyclicBarrier等。这些锁机制提供了比内置锁更灵活的锁定策略和更强大的同步...
JUC并发编程与源码分析视频课.zip
12-16
《JUC并发编程与源码分析视频课》是一门深入探讨Java并发编程的课程，主要聚焦于Java Util Concurrency（JUC）库的使用和源码解析。JUC是Java平台提供的一组高级并发工具包，它极大地简化了多线程编程，并提供了更...
深入理解Java高并发：JUC框架同步与锁机制解析
本资源深入探讨了JUC包中的高并发处理机制，包括同步机制、锁的使用、映射处理以及高并发场景的设置和调用接口。 同步和可重入锁是并发编程中用于控制多线程对共享资源访问的重要手段。同步主要是通过synchronized...
java的8锁现象
qq_45699784的博客
01-28 466
锁的8个现象我写了4个测试类，每个测试类里两个现象都是相似的！！！ /** * 8锁现象 * 1.先发短信还是先打电话？ 答：先发短信，再打电话，因为synchronized 锁的对象是方法的调用者，谁先执行谁先输出 * 2.在发短信方法中加4秒延时，看先发短信还是先打电话？ 答：还是先发短信，再打电话，因为synchronized 锁的对象是方法的调用者，谁先执行谁先输出，即使发短信方法卡着4秒但是锁还没有被释放 * */ public class TestLock1 { public
JUC学习笔记（二）：八锁现象
m0_56343209的博客
12-16 816
八锁现象主要是指 八种锁的情况，掌握了这八种情况我们以后碰到锁就能明白锁锁的是谁了 在了解八锁之前，我们需要先了解什么是锁： 锁是一种将资源私有化的的方式，在java中就是让某个类、变量、方法在同一个时刻只能被一个线程使用，保证数据的安全性，只要当使用锁的线程释放了这个锁，其它线程才能获取使用。 （1）让两个方法都加上同步锁 package com.lai.lock8; import java.util.concurrent.TimeUnit; /** * @author l...
JUC--8锁现象（对于锁的理解）
最新发布
m0_73856804的博客
03-24 742
两个同步方法变成了静态同步方法，因为static锁的是class类模板，而class类模板全局唯一，所以就想问题1一样.因此是先发短信。因为静态同步方法锁的是 全局唯一的Class类模板，而同步方法，锁的是当前对象this，两个锁，因此谁快谁先执行，所以先打电话。是先发短信，因为synchronized 锁的对象是方法的调用者，两个方法用的是同一个锁，谁先拿到，谁先执行。因为是两个对象，有两个调用者，所以有两个锁，那就是谁快谁先执行，而发短信被延迟4秒，因此是打电话。2.同样也是发短信，因为是同一个锁。
JUC并发编程-8锁现象
凹凸曼的博客
12-18 590
文章目录锁方法的调用者问题一问题二问题三问题四锁class对象问题五问题六同时锁方法的调用者和class对象问题七问题八 首先感谢下B站的狂神，在这里第一次听到“8锁现象”，并弄懂了“锁到底锁的是谁”。 8锁现象，实际对应的就是8个问题。 掌握了这8个问题后：可以清楚判断锁的是谁！知道什么是锁，锁到底锁的是谁！ 锁方法的调用者 问题一 如下代码：标准情况下，下边两个线程先打印 发短信 还是 打电话 ？ public class Test1 { public static void main(Stri
八锁现象的介绍及代码分析
weixin_43786099的博客
08-27 660
好的，前文我们简单的讲述了一下synchronized 锁的三种应用方式，他们是： 普通同步方法（实例方法），锁是当前实例对象 ，进入同步代码前要获得当前实例的锁 静态同步方法，锁是当前类的class对象 ，进入同步代码前要获得当前类对象的锁 同步方法块，锁是括号里面的对象，对给定对象加锁，进入同步代码库前要获得给定对象的锁。 好的我们知道了有这三种方式，但是他们三种不同的应用方式又有着什么不一样的区别呢，难道说还是只是位置不一样，其他作用都是一样的，那肯定不是的啦，他们的锁对象都是不一样的，下面我们就
深入理解JUC的8锁现象
qq_51447436的博客
04-15 8160
深入理解JUC的8锁现象
lock8锁详解现象深入理解
m0_50146072的博客
09-02 585
8锁现象 如何判断锁的是谁！永远的知道什么锁，锁到底锁的是谁！ 深刻理解我们的锁 1、标准访问，先发送邮件还是短信 Email 锁是this 2、暂停3S在邮件方法里，先发送邮件还是短信 Email 锁是this 3、新增hello普通方法，先发送邮件还是hello hello 加个普通方法后发现和同步锁无关 4、有两部手机，先发送邮件还是短信 EMS 锁是两个不同的this，但是需要隔4s才能发送email 5、两个静态同步方法，有一部手机，先发送邮件
【并发编程篇】详细讲解八种锁现象，彻底理解锁
小吉妙妙屋
12-18 1083
原因是因为先调用发短信的方法吗。不对，原因是因为synchronized锁的对象是方法的调用者(发短信和打电话这两个方法，都使用了synchronized)，而且这两个方法都被phone所调用，由于。
JUC并发编程（五）-8锁的现象
二总的猫
02-26 2170
5、8锁的现象 以下名词解释： 顺序执行：先调用的先执行； 随机执行：没有规律，与计算机硬件资源有关，哪个线程先得到资源就先执行，各个线程之间互不干扰。 5.1. 多个线程使用同一把锁-顺序执行 1、多个线程使用同一个对象，多个线程就是使用一把锁，先调用的先执行！ 示例1、标准访问，请问先打印邮件还是短信？ package com.interview.concurrent.lock.lo...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值