多线程与高并发（四）

news2025/1/12 23:16:41

【Exchanger】：

package Ten_Class.t04.no139;

import java.util.concurrent.Exchanger;

public class T12_TestExchanger {

    static Exchanger<String> exchanger = new Exchanger<>();

    public static void main(String[] args) {
        new Thread(() -> {
            String s = "T1";
            try {
                s = exchanger.exchange(s);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + " " + s);

        }, "t1").start();


        new Thread(() -> {
            String s = "T2";
            try {
                s = exchanger.exchange(s);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + " " + s);

        }, "t2").start();


    }
}

在这里插入图片描述
在这里插入图片描述
//交换后两个线程继续往前跑。（ 先执行exchange()方法的线程会进入阻塞状态 ）

【Exchanger注意】：

只能是两个线程之间，三个以及以上不清楚如何交换。
两个线程一个执行了exchange()方法 ， 另一个不执行，那么执行的那个线程会进入阻塞状态。

【 复习总结 】：

  • synchronized
  • volatile
  • AtomicXXX
  • 各种JUC同步锁
    ReentrantLock
    CountDownLatch
    CyclicBarrier
    Phaser
    ReadWriteLock - StampedLock
    Semaphore
    Exchanger
    LockSupport
    //JUC的锁中除了最后的LockSupport之外，其它的都是利用AQS来实现的。
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

【synchronized 和 ReentrantLock的不同之处 】：

sync系统自动加锁，自动解锁，RL需要我们手动加锁，手动解锁，RL可以出现各种各样的Condition , Condition代表的是不同的等待队列，RL底层是CAS实现，sync是四种状态的升级。

【淘宝面试题】：

实现一个容器，提供两个方法，add , size ;写两个线程，线程1添加10个元素到容器中，线程2实现监控元素的个数，当个数到5个时，线程2给出提示并结束。
【面试题】：
写一个固定容量同步容器，拥有put和get方法，以及getCount方法，能够支持2个生产者线程以及10个消费者线程的阻塞调用。

【 LockSupport 】：

package Ten_Class.t04.no141;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.LockSupport;

public class T13_TestLockSupport00 {
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                System.out.println(i);
                if (i == 5) {
                    LockSupport.park();  //park是停车的意思；————当前线程停止。
                }
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        t.start();

        try {
            TimeUnit.SECONDS.sleep(8);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("after 8 senconds!");

        LockSupport.unpark(t);    //叫醒线程。
    }
}

在这里插入图片描述

【实验】：

package Ten_Class.t04.no141;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.LockSupport;

public class T13_TestLockSupport01 {
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                System.out.println(i);
                if (i == 5) {
                    LockSupport.park();  //park是停车的意思；————当前线程停止。
                }
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        t.start();
        LockSupport.unpark(t);
    }
}

在这里插入图片描述
LockSupport.unpark(t); //这一句话是同时和t线程启动的。
//但是一上来t线程没有进行park , 这说明unpark可以先于park进行调用。先调用的话之后就没办法停车了，之后就没办法再调park()方法了。
先调用unpark()方法的话，之后的park()方法就相当于失效了。这种方法比wait、notify要更加灵活。

【 Volatile 】：

在这里插入图片描述

package Ten_Class.t04.no142;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;


public class T01_WithoutVolatile {

    List lists = new ArrayList();

    public void add(Object o) {
        lists.add(o);
    }

    public int size() {
        return lists.size();
    }

    public static void main(String[] args) {
        T01_WithoutVolatile c = new T01_WithoutVolatile();

        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                c.add(new Object());
                System.out.println("add " + i);

                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "t1").start();

        new Thread(() -> {
            while (true) {
                if (c.size() == 5) {
                    break;
                }
            }
            System.out.println(" t2  结束 ");
        }, "t2").start();
    }
}

在这里插入图片描述
//发现不行。
【错误点】：
1）没有加同步。
2）停止不了是因为永远没有检测到——线程之间不可见的问题。第一个线程变化了之后，第二个线程不会马上就能看到。

【 改 正 之 后 】：

package Ten_Class.t04.no142;

import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import java.util.concurrent.TimeUnit;

