JUC学习01——8锁问题和集合类安全性

最新推荐文章于 2024-08-01 01:55:16 发布
原创 最新推荐文章于 2024-08-01 01:55:16 发布 · 173 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #scala #tomcat

本文探讨了Java中的多线程基础，包括线程状态，以及Synchronized和Lock两种锁机制的使用和区别。通过生产者消费者问题的实现，展示了Synchronized和基于Condition的Lock如何实现线程间的通信。同时，文章指出了ArrayList、HashSet和HashMap在并发场景下的不安全性，并提供了CopyOnWriteArrayList和ConcurrentHashMap等线程安全的集合类解决方案。

目录标题

1. 多线程基础

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
线程有几个状态

public enum State {
       	// 新生
        NEW,
		// 运行
        RUNNABLE,
		// 阻塞
        BLOCKED,
		// 等待
        WAITING,
		// 超时等待
        TIMED_WAITING,
		// 终止
        TERMINATED;
}

公平锁：先来的先执行

非公平锁：十分不公平，可以插队（默认）

2. Synchronized和Lock

Synchronized

package com.xiaofan;

public class SaleTicketDemo01 {
    public static void main(String[] args) {
        // 并发： 多线程操作同一个资源类， 把资源类丢入线程
        final Ticket ticket = new Ticket();

        // @FunctionalInterface 函数式接口, jdk1.8 lambda 表达式(参数)->{代码}
        new Thread(()->{ for (int i = 0; i < 31; i++) ticket.sale(); }, "A").start();
        new Thread(()->{ for (int i = 0; i < 31; i++) ticket.sale(); }, "B").start();
        new Thread(()->{ for (int i = 0; i < 31; i++) ticket.sale(); }, "C").start();
    }
}

// 资源类 OOP
class Ticket {
    // 属性，方法
    private int number = 30;

    // 卖票的方式
    public synchronized void sale() {
        if (number > 0) {
            System.out.println(Thread.currentThread().getName() + "卖出了第" + (number--) + "张票, 剩余票数：" + number);
        }
    }
}

Lock

package com.xiaofan;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class SaleTicketDemo02 {
    public static void main(String[] args) {
        // 并发： 多线程操作同一个资源类， 把资源类丢入线程
        final Ticket2 ticket2 = new Ticket2();

        // @FunctionalInterface 函数式接口, jdk1.8 lambda 表达式(参数)->{代码}
        new Thread(()->{ for (int i = 0; i < 31; i++) ticket2.sale(); }, "A").start();
        new Thread(()->{ for (int i = 0; i < 31; i++) ticket2.sale(); }, "B").start();
        new Thread(()->{ for (int i = 0; i < 31; i++) ticket2.sale(); }, "C").start();

    }
}

// Lock三部曲
// 1. new ReentrantLock();
// 2. lock.lock();
// 3. lock.unlock(); 解锁
class Ticket2 {
    // 属性，方法
    private int number = 30;

    private Lock lock = new ReentrantLock();

    // 卖票的方式
    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();
        }
    }
}

Synchronized 和 Lock的区别

  1. Synchronized 内置的Java关键字， Lock是一个Java类
  2. Synchronized 无法判断获取锁的状态， Lock可以判断是否获取到了锁
  3. Synchronized 会自动释放锁， Lock必须要手动释放锁，如果不释放锁，死锁！
  4. Synchronized 线程1（获得锁，阻塞）、线程2（等待，傻傻的等）；Lock锁就不一定会等待下去
  5. Synchronized 可重入锁，不可以中断的，非公平锁；Lock，可重入锁，可以判断锁，非公平锁（可自己设置）
  6. Synchronized 适合锁少量的代码同步问题， Lock适合锁大量的同步代码！

在这里插入图片描述

3. 生产者和消费者问题

生产者和消费者问题Synchronized版

面试手写的： 单例模式、排序算法、生产者和消费者、死锁

package com.xiaofan.pc;


/**
 * 线程之间的通信问题： 生产者和消费者问题！ 等待环形， 通知唤醒
 * 线程交替执行   A B 操作同一个变量 num = 0
 * A num + 1
 * B num - 1
 */
