并发编程(三)- Local接口&集合线程安全问题

已于 2022-03-01 14:39:58 修改
阅读量3.8k 收藏 1
点赞数
分类专栏： 并发编程 文章标签： 安全 java 开发语言
于 2022-03-01 14:17:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/java123456111/article/details/123204681
版权

1、Local接口

​ LOCK是类，可通过类实现同步访问，多个接口实现类：可重入锁等

lock的编程步骤同synchronized

  1. 创建资源类，在资源类中创建属性和操作方法
  2. 创建多个线程，调用资源类的操作方法

可重入锁的代码定义

private final ReentrantLock lock = new ReentrantLock(true);

  • 上锁：lock.lock();

  • 解锁：lock.unlock();

    上锁与解锁中的代码如果出现异常，解锁会执行不了，所以最好加try..finally

代码：

@Slf4j
public class SaleTicket {
    public static void main(String[] args) {
        LTicket lTicket = new LTicket();

        new Thread(()->{
            for (int i = 0; i < 40; i++) {
                lTicket.sale();
            }
        },"AA").start();

        new Thread(()->{
            for (int i = 0; i < 40; i++) {
                lTicket.sale();
            }
        },"BB").start();

        new Thread(()->{
            for (int i = 0; i < 40; i++) {
                lTicket.sale();
            }
        },"CC").start();

    }
}

@Slf4j
class LTicket{
    private int number = 30;

    // 创建可重入锁
   private final ReentrantLock lock =  new ReentrantLock();

   public void sale(){
       // 上锁
       lock.lock();
       try {
           if(number > 0){
               System.out.println(Thread.currentThread().getName() + "卖出:" + number-- + "剩余：" + number);
           }
       } finally {
           // 解锁
           lock.unlock();
       }
   }

}
1.1 Lock和synchronized有以下几点不同

  • Lock是一个接口，而synchronized是Java中的关键字，synchronized是内置的语言实现。

  • synchronized在发生异常时，会自动释放线程占有的锁，因此不会导致死锁现象发生；而Lock在发生异常时，如果没有主动通过unlock()去释放锁，则很可能造成死锁现象，因此使用Lock时需要在finally块中释放锁；

  • Lock可以让等待锁的线程响应中断，而synchronized却无法办到。

  • Lock可以提高多个线程进行读操作的效率。

    ​ 在性能上来说，如果竞争资源不激烈，两者的性能是差不多的，而当竞争资源非常激烈时（既有大量线程同时竞争），此时Lock的性能要远远由于synchronized。

1.2 使用Lock和synchronized方式处理下面问题