public class T02_WithVolatile {
    //添加volatile ， 使t2能够得到通知֪ͨ
    volatile List lists = Collections.synchronizedList(new LinkedList<>());

    public void add(Object o) {
        lists.add(o);
    }

    public int size() {
        return lists.size();
    }

    public static void main(String[] args) {

        T02_WithVolatile c = new T02_WithVolatile();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                c.add(new Object());
                System.out.println("add " + i);
            }
        }, "t1").start();

        new Thread(() -> {
            while (true) {
                if (c.size() == 5) {
                    break;
                }
            }
            System.out.println("t2  结束");
        }, "t2").start();
    }
}

在这里插入图片描述

【注意】：

volatile List lists = Collections.synchronizedList(new LinkedList<>()); 
		//同步容器。

【 wait、notify 】：

【错误示例】：

/**
 * 曾经的面试题：（淘宝？）
 * 实现一个容器，提供两个方法，add，size
 * 写两个线程，线程1添加10个元素到容器中，线程2实现监控元素的个数，当个数到5个时，线程2给出提示并结束
 * <p>
 * 给lists添加volatile之后，t2能够接到通知，但是，t2线程的死循环很浪费cpu，如果不用死循环，该怎么做呢？
 * <p>
 * 这里使用wait和notify做到，wait会释放锁，而notify不会释放锁
 * 需要注意的是，运用这种方法，必须要保证t2先执行，也就是首先让t2监听才可以
 * <p>
 * 阅读下面的程序，并分析输出结果
 * 可以读到输出结果并不是size=5时t2退出，而是t1结束时t2才接收到通知而退出
 * 想想这是为什么？
 */
package Ten_Class.t04.no143;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;


public class T03_NotifyHoldingLock { //wait notify

    //添加volatile，使t2能够得到通知
    volatile List lists = new ArrayList();

    public void add(Object o) {
        lists.add(o);
    }

    public int size() {
        return lists.size();
    }

