JUC并发编程(一)

最新推荐文章于 2024-06-27 15:25:28 发布
最新推荐文章于 2024-06-27 15:25:28 发布
阅读量124 收藏
点赞数
分类专栏： #JAVA JUC并发编程 文章标签： java c# scala
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Monuomeng/article/details/119278927
版权

JUC并发编程(一)

文章目录

一. 什么是JUC

 java.util.concurrent
 java.util.concurrent.atomic
 java.util.concurrent.locks

同属于Java.util 工具包

在业务中:用普通的线程代码 Thread(普通的线程类)
Runnable 没有返回值、效率相比入 Callable相对较低!
所以，企业中Runnable用的比较少，更多的是Callable

之前学的callable 与lock都是 java.util 包下的

在这里插入图片描述
在这里插入图片描述

二. 进程和线程回顾

进程：一个程序，QQ.exe 等等程序的集合
一个进程往往包含多个线程，至少包含一个！
Java默认有多少个线程？ 两个：main线程，GC线程
对于Java而言,用Runnable,Thread,Callable 来开启线程

Java真的可以开启线程吗?
答案是:不能,本质上是调用本地方法(底层的C++),Java无法直接操作硬件

并发,并行

并发编程:并发,并行
并发:交替执行,一核cpu模拟出来多个线程，

并行:一起执行,多核cpu,多个线程可以同时执行，线程池

public class Demo01 {
    public static void main(String[] args) {
        //获取CPU线程数
        System.out.println(Runtime.getRuntime().availableProcessors());
    }
}
---------------结果---------------
8

并发编程的本质：充分利用CPU资源

线程有几个状态

//我们进入枚举类，可以看到有六个状态
public enum State {
        //新建
        NEW,
 		//运行
        RUNNABLE,
         //阻塞
        BLOCKED,
		//等待，死死的等
        WAITING,
		//超时等待
        TIMED_WAITING,
		//终止
        TERMINATED;
    }

wait 和 sleep 的区别

  1. 来自不同的类
    wait 属于Object类 sleep 属于Thread 类
  2. 关于锁的释放
    wait会释放锁，sleep不会释放
  3. 使用范围不同
    wait必须在同步代码块中使用
    sleep在任何地方都能用

三. Lock锁(重点)

1. 传统Synchronized

//基本的买票例子
/**
 * 真正的多线程开发，公司中的开发，降低耦合性
 * 线程就是一个单独的资源类，没有任何附属的操作
 * 1.属性 方法
 */
public class Demo01 {
    public static void main(String[] args) {
        //并发：多线程操作同一资源类，把资源类丢入线程
        Ticket ticket = new Ticket();
        //lambda表达式  (参数)->{代码}
        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();
        new Thread(()->{
            for (int i = 0; i < 40; i++) {
                ticket.sale();
            }
        },"c").start();
    }
}
//资源类  oop
class Ticket{
    //属性，方法
    private int number =50;
    //买票的方式
    //synchronized 的本质：队列，锁
    public synchronized void sale(){
        if(number>0){
            System.out.println(Thread.currentThread().getName()+"卖出了第"+(number--)+"票,剩余" +
                    number+"张票");
        }
    }
}
---------------结果---------------
A卖出了第50票,剩余49张票
A卖出了第49票,剩余48张票
A卖出了第48票,剩余47张票
。。。
B卖出了第3票,剩余2张票
A卖出了第2票,剩余1张票
A卖出了第1票,剩余0张票

2. Lock锁

在这里插入图片描述

lock锁中有三个接口
在这里插入图片描述

Condition 精确通知
在这里插入图片描述

标准Lock锁
在这里插入图片描述

ReadWriteLock 读写锁

在这里插入图片描述
lock锁中的两个用法：加锁/解锁
在这里插入图片描述
当我们打开ReentrantLock的源码中会发现：

