2021-07-21

最新推荐文章于 2023-02-27 10:57:45 发布
最新推荐文章于 2023-02-27 10:57:45 发布
阅读量3.3k 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/JiangHuFengZi/article/details/118975904
版权
本文详细介绍了Java中的线程同步概念，包括并发、线程安全问题及解决方案。通过实例展示了线程不安全的买票、取钱和集合操作，并分析了synchronized关键字在方法和代码块中的应用，以及死锁的概念和避免方法。还探讨了Lock接口的使用，如ReentrantLock，以及线程池的优势和ExecutorService的使用。最后，提到了生产者消费者问题的解决策略，如管程法和信号灯法。
摘要由CSDN通过智能技术生成

线程的同步(重点)

  • 多个线程操作同一个资源

并发

  • 并发：同一个对象被多个线程同时操作。

线程同步

  • 现实生活中，我们会遇到”同一个资源，多个人都想使用“的问题。比如，食堂排队打饭，每个人都想吃饭，最天然的解决办法就是，排队，一个个来。

  • 处理多线程问题时，多个线程访问同一个对象（并发），并且某些线程还想修改这个对象，这时候我们就需要线程同步，线程同步其实就是一种等待机制，多个需要同时访问此对象的线程进入这个对象的等待池形成队列，等待前面线程使用完毕，下一个线程在使用

  • 由于同一进程的多个线程共享同一块存储空间，在带来方便的同时，也带来了访问冲突问题，为了保证数据在方法中被访问的正确性，在访问时加入锁机制synchronized,当一个线程获得对象的的排它锁，独占资源，其他线程必须等待使用后释放锁即可，存在以下问题：

    • 一个线程持有锁会导致其他所有需要此锁的线程挂起；
    • 在多线程竞争下，加锁，释放锁会导致比较多的上下文切换和调度延时，引起性能问题；
    • 如果一个优先级高的线程等待一个优先级低的线程释放锁会导致优先级导致，引起性能问题。

线程不安全案例

案例一：

//不安全的买票
//线程不安全，出现了负数
public class UnsafeBuyTicket implements Runnable{
    private int ticket = 10;

    //定义一个标识位
    boolean flag = true;
    @Override
    public void run() {
        while (flag){
            buy();
        }
    }
    //判断是否有票
    public void buy(){
        if(ticket<=0){
            //改变标识位
            flag = false;
            return;
        }
        //模拟延时,提高问题的发生性
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"买到了第"+ticket--+"张票");
    }

    public static void main(String[] args) {
        UnsafeBuyTicket unsafeBuyTicket = new UnsafeBuyTicket();
        new Thread(unsafeBuyTicket,"小黄").start();
        new Thread(unsafeBuyTicket,"小明").start();
        new Thread(unsafeBuyTicket,"小蜜").start();
    }
}

案例二：

//不安全的取钱
//两个人去银行取钱
public class UnsafeBank {
    public static void main(String[] args) {
        //账户
        Account account = new Account(2000, "基金");
        Drawing you = new Drawing(account, 50, "你");
        Drawing girlFriend = new Drawing(account, 2000, "girlFriend");

        you.start();
        girlFriend.start();
        /*
            基金账户，余额为-50
            你手里的钱：50
            基金账户，余额为-50
            girlFriend手里的钱：2000
         */
    }
}

//账户
class Account{
    int money;//余额
    String name;//卡名

    public Account(int money, String name) {
        this.money = money;
        this.name = name;
    }
}

//银行：模拟取款
class Drawing extends Thread{

    Account account;//账户
    //取了多少钱
    int drawingMoney;
    //现在手里多少钱
    int nowMoney;

    public Drawing(Account account,int drawingMoney,String name){
        super(name);//通过线程的构造器将线程的名字，给到线程。
        this.account = account;
        this.drawingMoney= drawingMoney;
    }
    //取钱
    @Override
    public void run() {
        //判断有没有前
        if(account.money-drawingMoney<0){
            System.out.println(Thread.currentThread().getName()+"余额不足");
            return;
        }
        //sleep放大问题的发生性
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        account.money-=drawingMoney;
        //你手里的钱，等于你之前有的钱加上你现在取的钱
        nowMoney+=drawingMoney;
        System.out.println(account.name+"账户，余额为"+account.money);
        //Thread.currentThread().getName()=this.getName(),因为这个类继承了Thread类，就可以用父类的方法了
        System.out.println(getName()+"手里的钱："+nowMoney);
    }
}