    public static void main(String[] args) {
        T03_NotifyHoldingLock c = new T03_NotifyHoldingLock();

        final Object lock = new Object();

        new Thread(() -> {
            synchronized (lock) {
                System.out.println("t2 start");
                if (c.size() != 5) {
                    try {
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("t2 end");
            }

        }, "t2").start();

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

        new Thread(() -> {
            System.out.println("t1 start");
            synchronized (lock) {
                for (int i = 0; i < 10; i++) {
                    c.add(new Object());
                    System.out.println("add " + i);

                    if (c.size() == 5) {
                        lock.notify();     //不释放锁————虽然叫醒了，但是没有拿到锁。
                    }

                    try {
                        TimeUnit.SECONDS.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }, "t1").start();
    }
}

在这里插入图片描述

【修改】：

package Ten_Class.t04.no143;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;


public class T04_NotifyFreeLock {

    //添加volatile ，使t2能够得到通知。
    volatile List lists = new ArrayList();

    public void add(Object o) {
        lists.add(o);
    }

    public int size() {
        return lists.size();
    }

    public static void main(String[] args) {
        T04_NotifyFreeLock c = new T04_NotifyFreeLock();

        final Object lock = new Object();

        new Thread(() -> {
            synchronized (lock) {
                System.out.println("t2 启动");
                if (c.size() != 5) {
                    try {
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("t2 结束");
                //ͨ通知֪t继续执行1
                lock.notify();
            }

        }, "t2").start();

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

        new Thread(() -> {
            System.out.println("t1～～～启动");
            synchronized (lock) {
                for (int i = 0; i < 10; i++) {
                    c.add(new Object());
                    System.out.println("add " + i);

                    if (c.size() == 5) {
                        lock.notify();
                        // 释放锁，让t2得以执行。
                        try {
                            lock.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }

                    try {
                        TimeUnit.SECONDS.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }, "t1").start();
    }
}

在这里插入图片描述

【最核心的点】：

notify不会释放锁 ， 而wait是会释放锁的。wait要回来继续执行的时候还需要拿到锁才能继续执行。

【 CountDownLatch 、Semaphore 】：

package Ten_Class.t04.no145;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Semaphore;
import java.util.concurrent.locks.LockSupport;

public class T08_Semaphore {
    //添加volatile ， 使t2能够得到通知。
    volatile List lists = new ArrayList();

    public void add(Object o) {
        lists.add(o);
    }

    public int size() {
        return lists.size();
    }

    static Thread t1 = null, t2 = null;

    public static void main(String[] args) {
        T08_Semaphore c = new T08_Semaphore();
        Semaphore s = new Semaphore(1);

        t1 = new Thread(() -> {
            try {
                s.acquire();
                for (int i = 0; i < 5; i++) {
                    c.add(new Object());
                    System.out.println("add " + i);


                }
                s.release();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            try {
                t2.start();
                t2.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            try {
                s.acquire();
                for (int i = 5; i < 10; i++) {
                    System.out.println(i);
                }
                s.release();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }, "t1");

        t2 = new Thread(() -> {
            try {
                s.acquire();
                System.out.println("t2  结束");
                s.release();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "t2");

        //t2.start();
        t1.start();
    }
}

【 最终输出 】：
在这里插入图片描述

【 交叉打印案例 】：

在这里插入图片描述

【 synchronized 】：

【面试题】：

  • 面试题：写一个固定容量同步容器，拥有put和get方法，以及getCount方法，
  • 能够支持2个生产者线程以及10个消费者线程的阻塞调用。
    【解释】：
    生产者线程生产的东西装不下了，生产线程就会进入阻塞状态 ， 同样拿的线程拿不到东西了也会进入阻塞状态。
/**
 * 面试题：写一个固定容量同步容器，拥有put和get方法，以及getCount方法，
 * 能够支持2个生产者线程以及10个消费者线程的阻塞调用
 * <p>
 * 使用wait和notify/notifyAll来实现
 * <p>
 * 使用Lock和Condition来实现
 * 对比两种方式，Condition的方式可以更加精确的指定哪些线程被唤醒
 */
package Ten_Class.t04.no146;

import java.util.LinkedList;
import java.util.concurrent.TimeUnit;

public class MyContainer1<T> {
    final private LinkedList<T> lists = new LinkedList<>();
    final private int MAX = 10; //最多10个元素
    private int count = 0;


    public synchronized void put(T t) {
        while (lists.size() == MAX) { //想想为什么用while而不是用if？
            try {
                //this.notifyAll()
                this.wait(); //effective java
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        lists.add(t);
        ++count;
        this.notifyAll(); //通知消费者线程进行消费
    }

    public synchronized T get() {
        T t = null;
        while (lists.size() == 0) {
            try {
                //this.notifyAll()
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        t = lists.removeFirst();
        count--;
        this.notifyAll(); //通知生产者进行生产
        return t;
    }

    public static void main(String[] args) {
        MyContainer1<String> c = new MyContainer1<>();
        //启动消费者线程
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                for (int j = 0; j < 5; j++) System.out.println(c.get());
            }, "c" + i).start();
        }

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

        //启动生产者线程
        for (int i = 0; i < 2; i++) {
            new Thread(() -> {
                for (int j = 0; j < 25; j++) c.put(Thread.currentThread().getName() + " " + j);
            }, "p" + i).start();
        }
    }
}

【 背过这种写法 】：

    public synchronized void put(T t) {
        while (lists.size() == MAX) { //想想为什么用while而不是用if？
            //while后面的判断说明已经扔满了。

            try {
                //this.notifyAll()
                this.wait(); //effective java      //当前线程停住。
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        lists.add(t);
        ++count;
        this.notifyAll(); //通知消费者线程进行消费
    }

在这里插入图片描述
//加synchronized是因为有 ++count 这一句。

【 CAS 】：

【能否？】：
生产者线程只负责叫醒消费者；
消费者线程只负责叫醒生产者。

//下面的写法可以满足这个要求。

【 满足要求的写法 】：

/**
 * 面试题：写一个固定容量同步容器，拥有put和get方法，以及getCount方法，
 * 能够支持2个生产者线程以及10个消费者线程的阻塞调用
 * <p>
 * 使用wait和notify/notifyAll来实现
 * <p>
 * 使用Lock和Condition来实现
 * 对比两种方式，Condition的方式可以更加精确的指定哪些线程被唤醒
 *
 * @author mashibing
 */
package Ten_Class.t04.no146;

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

public class MyContainer2<T> {
    final private LinkedList<T> lists = new LinkedList<>();
    final private int MAX = 10; //最多10个元素
    private int count = 0;

    private Lock lock = new ReentrantLock();
    private Condition producer = lock.newCondition();
    private Condition consumer = lock.newCondition();

    public void put(T t) {
        lock.lock();
        try {
            while (lists.size() == MAX) { //想想为什么用while而不是用if？
                producer.await();
            }

            lists.add(t);
            ++count;
            consumer.signalAll(); //通知消费者线程进行消费
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public T get() {
        T t = null;
        lock.lock();
        try {
            while (lists.size() == 0) {
                consumer.await();
            }
            t = lists.removeFirst();
            count--;
            producer.signalAll(); //通知生产者进行生产
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
        return t;
    }

    public static void main(String[] args) {
        MyContainer2<String> c = new MyContainer2<>();
        //启动消费者线程
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                for (int j = 0; j < 5; j++) System.out.println(c.get());
            }, "c" + i).start();
        }

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

        //启动生产者线程
        for (int i = 0; i < 2; i++) {
            new Thread(() -> {
                for (int j = 0; j < 25; j++) c.put(Thread.currentThread().getName() + " " + j);
            }, "p" + i).start();
        }
    }
}

【本质】：

    private Condition producer = lock.newCondition();       //第一个条件；
    private Condition consumer = lock.newCondition();       //第二个条件；

Condition的本质就是等待队列 ；
在这里插入图片描述
当producer.awit( )的时候 ， 指的是这个线程进入P队列等待 ， 当consumer.awit（ ）的时候 ， 指的是这个线程进入C队列等待。
这样叫醒的时候，可以当读叫醒某个队列里的全部线程。
所以Condition的本质就是不同的等待队列。

【 探索源码 】：

【读源码的基础】：
1）数据结构基础
2）设计模式

【读源码的思路】：

更重要的是借鉴别人的思路 ， 具体的边界判定条件其实可以忽略。

【 AQS核心 】：

Template Method
Callback Function
父类默认实现
子类具体实现

【 源码阅读原则 】：

在这里插入图片描述
//有时候静态读会读不下去 ， 但是动态DEBUG就会发现问题所在。（有时会因为多态机制）
第一遍读的时候一些边界条件判断可以略过。

【 ReentrantLock 】：

    public void lock() {
        sync.lock();
    }
-->
private final Sync sync;    //sync原来是一个内部类；
-->
abstract static class Sync extends AbstractQueuedSynchronizer { ... }

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

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

相关文章

实验二十四 策略路由配置

实验二十四 策略路由配置

实验二十四 策略路由配置实验要求&#xff1a; 某企业通过路由器AR1连接互联网&#xff0c;由于业务儒要&#xff0c;与两家运营商ISPA和ISPB相连。 企业网内的数据流从业务类型上可以分为两类&#xff0c; 一类来自于网络172.16.0.0/16&#xff0c;另 一类 来自于网络172.17.0…
阅读更多...
百趣代谢组学分享:黑木耳多糖对小鼠肠道微生物及代谢表型的影响

百趣代谢组学分享:黑木耳多糖对小鼠肠道微生物及代谢表型的影响

文章标题&#xff1a;Effects of Auricularia auricula Polysaccharides on Gut Microbiota and Metabolic Phenotype in Mice 发表期刊&#xff1a;Foods 影响因子&#xff1a;5.561 作者单位&#xff1a;西北大学 百趣提供服务&#xff1a;发现代谢组学Standard-亲水版、1…
阅读更多...
dataCompare大数据对比之异源数据对比

dataCompare大数据对比之异源数据对比

在从0到1介绍一下开源大数据比对平台dataCompare 已经详细介绍了dataCompare 的功能&#xff0c;目前dataCompare 已经实现同源数据的对比 一、dataCompare 现有核心功能如下&#xff1a; (1)数量级对比 (2)一致性对比 (3)差异case 自动发现 (4)定时调度自动对比数据 二、…
阅读更多...
【个人解答版】笔试题-2023禾赛-FPGA

【个人解答版】笔试题-2023禾赛-FPGA

题目背景 笔试时间&#xff1a;2022.06.22应聘岗位&#xff1a;FPGA开发工程师 题目评价 难易程度&#xff1a;★★☆☆☆知识覆盖&#xff1a;★☆☆☆☆超纲范围&#xff1a;☆☆☆☆☆值得一刷&#xff1a;★☆☆☆☆ 文章目录1. 使用最少的电路实现二分频&#xff0c;给出…
阅读更多...
《机器学习实战》chap1 机器学习概览

《机器学习实战》chap1 机器学习概览

《机器学习实战》chap1 机器学习概览 Chap1 The Machine Learning Landscape 这本书第三版也已经出版了:https://github.com/ageron/handson-ml3 Hands-on Machine Learning with Scikit-Learn,Keras & TensorFlow 引入 很早的应用&#xff1a;光学字符识别(OCR&#xff0…
阅读更多...
远程办公之怎样在外网登录在线答题网站

远程办公之怎样在外网登录在线答题网站

很多学校或企业因为教学、测试需要&#xff0c;为学生或员工提供了在线答题平台网站&#xff0c;但弊端是这种在线答题平台只能在校内或在企业内网访问使用&#xff0c;在外网是无法登录访问的。在无公网Ip服务器上部署的web&#xff0c;默认情况下只能内网访问&#xff0c;公网…
阅读更多...
TLE4943C/CH505C轮速传感器芯片的输出协议介绍

TLE4943C/CH505C轮速传感器芯片的输出协议介绍

Infineon公司的TLE4943是一款集成式有源磁场传感器&#xff0c;适用于基于霍尔技术的车轮速度应用。它的基本功能是测量磁极轮或铁磁齿轮的速度。它具有使用AK协议进行通信的两线电流接口。该协议除了提供速度信号外&#xff0c;还提供其他信息&#xff0c;如车轮旋转方向和气隙…
阅读更多...
java安装教程-windows

java安装教程-windows

检查是否已经安装过jav打开cmd命令窗口 输入 java -v下载java安装包网址&#xff1a;https://www.oracle.com/java/technologies/downloads/安装java双击运行程序jdk-19_windows-x64_bin.exe&#xff0c;点击下一步进行安装可以更改安装路径&#xff0c;注意安装路径不能有中文…
阅读更多...
【TypeScript】TS类型守卫（六）

【TypeScript】TS类型守卫（六）

&#x1f431;个人主页&#xff1a;不叫猫先生 &#x1f64b;‍♂️作者简介&#xff1a;前端领域新星创作者、华为云享专家、阿里云专家博主&#xff0c;专注于前端各领域技术&#xff0c;共同学习共同进步&#xff0c;一起加油呀&#xff01; &#x1f4ab;系列专栏&#xff…
阅读更多...
独立开发变现周刊（第86期）：月收入4000美元的日程规划器

独立开发变现周刊（第86期）：月收入4000美元的日程规划器

分享独立开发、产品变现相关内容&#xff0c;每周五发布。目录1、NotionReads: 在Notion中管理你的阅读书籍2、Zaap.ai: 面向创作者的一站式工具3、microfeed: 开源的可自我托管的轻量级内容管理系统(CMS)4、Reactive Resume&#xff1a;一个免费的开源简历生成器5、一个月收入…
阅读更多...
2019年1月政企终端安全态势分析报告

2019年1月政企终端安全态势分析报告

声明 本文是学习2019年1月政企终端安全态势分析报告. 下载地址 http://github5.com/view/55037而整理的学习笔记,分享出来希望更多人受益,如果存在侵权请及时联系我们 漏洞利用病毒攻击政企分析 奇安信终端安全实验室监测数据显示&#xff0c;2019年4月&#xff0c;有6.7%的…
阅读更多...
JavaScript中的元编程

JavaScript中的元编程

紧接上回&#xff0c;伴随着Reflect&#xff0c;Proxy降世&#xff0c;为js带来了更便捷的元编程&#xff01; 什么是元编程&#xff1f;这词第一次听&#xff0c;有点懵&#xff0c;好像有点高级&#xff0c;这不得学一下装…进自己的知识库 概念 元编程是一种编程技术&…
阅读更多...
【数据结构与算法】Collection接口迭代器

【数据结构与算法】Collection接口迭代器

Java合集框架 数据结构是以某种形式将数据组织在一起的合集&#xff08;collection&#xff09;。数据结构不仅存储数据&#xff0c;还支持访问和处理数据的操作 在面向对象的思想里&#xff0c;一种数据结构也被认为是一个容器&#xff08;container&#xff09;或者容器对象…
阅读更多...
【MySQL】MySQL表的七大约束

【MySQL】MySQL表的七大约束

序号系列文章1【MySQL】MySQL介绍及安装2【MySQL】MySQL基本操作详解3【MySQL】MySQL基本数据类型4【MySQL】MySQL表的七大约束文章目录MySQL表的约束1&#xff0c;默认约束2&#xff0c;非空约束3&#xff0c;唯一约束4&#xff0c;主键约束5&#xff0c;自增约束6&#xff0c…
阅读更多...
详细分析单调栈，及正确性证明

详细分析单调栈，及正确性证明

什么是单调栈 对于一个数组&#xff0c;需要对每个位置生成&#xff0c;左右两边离它最近的&#xff0c;比它小&#xff08;或比它大&#xff09;的位置在哪 例如&#xff1a; 如果对每个位置都遍历下左右两边&#xff0c;找到第一个比它小的位置&#xff0c;就是O(N ^ 2)的…
阅读更多...
IPv6 时代如何防御 DDoS 攻击？

IPv6 时代如何防御 DDoS 攻击？

在互联网世界&#xff0c;每台联网的设备都被分配了一个用于标识和位置定义的 IP 地址。20 世纪 90 年代以来互联网的快速发展&#xff0c;联网设备所需的地址远远多于可用 IPv4 地址的数量&#xff0c;导致了 IPv4 地址耗尽。因此&#xff0c;协议 IPv6 的开发和部署已经刻不容…
阅读更多...
从第三方平台导出大数据量本地Excel怎么解决性能问题？

从第三方平台导出大数据量本地Excel怎么解决性能问题？

对于日常需要做分析的我们来说&#xff0c;周期性需要从第三方系统导出数据&#xff0c;日积月累数据量越来愈大&#xff0c;由开始的几百条数据慢慢增至十几万甚至百万级的数据量&#xff0c;在本地Excel直接做分析汇总老是卡顿等半天&#xff0c;效率日益低下&#xff0c;每天…
阅读更多...
连续四年发布科技趋势预测，他们在探索中国科技的“主干道”

连续四年发布科技趋势预测，他们在探索中国科技的“主干道”

&#xff0c;*本文配图由百度飞桨文心一格提供AI绘画技术支持。古希腊流传着一句谚语&#xff1a;智慧不仅是能够明察眼前&#xff0c;更要能够预测未来。身处科技界&#xff0c;一到年底年初我们就会看到各种各样的趋势预测。这些预测五花八门&#xff0c;神奇多变。但大多数科…
阅读更多...
JAVA中使用最广泛的本地缓存？Ehcache的自信从何而来3 —— 本地缓存变身分布式集群缓存，打破本地缓存天花板

JAVA中使用最广泛的本地缓存？Ehcache的自信从何而来3 —— 本地缓存变身分布式集群缓存，打破本地缓存天花板

大家好&#xff0c;又见面了。 本文是笔者作为掘金技术社区签约作者的身份输出的缓存专栏系列内容&#xff0c;将会通过系列专题&#xff0c;讲清楚缓存的方方面面。如果感兴趣&#xff0c;欢迎关注以获取后续更新。 上一篇文章中&#xff0c;我们知晓了如何在项目中通过不同的…
阅读更多...
【Python】Numpy处理多项式类Polynomial

【Python】Numpy处理多项式类Polynomial

文章目录构造函数求导和积分求根和反演采样与拟合其他方法构造函数 Numpy中提供了多项式模块&#xff0c;里面封装了一些用以快速解决多项式问题的类和函数&#xff0c;其中最重要类的自然是Polynomial&#xff0c;其构造函数为 class numpy.polynomial.polynomial.Polynomia…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023