JAVA-API（三）：多线程并发安全问题、集合框架

最新推荐文章于 2023-03-28 09:23:17 发布
最新推荐文章于 2023-03-28 09:23:17 发布
阅读量490 收藏
点赞数
文章标签： 大数据 java 开发语言 后端 网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq526017350/article/details/125826340
版权

一、多线程并发安全问题

1. 多线程并发安全问题

当多个线程并发操作同一临界资源，由于线程切换时机不确定，导致操作临界资源的顺序出现混乱严重时可能导致系统瘫痪。
临界资源：操作该资源的全过程同时只能被单个线程完成。

package thread;

/**
 * 多线程并发安全问题
 * 当多个线程并发操作同一临界资源，由于线程切换的时机不确定，导致操作顺序出现
 * 混乱，严重时可能导致系统瘫痪。
 * 临界资源:同时只能被单一线程访问操作过程的资源。
 */
public class SyncDemo {
    public static void main(String[] args) {
        Table table = new Table();
        Thread t1 = new Thread(){
            public void run(){
                while(true){
                    int bean = table.getBean();
                    Thread.yield();
                    System.out.println(getName()+":"+bean);
                }
            }
        };
        Thread t2 = new Thread(){
            public void run(){
                while(true){
                    int bean = table.getBean();
                    /*
                        static void yield()
                        线程提供的这个静态方法作用是让执行该方法的线程
                        主动放弃本次时间片。
                        这里使用它的目的是模拟执行到这里CPU没有时间了，发生
                        线程切换，来看并发安全问题的产生。
                     */
                    Thread.yield();
                    System.out.println(getName()+":"+bean);
                }
            }
        };
        t1.start();
        t2.start();
    }
}

class Table{
    private int beans = 20;//桌子上有20个豆子

    public int getBean(){
        if(beans==0){
            throw new RuntimeException("没有豆子了!");
        }
        Thread.yield();
        return beans--;
    }
}

2. synchronized关键字

synchronized有两种使用方式

  • 在方法上修饰，此时该方法变为一个同步方法

  • 同步块，可以更准确的锁定需要排队的代码片段

同步方法

当一个方法使用synchronized修饰后，这个方法称为"同步方法"，即：多个线程不能同时 在方法内部执行。只能有先后顺序的一个一个进行。 将并发操作同一临界资源的过程改为同步执行就可以有效的解决并发安全问题。

package thread;

/**
 * 多线程并发安全问题
 * 当多个线程并发操作同一临界资源，由于线程切换的时机不确定，导致操作顺序出现
 * 混乱，严重时可能导致系统瘫痪。
 * 临界资源:同时只能被单一线程访问操作过程的资源。
 */
public class SyncDemo {
    public static void main(String[] args) {
        Table table = new Table();
        Thread t1 = new Thread(){
            public void run(){
                while(true){
                    int bean = table.getBean();
                    Thread.yield();
                    System.out.println(getName()+":"+bean);
                }
            }
        };
        Thread t2 = new Thread(){
            public void run(){
                while(true){
                    int bean = table.getBean();
                    /*
                        static void yield()
                        线程提供的这个静态方法作用是让执行该方法的线程
                        主动放弃本次时间片。
                        这里使用它的目的是模拟执行到这里CPU没有时间了，发生
                        线程切换，来看并发安全问题的产生。
                     */
                    Thread.yield();
                    System.out.println(getName()+":"+bean);
                }
            }
        };
        t1.start();
        t2.start();
    }
}

class Table{
    private int beans = 20;//桌子上有20个豆子

    /**
     * 当一个方法使用synchronized修饰后，这个方法称为同步方法，多个线程不能
     * 同时执行该方法。
     * 将多个线程并发操作临界资源的过程改为同步操作就可以有效的解决多线程并发
     * 安全问题。
     * 相当于让多个线程从原来的抢着操作改为排队操作。
     */
    public synchronized int getBean(){
        if(beans==0){
            throw new RuntimeException("没有豆子了!");
        }
        Thread.yield();
        return beans--;
    }
}

同步块

有效的缩小同步范围可以在保证并发安全的前提下尽可能的提高并发效率。同步块可以更准确的控制需要多个线程排队执行的代码片段。