案例三：

//线程不安全的集合
public class UnsafeList {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        for (int i = 0; i < 10000; i++) {
            new Thread(()->{
                list.add(Thread.currentThread().getName());
            }).start();
        }
        System.out.println(list.size());//9995，结果不够一万
    }
}

同步方法

  • 由于我们可以通过private关键字来保证数据对象只能被方法访问，所以我们只需要针对方法提出一套机制，这套机制就是synchronized关键字，它包括两种用法：synchronized方法和synchronized块
  • synchronized方法控制对“对象”的访问，每个对像对应一把锁，每个synchronized方法都必须获得调用该方法的对象的锁才能执行，否则线程会阻塞，方法一旦执行，就独占该锁，直到方法返回才释放锁，后面被阻塞的线程才能获得这个锁，继续执行。

缺陷

  • 若将一个大的方法声明为synchronized将会印象效率，方法里面需要修改的内容才需要锁，锁的太多，浪费资源。

同步块

  • 同步块：synchronized(Obj){}
  • Obj称之为同步监视器
    • Obj可以是任何对像，但是推荐使用共享资源作为同步监视器
    • 同步方法中无需指定同步监视器，因为同步方法的同步监视器就是this，就是这个对象本身，或者是class[反射中讲解]
  • 同步监视器的执行过程
    1. 第一个线程访问，锁定同步监视器，执行其中代码。
    2. 第二个线程访问，发现同步监视器被锁定，无法访问。
    3. 第一个线程访问完毕，解锁同步监视器。
    4. 第二个线程访问，发现同步监视器没有锁，然后锁定并访问。

将案例加上锁

//取钱案例 
//取钱
    //synchronized默认锁的是this。就是它这个类本身
    @Override
    public void run() {
        //锁的对象就是变化的量，需要增删改
        synchronized (account){
            //判断有没有前
            if(account.money-drawingMoney<0){
                System.out.println(Thread.currentThread().getName()+"余额不足");
                return;
            }
            //sleep放大问题的发生性
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            account.money-=drawingMoney;
            //你手里的钱，等于你之前有的钱加上你现在取的钱
            nowMoney+=drawingMoney;
            System.out.println(account.name+"账户，余额为"+account.money);
            //Thread.currentThread().getName()=this.getName(),因为这个类继承了Thread类，就可以用父类的方法了
            System.out.println(getName()+"手里的钱："+nowMoney);
        }
    }

//买票案例
 //判断是否有票
    //加上 synchronized 就是同步方法，
    public synchronized void buy(){
        if(ticket<=0){
            //改变标识位
            flag = false;
            return;
        }
        //模拟延时,提高问题的发生性
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"买到了第"+ticket--+"张票");
    }

//集合案例
for (int i = 0; i < 10000; i++) {
                new Thread(() -> {
                    synchronized (list) {
                        list.add(Thread.currentThread().getName());
                    }}).start();
            }

JUC中线程安全的集合

//测试JUC安全类型的集合CopyOnWriteArrayList
public class TestJUC {
    public static void main(String[] args) {
        CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList();
        for (int i = 0; i < 10000; i++) {
            //Lambda表达式
            new Thread(()-> list.add(Thread.currentThread().getName())).start();
        }
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(list.size());//10000
    }
}

死锁

  • 多个线程各自占有一些共享资源，并且互相等待其他线程占有的资源才能运行，而导致两个或多个线程都在等待对方释放资源，都停止执行的情境，某一个同步块同时拥有："两个一上对象的锁"时，就可能会发生“死锁”的问题。
//死锁：多个线程互相拥有着对方需要的资源，然后形成僵持
public class DeadLock {
    public static void main(String[] args) {
        MakeUp  make1= new MakeUp(0, "灰姑凉");
        MakeUp  make2= new MakeUp(1, "白雪公主");

        make1.start();
        make2.start();
    }
}


//口红
class Lipstick{

}

//镜子
class Mirror{

}

class MakeUp extends Thread{
    //需要的资源只有一份，用static来保证只有一份
    static Lipstick lipstick = new Lipstick();
    static Mirror mirror = new Mirror();

    int choice;//选择
    String girlName;//使用化妆品的人

    public MakeUp(int choice,String girlName){
        this.choice = choice;
        this.girlName = girlName;
    }

