JUC-01

最新推荐文章于 2024-07-27 21:10:52 发布
最新推荐文章于 2024-07-27 21:10:52 发布
阅读量242 收藏
点赞数
分类专栏： 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/oldwangold/article/details/105617278
版权

JUC

1、什么是JUC

源码+官方文档
在这里插入图片描述

java.util工具包、包、分类

业务：普通的线程代码 Thread

Runable 没有返回值、效率相比于Callable相对较低
在这里插入图片描述
在这里插入图片描述

2、线程和进程

线程、进程，如果不能使用一句话说出来的技术，不扎实

进程：一个程序，QQ.exe Music.exe 程序的集合；

一个进程往往可以包含多个线程，至少包含一个！

在这里插入图片描述
Java默认有几个线程？

2个！ main线程和GC线程

线程：开了一个进程Typora，写字，自动保存（线程负责）

对于Java而言：Thread、Runnable、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 多核，多个线程可以同时执行；线程池
package com.won.demo01;

public class Test1 {
    public static void main(String[] args) {
        // 获取cpu的核数
        // CPU密集型，IO密集型
        System.out.println(Runtime.getRuntime().availableProcessors());
    }
}

并发编程的本质：充分利用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 必须要捕获异常

3、Lock锁（重点）

传统 Synchronized

package com.won.demo01;
// 基本的卖票例子
/*
真正的多线程开发，公司中的开发，降低耦合性
线程就是一个单独的资源类，没有任何附属的操作
1.属性、方法
 */
public class SaleTicketDemo01 {
    public static void main(String[] args) {
        // 并发：多线程操作同一个资源类，把资源类丢入线程
        Ticket ticket = new Ticket();

        // @FunctionalInterface 函数式接口，jdk1.8 lambda表达式 (参数)-> {代码}
        new Thread(()->{
            for (int i = 0; i < 60; i++) {
                ticket.sale();
            }
        },"A").start();
        new Thread(()->{
            for (int i = 0; i < 60; i++) {
                ticket.sale();
            }
        },"B").start();
        new Thread(()->{
            for (int i = 0; i < 60; 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 + "张票");
        }
    }
}

Lock接口

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
公平锁：十分公平，可以先来后到

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

package com.won.demo01;

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

// 基本的卖票例子
/*
真正的多线程开发，公司中的开发，降低耦合性
线程就是一个单独的资源类，没有任何附属的操作
1.属性、方法
 */
public class SaleTicketDemo02 {
    public static void main(String[] args) {
        // 并发：多线程操作同一个资源类，把资源类丢入线程
        Ticket2 ticket = new Ticket2();

        // @FunctionalInterface 函数式接口，jdk1.8 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();
    }
}

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

    Lock lock = new ReentrantLock();

    // 卖票的方式
    // synchronized 本质：队列，锁
    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 适合锁大量的同步代码！

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

4、生产者和消费者问题

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

生产者和消费者问题 synchronized版

package com.won.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();
    }

}

问题存在， A B C D 4个线程还安全吗？ 虚假唤醒

在这里插入图片描述

解决方法：if 改为 while 判断

package com.won.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.increment();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"C").start();
        new Thread(()->{
            try {
                for (int i = 0; i < 10; i++) {
                    data.decrement();
                }
            } 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版的生产者和消费者问题
在这里插入图片描述
通过 Lock 找到 Condition
在这里插入图片描述

代码实现：

package com.won.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) {
        Data2 data = new Data2();

        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.increment();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"C").start();
        new Thread(()->{
            try {
                for (int i = 0; i < 10; i++) {
                    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 (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    // -1
    public 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 精准的通知和唤醒线程
在这里插入图片描述
代码测试：

package com.won.pc;

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

/**
 * A 执行完调用 B，B 执行完调用 C，C 执行完调用 A
 */
public class C {
    public static void main(String[] args) {
        Data3 data = new Data3();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data.printA();
            }
        },"A").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data.printB();
            }
        },"B").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data.printC();
            }
        },"C").start();
    }
}

class Data3{ // 资源类　Lock

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

