Java（二十四）-- Java并发编程（二）

最新推荐文章于 2024-07-25 13:40:37 发布
最新推荐文章于 2024-07-25 13:40:37 发布
阅读量75 收藏 1
点赞数
分类专栏： Java 文章标签： java 开发语言 intellij-idea
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_55715583/article/details/125125388
版权

目录

Lock

用 synchronized 实现卖票

用 Lock 完成卖票

synchronized 和 lock 的区别 

公平锁

非公平锁

生产者消费者模式

synchronized

Lock

ConcurrentModificationException

并发访问异常

如何解决？

Set

Map

Lock

        JUC 提供的一种锁机制，功能和 synchronized 类似，是对 synchronized 的升级，它是一个接口。

        

        它的常用实现类是 ReentrantLock。

        synchronized 是通过 JVM 实现锁机制，ReentrantLock 是通过 JDK 实现锁机制。

        synchronized 是一个关键字，ReentrantLock 是一个类。

        重入锁：可以给同一个资源添加多把锁。

        synchronized 是线程执行完毕之后自动释放锁，ReentrantLock 需要手动解锁。

用 synchronized 实现卖票

import java.util.concurrent.TimeUnit;
​
public class Test {
    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();
    }
}
​
class Ticket{
    private Integer saleNum = 0;
    private Integer lastNum = 30;
​
    public synchronized void sale(){
        if(lastNum > 0){
            saleNum++;
            lastNum--;
            try {
                TimeUnit.MILLISECONDS.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"卖出了第"+saleNum+"张票，剩余"+lastNum+"张票");
        }
    }
​
}

用 Lock 完成卖票

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
​
public class Test2 {
    public static void main(String[] args) {
        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();
    }
}
​
class Ticket2{
    private Integer saleNum = 0;
    private Integer lastNum = 30;
    private Lock lock = new ReentrantLock();
​
    public void sale(){
​
        lock.lock();
        lock.lock();
        if(lastNum > 0){
            saleNum++;
            lastNum--;
            try {
                TimeUnit.MILLISECONDS.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"卖出了第"+saleNum+"张票，剩余"+lastNum+"张票");
        }
        lock.unlock();
        lock.unlock();
    }
}

synchronized 和 lock 的区别 

        1、synchronized 自动上锁，自动释放锁，Lock 手动上锁，手动释放锁。

        2、synchronized 无法判断是否获取到了锁，Lock 可以判断是否拿到了锁。

        3、synchronized 拿不到锁就会一直等待，Lock 不一定会一直等待。

        4、synchronized 是 Java 关键字，Lock 是接口。

        5、synchronized 是非公平锁，Lock 可以设置是否为公平锁。

公平锁

        很公平，排队，当锁没有被占用时，当前线程需要判断队列中是否有其他等待线程。

非公平锁

        不公平，插队，当锁没有被占用时，当前线程可以直接占用，而不需要判断当前队列中是否有等待线程。

        实际开发中推荐使用 Lock 的方式。

        ReentrantLock 具备限时性的特点，可以判断某个线程在一定的时间段内能否获取到锁，使用 tryLock 方法，返回值是 boolean 类型，true 表示可以获取到锁，false 表示无法获取到锁。

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
​
public class Test {
    public static void main(String[] args) {
        TimeLock timeLock = new TimeLock();
        new Thread(()->{
            timeLock.getLock();
        },"A").start();
        new Thread(()->{
            timeLock.getLock();
        },"B").start();
    }
}
​
class TimeLock{
    private ReentrantLock lock = new ReentrantLock();
​
    public void getLock(){
        try {
            if(lock.tryLock(3, TimeUnit.SECONDS)){
                System.out.println(Thread.currentThread().getName()+"拿到了锁");
                TimeUnit.SECONDS.sleep(5);
            }else{
                System.out.println(Thread.currentThread().getName()+"拿不到锁");
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            // 判断是否是当前线程占用的锁
            if(lock.isHeldByCurrentThread()){
                lock.unlock();
            }
        }
    }
​
}

生产者消费者模式

synchronized

import java.util.concurrent.TimeUnit;
​
public class Test {
    public static void main(String[] args) {
        Data data = new Data();
        new Thread(()->{
            for (int i = 0; i < 30; i++) {
                data.increment();
            }
        },"A").start();
        new Thread(()->{
            for (int i = 0; i < 30; i++) {
                data.decrement();
            }
        },"B").start();
    }
}
​
class Data{
    private Integer num = 0;
​
    public synchronized void increment(){
        while(num!=0){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        num++;
        this.notify();
        System.out.println(Thread.currentThread().getName()+"生产了汉堡"+num);
    }
​
    public synchronized void decrement(){
        while(num == 0){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        num--;
        this.notify();
        System.out.println(Thread.currentThread().getName()+"消费了汉堡"+num);
    }
}

        必须使用 while 判断，不能用 if，因为 if 会存在线程虚假唤醒的问题，虚假唤醒就是一些 wait 方法会在除了 notify 的其他情况被唤醒，不是真正的唤醒，使用 while 完成多重检测，避免这一问题。

Lock

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
​
public class Test {
    public static void main(String[] args) {
        Data data = new Data();
        new Thread(()->{
            for (int i = 0; i < 30; i++) {
                data.increment();
            }
        },"A").start();
        new Thread(()->{
            for (int i = 0; i < 30; i++) {
                data.decrement();
            }
        },"B").start();
    }
}
​
class Data{
    private Integer num = 0;
​
    private Lock lock = new ReentrantLock();
​
    private Condition condition = lock.newCondition();
​
    public void increment(){
        lock.lock();
        while(num!=0){
            try {
                condition.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        num++;
        condition.signal();
        System.out.println(Thread.currentThread().getName()+"生产了汉堡"+num);
        lock.unlock();
    }
​
    public synchronized void decrement(){
        lock.lock();
        while(num == 0){
            try {
                condition.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        num--;
        condition.signal();
        System.out.println(Thread.currentThread().getName()+"消费了汉堡"+num);
        lock.unlock();
    }
}

        使用 Lock 锁，就不能通过 wait 和 notify 来暂停线程和唤醒线程，而应该使用 Condition 的 await() 和 signal() 来暂停和唤醒线程。

ConcurrentModificationException

并发访问异常

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;
​
public class Test {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                try {
                    TimeUnit.MILLISECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //写
                list.add("a");
                //读
                System.out.println(list);
            },String.valueOf(i)).start();
        }
    }
}

如何解决？

        1、Vector（ArrayList 线程不安全，Vector 线程安全）

        

         

        2、Collections.synchronizedList

package com.icss.test2;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.TimeUnit;

public class Test {
    public static void main(String[] args) {
        List<String> list = Collections.synchronizedList(new ArrayList<>());
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                try {
                    TimeUnit.MILLISECONDS.sleep(1);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                list.add("a");
                System.out.println(list);
            },String.valueOf(i)).start();
        }
    }
}

