JUC并发编程 狂神第一讲

最新推荐文章于 2024-11-03 11:01:20 发布
最新推荐文章于 2024-11-03 11:01:20 发布
阅读量56 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51809035/article/details/125900580
版权

目录

1、线程和进程

进程：一个程序，QQ.exe
一个进程至少包含一个线程
java默认两个线程：main，GC

java开启线程的方式：Thread，Runable，Callable

java无法开线程

    public synchronized void start() {
        /**
         * This method is not invoked for the main method thread or "system"
         * group threads created/set up by the VM. Any new functionality added
         * to this method in the future may have to also be added to the VM.
         *
         * A zero status value corresponds to state "NEW".
         */
        if (threadStatus != 0)
            throw new IllegalThreadStateException();

        /* Notify the group that this thread is about to be started
         * so that it can be added to the group's list of threads
         * and the group's unstarted count can be decremented. */
        group.add(this);

        boolean started = false;
        try {
            start0();
            started = true;
        } finally {
            try {
                if (!started) {
                    group.threadStartFailed(this);
                }
            } catch (Throwable ignore) {
                /* do nothing. If start0 threw a Throwable then
                  it will be passed up the call stack */
            }
        }
    }
	//本地方法，底层的c++，java 无法直接操作
    private native void start0();

并行，并发

并发编程：并发，并行

  • 并发（多线程操作同一个资源）
    • CPU一核，模拟出多条线程，快速交替
  • 并行（多个人一起行走）
    • CPU多核，多个线程可以同时执行；线程池

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

线程有几个状态

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

wait/sleep区别

1.来自不同的类
wait =》 Object
sleep =》Thread

2.关于锁的释放
wait会释放锁，sleep不释放

3.使用的范围是不同的
wait 必须在同步代码块中
sleep可以在如何地方

4.是否捕获异常
wait和sleep都需要捕获异常

    public static void main(String[] args) throws InterruptedException {
        Thread.sleep(1);
        Thread thread = new Thread();
        thread.wait();
    }

2、Lock锁（重点）

传统Synchronize

Lock接口

在这里插入图片描述

在这里插入图片描述

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

public class SaleTicketDemo02 {
    public static void main(String[] args) {

        Ticket2 ticket = new Ticket2();

        new Thread(()->{
            for (int i = 0; i < 30; i++) {
                ticket.sale();
            }
        },"A").start();
        new Thread(()->{
            for (int i = 0; i < 30; i++) {
                ticket.sale();
            }
        },"B").start();
        new Thread(()->{
            for (int i = 0; i < 30; i++) {
                ticket.sale();
            }
        },"C").start();

    }
}


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()+"卖出了 "+(50 - --number)+" 张票，剩余 "+number+" 张票");
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }

    }
}

Synchronize 和 Lock 区别

  1. Synchronize 内置的java关键字，Lock是一个java类
  2. Synchronize 无法判断获取锁的状态，Lock 可以判断是否获取到了锁
  3. Synchronize 会自动释放锁，Lock必须要手动释放锁，如果不释放锁，死锁
  4. Synchronize 线程1（获取锁，阻塞），线程2（傻傻等待）；Lock锁就不一定等待下去；
  5. Synchronize 可重入锁，不可以中断的，非公平；Lock，可重入锁，可以判断锁，非公平（可以自己调节，默认false）；
  6. Synchronize 适合锁少量的代码同步问题，Lock适合锁大量的同步代码块
    可重入锁指的是可重复可递归调用的锁，在外层使用锁之后，在内层仍然可以使用，并且不发生死锁
    可重入锁：对象获取锁后还可以再次获取该锁

锁是什么，如何判断锁的是谁？

3、生产者和消费者问题

面试：单例模式，排序算法，生产者和消费者，死锁
Synchronize wait notify

生产者和消费者 Synchronize版

public class A {
    public static void main(String[] args) {
        Data data = new Data();

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

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    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();
    }
}

在这里插入图片描述

但如果存在多个线程的话就会出问题
虚假唤醒

需要把 if 改为 while

在这里插入图片描述

Lock 锁版本
condition.await();//等待
condition.signalAll();//唤醒全部

和Synchronize版本的区别就是，类名前面的Synchronize变成了：lock.lock()和lock.unlock()
lock.lock()；
try{
while(){ //用while可以防止虚假唤醒
等待
}
业务代码
唤醒其他线程
} catch（e）{

}finally{
lock.unlock()；
}


/**
 *  Lock锁
 */