public class A {
    public static void main(String[] args) {
        Data data = new Data();

        new Thread(()->{
            try {
                for (int i = 0; i < 10; i++) data.increment();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "A").start();

        new Thread(()->{
            try {
                for (int i = 0; i < 10; i++) data.decrement();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "B").start();
    }
}

// 判断等待， 业务， 通知
class Data {

    private int number = 0;

    //+1
    public synchronized void increment() throws InterruptedException {
        if (number != 0) {
            this.wait();
        }
        number ++;
        System.out.println(Thread.currentThread().getName() + " => " + number);
        // 通知其他线程， 我+1完毕了
        this.notifyAll();
    }

    //-1
    public synchronized void decrement() throws InterruptedException {
        if (number == 0) {
            this.wait();
        }
        number --;
        System.out.println(Thread.currentThread().getName() + " => " + number);
        // 通知其他线程， 我+1完毕了
        this.notifyAll();
    }
}

在这里插入图片描述

package com.xiaofan.pc;


/**
 * 线程之间的通信问题： 生产者和消费者问题！ 等待环形， 通知唤醒
 * 线程交替执行   A B 操作同一个变量 num = 0
 * A num + 1
 * B num - 1
 */
public class A {
    public static void main(String[] args) {
        Data data = new Data();

        new Thread(()->{
            try {
                for (int i = 0; i < 10; i++) data.increment();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "A").start();

        new Thread(()->{
            try {
                for (int i = 0; i < 10; i++) data.decrement();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "B").start();

        new Thread(()->{
            try {
                for (int i = 0; i < 10; i++) data.decrement();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "C").start();

        new Thread(()->{
            try {
                for (int i = 0; i < 10; i++) data.increment();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "D").start();
    }
}

// 判断等待， 业务， 通知
class Data {

    private int number = 0;

    //+1
    public synchronized void increment() throws InterruptedException {
        while (number != 0) {
            this.wait();
        }
        number ++;
        System.out.println(Thread.currentThread().getName() + " => " + number);
        // 通知其他线程， 我+1完毕了
        this.notifyAll();
    }

    //-1
    public synchronized void decrement() throws InterruptedException {
        while (number == 0) {
            this.wait();
        }
        number --;
        System.out.println(Thread.currentThread().getName() + " => " + number);
        // 通知其他线程， 我+1完毕了
        this.notifyAll();
    }
}

JUC版本的生产者和消费者

package com.xiaofan.pc;


import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 线程之间的通信问题： 生产者和消费者问题！ 等待环形， 通知唤醒
 * 线程交替执行   A B 操作同一个变量 num = 0
 * A num + 1
 * B num - 1
 */
public class B {
    public static void main(String[] args) {
        Data1 data1 = new Data1();
        new Thread(()->{ for (int i = 0; i < 10; i++) data1.increment(); }, "A").start();
        new Thread(()->{ for (int i = 0; i < 10; i++) data1.decrement(); }, "B").start();
        new Thread(()->{ for (int i = 0; i < 10; i++) data1.increment(); }, "C").start();
        new Thread(()->{ for (int i = 0; i < 10; i++) data1.decrement(); }, "D").start();

    }
}

// 判断等待， 业务， 通知
class Data1 {

    private int number = 0;
    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();

    //+1
    public void increment() {
        lock.lock();

        try{
            while (number != 0) {
                condition.await();
            }
            number ++;
            System.out.println(Thread.currentThread().getName() + " => " + number);
            // 通知其他线程， 我+1完毕了
            condition.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    //-1
    public void decrement() {
        lock.lock();

        try {
            while (number == 0) {
                condition.await();
            }
            number --;
            System.out.println(Thread.currentThread().getName() + " => " + number);
            // 通知其他线程， 我+1完毕了
            condition.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }


    }
}

Condition实现精准通知唤醒

package com.xiaofan.pc;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 多线程轮流打印 A-B-C
 */
public class C {
    public static void main(String[] args) {
        Data3 data3 = new Data3();

        new Thread(()->{ for (int i = 0; i < 10; i++) data3.printA();}, "线程1").start();
        new Thread(()->{ for (int i = 0; i < 10; i++) data3.printB();}, "线程2").start();
        new Thread(()->{ for (int i = 0; i < 10; i++) data3.printC();}, "线程3").start();
    }
}


class Data3 {

    private Lock lock = new ReentrantLock();
    private Condition condition1 = lock.newCondition();
    private Condition condition2 = lock.newCondition();
    private Condition condition3 = lock.newCondition();
    private int number = 1;  // 1A 2B 3C

    public void printA() {
        lock.lock();

        try {
            // 业务-判断-执行-通知
            while(number != 1) {
                condition1.await();
            }
            number = 2;
            System.out.println(Thread.currentThread().getName() + "=> A...");
            // 唤醒指定的人
            condition2.signal();

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }

    }

    public void printB() {
        lock.lock();

        try {
            // 业务-判断-执行-通知
            while(number != 2) {
                condition2.await();
            }
            number = 3;
            System.out.println(Thread.currentThread().getName() + "=> B...");
            condition3.signal();

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void printC() {
        lock.lock();

        try {
            // 业务-判断-执行-通知
            while(number != 3) {
                condition3.await();
            }
            number = 1;
            System.out.println(Thread.currentThread().getName() + "=> C...");
            condition1.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }


}

4. 8锁问题

如何判断锁的是谁！对象 Class

  • 总结
    • new this 具体的一个对象
    • static Class 唯一的一个模板

八锁问题
核心就是锁的只会是调用实体，只要是不同对象，对象和静态类模板就不会形成锁关系

5. 集合类不安全

5.1. List不安全

package com.xiaofan.unsafe;

import java.util.*;
import java.util.concurrent.CopyOnWriteArrayList;

// java.util.ConcurrentModificationException    并发修改异常！
public class ListTest {
    public static void main(String[] args) {
        // 单线程安全
        /*List<String> list = Arrays.asList("1", "2", "3");
        list.forEach(System.out::println);*/

        // 并发下ArrayList不安全的吗？synchronized：
        /**
         * 解决方案：
         * 1. List<String> list = new Vector<>();   Vector是1.0出来的，List是1.2出来的
         * 2. List<String> list = Collections.synchronizedList(new ArrayList<>());
         * 3. List<String> list = new CopyOnWriteArrayList<>();
         */
        // CopyOnWrite 写入时复制 COW 计算机程序设计的一种优化策略
        // 多个线程调用的时候，list读取的时候，固定的，写入（覆盖）， 在写入的时候避免覆盖，造成数据问题！读写分离
        // CopyOnWriteArrayList 比 Vector牛逼的地方是底层应用了Lock锁，而Vector应用了synchronized
        List<String> list = new CopyOnWriteArrayList<>();

        for (int i = 1; i <= 20; i++) {
            new Thread(()->{
                list.add(UUID.randomUUID().toString().substring(0, 5));
                System.out.println(list);
            }, String.valueOf(i)).start();
        }
    }
}

5.2. Set不安全

package com.xiaofan.unsafe;

import java.util.Collections;
import java.util.HashSet;
import java.util.Set;
import java.util.UUID;
import java.util.concurrent.CopyOnWriteArraySet;

// 同理：java.util.ConcurrentModificationException    并发修改异常！
public class SetTest {
    public static void main(String[] args) {

        /**
         * 解决方案：
         * 1. Set<String>set = Collections.synchronizedSet(new HashSet<>());
         * 2. Set<String>set = new CopyOnWriteArraySet<>();
         */
        Set<String>set = new CopyOnWriteArraySet<>();
        for (int i = 1; i <= 20; i++) {
            new Thread(()->{
                set.add(UUID.randomUUID().toString().substring(0, 5));
                System.out.println(set);
            }, String.valueOf(i)).start();
        }
    }
}
  • HashSet底层是什么？
public HashSet() {
    map = new HashMap<>();
}

// add set 本质就是map的key是无法重复的！
public boolean add(E e) {
    return map.put(e, PRESENT)==null;
}
// 不变的值
private static final Object PRESENT = new Object();

5.3. Map不安全

package com.xiaofan.unsafe;

import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;


// java.util.ConcurrentModificationException 并发修改异常
public class MapTest {
    public static void main(String[] args) {

        /**
         * 解决方案：
         * 1. Map<String, String> map = Collections.synchronizedMap(new HashMap<>());
         * 2. Map<String, String> map = new ConcurrentHashMap<>();
         */
        Map<String, String> map = Collections.synchronizedMap(new HashMap<>());

        for (int i = 1; i <= 10; i++) {
            new Thread(()->{
                map.put(Thread.currentThread().getName(), UUID.randomUUID().toString().substring(0, 5));
                System.out.println(map);
            }).start();
        }
    }
}
JUC并发编程第十四章——线程安全集合类
qq_64064246的博客
06-19 1045
重点介绍 java.util.concurrent.* 下的线程安全集合类，可以发现它们有规律，里面遍历时如果发生了修改，对于非安全容器来讲，使用机制也就是让遍历立刻失败，抛出ConcurrentModifificationException，不再继续遍历。
juc并发包的常用类、线程安全实现方式、锁机制及 JVM 优化策略
最新发布
qq_43857727的博客
04-07 1094
juc并发包的常用类、线程安全实现方式、锁机制及 JVM 优化策略。
Java并发编程JUC(二) 集合 锁
weixin_48244108的博客
06-18 294
个人学习整理之 Java并发编程JUC(二) 集合相关以及锁相关
如何设计java线程安全类_如何设计Java线程安全类？
weixin_39628070的博客
02-27 163
1.设计线程安全类需要考虑的因素？找出构成对象状态的所有变量。找出约束状态变量的不变性条件。建立对象状态的并发访问管理策略。注意：不变性条件——是指变量的取值范围。后验条件——是指状态改变的时候值是否合法。 不变的对象一定是线程安全的，除非需要必要的可见性，否则应将所有的域都声明为私有的；除非某个域是可变的，否则应将其声明为final域。这是良好的编程习惯。2.如何在多线程中访问不是线程安全的对象...
浅谈Java锁,与JUC的常用类,集合安全类,常用辅助类,读写锁,阻塞队列,线程池,ForkJoin,volatile,单例模式不安全,CAS,各种锁
fushuai优快云的博客
08-15 443
浅谈JUC的常用类 JUC就是java.util.concurrent…包下的类 回顾多线程 Java默认有几个线程？ 2 个 mian、GC Java 真的可以开启线程吗？ 开不了,点击源码得知:本地方法，底层的C++ ，Java 无法直接操作硬件 线程有几个状态 public enum State { NEW,//新生 RUNNABLE,//运行 BLOCKED,//阻塞 WAITING,//等待,死等
JUC学习之——多线程操作集合类的安全问题
qq_34118192的博客
06-17 453
Java中集合存在的线程安全问题 Java中，ArrayList、Hashset、HasMap等都是线程不安全的，主要原因就是其中许多操作（例如ArrayList中的add操作）是非原子的操作，这就导致多线程在操作这些集合类的时候会产生线程的安全性问题。 例如： List<Integer> list = new ArrayList<>(); for(i = 1;i <= 30; i++){ new Thread(() -> { list.add(i); Sys
JUC——线程安全集合类概述
m0_51710682的博客
08-01 981
Java 8数组（Node） +（ 链表 Node | 红黑树 TreeNode ） 以下数组简称（table），链表简称（bin）初始化，使用 cas 来保证并发安全，懒惰初始化 table树化，当 table.length < 64 时，先尝试扩容，超过 64 时，并且 bin.length > 8 时，会将链表树化，树化过程 会用 synchronized 锁住链表头put，如果该 bin 尚未创建，只需要使用 cas 创建 bin；
JUC并发编程——集合类不安全及Callable（基于狂神说的学习笔记）
Lyrical-Wander的博客
10-14 748
CopyOnWriteArrayList使用了一种特殊的写时复制机制，它在对数组进行修改时，会创建一个新的副本，而不是直接在原数组上进行修改。然而，由于每次修改都需要创建一个新的副本，所以在写入操作频繁的情况下，CopyOnWriteArrayList的性能可能会比较低。在写时复制策略中，数据结构被修改时，修改操作会在一个新的副本上进行，而不是直接在原始数据上进行。由于创建新数组和修改操作是在一个单独的写锁上进行的，因此多个线程可以同时读取原始数组，而不会看到正在进行的写入操作。关键字来实现线程安全。
深入理解JUC——JUC 线程安全集合类
Inception查缺补漏
08-26 310
JUC 线程安全集合类用来限制同时访问共享资源的线程上限。
JUC并发编程（13）——线程安全集合类
qq_51114283的博客
10-08 614
一、概述 线程安全集合类可以分为三大类 ： ① 遗留的安全集合如Hashtable，Vector。 ② 使用Collections装饰的线程安全类如Collections.synchronizedList、Collections.synchronizedMap等。 ③ JUC包下的线程安全集合如Blocking类、CopyOnWrite类、Concurrent类等。 ①是直接在方法上加上了synchronized锁，②是方法内部加上了synchronized锁。这里主要介绍的是JUC包下的线程安全集合类
Java——JUC
12-29
- `AtomicInteger`、`AtomicLong`等原子类提供了一种在不使用锁的情况下实现线程安全的方式，通过底层的CAS（Compare and Swap）操作保证了原子性，适用于简单的原子更新操作。 5. **Future和Callable接口** - `...
bilibili尚硅谷周阳老师JUC并发编程与源码分析课程笔记第三章——说说Java“锁“事
qq_46601365的博客
02-22 1377
1-2：一个对象里面如果有多个 synchronized 方法，某一个时刻内，只要一个线程去调用其中的一个synchronized方法，其它线程都只能等待。换句话说，某一个时刻内，只能有唯一的一个线程去访问这些synchronized方法。锁的是当前对象this，被锁定后，其它线程都不能进入到当前对象的其它的synchronized方法3-4：加个普通方法后发现和同步锁无关换成两个对象后，不是同一把锁了，情况立即变化5-6： 都换成静态同步方法后，情况又变化。
JUC集合类 ConcurrentHashMap源码解析 JDK8
anlian523的博客
07-19 2337
ConcurrentHashMap是一种支持并发操作的HashMap，并发控制方面，它使用更小粒度的锁——对每个哈希桶的头节点加锁。虽然这样使得效率更高，能让读写操作最大程序的并发执行，但也造成了读写操作的一致性很弱，比如size()返回的大小可能已经与真实大小不一样，比如clear()调用返回后Map中却拥有着元素。 JDK8的ConcurrentHashMap并不是完美，在阅读源码之前，建议先看看ConcurrentHashMap有些什么bug，以免在这些地方钻牛角尖。
idea运行项目报错Cannot run program “C:\Program Files\Java\jdk1.8.0_121\bin\java.exe......解决办法
热门推荐
david2000999的博客
03-16 3万+
在环境变量都配置完好的情况下，基本就是idea的配置除了问题可以检查以下几点。 1、SDKs检查 2、路径检查 3、项目配置检查
图片base64编码
david2000999的博客
01-14 9981
目录图片base64编码1. 图片base64说明2. 图片base64工具类 图片base64编码 1. 图片base64说明 图片的base64编码就是可以将一张图片数据编码成一串字符串，使用该字符串代替图像地址url 在前端页面中常见的base64图片的引入方式： <img src="data:image/png;base64,iVBORw0..> 1.优点 （1）base64格式的图片是文本格式，占用内存小，转换后的大小比例大概为1/3，降低了资源服务器的消耗； （2）网页中使用bas
Consider injecting the bean as one of its interfaces or forcing the use of CGLib-based proxies 问题解决
david2000999的博客
05-05 8272
Consider injecting the bean as one of its interfaces or forcing the use of CGLib-based proxies by setting proxyTargetClass=true on @EnableAsync and/or @EnableCaching. 问题描述 Spring Boot 项目，启用事务支持时出现以下错误： Error starting ApplicationContext. To display the auto
Java动态生成pdf文件（用于实时生成电子证书）
david2000999的博客
04-05 5927
1.首先，新建一个word文档，内容如下，另存为pdf格式，我的命名：mytest.pdf。 2.用Adobe Acrobat Pro 打开刚刚制作的pdf文件。如下图： 3.点击创建–>PDF表单–>使用当前文档–>使用当前文档，一直点下一步完成。（有的版本Adobe Acrobat Pro软件右边有准备表单，直接点击准备表单是同样的效果） 4.上面好多给框，双击黑框可以修改名称，还可以设置字体大小，如下图 5.图片的地方没有黑框，我们可以在空白处点击右键，选择文本域，给
Java实验三报告IO流
david2000999的博客
05-02 5111
实验目的： 了解Java IO，掌握IO处理的设计方法。重点掌握Java IO主要的类如下： 1. File（文件特征与管理）：用于文件或者目录的描述信息，例如生成新目录，修改文件名，删除文件，判断文件所在路径等。 2. InputStream（二进制格式操作）：抽象类，基于字节的输入操作，是所有输入流的父类。定义了所有输入流都具有的共同特征。 3. OutputStream（二进制格式操作）：抽象类。基于字节的输出操作。是所有输出流的父类。定义了所有输出流都具有的共同特征。 4.FileOutputStr
Cannot resolve org.springframework.boot:spring-boot-starter-logging:2.2.1.RELEASE解决办法
david2000999的博客
06-07 4697
原因1 maven下载jar包不完整，找到本地maven仓库删除重新下载 原因2 idea检测机制的bug,我当时pom文件虽然显示爆红，但是依然可以运行
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值