    @Override
    public void run() {
        //化妆
        makeup();

    }
    //化妆,互相拥有对方的锁，就是需要拿到对方的资源
    private void makeup(){
        if (choice==0){
            synchronized (lipstick){//获得口红的锁
                System.out.println(this.girlName+"获得口红的锁");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (mirror){//一秒后想获得镜子
                    System.out.println(this.girlName+"获得镜子的锁");
                }
            }
        }else {
            synchronized (mirror){//获得镜子的锁
                System.out.println(this.girlName+"获得镜子的锁");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (lipstick){//一秒后想获得口红
                    System.out.println(this.girlName+"获得口红的锁");
                }
            }
        }
    }
}

死锁避免方法

  • 产生死锁的四个必要条件：
    1. 互斥条件：一个资源每次只能被一个进程使用。
    2. 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。
    3. 不剥夺条件：进程已获得的资源，在未使用完之前，不能强行剥夺。
    4. 循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系。
//化妆,互相拥有对方的锁，就是需要拿到对方的资源
    private void makeup(){
        if (choice==0){
            synchronized (lipstick){//获得口红的锁
                System.out.println(this.girlName+"获得口红的锁");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            synchronized (mirror){//一秒后想获得镜子
                System.out.println(this.girlName+"获得镜子的锁");
            }
        }else {
            synchronized (mirror){//获得镜子的锁
                System.out.println(this.girlName+"获得镜子的锁");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (lipstick){//一秒后想获得口红
                    System.out.println(this.girlName+"获得口红的锁");
                }
            }
        }
    }

Lock(锁)

  • 从JDK 5.0 开始，Java提供了更强大的线程同步机制——通过显示定义同步锁对像来实现同步。同步锁使用Lock对象充当。
  • java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独立访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象
  • ReentrantLock类实现了Lock，它拥有与synchtonized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock,可以显示加锁，释放锁。

在这里插入图片描述

//测试Lock锁
public class TestLock {
    public static void main(String[] args) {
        TestLock2 testLock2 = new TestLock2();
        new Thread(testLock2).start();
        new Thread(testLock2).start();
        new Thread(testLock2).start();
    }
}
class TestLock2 implements Runnable{

    int ticketNums = 10;
    //定义Lock锁
    private ReentrantLock lock = new ReentrantLock();
    @Override
    public void run() {
        while (true){
            try {
                lock.lock();//加锁
                if (ticketNums>0){
                    try {
                        Thread.sleep(200);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(ticketNums--);
                }else {
                    break;
                }
            }finally {
                //解锁
                lock.unlock();
            }
        }
    }
}

synchronized与Lock的对比

  • Lock是显示锁（手动开启和关闭锁，别忘记关闭锁），synchronized是隐式锁，出了作用域自动释放。
  • Lock只有代码块锁，synchronized有代码块锁和方法锁
  • 使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性（提供更多的子类）
  • 优先使用顺序：
    • Lock > 同步代码块（已经进入了方法体，分配了相应资源）> 同步方法（在方法体之外）

线程协作

生产者消费者问题

  • 假设仓库中只能存放一件产品，生产者将生产出来的产品放入仓库，消费者将仓库中产品取走消费。
  • 如果仓库中没有产品，则生产者将产品放入仓库，否则停止生产并等待，直到仓库中的产品被消费者取走为止。
  • 如果仓库中放有产品，则消费者可以将产品取走消费，否则停止消费并等待，直到仓库中再次放入产品为止。
//测试生产者消费者模型-->利用缓冲区解决：管程法
//生产者，消费者，产品，缓冲区
public class TestPC {
    public static void main(String[] args) {
        SynContainer container = new SynContainer();
        new Productor(container).start();
        new Consumer(container).start();
    }
}
//生产者
class Productor extends Thread{
    SynContainer container;
    public Productor(SynContainer container){
        this.container = container;
    }
    //生产
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            //把这只鸡丢入缓冲区
            container.push(new Chicken(i));
            System.out.println("生产了"+i+"只鸡");
        }
    }
}
//消费者
class Consumer extends Thread{
    SynContainer container;
    public Consumer(SynContainer container){
        this.container = container;
    }
    //消费
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("消费了-->"+container.pop().id+"只鸡");
        }
    }
}
//产品
class Chicken{
    int id;//产品编号
    public Chicken(int id) {
        this.id = id;
    }
}
//缓冲区
class SynContainer{
    //需要一个容器大小
    Chicken[] chickens = new Chicken[5];
    //容器计数器
    int count = 0;