public class B {
    public static void main(String[] args) {
        Data2 data = new Data2();

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

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

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

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

//判断等待，业务，通知
class Data2 {     //数字 资源类
    private int number = 0;

    Lock lock = new ReentrantLock();
    Condition condition = lock.newCondition();

//    condition.await();//等待
//    condition.signalAll();//唤醒全部

    //+1
    public void increment() throws InterruptedException {

        lock.lock();

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

    }

    //-1
    public synchronized void decrement() throws InterruptedException {

        lock.lock();

        try {
            while (number == 0) {
                //等待
                condition.await();
            }

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

    }
}

Condition 为什么要使用它，而不使用

Condition可以精准的通知和唤醒线程


/**
 * A执行完调用B
 * B执行完调用C
 * C执行完调用A
 */
public class C {
    public static void main(String[] args) {
        Data3 data3 = new Data3();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data3.printA();
            }
        },"A").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data3.printB();
            }
        },"B").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data3.printC();
            }
        },"C").start();
    }
}

//资源类
class Data3{

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

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

        try {
            //业务，判断 -》 执行 -》 通知
            while(number!=1){
                //等待
                condition1.await();
            }
            System.out.println(Thread.currentThread().getName()+"=>AAAAA");
            //唤醒指定线程
            number=2;
            condition2.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

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

        try {
            //业务，判断 -》 执行 -》 通知
            while(number!=2){
                //等待
                condition2.await();
            }
            System.out.println(Thread.currentThread().getName()+"=>BBBBB");
            //唤醒指定线程
            number=3;
            condition3.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

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

        try {
            //业务，判断 -》 执行 -》 通知
            while(number!=3){
                //等待
                condition3.await();
            }
            System.out.println(Thread.currentThread().getName()+"=>CCCCC");
            //唤醒指定线程
            number=1;
            condition1.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

}

4、8锁

1.Synchronize 锁方法 锁的是方法的调用者

public class Test1 {
    public static void main(String[] args) {
        Phone phone = new Phone();

        new Thread(()->{
            phone.sendSms();
        },"A").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(()->{
            phone.call();
        },"B").start();
    }
}
class Phone{

    //synchronize 锁的对象是方法的调用者
    //两个方法用的是同一个锁，谁先拿到谁先执行

    public synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("sendSms");
    }

    public synchronized void call(){
        System.out.println("call");
    }
}

结果：

sendSms
call

2.当有两个调用者时，就不会锁，普通方法也不会锁

public class Test2 {
    public static void main(String[] args) {
        //两个调用对象
        Phone2 phone = new Phone2();
        Phone2 phone2 = new Phone2();

        new Thread(()->{
            phone.sendSms();
        },"A").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(()->{
            //普通方法
//            phone.hello();
            //不同对象，call和sendSms不会锁在一起
            phone2.call();
        },"B").start();
    }
}
class Phone2{

    //synchronize 锁的对象是方法的调用者
    //两个方法用的是同一个锁，谁先拿到谁先执行

    public synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("sendSms");
    }

    public synchronized void call(){
        System.out.println("call");
    }

    //普通方法没有锁
    public void hello(){
        System.out.println("hello");
    }
}

结果：
call
sendSms

3.锁前面加static 锁的是Class，和调用者无关

public class Test3 {
    public static void main(String[] args) {
        Phone3 phone = new Phone3();
        Phone3 phone2 = new Phone3();

        new Thread(()->{
            phone.sendSms();
        },"A").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(()->{
            phone2.call();
        },"B").start();
    }
}
class Phone3{

    //static 静态方法
    //类一加载就有了，锁的对象是Class，不是调用者
    public static synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("sendSms");
    }

    public static synchronized void call(){
        System.out.println("call");
    }
}

结果：
sendSms
call

4.Class的锁和普通方法的锁是不一样的
锁的东西不一样，相互不影响


public class Test4 {
    public static void main(String[] args) {
        Phone4 phone = new Phone4();

        new Thread(()->{
            phone.sendSms();
        },"A").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(()->{
            phone.call();
        },"B").start();
    }
}
class Phone4{

    //静态同步方法
    //static 静态方法,锁的对象是Class
    public static synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("sendSms");
    }

    //普通同步方法
    public synchronized void call(){
        System.out.println("call");
    }
}

结果：
call
sendSms

小结：
Test1：synchronize方法 （同步锁）锁的调用者
Test2：普通方法和synchronize互不影响，同一调用者时也互不影响
Test3：static synchronize 锁的是Class对象
Test4：锁对象和锁调用者是互不影响的

