java八股文面试[多线程]——线程间通信方式

news2024/11/16 18:37:47

多个线程在并发执行的时候，他们在CPU中是随机切换执行的，这个时候我们想多个线程一起来完成一件任务，这个时候我们就需要线程之间的通信了，多个线程一起来完成一个任务，线程通信一般有4种方式：

通过 volatile 关键字
通过 Object类的 wait/notify 方法
通过 condition 的 await/signal 方法
通过 join 的方式

现在有一个问题，两个线程分别打印字符串，但是当线程A每输出两次的时候，线程B就输出一次，如此反复10次。

通过 volatile 关键字

通过 volatile 关键字来实现这个任务，这个也是最简单的一种实现方式，大致思路 volatile 是共享内存的，两个线程共享一个标志位，当标志位更改的时候就执行不同的线程。
 

public class VolatileDemo {
    private static volatile boolean flag = true;  //定义一个标志位，当标志位更改的时候不同的线程被执行

    public static void main(String[] args) {
        //线程A启动
        new Thread(() -> {
            int i = 0;
            while(true){  //进行死循环，一直输出语句
                if (flag){  //对标志位的判断，符合就执行
                    System.out.println(Thread.currentThread().getName()+" ===>" + ++i); //输出语句
                    if (i%2==0){  //如果语句输出两次了 改变标志位
                        flag  =false;
                    }
                    if (i == 10) break;  //到达十次，结束循环
                }
            }
        }, "A").start();
        new Thread(() -> {
            int i = 0;
            while(true){
                if (!flag){  //判断条件不一样
                    System.out.println(Thread.currentThread().getName()+" 被唤醒啦 " + ++i);
                    flag  = true;  //改变标志位
                    if (i == 5) break;
                }
            }
        }, "B").start();
    }
}

我们发现我们这个位置用的while循环的，用for循环指定次数可以吗，是不可以的，因为我们只是改变了标志位，但是并没有立刻唤醒另外一个线程让他执行，虽然我打印的语句是我被唤醒了，但是实际上只是线程A处于死循环，啥子也不做，直到线程B抢到了时间片，进行对标志位的判断，然后输出语句，在进行空循环，等待A抢到时间片，如此反复，可以自己在if判断外面加一条计数语句，来验证一下结果，如果想要立刻唤醒的话，那么就是另外一种方法啦。

通过 Object类的 wait/notify 方法

对于上面的volatile关键字这个方法来说，我们的线程执行了很多次空循环，来等待另外一个线程来获取锁，这种操作无疑是十分消耗CPU的资源的，所以说为了解决这种情况，我们就需要一种机制可以实现线程之间的通信，可以唤醒其他的线程，而不是等待直到自己获取CPU的时间片，我们都知道，Object类提供了三个线程间通信的方法，wait()，notify()，notifyAll()。这三个方法必须都在同步代码块中执行的。

方法名具体操作
wait()wait()方法执行前，是必须要获得对应的锁的，当执行wait()方法后，线程就会释放掉自己所占有的锁，释放CPU，然后进入阻塞状态，直到被notify()方法唤醒。
notify()会唤醒一个处于等待该对象锁的线程，然后继续往下执行，直到执行完退出对象锁锁住的区域（synchronized修饰的代码块）后再释放锁。
notifyAll()和notify()方法差不多，只不过他是唤醒所有等待该对象锁的线程，让他们进入就绪队列，但是谁执行就看谁抢占到CPU，notify()方法也是这样，只不过是唤醒随机的一个而已

每个锁对象都有两个队列，一个是就绪队列，一个是阻塞队列。就绪队列存储了已就绪（将要竞争锁）的线程，阻塞队列存储了被阻塞的线程。当一个阻塞线程被唤醒后，才会进入就绪队列，进而等待CPU的调度；反之，当一个线程被wait后，就会进入阻塞队列，等待被唤醒。