默认定义了一个非公平锁
当传入一个布尔值为true则为公平锁
公平锁：非常公平，先来后到
非公平锁：可以插队(默认)
Synchronized 默认也是非公平锁

在这里插入图片描述

用Lock锁重写卖票实例：

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

public class Demo02 {
    public static void main(String[] args) {
        //并发：多线程操作同一资源类，把资源类丢入线程
        Ticket2 ticket = new Ticket2();
        //lambda表达式  (参数)->{代码}
        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();
        new Thread(()->{
            for (int i = 0; i < 40; i++) {
                ticket.sale();
            }
        },"c").start();

    }
}
//资源类  oop
class Ticket2{
    //属性，方法
    private int number =50;
    //买票的方式
    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();  //解锁
        }
    }
}
---------------结果---------------
A卖出了第50票,剩余49张票
B卖出了第49票,剩余48张票
B卖出了第48票,剩余47张票
。。。
A卖出了第2票,剩余1张票
A卖出了第1票,剩余0张票

Synchronized 和 Lock锁的区别

  1. Synchronized 是Java内置的关键字，Lock是一个Java类
  2. Synchronized 无法判断获取锁的状态，Lock可以判断是否获取到了锁
  3. Synchronized 是自动的，会自动释放锁，Lock必须手动释放锁 容易发生死锁
  4. Synchronized 线程1(获得锁，阻塞) 线程2(等待，死等) ，Lock锁不一定会一直等待
  5. Synchronized 可重入锁，不可中断，非公平，Lock可重入，可以判断锁，可设置公平与否
  6. Synchronized 适合锁少量的代码同步问题，Lock锁适合锁大量的同步代码块

四. 生产者和消费者

1. Synchronized 版

/**
 * 线程之间的通信问题，生产者与消费者问题(等待唤醒，通知提醒)
 * 线程交替执行，操作同一变量，使num=0
 */