5、集合类不安全

List Set 阻塞队列

List不安全


//ConcurrentModificationException
public class ListTest {
    public static void main(String[] args) {
        /**
         * 并发下ArrayList不安全
         */
//        List<String> list = Collections.synchronizedList(new ArrayList<>());
        //写入时复制 多线程调用的时候
        //在写入的时候避免覆盖造成数据问题
        //读写分离  CopyOnWriteArrayList 比 Vector效率高
        List<String> list = new CopyOnWriteArrayList<>();
        //synchronize效率低
//        List<String> list = new Vector<>();

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

Set安全

public class SetTest {
    public static void main(String[] args) {
//        Set<String> set = new HashSet<>();
//        Set<String> set = Collections.synchronizedSet(new HashSet<>());
        Set<String> set = new CopyOnWriteArraySet<>();
        for (int i = 0; i < 100; i++) {
            new Thread(()->{
                set.add(UUID.randomUUID().toString().substring(0,5));
                System.out.println(set);
            }).start();
        }
    }
}

HashSet 底层就是HashMap

在这里插入图片描述

Map不安全

ConcurrentHashMap

public class MapTest {
    public static void main(String[] args) {
//        Map<String, String> map = new HashMap<String, String>(16,0.75f);
        //加载因子，初始化容量

//        Map<String, String> map = Collections.synchronizedMap(new HashMap<>());
        Map<String, String> map = new ConcurrentHashMap<>();

        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                map.put(Thread.currentThread().getName(), UUID.randomUUID().toString().substring(0,5));
                System.out.println(map);
            }).start();
        }
    }
}

6、Callable（简单）

@FunctionalInterface
public interface Callable<V> {
    V call() throws Exception;
}

返回结果并可能引发异常任务。实现者定义一个没有参数的单一方法，称为call

Callable 类似 Runnable 因为它们都是为实例可能有另一个线程执行的类设计的。然而， A Runnable 不返回结果，也不能抛出被检查的异常

  1. 可以有返回值
  2. 可以抛出异常
  3. 方法不同，run() / call()

Runnable 的实现类 FutureTask类
FutureTask：
两个构造： Callable 的 和Runnable

    public FutureTask(Callable<V> callable) {
        if (callable == null)
            throw new NullPointerException();
        this.callable = callable;
        this.state = NEW;       // ensure visibility of callable
    }
    public FutureTask(Runnable runnable, V result) {
        this.callable = Executors.callable(runnable, result);
        this.state = NEW;       // ensure visibility of callable
    }

Test：

public class CallableTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        MyThread myThread = new MyThread();

        FutureTask futureTask = new FutureTask<>(myThread);
        new Thread(futureTask,"A").start();
        new Thread(futureTask,"B").start();

        String string = (String) futureTask.get();//Callable的返回值
    }
}
class MyThread implements Callable<String> {

    @Override
    public String call() throws Exception {
        System.out.println("111");
        return "123";
    }
}

结果只有打印一个 111
结果会被缓存，提高效率
细节：

  1. 有缓存
  2. 结果可以需要等待会阻塞

7、常用的辅助类

7.1、CountDownLatch

  1. 允许一个或多个线程等待直到在其他线程中执行的一组操作完成的同步辅助。

  2. A CountDownLatch用给定的计数初始化。 await方法阻塞，直到由于countDown()方法的调用而导致当前计数达到零，之后所有等待线程被释放，并且任何后续的await 调用立即返回。 这是一个一次性的现象 - 计数无法重置。 如果您需要重置计数的版本，请考虑使用CyclicBarrier 。

  3. A CountDownLatch是一种通用的同步工具，可用于多种用途。 一个CountDownLatch为一个计数的CountDownLatch用作一个简单的开/关锁存器，或者门：所有线程调用await在门口等待，直到被调用countDown()的线程打开。 一个CountDownLatch初始化N可以用来做一个线程等待，直到N个线程完成某项操作，或某些动作已经完成N次。

  4. CountDownLatch一个有用的属性是，它不要求调用countDown线程等待计数到达零之前继续，它只是阻止任何线程通过await ，直到所有线程可以通过。

当计数为0，才能执行后面的close door

public class CountDownLatchDemo {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(6);

        for (int i = 0; i < 6; i++) {
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+" Go Out");
                countDownLatch.countDown();     //数量-1
            },""+i).start();

        }

        countDownLatch.await();     //等待计数器归零
        System.out.println("close door");
    }
}