public class WaitAndNotify {
    public static void main(String[] args) {
        Object lock = new Object();  //创建一个锁对象
        new Thread(() -> {
            for (int i = 1; i <= 10; i++) {
                synchronized (lock) {  //首先需要获取锁
                    System.out.println(Thread.currentThread().getName() + " ==> " + i);
                    if (i % 2 == 0) {
                        lock.notify();  //唤醒线程B
                        if (i!=10){
                            try {
                                lock.wait();  //让自己等待
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }
                    }
                }
            }
        }, "A").start();
        new Thread(() -> {
            for (int i = 1; i <= 5; i++) {
                synchronized (lock) {
                    lock.notify();  //我们看到，执行notify方法时，后面的代码还是执行了，并不是立刻释放资源
                    System.out.println(Thread.currentThread().getName() + "我执行了notify方法 " + i);
                    if (i!=5){
                        try {
                            lock.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }, "B").start();
    }
}

通过上面的代码我们发现，当执行notify方法时，我们并不会立刻释放锁资源，而是在执行完我们代码块里面的内容时才会释放掉锁资源，而wait()方法则会立刻释放掉锁资源，进入阻塞状态，这里我们有举例子，可以自己在wait()方法后面加上一个输出语句。我们进行交替通信的规则就是，执行wait(）方法，释放掉锁资源，然后执行 notify() 方法，唤醒其他的线程，在代码中，我在wait()方法上加了一个判断，如果是最后一次的话，那么我就不执行，为什么，因为我在执行wait()方法的时候，那么线程除非被唤醒，否则就会一直阻塞，这样的话我们的demo就不可以结束了，一直处于允许状态。

通过 condition 的 await/signal 方法

Condiction对象是通过lock对象来创建得(调用lock对象的newCondition()方法)，他在使用前也是需要获取锁得，其中，Lock 替代了 synchronized 方法和语句的使用，Condition 替代了 Object 监视器方法的使用。Condiction对象得常用方法：

await() : 线程自主释放锁，进入沉睡状态，直到被再次唤醒。
await(long time, TimeUnit unit) ：线程自主释放锁，进入沉睡状态，被唤醒或者未到达等待时间时一直处于等待状态。
signal()： 唤醒一个等待线程。
signal()All() ：唤醒所有等待线程,能够从等待方法返回的线程必须获得与Condition相关的锁。

    public static void main(String[] args) {
        //设置一个锁
        Lock lock = new ReentrantLock();
        Condition condition = lock.newCondition();
        AtomicInteger number = new AtomicInteger(1);
        AtomicInteger count = new AtomicInteger(1);
        new Thread(()->{
            while (count.get() != 10){
                lock.lock();
                try {
                    count.getAndIncrement();
                    if (number.get() != 1 && count.get() != 11){
                        condition.await();
                    }
                    number.getAndIncrement();
                    System.out.println(Thread.currentThread().getName() + "---> 生产");
                    condition.signalAll();
                }catch (Exception e){
                    e.printStackTrace();
                }finally {
                    lock.unlock();
                }
            }
        },"producter").start();
        new Thread(()->{
            while (count.get() != 10 ){
                lock.lock();
                try {
                    count.getAndIncrement();
                    if (number.get() != 2 && count.get() != 11){
                        condition.await();
                    }
                    number.getAndDecrement();
                    System.out.println(Thread.currentThread().getName() + "---> 消费");
                    condition.signalAll();
                }catch (Exception e){
                    e.printStackTrace();
                }finally {
                    lock.unlock();
                }
            }
        },"customer").start();
    }

await操作会立刻释放掉锁，进入阻塞状态，singal会唤醒等待队列中的头节点(失败就依次唤醒)。这个代码逻辑有大问题，只是这样写看得出数据之间的交换即可。注意点：代码一定要在lock和unlock之间。

通过 join 方法来实现线程通信
    public static void main(String[] args) throws InterruptedException {
        Thread A = new Thread(() -> {
            System.out.println("执行完毕");
        },"A");
        Thread B = new Thread(()->{
            try {
                Thread.sleep(1000L);
                System.out.println(Thread.currentThread().getName() + "测试join");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            },"B");
        A.start();
        B.start();
        B.join();
        System.out.println("Main线程");
    }

简单来说，就是join方法会让自己提前执行，比如上面的例子中就是让Main线程阻塞了，等待B线程执行完毕后才会执行。本质就是调用了wait方法，让当前线程阻塞，直到另一个线程执行完毕。(当前线程wait后，执行join方法的线程大概率抢到锁资源，而且当一个线程执行完毕后，会默认调用notifyAll方法。)

小结
其实准确来说，应该只有三种可以通信的方式，join只是让当前线程先执行完，并没有说根据两个线程之间数据的共享。

线程之间的通信方式主要有以下几种：


共享变量：线程之间可以通过共享变量来进行通信。不同的线程可以共享同一个变量，并在变量上进行读写操作。需要注意的是，共享变量可能会引发线程安全问题，需要通过同步机制来确保线程安全。

锁机制：锁机制是一种常用的线程同步机制，可以保证在同一时间只有一个线程能够访问共享资源。Java提供了多种锁类型，如 synchronized 关键字、ReentrantLock 类等。

条件变量：条件变量是一种线程间通信机制，它用于在一个共享资源上等待某个条件的成立。Java 提供了 Condition 接口来支持条件变量的实现，在使用 Condition 时需要先获取锁，然后调用 await() 方法等待条件成立，当条件成立时可以通过 signal() 或 signalAll() 方法唤醒等待该条件的线程。

信号量：信号量是一种常见的线程同步机制，可用于控制多个线程对共享资源的访问。Java 提供了 Semaphore 类来实现信号量，Semaphore 类有两个常用的方法 acquire() 和 release()，分别用于获取和释放信号量。

管道：管道是一种用于线程间通信的高级机制，它可以实现一个线程向另一个线程传送数据。Java 提供了 PipedInputStream 和 PipedOutputStream 两个类来支持管道的实现，其中 PipedInputStream 用于读取数据，PipedOutputStream 用于写入数据。

需要注意的是，以上通信方式都需要在多线程程序中谨慎使用，需要考虑线程安全和性能等方面的问题。为了确保程序正确、高效地运行，需要根据具体情况选择合适的线程通信方式，并进行相应的测试和优化。

具体的示例
共享变量
public class SharedData {
    private int value;
    public synchronized int getValue() { 
        return value; 
    }
    public synchronized void setValue(int value) { 
        this.value = value; 
    }
}

   在这个示例中，定义了一个共享数据类 SharedData，其中包含一个整型变量 value 和两个同步方法 getValue() 和 setValue()，用于获取和设置变量的值。由于这两个方法都是同步的，因此多个线程可以安全地访问该变量。

public class SharedDataExample {
    public static void main(String[] args) throws InterruptedException {
        SharedData sharedData = new SharedData();
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                sharedData.setValue(i);
                System.out.println(Thread.currentThread().getName() + " write " + sharedData.getValue());
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                System.out.println(Thread.currentThread().getName() + " read " + sharedData.getValue());
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        thread1.start();
        thread2.start();
        thread1.join();
        thread2.join();
    }
}

在这个示例中，创建了两个线程分别用于读写共享数据 SharedData，多次执行该示例可以看到控制台输出表明两个线程在安全地访问共享变量。

锁机制
public class LockExample {
    private static Lock lock = new ReentrantLock();
    private static int count = 0;
    private static void increase() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }
    public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 10000; i++) {
                increase();
            }
        });
        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 10000; i++) {
                increase();
            }
        });
        thread1.start();
        thread2.start();
        thread1.join();
        thread2.join();
        System.out.println(count);
    }
}