public class Demo03 {
    public static void main(String[] args) {
        Data data = new Data();
        new Thread(()->{
            for (int i = 0; i < 5; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();
        new Thread(()->{
            for (int i = 0; i < 5; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"B").start();
    }
}

class Data{  //资源类  数字num
    private int num=1;
    //+1
    public synchronized void increment() throws InterruptedException {
        if (num!=0){
            //等待操作
            this.wait();
        }
        num++;
        //通知其他线程，工作完毕
        System.out.println(Thread.currentThread().getName()+"=>"+num);
        this.notifyAll();
    }

    //-1
    public synchronized void decrement() throws InterruptedException {
        if (num==0){
            //等待操作
            this.wait();
        }
        num--;
        //通知其他线程，工作完毕
        System.out.println(Thread.currentThread().getName()+"=>"+num);
        this.notifyAll();
    }
}
---------------结果---------------
B=>0
A=>1
B=>0
A=>1
B=>0
A=>1
B=>0
A=>1
B=>0
A=>1

问题:如果线程超过两个，会有什么问题？
答：会出现虚假唤醒问题
应该将if改成while，防止虚假唤醒问题

/**
 * 线程之间的通信问题，生产者与消费者问题(等待唤醒，通知提醒)
 * 线程交替执行，操作同一变量，使num=0
 */
public class Demo03 {
    public static void main(String[] args) {
        Data data = new Data();
        new Thread(()->{
            for (int i = 0; i < 5; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();
        new Thread(()->{
            for (int i = 0; i < 5; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"B").start();
        new Thread(()->{
            for (int i = 0; i < 5; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"C").start();
        new Thread(()->{
            for (int i = 0; i < 5; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"D").start();
    }
}

class Data{  //资源类  数字num
    private int num=1;
    //+1
    public synchronized void increment() throws InterruptedException {
        while (num!=0){
            //等待操作
            this.wait();
        }
        num++;
        //通知其他线程，工作完毕
        System.out.println(Thread.currentThread().getName()+"=>"+num);
        this.notifyAll();
    }

    //-1
    public synchronized void decrement() throws InterruptedException {
        while (num==0){
            //等待操作
            this.wait();
        }
        num--;
        //通知其他线程，工作完毕
        System.out.println(Thread.currentThread().getName()+"=>"+num);
        this.notifyAll();
    }
}
---------------结果---------------
B=>0
A=>1
B=>0
C=>1
B=>0
A=>1
B=>0
C=>1
D=>0
A=>1
B=>0
C=>1
D=>0
A=>1
D=>0
C=>1
D=>0
A=>1
D=>0
C=>1

2.JUC版生产者消费者

要用Lock代替Synchronized ，就必须配套替换 wait 和 nodity
这就提到了之前的Condition,在JDK帮助文档中，明确介绍
在这里插入图片描述
代码实现：

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

public class Demo04 {
    public static void main(String[] args) {
        Data2 data2 = new Data2();
        new Thread(()->{
            for (int i = 0; i < 5; i++) {
                try {
                    data2.incerment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();
        new Thread(()->{
            for (int i = 0; i < 5; i++) {
                try {
                    data2.decerment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"B").start();
        new Thread(()->{
            for (int i = 0; i < 5; i++) {
                try {
                    data2.incerment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"C").start();
        new Thread(()->{
            for (int i = 0; i < 5; i++) {
                try {
                    data2.decerment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"D").start();
    }
}
class Data2{
    private int num=1;
    Lock lock = new ReentrantLock();
    Condition condition = lock.newCondition();
    public void incerment() throws InterruptedException {
        lock.lock();
        try {
            //业务代码
            while (num!=0){
                condition.await();
            }
            num++;
            System.out.println(Thread.currentThread().getName()+"=>"+num);
            condition.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
    public void decerment() throws InterruptedException {
        lock.lock();
        try {
            while (num==0){
                condition.await();
            }
            num--;
            System.out.println(Thread.currentThread().getName()+"=>"+num);
            condition.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}
---------------结果---------------
B=>0
A=>1
B=>0
C=>1
B=>0
C=>1
B=>0
C=>1
D=>0
C=>1
D=>0
C=>1
D=>0
A=>1
D=>0
A=>1
D=>0
A=>1
B=>0
A=>1

Condition的优点：精准通知和唤醒线程

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

/**
 * 不同于上一个例子
 * 这次要顺序执行A B C
 */
public class Demo05 {
    public static void main(String[] args) {
        Data3 data3 = new Data3();
        new Thread(()->{
            for (int i = 0; i < 5; i++) {
                data3.printA();
            }
        },"A").start();
        new Thread(()->{
            for (int i = 0; i < 5; i++) {
                data3.printB();
            }
        },"B").start();
        new Thread(()->{
            for (int i = 0; i < 5; i++) {
                data3.printC();
            }
        },"C").start();
    }
}

class Data3{
    private int num=1;  //num=1 A, 2 B,3 C
    private Lock lock = new ReentrantLock();
    private Condition condition1 = lock.newCondition();
    private Condition condition2 = lock.newCondition();
    private Condition condition3 = lock.newCondition();

    public void printA(){
        lock.lock();
        try {
            while (num!=1){
                condition1.await();
            }
            System.out.println(Thread.currentThread().getName()+"=>执行了PrintA");
            num=2;
            condition2.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public void printB(){
        lock.lock();
        try {
            while (num!=2){
                condition2.await();
            }
            System.out.println(Thread.currentThread().getName()+"=>执行了PrintB");
            num=3;
            condition3.signal();

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public void printC(){
        lock.lock();
        try {
            while (num!=3){
                condition3.await();
            }
            System.out.println(Thread.currentThread().getName()+"=>执行了PrintC");
            num=1;
            condition1.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}
---------------结果---------------
A=>执行了PrintA
B=>执行了PrintB
C=>执行了PrintC
A=>执行了PrintA
B=>执行了PrintB
C=>执行了PrintC
A=>执行了PrintA
B=>执行了PrintB
C=>执行了PrintC
A=>执行了PrintA
B=>执行了PrintB
C=>执行了PrintC
A=>执行了PrintA
B=>执行了PrintB
C=>执行了PrintC

五. 8锁的现象

根据上面的实例，请问锁是什么，如何判断锁的是谁？

锁的内容：对象，与class模板

8锁,就是关于锁的8个问题
1、标准情况下,两个线程先打印发短信还是打电话?1/发短信2/打电话
2、 sendsms延迟4秒,两个线程先打印发短信还是打电话?1/发短信2/打电话

//问题1
//标准情况下,两个线程先打印发短信还是打电话?1/发短信2/打电话
import java.util.concurrent.TimeUnit;

public class Demo06 {
    public static void main(String[] args) {
        Phone phone = new Phone();
        new Thread(()->{  //线程A
            phone.sendSms();
        },"A").start();
        //捕获异常
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{   //线程B
            phone.call();
        },"B").start();
    }
}

class Phone{
    public synchronized void sendSms(){
        System.out.println("发短信");
    }
    public synchronized void call(){
        System.out.println("打电话");
    }
}

//问题2
//sendsms延迟4秒,两个线程先打印发短信还是打电话?1/发短信2/打电话
import java.util.concurrent.TimeUnit;

public class Demo06 {
    public static void main(String[] args) {
        Phone phone = new Phone();
        new Thread(()->{  //线程A
            phone.sendSms();
        },"A").start();
		try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{   //线程B
            phone.call();
        },"B").start();
    }
}

class Phone{
    public synchronized void sendSms(){
        //捕获异常
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    public synchronized void call(){
        System.out.println("打电话");
    }
}

//问题3
//新增普通线程，sendsms延迟4秒,两个线程先打印发短信还是hello?1/发短信2/hello
import java.util.concurrent.TimeUnit;

public class Demo06 {
    public static void main(String[] args) {
        Phone phone = new Phone();
        new Thread(()->{  //线程A
            phone.sendSms();
        },"A").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{   //线程B
            phone.hello();
        },"B").start();
    }
}

class Phone{
    public synchronized void sendSms(){
        //捕获异常
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    public synchronized void call(){
        System.out.println("打电话");
    }
    public void hello(){
        System.out.println("hello");
    }
}

//问题4
//两个对象，两个线程先打印发短信还是打电话 1/发短信2/打电话
import java.util.concurrent.TimeUnit;

public class Demo06 {
    public static void main(String[] args) {
        //两个对象
        Phone phone1 = new Phone();
        Phone phone2 = new Phone();
        new Thread(()->{  //线程A
            phone1.sendSms();
        },"A").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{   //线程B
            phone2.call();
        },"B").start();
    }
}

class Phone{
    public synchronized void sendSms(){
        //捕获异常
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    public synchronized void call(){
        System.out.println("打电话");
    }
}

//问题5
//两个静态同步方法，两个线程先打印发短信还是打电话 1/发短信2/打电话
import java.util.concurrent.TimeUnit;

public class Demo06 {
    public static void main(String[] args) {
        Phone phone = new Phone();
        new Thread(()->{  //线程A
            phone.sendSms();
        },"A").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{   //线程B
            phone.call();
        },"B").start();
    }
}

class Phone{
    public static synchronized void sendSms(){
        //捕获异常
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    public static synchronized void call(){
        System.out.println("打电话");
    }
}

//问题6
//两个对象，两个静态同步方法，两个线程先打印发短信还是打电话 1/发短信2/打电话
import java.util.concurrent.TimeUnit;

public class Demo06 {
    public static void main(String[] args) {
        Phone phone1 = new Phone();
        Phone phone2 = new Phone();
        new Thread(()->{  //线程A
            phone1.sendSms();
        },"A").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{   //线程B
            phone2.call();
        },"B").start();
    }
}

class Phone{
    public static synchronized void sendSms(){
        //捕获异常
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    public static synchronized void call(){
        System.out.println("打电话");
    }
}

//问题7
//一个静态同步方法，一个普通同步方法，一个对象
//两个线程先打印发短信还是打电话 1/发短信2/打电话
import java.util.concurrent.TimeUnit;

public class Demo06 {
    public static void main(String[] args) {
        Phone phone = new Phone();
        new Thread(()->{  //线程A
            phone.sendSms();
        },"A").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{   //线程B
            phone.call();
        },"B").start();
    }
}

class Phone{
    public static synchronized void sendSms(){
        //捕获异常
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    public synchronized void call(){
        System.out.println("打电话");
    }
}

//问题8
//一个静态同步方法，一个普通同步方法，两个对象
//两个线程先打印发短信还是打电话 1/发短信2/打电话
import java.util.concurrent.TimeUnit;

public class Demo06 {
    public static void main(String[] args) {
        Phone phone1 = new Phone();
        Phone phone2 = new Phone();

        new Thread(()->{  //线程A
            phone1.sendSms();
        },"A").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{   //线程B
            phone2.call();
        },"B").start();
    }
}

class Phone{
    public static synchronized void sendSms(){
        //捕获异常
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    public synchronized void call(){
        System.out.println("打电话");
    }
}

答案：
1、发短信 打电话
2、发短信 打电话
原因：synchronized锁的对象是方法的调用者!
两个方法用的是同一个锁(phone)，谁先拿到锁谁先执行
3、hello 发短信
hello没有锁，不是同步方法，不受锁的影响
4、打电话 发短信
两个对象，两个调用者，两个锁，没有冲突
5、发短信 打电话
Phone是唯一的一个CLass对象，类一加载就有了，锁的是Class
6、发短信 打电话
两个对象的Class类模板只有一个，锁的是Class
7、打电话 发短信
8、打电话 发短信
两个锁 锁的内容不一样，没有冲突

六. 集合类不安全

1.List不安全

实例一：

//安全线程实例
import java.util.Arrays;
import java.util.List;

public class ListTest {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("1", "2", "3", "4");
        list.forEach(System.out::println);
    }
}
结果：
1
2
3
4

//不安全实例，及解决方案
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;

//java.util.ConcurrentModificationException  并发修改异常
public class ListTest {
    public static void main(String[] args) {
        //并发下，arraylist是不安全的
        /*
            解决方案：
            1.将List<Object> list = new ArrayList<>();
            修改为：List<Object> list = new Vector<>();
            2.将List<Object> list = new ArrayList<>();
            修改为：List<Object> list = Collections.synchronizedList(new ArrayList<>());
            3.将List<Object> list = new ArrayList<>();
            修改为：List<Object> list = new CopyOnWriteArrayList<>();
         */
        //CopyOnWrite 写入时复制 ，简称COW ，是计算机程序设计领域的一种优化策略
        //多个线程调用的时候，资源在读取的时候是一个固定的，但是写入的时候，可能会出现覆盖操作
        //相当于在写入的时候避免覆盖造成数据问题
        //后面会讲 mycat
        List<Object> list = new ArrayList<>();
        for (int i = 1; i < 11; i++) {
            new Thread(()->{
                list.add(UUID.randomUUID().toString().substring(0,10));
                System.out.println(list);
            },String.valueOf(i)).start();
        }
    }
}
//注：JDK11 后将 COW(CopyOnWrite)修改为了synchronized

2.Set不安全

//Set 同理
import java.util.HashSet;
import java.util.Set;
import java.util.UUID;

//同样出现了java.util.ConcurrentModificationException  并发修改异常
public class SetTest {
    public static void main(String[] args) {
        /*
        解决方法：
        1.Set<String> set = new HashSet<>();
        修改为：Set<String> set = Collections.synchronizedSet(new HashSet<>());
        2.Set<String> set = new HashSet<>();
        修改为：Set<String> set = new CopyOnWriteArraySet<>();
         */
        Set<String> set = new HashSet<>();
        for (int i = 1; i < 10; 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;
}

在这里插入图片描述

Map不安全

import java.util.HashMap;
import java.util.Map;
import java.util.UUID;

public class MapTest {
    public static void main(String[] args) {
        //map是这样用的吗,默认等价于什么
        //不是,默认等价于new HashMap<>(16,0.75);
        //加载因子,初始化容量
        //方法一:Map<String, Object> map = Collections.synchronizedMap(new HashMap<>());
        //方法二:Map<String, Object> map = new ConcurrentHashMap<>();
        Map<String, Object> map = new HashMap<>();
        for (int i=1;i<11;i++) {
            new Thread(()->{
                map.put(Thread.currentThread().getName(), UUID.randomUUID().toString().substring(0,5));
                System.out.println(map);
            },String.valueOf(i)).start();
        }
    }
}

ConcurrentHashMap的原理:

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

莫诺蒙
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JUC并发编程
识时务者的个人博客
07-08 14万+
JUC并发编程 JUC简介 进程、线程的关系 Java默认有两个线程 线程的六种状态 并发、并行的关系： Lock锁 Synchronized 和 Lock的区别 8锁现象 问题一 : 在标准情况下，两个线程先打印 发短信 还是 打电话 ？ 问题二 : 在发短信方法中，延迟4秒，两个线程先打印 发短信 还是 打电话？ 问题三 : Phone类增加一个普通方法，线程B调用，那么两个线程先打印 发短信
JUC 并发编程
m0_53067943的博客
07-10 968
主要对于juc的知识点总结
JUC(并发编程)
abc98526的博客
04-17 1万+
1.什么是JUC? JUC是指javaUtil包中的三个操作线程的包! 2.线程进程和程序 程序(Program):是一个静态的概念，一般对应于操作系统中的一个可执行的文件 ，比如：我们要启动酷狗听音乐，则对应酷狗可执行程序。当我们双击酷狗，则加载 程序到内存中，开始执行该程序，于是产生了"进程". 进程:执行中的程序叫做进程(Process),是一个动态的概念。现代的操作系统都可以同时启动多个进程。比如:我们在用酷狗听音乐，也可以使用wps写文档，也可以同时用浏览器查看网页。可以通过
周阳老师JUC并发编程
qq_44300280的博客
11-16 5295
周阳老师JUC并发编程
JUC并发编程超详细详解篇
热门推荐
白大锅的博客，毕设WangLoveBai_999
12-15 7万+
文章目录前言一、JUC并发编程简介及准备1.1.本系列讲解思路1.2.知识储备1.3.用到的依赖1.4.logback.xml 配置二、进程与线程2.1.进程与线程2.1.1.进程2.1.2.线程2.1.3.对比2.2.并行与并发2.2.1.两者区别直观解释2.3.应用2.3.1. 应用之异步调用（案例1）2.3.2.应用之提高效率（案例1）三、Java 线程3.1.本节主讲内容3.2.创建和运行线程3.2.1.方法一，直接使用 Thread3.2.2.方法二，使用 Runnable 配合 Thread3.
JUC并发编程面试题
weixin_45081813的博客
04-06 2340
文章目录1. 并行和并发有什么区别？2. 线程和进程的基本概念、线程的基本状态以及状态之间的关系？3.守护线程是什么？4.创建线程有哪几种方式？5. sleep() 和 wait() 有什么区别？6.线程的 run() 和 start() 有什么区别？7.创建线程池有哪几种方式？8.在 Java 程序中怎么保证多线程的运行安全？9.什么是死锁？怎么防止死锁？10.synchronized 和 volatile 的区别是什么？11.synchronized 和 Lock 有什么区别？12.synchroniz
JUC 并发编程学习笔记（总）
Java技术一点通
10-19 2260
JUC指的就是工具包的简称，里面的工具类可以很方便的实现多线程的开发。java.util工具包、包、分类。业务：普通的线程代码 Thread。Runnable没有返回值、效率相比Callable相对较低！
JUC并发编程详解
yyhgo_的博客
12-13 455
JUC并发编程详解
JUC并发编程常见面试题目
corlor_龙的博客
04-26 1734
1. 进程和线程，并发和并行 进程：进程是计算机程序在一个数据集上的一次运行过程，也是资源分配和调度的基本单位 线程：线城是进程中的一个执行单元。一个进程中至少有一个线程 并行：指的是两个或多个事件在同一时刻发生， 并发：指的是两个或多个事件在同一时间间隔内发生 2. 守护线程和用户线程的区别 用户 (User) 线程：运行在前台，执行具体的任务，如程序的主线程 守护 (Daemon) 线程：运行在后台，为用户线程服务。一旦所有用户线程都结束运行，守护线程会随 JVM 一起结束工作，如垃圾回收线
尚硅谷JUC并发编程与源码分析
一个沉迷Java，无法自拔的Coder
07-07 557
深入理解JUC并发编程
juc并发编程脑图以及相关示例代码
07-30
juc并发编程脑图以及相关示例代码
Java后端开发，JUC并发编程Java后端开发，JUC并发编程
04-14
Java后端开发，JUC并发编程Java后端开发，JUC并发编程Java后端开发，JUC并发编程Java后端开发，JUC并发编程Java后端开发，JUC并发编程Java后端开发，JUC并发编程Java后端开发，JUC并发编程Java后端开发，JUC并发编程...
JUC并发编程.rar
12-14
含有并发编程相关案例源码及详细讲解 从无到有带你深入了解什么是并发编程
尚硅谷大厂必备技术之JUC并发编程基础视频 配套资料（自己根据视频整理课件，和代码）
09-23
【尚硅谷】大厂必备技术之JUC并发编程视频 配套资料，自己根据视频整理 pdf 课件，和代码 视频地址：...
JUC并发编程视频教程
11-28
* 颠覆一些你以为"正确"的认知，纠正其它同类视频的错误* 100+ 张手绘图 & 流程图，帮助你形成正确的"多线程世界观"* 以知识点为主线、穿插讲解"应用"，"原理"和"多线程设计模式"，多维度学懂并发主讲内容第一章：...
Lombok的hashCode方法
最新发布
LiZhen314的博客
06-27 352
在继承关系中，父类的hashCode针对父类的所有属性进行运算，而子类的hashCode却只是针对子类才有的属性进行运算，立此贴提醒自己。callSuper = false，根据子类自身的字段值 来生成hashcode， 当两个子类对象比较时，只有子类对象的本身的字段值相同，父类字段值可以不同，callSuper = true，根据子类自身的字段值和从父类继承的字段值 来生成hashcode，当两个子。比较时，只有子类对象的本身的字段值和继承父类的字段值都相同，equals方法的返回值是true。
日常工作记录目录
与海
06-21 720
EasyExcel实现二维码下载与展示
Homebrew使用
gghh2015的博客
06-21 510
具体参考：https://blog.csdn.net/m0_67402970/article/details/126434901。简介：https://www.jianshu.com/p/f4c9cf0733ea。2、查看安装路径：brew list maven。官网：https://brew.sh/
Rust高性能日志库tklog0.0.8—支持mod设置参数
donnie4w技术专栏
06-21 945
tklog是rust高性能结构化日志库，支持同步日志，异步日志，支持自定义日志的输出格式，支持按时间，按文件大小分割日志文件，支持日志文件压缩备份，支持官方日志库标准API，支持mod独立参数设置
juc并发编程线程池
06-18
线程池是并发编程中常用的一种机制，它允许您预先创建一组线程，并在需要执行任务时重用这些线程，从而提高性能和资源管理。 `Executors`类提供了一些预定义的线程池工厂方法，如`newFixedThreadPool()`, `...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值