    //生产者放入产品
    public synchronized void push(Chicken chicken){
        //如果容器满了，就需要等待消费者消费
        if(count== chickens.length){
            //通知消费者消费，生产等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //如果没有满，我们就需要丢入产品
        chickens[count] = chicken;
        count++;
        //可以通知消费者消费了
        this.notifyAll();
    }

    //消费者消费产品
    public synchronized Chicken pop(){
        //判断能否消费
        if(count==0){
            //等待生产者生产，消费者等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //如果可以消费
        count--;
        Chicken chicken = chickens[count];
        //吃完了，通知生产者生产
        this.notifyAll();
        return chicken;
    }
}
  • 总结：通过容器的容量满否，来决定什么时候让一个线程运行让另一个等待。
//测试生产者消费者问题2：信号灯法，标志位解决
public class TestPC2 {
    public static void main(String[] args) {
        TV tv = new TV();
        new Player(tv).start();
        new Watcher(tv).start();
    }

}
//生产者-->演员
class Player extends Thread{
    TV tv;
    public Player(TV tv){
        this.tv = tv;
    }
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            if (i%2==0){
                this.tv.play("快乐大本营播放中");
            }else{
                this.tv.play("抖音：记录美好生活");
            }
        }
    }
}
//消费者-->观众
class Watcher extends  Thread{
    TV tv;
    public Watcher(TV tv){
        this.tv = tv;
    }
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            tv.watch();
        }
    }
}
//产品-->节目
class TV{
    //演员表演，观众等待
    //观众观看，演员等待
    String voice;//表演的节目
    boolean flag = true;
    //表演
    public synchronized  void play(String voice){
        if (!flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("演员表演了："+voice);
        //通知观众观看
        this.notifyAll();//通知唤醒
        this.voice = voice;
        this.flag = !this.flag;
    }
    //观看
    public synchronized void watch(){
        if(flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("观看了："+voice);
        //通知演员表演
        this.notifyAll();
        this.flag=!this.flag;
    }
}
  • 总结：通过标志位来确定什么时候让一个线程等待，一个线程运行。

使用线程池

  • 背景：经常创建和销毁，使用量特别大的资源，比如并发情况下的线程，对性能影响很大。

  • 思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁，实现重复利用。类似生活中的公共交通工具。

  • 好处：

    • 提高响应速度（减少了创建新线程的时间）
    • 降低资源消耗（重复利用线程池中线程，不需要每次都创建）
    • 便于线程管理（…）
      • corePoolSize：核心池的大小
      • maximumPoolSiae：最大线程数
      • keepAliveTime：线程没有任务时最多保持多长时间后会终止

  • JDK 5.0起提供线程相关API：ExecutorService 和 Execcutors

  • ExecutorService：真正的线程池接口。常见子类ThreadPoolExecutor

    • void execute(Runnable command)：执行任务、命令，没有返回值，一般用来执行Runnable。
    • Future submit(Callabletask)：执行任务，有返回值，一般又来执行Callable。
    • void shutdown()：关闭连接池。

  • Executors：工具类，线程池的工厂类，用于创建并返回不同类型的线程池。

//测试线程池
public class TestPool {
    public static void main(String[] args) {
        //1.创建服务，创建线程
        //newFixedThreadPool 参数为：线程池大小
        ExecutorService service = Executors.newFixedThreadPool(10);
        //执行
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        //2.关闭连接
        service.shutdownNow();
    }
}
class MyThread implements Runnable{
    @Override
    public void run() {
         System.out.println(Thread.currentThread().getName());
        /*
            pool-1-thread-1
            pool-1-thread-2
            pool-1-thread-3
            pool-1-thread-4
        */
    }
}

总结

//回顾线程的创建
public class ThreadNew {
    public static void main(String[] args) {
        MyThread myThread1 = new MyThread();
        myThread1.start();

        MyThread2 myThread2 = new MyThread2();
        Thread thread = new Thread(myThread2);
        thread.start();

        FutureTask<Integer> futureTask =new FutureTask<Integer>( new MyThread3());
        new Thread(futureTask).start();

        try {
            Integer integer = futureTask.get();
            System.out.println(integer);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

    }
}
//1.继承Thread类
class MyThread extends Thread{
    @Override
    public void run() {
        System.out.println("MyThread");
    }
}
//2.实现Runnable接口
class MyThread2 implements Runnable{
    @Override
    public void run() {
        System.out.println("MyThread2");
    }
}
//3.实现Callable接口
class MyThread3 implements Callable<Integer>{
    @Override
    public Integer call() throws Exception {
        System.out.println("MyThread3");
        return 100;
    }
}
JiangHuFengZi
关注
Python async, await 的理解与使用
pydby01的博客
12-19 5793
关于 Python 中 async, await 关键字的一些知识在去年的一篇探索 Flask 对 asyncio 的支持有讲到，一直没在实际上用过它们，所以基本上也就忘干净了。随着Flask2 加入了 async 的特性，以及 FastAPI 从一开始支持 async, 又觉得有必要重新温习一下 Python 中如何使用 async, await 关键字了。 注：由于 Flask 支持了 async, 号称 async 化 Flask 的Quart项目开始变得无足轻重了。 本文主要的学习材...
3: 00npm start的时候报了奇怪的错误A42E6F node::MakeCallback+4719 4: 00007FF75AA170F0 node::DecodeWrite+13120
weixin_44092085的博客
07-28 6005
报了一堆奇怪的错 node_contextify.cc:635: Assertion `args[1]->IsString()’ failed. 1: 00007FF75AA6832A v8::internal::GCIdleTimeHandler::GCIdleTimeHandler+4506 2: 00007FF75AA42DB6 node::MakeCallback+4534 3: 00007FF75AA42E6F node::MakeCallback+4719 4: 00007FF75AA17
笔记：终极异步操作解决方案-async 函数
clbdgs的博客
11-10 4837
async async是 ES7 才有的与异步操作有关的关键字。 用法 如果有多个异步操作，并每个异步操作需要获得上一个异步操作的执行结果才继续执行，async函数则可以清晰明了的表达他们的关系且用法简单，使用await操作符即可。 await 操作符用于等待一个 Promise 对象, 它只能在异步函数 async function 内部使用。 代码 由于目前一些浏览器不支持async函数，所以...
NTS-Net复现出bug
qq_39456074的博客
11-23 2074
最近看这篇论文《Learning to Navigate for Fine-grained Classification》，下载了源码想要复现
npm报错npm ERR! Unexpected end of JSON input while parsing near ‘...sh_time“:144935090300‘
熟悉JS拼写的FE
09-16 3369
解决【npm ERR! Unexpected end of JSON input while parsing near ‘…sh_time":144935090300’】方案 前言:我们在npm install时有时会报以下的错，附图: 解决方案 这时可以先执行下面的命令： npm cache clean --force 然后再执行npm install就可以了 直接执行 npm cache clean --force, 如果执行成功，再npm install即可。 如果执行失败，请先升级
英语题翻译14
zanhhhhhh的博客
01-30 1589
Online Judge | JXNUOJ Ignatius is building an Online Judge, now he has worked out all the problems except the Judge System. The system has to read data from correct output file and user's result file, then the system compare the two files. If the two file
第2章 简单程序设计(C++版)_第二节　运算符和表达式-2021-07-21.pdf
08-25
C++程序设计语言中的运算符和表达式是构成程序逻辑的基础，它们是执行各种数据处理和运算的符号和规则。在学习C++时，理解不同的运算符和表达式的用法对于编写程序至关重要。 首先，我们来看一下运算符的类型和作用...
工业4.0及智能制造解决方案[2021-07-21]（70页）.pdf
05-21
总的来说，工业4.0是制造业向更高层次发展的里程碑，它通过技术创新和模式重构，旨在打造一个更高效、灵活、可持续和人性化的生产环境，以应对21世纪的挑战和机遇。随着科技的不断进步，我们有理由相信，工业4.0将...
ZX02计算结果2021-07-011
08-08
文档"ZX02计算结果2021-07-011"涉及的是金融投资领域中的量化交易策略，特别是基于成交量择时的算法。在金融市场上，成交量是衡量市场活跃度的重要指标，通过分析成交量数据，投资者可以预测未来价格走势，制定相应...
2021-11-07
YYds6668的博客
11-07 1978
简单使用TCP协议,实现客户端和服务器端之间的文件和信息传输,并实现可以重复添加自定义文件的类型和名称.
从一个三行四列的整型二维数组中查找第一个出现的负数。
m0_54632021的博客
02-06 803
#include<stdio.h> int main() { int a[3][4]; int i,j; for(i=0;i<3;i++) for(j=0;j<4;j++) scanf("%d",&a[i][j]); int flag=1; for(i=0;i<3&&flag;i++) for(j=0;j<4;j++) if(a[
: Null key returned for cache operation
qq_39836064的博客
11-20 1856
初级Android开发越来越落寞了，今天开始给自己写接口了 数据库插入数据后 提示: Null key returned for cache operation。。。。， 数据插入成功，但是控制台还是报错了，后来仔细一检查用了缓存注解@CacheEvict（xxxx）移除旧好了，果然cv 的习惯不好。 ...
/滑动窗口/数组模拟单调队列/
m0_73843712的博客
02-27 831
学习滑动窗口
LInux下Mplayer字幕乱码,日文字体部分乱码解决方案
热门推荐
weixin_34233618的博客
06-14 5万+
ASS字幕如果不能加载的话，则需要把ASS字幕编码由utf16转换为utf8 用gedit也可以用这个也可以：iconv -f utf16 -t utf8 subtitle_utf16.ass &gt; subtitle_utf8.ass 在Preferenecs-&gt;Subtitles&amp;OSD中 Encoding选Simplified Chinese charset(CP93...
npm ERR! Unexpected end of JSON input while parsing near ‘...sh_time“:141072930277‘
m0_46335240的博客
10-22 403
在安装mysql2时，第一次安装卡住了，中途把安装的cmd界面关了，之后安装就一直提示“error Unexpected end of JSON input while parsing near '...8"}},"1.1.0":{"name":'”。 解决方法：报这个错误是因为有缓存，需要清除缓存。 先用npm cache clean --force，执行成功后，再npm i mysql2; 如果没成功，先升级npm，即npm i npm -g，然后再npm cache clean --force，
esp32 arduino 堆栈溢出
qq_39993707的博客
01-31 4382
***ERROR*** A stack overflow in task loopTask has been detected. Guru Meditation Error: Core 1 panic'ed (Unhandled debug exception).
NHibernate遇到的问题集 持续更新。
dianye9724的博客
02-13 193
NHibernate遇到的问题集 持续更新。 问题1： “NHibernate.TypeMismatchException”类型的异常在 NHibernate.dll 中发生，但未在用户代码中进行处理 其他信息: Provided id of the wron...
【Neon】配置Android Studio错误
小小小草儿的博客哟
07-04 778
在使用Android studio的时候，出现错误Gradle project sync failed.Basic functionality(e.g. editing, debugging) will not work properly. 经过分析，发现错误Android update causing error: Error: java.nio.file.AccessDeniedExcept...
结果是这样的，没有根据id排：start_date end_date 0 2020-01-15 2020-04-27 1 2020-09-30 2020-10-10 2 2021-02-07 2021-02-22 3 2021-03-06 2021-03-24 4 2020-01-21 2020-03-03 .. ... ... 639 2021-03-09 2021-03-18 640 2021-03-24 2021-04-01 641 2020-01-12 2020-04-19 642 2021-02-09 2021-02-18 643 2020-01-18 2020-03-09
最新发布
06-03
如果你想根据企业id对结果进行排序，可以在输出结果之前加上一行代码： ```python result = result.sort_values(by=['id']) ``` 此代码将会根据id对结果进行排序，使得每个企业的结果排在一起。完整的代码如下： ```python mean = DataFrame.groupby(['id'])['amount'].mean() # 列出每个企业用电量低于均值时间超过一周的时间段，标记起始时间和结束时间，省略中间时间 filtered_data = DataFrame[DataFrame['amount'] < DataFrame['id'].map(mean)] filtered_data['date'] = pd.to_datetime(filtered_data['date']) filtered_data['diff'] = filtered_data.groupby('id')['date'].diff().dt.days filtered_data['period'] = (filtered_data['diff'] > 1).cumsum() # 找出连续时间段，并计算起始时间和结束时间 result = filtered_data.groupby(['id', 'period']).agg(start_date=('date', 'min'), end_date=('date', 'max')) result = result[result['end_date'] - result['start_date'] > pd.Timedelta(days=7)].reset_index(drop=True) # 根据id排序输出结果 result = result.sort_values(by=['id']) print(result) ``` 输出结果将会按照企业id进行排序。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值