（1）有两个线程，实现对一个初始值是0的变量，一个线程对值+1，另外一个线程对值-1的操作

  • 使用synchrionzed方法

    public class ThreadDemo01 {
    public static void main(String[] args) {
        share share = new share();

        new Thread(()->{
            for (int i = 1; i <= 10 ; i++) {
                try {
                    share.incr();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"AA").start();

        new Thread(()->{
            for (int i = 1; i <= 10 ; i++) {
                try {
                    share.decr();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"BB").start();
    }
}

class share{

    private int number = 0;

    // +1方法
    public synchronized void incr() throws InterruptedException {
        if(number != 0){
            //等待
            this.wait();
        }
        //如果number等于0，则加一
        number++;
        System.out.println(Thread.currentThread().getName() + " : " + number);
        //在通知其他线程
        this.notifyAll();
    }

    // -1方法
    public synchronized void decr() throws InterruptedException {
        // 判断number不等于1，则等待
        if(number != 1){
            this.wait();
        }
        number--;
        System.out.println(Thread.currentThread().getName() + " : " + number);
        //在通知其他线程
        this.notifyAll();
    }
}

    打印结果：

    结果是两个线程交替执行各10次
    在这里插入图片描述

如果使用多个线程，添加额外两个线程，且操作要依次执行

new Thread(()->{
    for (int i = 1; i <=10; i++) {
        try {
            share.incr(); //+1
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
},"CC").start();

new Thread(()->{
    for (int i = 1; i <=10; i++) {
        try {
            share.decr(); //-1
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
},"DD").start();

打印结果:
在这里插入图片描述

要么出现大于1的值，要么出现小于0的值。这种现象出现的原因就是因为主要是调用wait()方法出现虚假唤醒现象导致：如果一个线程执行完毕后，通知其他线程，该线程又进入等待睡眠，可能会因为某些原因被唤醒后，if结构的语句就不会判断了，一直往下执行，所以需要将if换成while结构，每次都判断。因为wait在哪里睡眠就在哪里被唤醒，结果被某个异常唤醒了后回不去了，if结构不会再判断了，需要更改为while，一般wait()方法使用在循环里面。

while(number != 0) { // 判断number值是否是0，如果不是0，等待
    this.wait(); // 在哪里睡，就在哪里醒
}

打印结果：
在这里插入图片描述

2、线程间的定制化通信

2.1 需求如下图

​ 所谓定制化通信，需要让线程进行一定的顺序操作。

​ 案例：启动三个线程，按照如下要求：

​ AA打印5次，BB打印10次，CC打印15次，一共进行10轮

具体思路：

​ 每个线程添加一个标志位，是该标志位则执行操作，并且修改为下一个标志位，通知下一个标志位的线程
在这里插入图片描述

具体代码：

//第一步 创建资源类
class ShareResource {
    //定义标志位
    private int flag = 1;  // 1 AA     2 BB     3 CC

    //创建Lock锁
    private Lock lock = new ReentrantLock();

    //创建三个condition
    private Condition c1 = lock.newCondition();
    private Condition c2 = lock.newCondition();
    private Condition c3 = lock.newCondition();

    //打印5次，参数第几轮
    public void print5(int loop) throws InterruptedException {
        //上锁
        lock.lock();
        try {
            //判断
            while(flag != 1) {
                //等待
                c1.await();
            }
            //干活
            for (int i = 1; i <=5; i++) {
                System.out.println(Thread.currentThread().getName()+" :: "+i+" ：轮数："+loop);
            }
            //通知
            flag = 2; //修改标志位 2
            c2.signal(); //通知BB线程
        }finally {
            //释放锁
            lock.unlock();
        }
    }

    //打印10次，参数第几轮
    public void print10(int loop) throws InterruptedException {
        lock.lock();
        try {
            while(flag != 2) {
                c2.await();
            }
            for (int i = 1; i <=10; i++) {
                System.out.println(Thread.currentThread().getName()+" :: "+i+" ：轮数："+loop);
            }
            //修改标志位
            flag = 3;
            //通知CC线程
            c3.signal();
        }finally {
            lock.unlock();
        }
    }

    //打印15次，参数第几轮
    public void print15(int loop) throws InterruptedException {
        lock.lock();
        try {
            while(flag != 3) {
                c3.await();
            }
            for (int i = 1; i <=15; i++) {
                System.out.println(Thread.currentThread().getName()+" :: "+i+" ：轮数："+loop);
            }
            //修改标志位
            flag = 1;
            //通知AA线程
            c1.signal();
        }finally {
            lock.unlock();
        }
    }
}

public class ThreadDemo3 {
    public static void main(String[] args) {
        ShareResource shareResource = new ShareResource();
        new Thread(()->{
            for (int i = 1; i <=10; i++) {
                try {
                    shareResource.print5(i);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"AA").start();

        new Thread(()->{
            for (int i = 1; i <=10; i++) {
                try {
                    shareResource.print10(i);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"BB").start();

        new Thread(()->{
            for (int i = 1; i <=10; i++) {
                try {
                    shareResource.print15(i);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"CC").start();
    }
}

3、集合的线程安全

/**
 * @author xxx
 * @date 2022-03-01 10:53
 * @description
 *  线程不安全问题：
 *      List集合是线程不安全的
 *      造成的原因：并发修改异常
 */
public class ThreadDemo {

    public static void main(String[] args) {
        List<String> list = new ArrayList<>();

        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                // 向集合中添加数据
                list.add(UUID.randomUUID().toString().substring(0,8));

                // 从集合中取数据
                System.out.println(list);
            },String.valueOf(i)).start();
        }
    }
}

打印结果：
在这里插入图片描述

查看源码,主要是这个添加的方法是因为该方法在列表中是不安全的，没有synchronized声明

boolean add(E e);

java.util.ConcurrentModificationException为并发修改问题

3.1 Vector解决List线程不安全

通过list下的实现类Vector

因为在Vector下的add普遍都是线程安全

查看源码

public synchronized boolean add(E e) {
        modCount++;
        add(e, elementData, elementCount);
        return true;
    }

在改变代码时，只需要将其修改为List<String> list = new Vector<>();

但此方法用的比较少，因为在jdk 1.0的版本适用

3.2 Collections解决List线程不安全

Collections类中的很多方法都是static静态
其中有一个方法是返回指定列表支持的同步（线程安全的）列表为synchronizedList(List <T> list)
具体代码为

List<String> list = Collections.synchronizedList(new ArrayList<>());

此方法也比较古老，很少使用

3.3 CopyOnWriteArrayList解决List线程不安全
// CopyOnWriteArrayList解决线程安全性问题
List<String> list = new CopyOnWriteArrayList<>();

涉及的底层原理是写时复制技术

  • 读得时候并发（多个线程操作），支持并发读
  • 独立写，每次写都是先复制相同的空间到某个区域，将需要添加的内容写到新区域，内容写完之后，再新旧合并，再读取新区域的内容。这个方案的好处是即坚固了并发读，又照顾到了独立写。不会产生修改并发异常
3.4 HashSet集合线程不安全问题解决
		/**
         * 演示HashSet集合不安全问题
         */
        Set<String> set = new HashSet<>();
        for (int i = 0; i < 40; i++) {
            new Thread(()->{
                // 向集合中添加数据
                set.add(UUID.randomUUID().toString().substring(0,8));

                // 从集合中取数据
                System.out.println(set);
            },String.valueOf(i)).start();
        }

打印结果：
在这里插入图片描述

解决HashSet集合线程不安全的问题是使用CopyOnWriteArraySet()方法

		Set<String> set =new CopyOnWriteArraySet<>();
        for (int i = 0; i < 40; i++) {
            new Thread(()->{
                // 向集合中添加数据
                set.add(UUID.randomUUID().toString().substring(0,8));

                // 从集合中取数据
                System.out.println(set);
            },String.valueOf(i)).start();
        }
3.5 HashMap线程不安全处理方案
/**
         * 演示HashMap线程不安全问题
         */
        Map<String, String> hashMap = new HashMap<>();
        for (int i = 0; i < 40; i++) {
            String key = String.valueOf(i);
            new Thread(()->{
                // 向集合中添加数据
//                set.add(UUID.randomUUID().toString().substring(0,8));
                hashMap.put(key,UUID.randomUUID().toString().substring(0,8));
                // 从集合中取数据
                System.out.println(hashMap);
            },String.valueOf(i)).start();
        }

打印结果：
在这里插入图片描述

ConcurrentHashMap类是HashMap的实现类

将其代码修改为

Map<String,String> map = new ConcurrentHashMap<>();

通过这行代码可以编程线程安全问题

程序员老石
关注
专栏目录
Android中的线程（二）线程安全 & 线程同步
川峰的博客
06-08 2736
文章目录线程安全synchronizedReentrantLockvolatile 线程安全 线程安全又叫线程同步，在Java中多个线程同时访问一个可共享的资源变量时，有可能会导致数据不准确，导致使用该变量的逻辑出现问题，因此使用同步锁来保证一个线程对该资源的操作完成之前，其他线程不会对其进行操作，即保证线程同步安全。 因此线程同步的本质就是线程排队，这可能跟它的字面意思相反，它的目的就是保证线程按照先后顺序一个一个的访问共享资源，为了避免同时操作同一个共享资源。 在Java中实现线程安全的主要手段有：
实战系列-Java中线程安全集合类(一)
初学者
06-06 2624
导语   在Java开发中我们经常会遇到集合类线程安全的问题，在Java语言的发展过程中，从最初的线程不安全的集合类，到现在基本上支持很多的线程安全的集合类，在开发过程中，有些场景中不需要注意线程安全问题，当时在一个并发场景中就必须要使用到线程安全的集合类，那么下面就来看看在Java中比较常见的线程安全集合类以及其原理。 文章目录ConcurrentHashMap原理 ConcurrentHashMap原理   ConcurrentHashMap是线程安全且高效的HashMap集合类，在工作环境中并发与.
J2EE学习笔记六：本地与远程接口
鱼与飞鸟
12-05 2390
本地接口(Local Interface)是EJB的特征之一，它的主要目的是提高位于同一EJB容器中的企业bean(enterprise bean)之间相互访问的性能。比如说，一个会话bean要调用某个实体bean中的一些方法，并且这个会话bean和实体bean存在于同一个EJB服务器中，那么使用本地接口速度就会更快并且耗费更少的资源，因为此时会话bean和实体bean在同一个JVM中运行，它们使
线程安全：TheadLocal
sdfsfaf的博客
09-12 216
苦逼菜狗程序猿，用来总结和备忘，大家勿喷。 线程安全 概念 多个线程并发访问一个类，一个类始终都能表现出正确的行为。 线程安全和非安全的代码列子 非全选代码举例 package org.cc.safely; public class CountTest implements Runnable { private int count=5; @Override publi...
统计集合接口之间的关系以及线程安全的实现类
zzzzzzzzzzzzzzdd的博客
12-20 314
统计集合接口之间的关系以及线程安全的实现类 闲来无事，复习一下所学过的集合接口和实现类，首先是最大的Collection接口和Map接口，Collection 下面又有三个子接口List、Set 和Queue。Map下有一个子接口SortedMap。 其中List接口下面有实现类ArrayList，LinkedList，vector，CopyOnWriteArrayList四个实现类，Set下面...
14. 线程安全类型-ThreadLocal
Java 程序源
09-01 1198
在多线程开发中, 我们有时需要用到一些和线程状态相关的变量, 每个线程所拥有的变量不一致. java 提供了ThreadLocal 变量来实现. 1. ThreadLocal ThreadLocal 为每一个使用该变量的线程创建了一个副本, 使得每一个线程都可以独立地变更自己的副本, 与其它线程的副本隔离, 以实现线程对象的私有变量. 1.1 ThreadLocal API 方法签名 方法...
ThreadLocal线程安全示例及其原理
weixin_47053123的博客
07-10 4840
线程安全是多线程编程时的计算机程序代码中的一个概念。 在拥有共享数据的多条线程并行执行的程序中，线程安全的代码会通过同步机制保证各个线程都可以正常且正确的执行，不会出现数据污染等意外情况。 多个线程访问同一个对象时，如果不用考虑这些线程在运行时环境下的调度和交替执行，也不需要进行额外的同步，或者在调用方进行任何其他操作，调用这个对象的行为都可以获得正确的结果，那么这个对象就是线程安全的。 ...
JAVA并发编程与高并发解决方案 - 并发编程 三 之 线程安全策略
chuIllusions 的 博客
05-17 1702
JAVA并发编程与高并发解决方案 - 并发编程 三 版本 作者 内容 2018.5.17 chuIllusions 线程安全策略 线程安全策略 ​ 创建后状态不能被修改的对象叫作不可变对象。不可变对象天生就是线程安全的。它们的常量（变量）是在构造函数中创建的，既然它们的状态无法被修改，那么这些常量永远不会被改变——不可变对象永远是线程安全的。...
Java-jdk10-最新最全多线程编程实战指南-核心篇
12-14
通过阅读《Java-jdk10-最新最全多线程编程实战指南-核心篇》这本书，开发者不仅可以理解Java多线程编程的基础知识，还能掌握高级并发编程技巧，从而在实际项目中实现高性能、高并发的程序设计。对于Java开发者来说，...
静态类与并发编程：静态成员的线程安全实践
在多线程编程环境中，静态类与并发编程的概念紧密相关。静态类是一种没有实例的类，其成员变量和方法由所有类实例共享。这使得静态类在多线程应用程序中成为数据共享和并发执行的天然候选者。 ## 1.1 静态类的基本...
Java8中LocalDate详解&Date线程不安全的原因
qq_43842093的博客
10-22 2341
除了使用起来更加简单和灵活，主要是传统的时期处理类Date、Calendar不是多线程安全的，而LocalDate 线程安全的，所以不用担心并发问题。 Date线程不安全的原因
c语言 local,什么是C语言局部程序块(local block)?
weixin_42548708的博客
05-19 1742
局部程序块是指一对大括号({})之间的一段C语言程序。一个C函数包含一对大括号，这对大括号之间的所有内容都包含在一个局部程序块中。if语句和swich语句也可以包含一对大括号，每对大括号之间的代码也属于一个局部程序块。此外，你完全可以创建你自己的局部程序块，而不使用C函数或基本的C语句。你可以在局部程序块中说明一些变量，这种变量被称为局部变量，它们只能在局部程序块的开始部分说明，并且只在说明它的局...
SimpleDateFormat线程不安全及解决方案及LocalDate和Date的相互转换/获取一段时间内的所有日期
爪哇人的博客
10-03 2206
1 simpleDateFormat的用法 simpleDateFormat是Java提供的一个格式化和解析日期的工具类。它可以进行格式化（日期->文本），解析（文本->日期）和规范化。 我们可以使用SimpleDateFormat方法中的format方法将data类转为String类型，并转为我们想要的格式 我们也可以使用SimpleDateFormat方法中的parse方法中的将String类型转为data类型 2 SimpleD...
global 和 local 的区别
编程资料大全
06-14 2649
global 和 local 的区别 global 是全局的!有几行数据程序就要回放几次!!不能重新设置!! local 是局部的!有几行数据action 就要回访几次!!设置action的重复次数的操作:反击action,选择action call property,即可进行选择.下面有几种情况: 1.当global 有不止一行的数据,action call property-&gt...
linux编程 - C/C++每线程（thread-local）变量的使用
热门推荐
落尘纷扰的专栏
05-12 3万+
在一个进程中定义的全局或静态变量都是所有线程可见的，即每个线程共同操作一块存储区域。而有时我们可能有这样的需求：对于一个全局变量，每个线程对其的修改只在本线程内有效，即每个线程虽然共享这个全局变量的名字，但这个变量的值就像只有在本线程内才会被修改和读取一样。 线程局部存储和线程特有数据都可以实现上述需求。 1. 线程局部存储 线程局部存储提供了持久的每线程存储，每个线程都拥有一份对变量的拷贝
线程安全的集合接口和类的总结
taiguolaotu的博客
08-04 293
集合的整理 Collection |- List (ArrayList LinkedList Vector CopyOnWriteArrayList) |- Set (HashSet LinkedHashSet CopyOnWriteArraySet) |- SortedSet (TreeSet) |- Queue(LinkedList ConcurrentLinkedQueue) |- BlockingQueue (ArrayBlockingQueue LinkedBlo
LocalAPI和API的区别
jason的笔记
10-30 1292
从nova/conductor/__init__.py中可以看到conductor最终定义了四种class CONF = nova.conf.CONF def API(*args, **kwargs): use_local = kwargs.pop('use_local', False) if CONF.conductor.use_local or use_local:
localStorage接口的使用心得
牧之的天空
04-30 1457
现在在移动端上的需求趋势是越来越多，因此在PC端上不是那么好派上场的功能接口，在移动端上是可以尽情地发挥了。这里分享一下localStorage接口的使用心得。 一、localStorage兼容性 两大平台的系统版本：Android from 2.0 on，Safari from 3.x on（限于设备条件不足，没有新身验证，从以下数据也可以放心使用）。对于大部分移动端用户
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值