    public void printA() {
        lock.lock();
        try {
            // 业务，判断 -> 执行 -> 通知
            while (number != 1) {
                // 等待
                condition1.await();
            }
            System.out.println(Thread.currentThread().getName() + "=>AAAAA");
            // 唤醒，唤醒指定的人 B
            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");
            // 唤醒，唤醒指定的人，C
            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");
            // 唤醒，唤醒指定的人，A
            number = 1;
            condition1.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

5、8锁现象

如何判断锁的是谁！

对象、Class

package com.won.lock8;

import java.util.concurrent.TimeUnit;

/**
 * 8锁，就是关于锁的8个问题
 * 1.在标准情况下，两个线程是先打印 发短信还是打电话？ 1、发短信 -> 2、打电话
 * 2.sendSms延迟4秒，两个线程是先打印 发短信还是打电话？ 1、发短信 -> 2、打电话
 */
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{
    // synchronized 锁的对象是方法的调用者！
    // 两个方法用的是同一个锁，谁先拿到谁执行
    public synchronized void sendSms() {
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

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

}

package com.won.lock8;

import java.util.concurrent.TimeUnit;

/**
 * 3.增加了一个普通方法后，先执行发短信还是hello？ 普通方法
 * 4.两个对象，两个同步方法，发短信还是 打电话？ 打电话！
 */
public class Test2 {
    public static void main(String[] args) {
        // 两个对象，两个调用者，两把锁！
        Phone2 phone1 = new Phone2();
        Phone2 phone2 = new Phone2();

        // 锁的存在
        new Thread(()->{
            phone1.sendSms();
        },"A").start();

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

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

class Phone2{
    // synchronized 锁的对象是方法的调用者！
    // 两个方法用的是同一个锁，谁先拿到谁执行
    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");
    }

}

package com.won.lock8;

import java.util.concurrent.TimeUnit;

/**
 * 5.增加两个静态的同步方法，只有一个对象，先打印 发短信？打电话？ 发短信
 * 6.两个对象，增加两个静态的同步方法，先打印 发短信？打电话？ 发短信
 */
public class Test3 {
    public static void main(String[] args) {
        // 两个对象的Class类模板只有一个，static，锁的是Class
        Phone3 phone1 = new Phone3();
        Phone3 phone2 = new Phone3();

        // 锁的存在
        new Thread(()->{
            phone1.sendSms();
        },"A").start();

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

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

// Phone3唯一的一个class对象
class Phone3{
    // synchronized 锁的对象是方法的调用者！
    // static 静态方法
    // 类一加载就有了！ 锁的是 Class
    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("打电话");
    }

}

package com.won.lock8;

import java.util.concurrent.TimeUnit;

/**
 * 7.一个静态的同步方法，一个普通的同步方法，一个对象，先打印 发短信？打电话？ 打电话
 * 8.一个静态的同步方法，一个普通的同步方法，两个对象，先打印 发短信？打电话？ 打电话
 */
public class Test4 {
    public static void main(String[] args) {
        // 两个对象的Class类模板只有一个，static，锁的是Class
        Phone4 phone1 = new Phone4();
        Phone4 phone2 = new Phone4();

        // 锁的存在
        new Thread(()->{
            phone1.sendSms();
        },"A").start();

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

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

// Phone4唯一的一个class对象
class Phone4{
    // 静态的同步方法 锁的是 Class 类模板
    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("打电话");
    }

}

小结

new：this，具体的一个手机

static：Class，唯一的一个模板

王加油
关注
专栏目录
Java并发3 ——关于锁的生产者和消费者问题
weixin_51818357的博客
07-24 156
这个问题是一步步进阶的， if，while 虚假唤醒问题 一开始是这样 package com.kuang.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(()-
JUC-01（多线程）
09-26 37
所谓守护线程，是指在程序运行的时候在后台提供一种通用服务的线程，比如垃圾回收线程就是一个很称职的守护者，并且这种线程并不属于程序中不可或缺的部分。所以说多线程程序的执行是有随机性，因为谁抢到CPU的使用权是不一定的。假如线程甲和线程乙在交替执行，某个时间点线程甲做出了礼让，所以在这个时间点线程乙拥有了CPU资源，执行业务逻辑，但不代表线程甲一直暂停执行。其作用是中断此线程（此线程不一定是当前线程，而是指调用该方法的Thread实例所代表的线程），但实际上只是给线程设置一个中断标志，线程仍会继续运行。
JUC-什么是JUC-01
rr18758236029的博客
11-02 170
JUC-什么是JUC-01 什么是JUC java.util.concurrent 工具包 业务：普通的线程代码Thread Runnable：没有返回值，效率相比Callable相对较低 线程和进程 线程、进程 进程：1个程序，程序的集合 一个进程往往包含多个线程，至少包含1个 java默认两个线程，mainGC 线程：开了一个进程Typora，写字，自动保存（线程负责） 对java：Thread，Runnable，Callable java无法直接操作线程，通过本地方法 并发，并行 并发（多线程操作同一
JUC-01概述
Logan的博客
08-20 191
1 什么是 JUC 1.1 JUC 简介 在 Java 中，线程部分是一个重点，本篇文章说的 JUC 也是关于线程的。JUC就是 java.util .concurrent 工具包的简称。这是一个处理线程的工具包，JDK 1.5 开始出现的。 1.2 进程与线程 进程（Process） 是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。 在当代面向线程设计的计算机结构中，进程是线程的容器。程序是指令、数据及其组织形式的描述，进程是程序的实体。是计算
JUC-01线程基础知识
天上地下的博客
08-07 172
注意事项： 高内聚低耦合前提下，封装思想 判断、干活、通知 防止虚假唤醒,wait方法要注意使用while判断 注意标志位flag，可能是volatile的 使用JUC原因： 硬件方面 摩尔定律失效 软件方面 高并发系统，异步+回调生产需求 多线程相关概念： 进程 是程序的⼀次执⾏，是系统进⾏资源分配和调度的独⽴单位，每⼀个进程都有它⾃⼰的内存空间和系统资源 线程 一个进程包含一个或多个线程 在同⼀个进程内⼜可以执⾏多个任...
JUC-01：基础知识
xiaozhang960825的博客
03-07 107
JUC基础知识
JUC-01 线程入门&如何创建线程
CoderNames的博客
07-02 82
文本主要讲3个问题： 1.线程是什么？ 2.线程有哪些状态？各状态间的转换了解吗？ 3. 创建线程的3种方法 这些你都了解吗？
JUC-01 线程的创建和状态转换
程序员一棵树
04-10 461
线程是什么？ 线程有哪些状态？各状态间的转换了解吗？ 创建线程的3种方法你都了解吗？
[JUC-01] 前置概念
学哥斌的博客
08-11 338
并发编程的概念，进程和线程
juc-12-线程池2-线程池的使用
qq_20633779的博客
12-01 363
这是线程池第二篇文章，上一篇文章写了如何创建线程池，这篇文章用代码来演示通过 ThreadPoolExecutor 和 Executors的静态工厂方法创建线程池，以及这些线程池的基本使用，然后重点讲解 ThreadPoolExecutor 的实现接口 ExecutorService 中的常用API，如何通过这些API来管理线程池。 1、ThreadPoolExecutor 创建线程池 从上篇文章《juc-12-线程池2-线程池的使用》中，我们学习到 ThreadPoolExecutor 几个重载的构造
JUC----Volatile与JMM之间的联系
weixin_65237252的博客
07-27 898
volatile保证不同线程对共享变量操作的可见性，也就是说一个线程修改了volatile修饰的变量，当修改写回主内存时，另外一个线程立即看到最新的值。但是volatile不保证原子性。
Java并发编程札记-(六)JUC线程池-01概述
潘威威的博客
01-04 1858
前面的例子中总是需要线程时就创建，不需要就销毁它。但频繁创建和销毁线程是很耗资源的，在并发量较高的情况下频繁创建和销毁线程会降低系统的效率。线程池可以通过重复利用已创建的线程降低线程创建和销毁造成的消耗。 参考JDK1.8中的相关类，画出下图。 (此图不是十分准确，有些类实现了两个接口，这里只展示出了一个) 本章只是简单地介绍下它们，在以后的文章中会选一些最重要的来学习。 Execut
JUC详解-12-4大函数式接口
baidu_38126306的博客
11-17 187
JUC 详解 -> 四大函数式接口 新时代的程序员：lambda表达式、链式编程、函数式接口、Stream流式计算 函数式接口：只有一个方法的接口，如Runnable接口 @FunctionalInterface public interface Runnable { public abstract void run(); } 超级多FunctionalInterface 简化编程模型，在新版本的框架底层大量应用！ foreach(消费者类的函数式接口) 四大原生的函数式
基于《狂神说Java》JUC并发编程--学习笔记
wudidahuanggua的博客
06-15 863
本笔记仅做学习与复习使用，不存在刻意抄袭。给各位学友强烈推荐《遇见狂神说》他的整套Java学习路线使我获益匪浅！！!点击跳转至遇见狂神说哔哩哔哩首页如果你也是狂神的小迷弟，可以加我好友一起探讨学习。 ...
_Command_line_settings_desktop_wallpaper_tool,_Su_command-wallpa
最新发布
09-17
_Command_line_settings_desktop_wallpaper_tool,_Su_command-wallpaper
IMG_20240917_151703.jpg
09-17
IMG_20240917_151703.jpg
吉他谱_Pneuma - Tool.pdf
09-17
初级入门吉他谱 guitar tab
Java项目-基于SSM+Jsp的计算机网络课程试卷生成器系统的设计与实现（源码+数据库脚本+部署视频+代码讲解视频+全套软件）
09-17
【基于SSM+Jsp的计算机网络课程试卷生成器系统的设计与实现】高分通过项目，已获导师指导。 本项目是一套基于SSM+Jsp的计算机网络课程试卷生成器系统，主要针对计算机相关专业的正在做毕设的学生和需要项目实战练习的Java学习者。也可作为课程设计、期末大作业 包含：项目源码、数据库脚本、开发说明文档、部署视频、代码讲解视频、全套软件等，该项目可以直接作为毕设使用。 项目都经过严格调试，确保可以运行！
"Java-JUC-多线程 进阶：遇见狂神说的JUC并发编程进阶版概要
Java-JUC-多线程进阶是一门关于Java并发编程的课程，来源于B站的《遇见狂神说》。这门课程于2019年5月31日发布，主要涵盖了以下主题：JUC的概念，进程和线程的回顾，Lock锁的使用，生产者和消费者模式，8锁的现象，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值