语法：

synchronized(同步监视器对象){
   需要多线程同步执行的代码片段
}

同步监视器对象即上锁的对象,要想保证同步块中的代码被多个线程同步运行，则要求多个线程看到的同步监视器对象是同一个。

package thread;

/**
 * 有效的缩小同步范围可以在保证并发安全的前提下尽可能提高并发效率。
 *
 * 同步块
 * 语法:
 * synchronized(同步监视器对象){
 *     需要多个线程同步执行的代码片段
 * }
 * 同步块可以更准确的锁定需要多个线程同步执行的代码片段来有效缩小排队范围。
 */
public class SyncDemo2 {
    public static void main(String[] args) {
        Shop shop = new Shop();
        Thread t1 = new Thread(){
            public void run(){
                shop.buy();
            }
        };
        Thread t2 = new Thread(){
            public void run(){
                shop.buy();
            }
        };
        t1.start();
        t2.start();
    }
}

class Shop{
    public void buy(){
        /*
            在方法上使用synchronized，那么同步监视器对象就是this。
         */
//    public synchronized void buy(){
        Thread t = Thread.currentThread();//获取运行该方法的线程
        try {
            System.out.println(t.getName()+":正在挑衣服...");
            Thread.sleep(5000);
            /*
                使用同步块需要指定同步监视器对象，即:上锁的对象
                这个对象可以是java中任何引用类型的实例，只要保证多个需要排队
                执行该同步块中代码的线程看到的该对象是"同一个"即可
             */
            synchronized (this) {
//            synchronized (new Object()) {//没有效果!
                System.out.println(t.getName() + ":正在试衣服...");
                Thread.sleep(5000);
            }

            System.out.println(t.getName()+":结账离开");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }
}

在静态方法上使用synchronized

当在静态方法上使用synchronized后，该方法是一个同步方法。由于静态方法所属类，所以一定具有同步效果。

静态方法使用的同步监视器对象为当前类的类对象(Class的实例)。

注：类对象会在后期反射知识点介绍。

package thread;

/**
 * 静态方法上如果使用synchronized，则该方法一定具有同步效果。
 */
public class SyncDemo3 {
    public static void main(String[] args) {
        Thread t1 = new Thread(){
            public void run(){
                Boo.dosome();
            }
        };
        Thread t2 = new Thread(){
            public void run(){
                Boo.dosome();
            }
        };
        t1.start();
        t2.start();
    }
}
class Boo{
    /**
     * synchronized在静态方法上使用是，指定的同步监视器对象为当前类的类对象。
     * 即:Class实例。
     * 在JVM中，每个被加载的类都有且只有一个Class的实例与之对应，后面讲反射
     * 知识点的时候会介绍类对象。
     */
    public synchronized static void dosome(){
            Thread t = Thread.currentThread();
            try {
                System.out.println(t.getName() + ":正在执行dosome方法...");
                Thread.sleep(5000);
                System.out.println(t.getName() + ":执行dosome方法完毕!");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

静态方法中使用同步块时，指定的锁对象通常也是当前类的类对象

class Boo{
    public static void dosome(){
        /*
            静态方法中使用同步块时，指定同步监视器对象通常还是用当前类的类对象
            获取方式为:类名.class
         */
        synchronized (Boo.class) {
            Thread t = Thread.currentThread();
            try {
                System.out.println(t.getName() + ":正在执行dosome方法...");
                Thread.sleep(5000);
                System.out.println(t.getName() + ":执行dosome方法完毕!");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

互斥锁

当多个线程执行不同的代码片段，但是这些代码片段之间不能同时运行时就要设置为互斥的。

使用synchronized锁定多个代码片段，并且指定的同步监视器是同一个时，这些代码片段之间就是互斥的。

package thread;

/**
 * 互斥锁
 * 当使用synchronized锁定多个不同的代码片段，并且指定的同步监视器对象相同时，
 * 这些代码片段之间就是互斥的，即:多个线程不能同时访问这些方法。
 */
public class SyncDemo4 {
    public static void main(String[] args) {
        Foo foo = new Foo();
        Thread t1 = new Thread(){
            public void run(){
                foo.methodA();
            }
        };
        Thread t2 = new Thread(){
            public void run(){
                foo.methodB();
            }
        };
        t1.start();
        t2.start();
    }
}
class Foo{
    public synchronized void methodA(){
        Thread t = Thread.currentThread();
        try {
            System.out.println(t.getName()+":正在执行A方法...");
            Thread.sleep(5000);
            System.out.println(t.getName()+":执行A方法完毕!");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    public synchronized void methodB(){
        Thread t = Thread.currentThread();
        try {
            System.out.println(t.getName()+":正在执行B方法...");
            Thread.sleep(5000);
            System.out.println(t.getName()+":执行B方法完毕!");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

二、聊天室（续）

1. 实现服务端发送消息给客户端

在服务端通过Socket获取输出流，客户端

最低0.47元/天 解锁文章
戴假发的凡士林
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
多线程池多线程导入Excel数据到数据库，使用Apache POI把数据库数据导出为Excel文件
m0_74436268的博客
06-14 1493
调试多线程程序可能会更加困难，并且由于线程之间的相互依赖关系，修改一个线程可能会对其他线程产生影响，增加了维护的复杂性。这种上下文切换会引入一定的开销，特别是当线程数目很多时，上下文切换的开销可能会超过线程并发带来的性能提升。线程安全问题：多线程并发操作共享的数据时，需要考虑线程安全性。内存占用：每个线程都需要分配一定的内存空间，当同时运行大量线程时，会消耗大量的内存资源。尽管多线程池可以提高数据上传的效率，但在使用时需要权衡以上缺点，根据具体情况进行合理的调度和控制，以确保系统的稳定性和性能。
【多线程】如何保证线程安全
后而来者
09-13 2270
原文链接 一、线程安全等级 之前的博客中已有所提及“线程安全”问题，一般我们常说某某类是线程安全的，某某是非线程安全的。其实线程安全并不是一个“非黑即白”单项选择题。按照“线程安全”的安全程度由强到弱来排序，我们可以将java语言中各种操作共享的数据分为以下5类：不可变、绝对线程安全、相对线程安全、线程兼容和线程对立。 1、不可变 在java语言中，不可变的对象一定是线程安全的，无论是对象的方法实现还是方法的调用者，都不需要再采取任何的线程安全保障措施。如final关键字修饰的数据不可修改，可靠性最高。
高并发场景下的线程安全
weixin_61294560的博客
10-08 648
并发场景总结
IO、集合、多线程等基础框架
编程日常记录与总结 https://franciswmf.iteye.com
07-10 2392
[b]1、集合[/b] Java集合总览 [url]http://www.importnew.com/13801.html[/url] Java集合类详解 [url]http://blog.csdn.net/u014136713/article/details/52089156[/url] Java基础——集合（一）——集合体系、Collection集合 [url]http:/...
使用magic-api ，让你的开发效率蹭蹭提升
我是香菜
03-28 6487
magic-api使用过程中的一些问题
JAVA_API1.6文档（中文）
04-12
java.util.concurrent.atomic 类的小工具包，支持在单个变量上解除锁的线程安全编程。 java.util.concurrent.locks 为锁和等待条件提供一个框架的接口和类，它不同于内置同步和监视器。 java.util.jar 提供读写 ...
javaswing程序源码-java-book:《Java编程：综合入门》一书的源代码
05-19
java swing程序源码 Java 7 程序设计入门经典 《Java 7 程序设计入门经典》根据最新的 Java ...包的大部分内容，以及集合框架、网络和并发 API 等。 Java Programming: A Comprehensive Introducti
Java 集合方面的面试题
03-24
Java 中集合框架的主要接口是什么？ ArrayList 和 LinkedList 有什么区别？ HashSet 和 TreeSet 有什么区别？ HashMap 和 TreeMap 有什么区别？ 什么是迭代器？如何使用它来遍历集合？ 什么是 fail-fast 机制？ 如何...
java api最新7.0
10-26
java.util.concurrent.atomic 类的小工具包，支持在单个变量上解除锁的线程安全编程。 java.util.concurrent.locks 为锁和等待条件提供一个框架的接口和类，它不同于内置同步和监视器。 java.util.jar 提供读写 JAR ...
Java 1.6 API 中文 New
10-26
java.util.concurrent.atomic 类的小工具包，支持在单个变量上解除锁的线程安全编程。 java.util.concurrent.locks 为锁和等待条件提供一个框架的接口和类，它不同于内置同步和监视器。 java.util.jar 提供读写 JAR ...
Java并发API案例分析之并发设计原理
陆海潘江的博客
01-15 3741
并发、并行、同步、锁、线程安全……这一篇我记录了学习并发设计原理的关键知识，还有一些常用重要的Java并发编程API，学习一些关于并发程序设计的原理，弄懂来龙去脉，相对更加深入地理解并这部分知识。在学习理论知识后，对这个部分有了更深层的理解！
Java并发协作控制之相关API
zucc_shen的博客
07-11 97
线程协作 Thread/Executor/Fork-Join – 线程启动，运行，结束 – 线程之前缺少协作 synchronized 同步 – 限定只能一个线程进入关键区 – 简单粗暴，性能损失大 Lock Lock实现同步的效果 – 实现更复杂的临界区结构 – tryLock方法可以预判锁是否空闲 – 允许分离读写操作，多个读，一个写 – 性能更好 ReentrantLock 类，可重入的互斥锁 ReentrantReadWriteLock 类，可重入的读写锁 lock和unlock函数 奶茶店
[Java]并发编程-API
Twiss的博客
02-19 274
一、synchronized和volatile关键字 手动上锁，自动释放锁。 锁的是对象有两种：1、类的实例，指向堆里的唯一的实例；2、类的字节码。 锁对象的改变 package com.sync; import java.util.concurrent.TimeUnit; public class ChangeOfLockObject { Object o = new Objec...
Java高并发秒杀API(一)之业务分析与DAO层
不积跬步，无以至千里
10-04 9020
Java高并发秒杀API(一)之业务分析与DAO层 本SSM实战项目使用了Maven进行依赖管理，如果有不清楚Maven是什么的可以参考这篇文章 1. 创建Maven项目和依赖 1.1 创建项目前需要先安装Maven，并设置好环境变量 Maven下载 设置环境变量 新建变量MAVEN_HOME，值为Maven的目录X:\XXX\apache-maven-XXX 将%...
java多线程框架_Java基础之多线程框架
weixin_42189611的博客
02-12 1027
一.进程与线程的区别1.定义：进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动,进程是系统进行资源分配和调度的一个独立单位。线程是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位.线程自己基本上不拥有系统资源,只拥有一点在运行中必不可少的资源(如程序计数器,一组寄存器和栈),但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源。2.关系：一个线程...
JAVA并发之多线程引发的问题剖析以及如何保证线程安全
srs1995的博客
10-26 649
JAVA多线程中的各种问题剖析 首先开始之前 需要提及一下前置章节 能够更加深入了解本节所讲 JAVA并发之基础概念篇 JAVA并发之进程VS线程篇 首先我们来说一下并发的优点,根据优点特性,引出并发应当注意的安全问题 1并发的优点 技术在进步，CPU、内存、I/O 设备的性能也在不断提高。但是，始终存在一个核心矛盾：CPU、内存、I/O 设备存在速度差异。CPU 远快于内存，内存远快于 I/O 设备。 根据木桶短板理论可知，一只木桶能装多少水，取决于最短的那块木板。程序整体性能取决于最慢的操作—
java 高并发写入文件时切换文件_RandomAccessFile文件锁踩坑--write高并发引起漏数据...
weixin_29391349的博客
02-28 1185
背景多线程写入文件，要考虑线程同步问题，实现数据完整落盘磁盘备份。操作系统：win10：没问题centos7：有问题public static void writeFileLock(String content, String filePath) {File file = new File(filePath);RandomAccessFile raf = null;FileChannel file...
java多线程那些重点
最新发布
07-20
8. 线程安全的集合类：Java提供了线程安全的集合类，如ConcurrentHashMap和CopyOnWriteArrayList等，用于在多线程环境下安全地操作集合。 以上是Java多线程的一些重点，掌握这些概念和技术可以帮助您更好地理解和...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值