        3、JUC：CopyOnWriteArrayList

import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.TimeUnit;
​
public class Test2 {
    public static void main(String[] args) {
        List<String> list = new CopyOnWriteArrayList<>();
        for (int i = 0; i < 10; i++) {
            new Thread((()->{
                try {
                    TimeUnit.MILLISECONDS.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                list.add("a");
                System.out.println(list);
            })).start();
        }
    }
}

        CopyOnWrite 写时复制，当我们往一个容器添加元素的时候，不是直接给容器添加，而是先将当前容器复制一份，向新的容器中添加数据，添加完成之后，再将原容器的引用指向新的容器。

 

Set

import java.util.List;
import java.util.Set;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.CopyOnWriteArraySet;
import java.util.concurrent.TimeUnit;
​
public class Test2 {
    public static void main(String[] args) {
        Set<String> set = new CopyOnWriteArraySet<>();
        for (int i = 0; i < 10; i++) {
            final int temp = i;
            new Thread((()->{
                try {
                    TimeUnit.MILLISECONDS.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                set.add(String.valueOf(temp)+"a");
                System.out.println(set);
            })).start();
        }
    }
}

Map

import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.CopyOnWriteArraySet;
import java.util.concurrent.TimeUnit;
​
public class Test2 {
    public static void main(String[] args) {
        Map<String,String> map = new ConcurrentHashMap<>();
        for (int i = 0; i < 10; i++) {
            final int temp = i;
            new Thread((()->{
                try {
                    TimeUnit.MILLISECONDS.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                map.put(UUID.randomUUID().toString().substring(0,3),UUID.randomUUID().toString().substring(0,2));
                System.out.println(map);
            })).start();
        }
    }
}
bug 消灭师
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java高级编程--多线程（二）
༺ཌ༈君纤༈ད༻
06-11 247
多线程程序将单个任务按照功能分解成多个子任务来执行，每个子任务称为一个线程，多个线程共同完成主任务的运行过程，这样可以缩短用户等待时间，提高服务效率。本篇博客将继续介绍Java开发中多线程的使用。
Java并发编程（一）——线程
lkl713的专栏
03-21 764
Java并发编程（一）——线程一，线程的实现方式　　Java中实现多线程有两种方式，如下：1，继承java.lang.Thread类，重载它的run()方法； 2，实现java.lang.Runnable接口，重载接口中的run()方法。　　这两种实现方式没有优劣，但由于Java中不允许多继承，所以使用第二种实现接口的方式更加灵活。 　　另外需要注意的是实现了Runnable的类，就像其字面描述
Java多线程实战-CompletableFuture异步编程优化查询接口响应速度
热门推荐
qq_35716689的博客
03-20 15万+
CompletableFuture为Java提供了强大的异步编程能力,可以极大地提高应用的并发能力和响应速度。通过并行执行多个查询任务,我们可以大幅减少接口的响应时间,优化用户体验。同时,CompletableFuture的代码风格函数式、简洁、优雅,也使得代码更加易读易维护。 但是,异步编程也不是万能的,它需要开发者转变思维模式,还需要权衡利弊。在实际项目中,我们可以结合其他优化手段,选择合适的方案,以达到最佳的性能效果。
Java并发编程-ThreadPool线程池
Java硬件工程师的博客
01-29 5026
1.线程池的优势 1.1.引言 与数据库线程池类似，如果没有数据库连接池，那么每次对数据库的连接池都要new来获取连接池。重复的连接和释放操作会消费大量的系统资源，我们可以使用数据库连接池，直接去池中取连接池。 同样，在没有线程池之前，我们也是通过new Thread.start()来获取线程，现在我们也不需要new了，这样就能实现复用，使得我们系统变得更加高效。 1.2.为什么要使用线程池 例子： 10年前单核CPU电脑，假的多线程，像马戏团小丑玩多个球，CPU需要来回切换。 现在是多核电脑，多个线程各
Java并发编程-线程池
千月落
02-21 1万+
Java 中的线程池是运用场景最多的并发框架，几乎所有需要异步或并发执行任务的程序都可以使用线程池。
62-Java并发编程实战
10-10
62-Java并发编程实战62-Java并发编程实战62-Java并发编程实战62-Java并发编程实战62-Java并发编程实战62-Java并发编程实战62-Java并发编程实战62-Java并发编程实战62-Java并发编程实战62-Java并发编程实战62-Java...
Java并发编程-3.pdf
05-28
Java并发编程中的多线程协作机制 在 Java 并发编程中，多线程协作机制是非常重要的一部分。多线程协作机制是指在多线程编程中，多个线程之间如何协作、同步和通信，以达到共同完成某个任务的目的。Java 提供了多种...
java-并发编程-知识点汇总
09-05
java_并发编程_知识点汇总
Java学习资料-并发编程.zip
06-18
Java并发编程是Java开发中的重要领域，特别是在多核处理器和分布式系统中，高效地利用多线程进行并发处理是提升程序性能的关键。本资源包包含了两大部分，旨在帮助学习者深入理解和掌握Java并发编程的核心概念和技术...
12. Hibernate 模板设计模式
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 1220
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
Java-Lambda
lizhiwei21的博客
07-21 506
lambda表达式可以理解为对匿名内部类的一种简化 , 但是本质是有区别的面向对象思想 :强调的是用对象去完成某些功能函数式编程思想 :强调的是结果 , 而不是怎么去做。
Promise 详解（原理篇）
山重水复疑无路，柳暗花明又一村。
07-20 805
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
Java读取文件中多个JSON对象，并且16进制字符串和byte相互转换，将byte转为16进制字符串并写入json文件
weixin_43561432的博客
07-24 286
【代码】Java读取文件中多个JSON对象，并且16进制字符串和byte相互转换，将byte转为16进制字符串并写入json文件。
淘客返利系统中的服务发现与注册机制详解
技术研究中心
07-22 2178
通过服务注册中心，服务提供者可以将自己注册到注册中心，服务消费者可以从注册中心获取服务提供者的地址，以实现服务调用。本文详细介绍了淘客返利系统中服务发现与注册机制的实现，包括Eureka的配置与代码示例。通过Eureka，我们可以轻松实现服务的注册与发现，确保分布式系统中各个服务之间的通信。在本文中，我们将深入探讨淘客返利系统中的服务发现与注册机制，并结合Java代码进行详细讲解。在我们的淘客返利系统中，我们采用Eureka作为服务发现与注册的工具。在我们的淘客返利系统中，首先需要配置Eureka服务器。
Java实现拼图小游戏
Aishangyuwen的博客
07-22 1356
Java实现拼图小游戏
华为OD机试 - 分披萨 - 递归（Java 2024 D卷 200分）
学Java，找哪吒
07-21 1006
递归算法通过函数调用自身解决问题，每次递归调用都处理问题的一个子部分，直到达到基准条件，从而构建最终解。
Java代码基础算法练习-数的特性-2024.07.25
最新发布
Sakurapaid的博客
07-25 270
小A喜欢两种性质都成立的数字，小B喜欢至少符合一种性质的数字，小C喜欢不符合这两种性质的 数字。给出一个数字，请输出三个人是否喜欢这个数字。如果喜欢输出1，否则输出0，用空格分隔。输入数字 num，先定义三个整型代表三个人的喜欢与否，先默认设为 0。之后判断num对于性质1、2的条件，分别用 boolen 类型标识。对于每个整型进行判断，是否改为 1 代表喜欢。性质2：大于4且不大于12;
【Java并发编程之美 | 第三篇】Java 并发包中锁原理剖析之AQS、ReentrantLock独占可重入锁
踢桃的成长之路
07-21 860
Java 并发包中锁原理剖析之AQS、ReentrantLock独占可重入锁
Java并发编程权威指南 - JVM平台并发实践
在Java并发编程中，主要涉及以下几个核心知识点： 1. **线程与多线程**：Java中的线程是并发执行的基本单元，理解线程的创建、启动、同步、中断和停止等操作是并发编程的基础。 2. **线程安全**：在多线程环境下，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

bug 消灭师

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

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

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

打赏作者

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

抵扣说明：

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

余额充值