7.2、CyclicBarrier

加法计数器

public class CyclicBarrierDemo {
    public static void main(String[] args) {
        CyclicBarrier cyclicBarrier = new CyclicBarrier(8,()->{
            System.out.println("召唤成功！");
        });

        for (int i = 0; i < 7; i++) {
            final int temp = i;
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+" 第"+temp+"颗龙珠");
                try {
                    cyclicBarrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            },""+i).start();
        }
    }
}

7.3、Semaphore

//限流
public class SemaphoreDemo {
    public static void main(String[] args) {
        //线程数量
        Semaphore semaphore = new Semaphore(3);

        for (int i = 0; i < 6; i++) {
            new Thread(()->{
                try {
                    semaphore.acquire();    // 获取得到
                    System.out.println(Thread.currentThread().getName()+"抢到车位");
                    TimeUnit.SECONDS.sleep(2);
                    System.out.println(Thread.currentThread().getName()+"离开车位");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    semaphore.release();    //release()     释放
                }
            },""+i).start();
        }
    }
}

semaphore.acquire();
semaphore.release(); //release() 释放
作用：多个共享资源互斥的使用！并发限流，控制最大的线程数

猴子会跳舞
关注
JUC并发编程入门学习笔记（狂神说）
Free的午后
08-06 1218
因为热爱所以坚持，因为热爱所以等待。熬过漫长无戏可演的日子，终于换来了人生的春天，共勉！！！ 1. 什么是JUC JUC就是java.util.concurrent下面的类包，专门用于多线程的开发。 2. 线程和进程 进程是操作系统中的应用程序、是资源分配的基本单位，线程是用来执行具体的任务和功能，是CPU调度和分派的最小单位 一个进程往往可以包含多个线程，至少包含一个 1）进程 一个程序，QQ.EXE Music.EXE；数据+代码+pcb 一个进程可以包含多个线程，至少包含一个线..
JUC（狂神）
weixin_45769722的博客
09-26 309
JUC 1.什么是JUC JUC就是java.util.concurrent下面的类包，专门用于多线程的开发。 2.进程和线程 线程、进程，（如果不能用一句话说出来的技术，不扎实） 进程：一个程序，QQ.exe,Music.exe 程序的集合 一个进程往往可以包含多个线程，至少包含一个！ java默认有几个线程？2个 main 、GC 线程：开了个进程Typora ，写字，自动保存（线程负责的） 对于Java而言：Thread Runnable Callable Java真的可以开启线程吗？ 开不了的
狂神JUC——可重入锁
黄坤的博客
06-02 378
package com.company; //可重入锁 public class ReentrantLock { public static void main(String[] args) { Phone phone = new Phone(); new Thread(phone::sms,"A").start(); new Thread(phone::sms,"B").start(); } } class Phone{ p
⚡️狂神JUC学习笔记
Lemonyuki的博客
08-02 343
文章目录零、JUC是个啥一、回顾多线程知识1-线程和进程2-并发、并行3-线程有几个状态4-wait/sleep的区别二、Lock锁（重点）1-传统 Synchronized2-Lock接口3-Synchronized和Lock 区别三、生产者和消费者问题1-生产者和消费者问题 Synchronized 版2-JUC版的生产者和消费者问题3-Condition 精准的通知和唤醒线程四、8锁现象1-案例1：2-案例2：3-案例3：4-案例4：五、集合类不安全1-List不安全2-set不安全3-Map 不安全
狂神JUC——阻塞队列
黄坤的博客
06-02 397
package com.company; //阻塞队列 import java.sql.Time; import java.util.concurrent.ArrayBlockingQueue; import java.util.concurrent.TimeUnit; //什么时候使用阻塞队列？ 1、多线程并发处理 2、线程池 public class BlockingQueueTest { public static void main(String[] args) throws Int
狂神JUC——8锁现象彻底理解锁
黄坤的博客
06-02 999
1-2锁 package com.company.lock_8; /** * 8锁问题，就是关于锁的8个问题！，判断锁的是谁 */ import java.util.concurrent.TimeUnit; /** * 1.标志情况下，两个线程先打印，发短信？ 打电话？ * 2.sendSms延迟4秒，两个线程先打印，发短信？ 打电话？ */ public class Lock_1To2 { public static void main(String[] args) throw.
JUC并发编程 狂神第三讲
一起加油！！！
07-29 61
juc狂神第三讲
JUC(并发编程)
热门推荐
abc98526的博客
04-17 1万+
1.什么是JUC? JUC是指javaUtil包中的三个操作线程的包! 2.线程进程和程序 程序(Program):是一个静态的概念，一般对应于操作系统中的一个可执行的文件 ，比如：我们要启动酷狗听音乐，则对应酷狗可执行程序。当我们双击酷狗，则加载 程序到内存中，开始执行该程序，于是产生了"进程". 进程:执行中的程序叫做进程(Process),是一个动态的概念。现代的操作系统都可以同时启动多个进程。比如:我们在用酷狗听音乐，也可以使用wps写文档，也可以同时用浏览器查看网页。可以通过
Juc并发编程学习笔记---狂神说（全）
ProGram_Java521的博客
10-31 1620
Juc并发编程学习笔记---狂神说（全）
狂神说多线程学习笔记整理（二）~JUC并发编程
指尖上的革新
08-05 607
juc指 java.util.concurrent包线程与进程 进程：一个程序的集合，一个进程往往可以包含多个线程，至少包含一个 线程：是执行程序的一次执行过程，它是一个动态的概念。是系统资源分配的单位Java启动线程的三种方式： 继承Thread类 实现Runnable类 实现callable类Java是不能开启线程的，源码展示 并发与并行 并发：（多线程操作同一资源） Cpu单核，模拟出条多线程 并行（多个人一起走） Cup多核，多个线程可以同时执行 并发编程的本质：充分利用CPU的资源线程的状态 1.
JUC并发编程.md
01-28
#### 一、JUC并发编程简介 JUC（Java Util Concurrency）是Java标准库中的一个子包，提供了一系列高级并发工具类和接口，旨在简化多线程编程的复杂性。它包括了各种锁机制、线程池、信号量、屏障等实用组件，为开发...
基于《狂神说Java》JUC并发编程--学习笔记
wudidahuanggua的博客
06-15 909
本笔记仅做学习与复习使用，不存在刻意抄袭。给各位学友强烈推荐《遇见狂神说》他的整套Java学习路线使我获益匪浅！！!点击跳转至遇见狂神说哔哩哔哩首页如果你也是狂神的小迷弟，可以加我好友一起探讨学习。 ...
狂神JUC并发编程详细笔记整理
总的来说，这份JUC并发编程的笔记是对狂神课程内容的系统梳理，它不仅包含了理论知识，还有实践中的图形辅助和对弹幕大神建议的融入。对于希望巩固和加深对Java并发编程理解的学习者来说，这份笔记无疑是一份宝贵的...
HashMap为什么线程不安全？
最新发布
rnnf_yyds的博客
11-03 137
HashMap底层是基于数组 + 链表（在 Java 8 以后，当链表长度超过一定阈值时会转换为红黑树）的数据结构。在多线程环境下，当多个线程同时对HashMap进行put操作时，可下面这种情况：假设两个线程 A 和 B 同时执行put操作，它们计算出的插入位置相同（假设为index线程 A 先获取到了当前index位置的节点，在它还没来得及将新节点插入链表（或树）时，线程 B 也获取到了这个位置的节点。
[自用，更新自day5]瑞吉外卖代码及笔记
lapiii的博客
11-01 814
当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。Mybatis Plus公共字段自动填充，也就是在插入或者更新的时候为指定字段赋予指定的值，使用它的好处就是可以统一对这些字段进行处理，避免了重复代码。因为在分页查询的Dish的records(菜品记录中)，只有这个菜品所属的categoryId，但是我们需要分页的时候展示的是菜品名字。
JAVA 插入 JSON 对象到 PostgreSQL
qq_52143611的博客
10-30 874
在现代软件开发中，由于 JSON 数据的轻量和通用性，处理 JSON 数据已经变得无处不在。PostgreSQL凭借其对 JSON 的强大支持，为存储和查询 JSON 数据提供了出色的平台。为了将JSON数据保存到PostgreSQL数据库中，我们可以将JSON数据转换为PostgreSQL的JSONB类型数据，然后将其存储在数据库中。在Java中，我们可以使用JDBC或者基于ORM框架的方式来实现这一功能。
SpringSession源码分析
lkr_lkr的博客
11-01 252
默认对常规Session的理解和使用，如何使用Set-Cookie。
函数式接口与回调函数实践
m0_37635053的博客
10-29 412
函数式接口与回调函数
Java复习24（PTA)
2301_79272475的博客
10-30 409
Java复习24（PTA)：多种排序的book类*
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值