在这个示例中，使用了 Lock 接口和 ReentrantLock 类来对计数器进行同步，多次执行该示例可以看到最终输出的计数器值为 20000。

信号量
public class SemaphoreExample {
    private static Semaphore semaphore = new Semaphore(2);
    private static void doWork() throws InterruptedException {
        semaphore.acquire();
        System.out.println(Thread.currentThread().getName() + " start working");
        Thread.sleep(1000);
        System.out.println(Thread.currentThread().getName() + " finish working");
        semaphore.release();
    }
    public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new Thread(() -> {
            try {
                doWork();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        Thread thread2 = new Thread(() -> {
            try {
                doWork();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        Thread thread3 = new Thread(() -> {
            try {
                doWork();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        thread1.start();
        thread2.start();
        thread3.start();
        thread1.join();
        thread2.join();
        thread3.join();
    }
}

  在这个示例中，使用了 Semaphore 类来定义了一个信号量，线程1、线程2、线程3都需要获取信号量才能进行工作，每次执行 doWork() 方法需要占用资源，执行完毕后释放信号量。

管道
public class PipeExample {
    static class WriterThread extends Thread {
        private PipedOutputStream output;
        WriterThread(PipedOutputStream output) {
            this.output = output;
        }
        @Override
        public void run() {
            try {
                for(int i=1;i<=10;i++) {
                    output.write(i);
                    System.out.println("写入数据：" + i);
                    Thread.sleep(1000);
                }
            } catch(Exception e) {
                e.printStackTrace();
            } finally {
                try {
                    output.close();
                } catch(Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }
    static class ReaderThread extends Thread {
        private PipedInputStream input;
        ReaderThread(PipedInputStream input) {
            this.input = input;
        }
        @Override
        public void run() {
            try {
                int value;
                while((value=input.read()) != -1) {
                    System.out.println("读取数据：" + value);
                }
            } catch(Exception e) {
                e.printStackTrace();
            } finally {
                try {
                    input.close();
                } catch(Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }
    public static void main(String[] args) throws IOException {
        PipedOutputStream output = new PipedOutputStream();
        PipedInputStream input = new PipedInputStream(output);
        Thread thread1 = new WriterThread(output);
        Thread thread2 = new ReaderThread(input);
        thread1.start();
        thread2.start();
        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

在这个示例中，使用了 PipedOutputStream 类和 PipedInputStream 类来定义了一个管道，线程1向管道中写入数据，线程2从管道中读取数据，通过管道来实现两个线程之间的通信。

知识来源：

【23版面试突击】 在Java中线程间有哪些通信方式？_哔哩哔哩_bilibili

线程通信的四种方式_我是哎呀呀的博客-CSDN博客

Java线程之间如何通信的，有哪些方式？_java线程间通信的几种方法_Ascend1797的博客-CSDN博客

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/957089.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

详解IP协议

详解IP协议

在介绍IP协议之前&#xff0c;先抛出一个概念&#xff1a;IP地址的作用——定位主机&#xff0c;具有将数据从主机A跨网络传输到主机B的能力&#xff0c;有了TCP提供的策略&#xff0c;例如滑动窗口、拥塞控制等&#xff0c;IP去执行它&#xff0c;所以我们通常叫TCP/IP协议&am…
阅读更多...
阿里云centos9stream安装宝塔+vscode（code-server）集成云端开发环境

阿里云centos9stream安装宝塔+vscode（code-server）集成云端开发环境

一、 安装宝塔面板 官网 https://www.bt.cn/new/download.htm 题外话&#xff1a;虽然感觉现在宝塔没以前好用了&#xff0c;而且有centos7、8 mysql编译导致OOM服务器挂掉无法ssh登录的情况&#xff0c;但他还是远程管理服务器的好选择&#xff0c;提示宝塔只支持最新的centos…
阅读更多...
基于广义正态分布算法优化的BP神经网络（预测应用） - 附代码

基于广义正态分布算法优化的BP神经网络（预测应用） - 附代码

基于广义正态分布算法优化的BP神经网络&#xff08;预测应用&#xff09; - 附代码 文章目录 基于广义正态分布算法优化的BP神经网络&#xff08;预测应用&#xff09; - 附代码1.数据介绍2.广义正态分布优化BP神经网络2.1 BP神经网络参数设置2.2 广义正态分布算法应用 4.测试结…
阅读更多...
[管理与领导-60]：IT基层管理者 - 扩展技能 - 3 - 通过面试招到合适的人选

[管理与领导-60]：IT基层管理者 - 扩展技能 - 3 - 通过面试招到合适的人选

目录 前言&#xff1a; 一、招聘 1.1 什么是招聘 1.2 招聘 VS 招募 1.3 甄选 1.4 招聘中的重要原则 1.5 招聘的本质 1.6 人才匹配的维度 1.7 人员招聘中的误区 二、面试 2.1 何为面试 2.2 为什么面试 2.3 面试的注意事项 2.4 面试的误区 2.5 如何进行面试 前言…
阅读更多...
Vulnstack----5、ATTCK红队评估实战靶场五

Vulnstack----5、ATTCK红队评估实战靶场五

文章目录 一 环境搭建二 外网渗透三 内网信息收集3.1 本机信息收集3.2 域内信息收集 四 横向移动4.1 路由转发和代理通道4.2 抓取域用户密码4.3 使用Psexec登录域控4.4 3389远程登录 五、痕迹清理 一 环境搭建 1、项目地址 http://vulnstack.qiyuanxuetang.net/vuln/detail/7/ …
阅读更多...
交互设计都有哪些准则？

交互设计都有哪些准则？

UI交互设计的本质不是完全基于用户的需求&#xff0c;而是交互设计师需要学习根据用户描述的产品形式来了解用户需要什么。 在交互设计过程中&#xff0c;遵循科学交互设计的本质是整个交互设计过程的重要组成部分&#xff0c;这与产品使用过程中给用户带来的体验密切相关。本…
阅读更多...
matlab函数 状态空间系统ss、能控性矩阵ctrb、矩阵的秩rank、能控标准型canon、零极点配置place、系统极点pole等函数（线性定常系统）

matlab函数 状态空间系统ss、能控性矩阵ctrb、矩阵的秩rank、能控标准型canon、零极点配置place、系统极点pole等函数（线性定常系统）

matlab函数 能控性矩阵ctrb、能控标准型canon、零极点配置place 第一章&#xff0c;线性定常系统 ss 如果已知线性定常系统的ABCD四个矩阵&#xff0c;可以得到状态空间系统 其他更具体的用法请直接看帮助文档。 用法&#xff1a;ss(A,B,C,D) 假如 可以输入 A [-1.5,-2…
阅读更多...
Java连接websocket优雅断线、重连功能

Java连接websocket优雅断线、重连功能

为了实现优雅重连和重试&#xff0c;您需要在代码中添加一些逻辑来处理连接失败或断开连接的情况。 实现代码如下&#xff1a; import javax.websocket.*; import java.io.IOException;ClientEndpoint public class WebSocketClientEndpoint {private Session userSession n…
阅读更多...
【区块链 | IPFS】浅谈 | IPFS数据存储原理

【区块链 | IPFS】浅谈 | IPFS数据存储原理

IPFS在数据存储方面采用的是分散式的文件存储，区别于HTTP协议的位置寻址，IPFS是基于内容寻址，当文件上传到IPFS节点存储时，节点会对文件进行Merkle DAG（默克尔有向无环图）的格式组织分块存储，在存储完毕后，文件将以Merkle DAG的根哈希数来表示该文件，用户可以从IPFS构…
阅读更多...
【JAVA基础——JAVA虚拟机JVM】

【JAVA基础——JAVA虚拟机JVM】

JVM 文章目录 JVM一.JVM结构1.1.JVM包含两个子系统和两个组件1.2.运行时数据区1.2.1.简介1.2.2.程序计数器1.2.3.虚拟机栈1.2.4.堆1.2.5.本地方法栈1.2.6.方法区(永久代实现)java8-1.2.7.元空间(Metaspace)1.2.8.JVM字节码执行引擎1.2.9.直接内存(Direct Memory)1.2.10.垃圾收集…
阅读更多...
three.js(三)：three.js的渲染结构

three.js(三)：three.js的渲染结构

three.js 的渲染结构 概述 three.js 封装了场景、灯光、阴影、材质、纹理和三维算法&#xff0c;不必在直接用WebGL 开发项目&#xff0c;但有的时候会间接用到WebGL&#xff0c;比如自定义着色器。three.js 在渲染三维场景时&#xff0c;需要创建很多对象&#xff0c;并将它…
阅读更多...
C语言柔性数组详解：让你的程序更灵活

C语言柔性数组详解：让你的程序更灵活

柔性数组 一、前言二、柔性数组的用法三、柔性数组的内存分布四、柔性数组的优势五、总结 一、前言 仔细观察下面的代码&#xff0c;有没有看出哪里不对劲&#xff1f; struct S {int i;double d;char c;int arr[]; };还有另外一种写法&#xff1a; struct S {int i;double …
阅读更多...
Sublime Text汉化，主打简单明了

Sublime Text汉化，主打简单明了

在Sublime中设置中文的步骤如下&#xff1a; 1.打开Sublime Text&#xff0c;使用快捷键ShiftCtrlP&#xff08;MacOS下cmdShiftP&#xff09;&#xff0c;弹出查找栏。 2.在搜索框中输入关键字"install"&#xff0c;出现下拉选项&#xff0c;点击选择其中的"P…
阅读更多...
Dubbo 应用切换 ZooKeeper 注册中心实例，流量无损迁移

Dubbo 应用切换 ZooKeeper 注册中心实例，流量无损迁移

首先思考一个问题&#xff1a;如果 Dubbo 应用使用 ZooKeeper 作为注册中心&#xff0c;现在需要切换到新的 ZooKeeper 实例&#xff0c;如何做到流量无损&#xff1f; 本文提供解决这个问题的一种方案。 场景 有两个基于 Dubbo 的微服务应用&#xff0c;一个是服务提供者&…
阅读更多...
北京收录2023开学了《乡村振兴战略下传统村落文化旅游设计》中建博后许少辉八一新书

北京收录2023开学了《乡村振兴战略下传统村落文化旅游设计》中建博后许少辉八一新书

北京收录2023开学了《乡村振兴战略下传统村落文化旅游设计》中建博后许少辉八一新书
阅读更多...
【业务功能篇92】微服务-springcloud-多线程-异步处理-异步编排-CompletableFutrue

【业务功能篇92】微服务-springcloud-多线程-异步处理-异步编排-CompletableFutrue

三、CompletableFutrue 一个商品详情页 展示SKU的基本信息 0.5s展示SKU的图片信息 0.6s展示SKU的销售信息 1sspu的销售属性 1s展示规格参数 1.5sspu详情信息 1s 1.ComplatableFuture介绍 Future是Java 5添加的类&#xff0c;用来描述一个异步计算的结果。你可以使用 isDone方…
阅读更多...
WPF工控机textbox获得焦点自动打开软键盘

WPF工控机textbox获得焦点自动打开软键盘

1.通过nuget安装 osklib.wpf 2.在textbox getFoucs中敲入如下代码即可实现获得焦点弹出软键盘 private void txtPLC_IP_GotFocus(object sender, RoutedEventArgs e){try{// Osklib.OnScreenKeyboard.Close();Osklib.OnScreenKeyboard.Show();}catch (Exception ex){MessageB…
阅读更多...
烟草企业物流管理信息系统的分析与设计(论文+源码)_kaic

烟草企业物流管理信息系统的分析与设计(论文+源码)_kaic

摘要 在经济高速发展的今天&#xff0c;物流业已经成为支撑国民经济的基础性产业。作为一种新型服务业&#xff0c;物流业集仓储、运输、信息等为一体&#xff0c;发展成为复合型战略性产业。S烟草企业设计的物流管理信息系统利用B/S模式的三层结构&#xff0c;基于JSP技术和J…
阅读更多...
13.108.Spark 优化、Spark优化与hive的区别、SparkSQL启动参数调优、四川任务优化实践：执行效率提升50%以上

13.108.Spark 优化、Spark优化与hive的区别、SparkSQL启动参数调优、四川任务优化实践：执行效率提升50%以上

13.108.Spark 优化 1.1.25.Spark优化与hive的区别 1.1.26.SparkSQL启动参数调优 1.1.27.四川任务优化实践&#xff1a;执行效率提升50%以上 13.108.Spark 优化&#xff1a; 1.1.25.Spark优化与hive的区别 先理解spark与mapreduce的本质区别&#xff0c;算子之间&#xff08;…
阅读更多...
什么是架构，架构的本质是什么

什么是架构，架构的本质是什么

不论是开发人员还是架构师&#xff0c;我们都一直在跟软件系统打交道&#xff0c;架构是在工作中出现最频繁的术语之一。那么&#xff0c;到底什么是架构&#xff1f;你可能有自己的答案&#xff0c;也有可能没有答案。对“架构”的理解需要我们不断在实践中思考、归纳、演绎&a…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023