叶秋学长
叶秋学长

一道很有意思的面试题目，快加入到这场头脑风暴游戏里吧~

小伙伴们，小叶秋最近看到一个面试题目，感觉挺有意思的，大意如下：

一道很有意思的面试题目，快加入到这场头脑风暴游戏里吧~_第1张图片

ok，大家看到这个题，可以先理解下，这里启动了两个线程，a 和 b，但是虽然说 a 在 b 之前 start，不一定就可以保证线程 a 的逻辑，可以先于线程 b 执行。

所以，这里的意思是，线程 a 和 b，执行顺序互不干扰，我们不应该假定其中一个线程可以先于另外一个执行。

另外，既然是面试题，那常规做法自然是不用上了，比如让 b 先 sleep 几秒钟之类的，如果真这么答，那可能面试就结束了吧。

好，我们下面开始分析解法。

可见性保证

程序里定义了一个全局变量，var = 1。

线程a会修改这个变量为2，线程b则在变量为2时，执行自己的业务逻辑。

那么，这里首先，我们要做的是，先讲var使用volatile修饰，保证多线程操作时的可见性。

public static volatile int var = 1;

解法分析

经过前面的可见性保证的分析，我们知道，要想达到目的，其实就是要保证：

a中的对var+1的操作，需要先于b执行。

但是，现在的问题是，两个线程同时启动，不知道谁先谁后，怎么保证 a 先执行，b 后执行呢？

让线程 b  先不执行，大概有两种思路：一种是阻塞该线程，一种是不阻塞该线程。阻塞的话，我们可以想想，怎么阻塞一个线程。

大概有下面这些方法：

  • synchronized，取不到锁时，阻塞

  • java.util.concurrent.locks.ReentrantLock#lock，取不到锁时，阻塞

  • object.wait，取到synchronized了，但是因为一些条件不满足，执行不下去，调用wait，将释放锁，并进入等待队列，线程暂停运行

  • java.util.concurrent.locks.Condition.await，和object.wait类似，只不过object.wait在jvm层面，使用c++实现，Condition.await在jdk层面使用java语言实现

  • threadA.join()，等待对应的线程threadA执行完成后，本线程再继续运行；threadA没结束，则当前线程阻塞；

  • CountDownLatch#await，在对应的state不为0时，阻塞

  • Semaphore#acquire()，在state为0时（即剩余令牌为0时），阻塞

  • 其他阻塞队列、FutureTask等等

如果不让线程进入阻塞，则一般可以让线程进入一个while循环，循环的退出条件，可以由线程a来修改，线程a修改后，线程b跳出循环。

比如：

volatile boolean stop = false;
while (!stop){
    ...
}

上面也说了这么多了，我们实际上手写一写吧。

错误解法1--基于wait

下面的思路是基于wait、notify。

线程b直接wait，线程a在修改了变量后，进行notify。

public class Global1 {
    public static volatile int var = 1;
    public static final Object monitor = new Object();

    public static void main(String[] args) {
        Thread a = new Thread(() -> {
            // 1
            Global1.var++;
            // 2
            synchronized (monitor) {
                monitor.notify();
            }
        });
        Thread b = new Thread(() -> {
            // 3
            synchronized (monitor) {
                try {
                    monitor.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            // 4
            if (Global1.var == 2) {
                //do something;
                System.out.println(Thread.currentThread().getName() + " good job");
            }
        });
        a.start();
        b.start();
    }
}

大家觉得这个代码能行吗？

实际是不行的。因为实际的顺序可能是：

线程a--1
线程a--2
线程b--1
线程b--2

在线程 a-2 时，线程 a 去 notify，但是此时线程 b 还没开始 wait，所以此时的 notify 是没有任何效果的：

没人在等，notify 个锤子。

怎么修改，本方案才行得通呢？

那就是，修改线程 a 的代码，不要急着 notify，先等等。

Thread a = new Thread(() -> {
    Global1.var++;
    try {
        TimeUnit.SECONDS.sleep(2);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    synchronized (monitor) {
        monitor.notify();
    }
});

但是这样的话，明显不合适，有作弊嫌疑，也不优雅。

错误解法2--基于condition的signal

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

public class Global1 {
    public static volatile int var = 1;
    public static final ReentrantLock reentrantLock = new ReentrantLock();
    public static final Condition condition = reentrantLock.newCondition();

    public static void main(String[] args) {
        Thread a = new Thread(() -> {
            Global1.var++;
            final ReentrantLock lock = reentrantLock;
            lock.lock();
            try {
                condition.signal();
            } finally {
                lock.unlock();
            }
        });
        Thread b = new Thread(() -> {
            final ReentrantLock lock = reentrantLock;
            lock.lock();
            try {
                condition.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }

            if (Global1.var == 2) {
                //do something;
                System.out.println(Thread.currentThread().getName() + " good job");
            }
        });
        a.start();
        b.start();
    }
}

这个方案使用了 Condition 对象来实现 object 的 notify、wait 效果。当然，这个也有同样的问题。

正确解法1--基于错误解法2进行改进

我们看看，前面问题的根源在于，我们线程 a，在去通知线程 b 的时候，有可能线程 b 还没开始 wait，所以此时通知失效。

那么，我们是不是可以先等等，等线程 b 开始 wait 了，再去通知呢？

Thread a = new Thread(() -> {
    Global1.var++;
    final ReentrantLock lock = reentrantLock;
    lock.lock();
    try {
        // 1
        while (!reentrantLock.hasWaiters(condition)) {
            Thread.yield();
        }
        condition.signal();
    } finally {
        lock.unlock();
    }
});

1 处代码，就是这个思想，在 signal 之前，判断当前 condition 上是否有 waiter 线程，如果没有，就死循环；如果有，才去执行 signal。

这个方法实测是可行的。

正确解法2

对正确解法 1，换一个 api，就变成了正确解法 2.

Thread a = new Thread(() -> {
    Global1.var++;
    final ReentrantLock lock = reentrantLock;
    lock.lock();
    try {
        // 1
        while (reentrantLock.getWaitQueueLength(condition) == 0) {
            Thread.yield();
        }
        condition.signal();
    } finally {
        lock.unlock();
    }
});

1 这里，获取 condition 上等待队列的长度，如果为 0，说明没有等待者，则死循环。

正确解法3--基于Semaphore

刚开始，我们初始化一个信号量，state 为 0。

线程 b 去获取信号量的时候，就会阻塞。

然后我们线程 a 再去释放一个信号量，此时线程 b 就可以继续执行。

public class Global1 {
    public static volatile int var = 1;
    public static final Semaphore semaphore = new Semaphore(0);

    public static void main(String[] args) {
        Thread a = new Thread(() -> {
            Global1.var++;
            semaphore.release();
        });
        a.setName("thread a");
        Thread b = new Thread(() -> {
            try {
                semaphore.acquire();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            if (Global1.var == 2) {
                //do something;
                System.out.println(Thread.currentThread().getName() + " good job");
            }
        });
        b.setName("thread b");
        a.start();
        b.start();
    }
}

正确解法4--基于CountDownLatch

public class Global1 {
    public static volatile int var = 1;
    public static final CountDownLatch countDownLatch = new CountDownLatch(1);

    public static void main(String[] args) {
        Thread a = new Thread(() -> {
            Global1.var++;
            countDownLatch.countDown();
        });
        a.setName("thread a");
        Thread b = new Thread(() -> {
            try {
                countDownLatch.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            if (Global1.var == 2) {
                //do something;
                System.out.println(Thread.currentThread().getName() + " good job");
            }
        });
        b.setName("thread b");
        a.start();
        b.start();
    }
}

正确解法5--基于BlockingQueue#

这里使用了 ArrayBlockingQueue，其他的阻塞队列也是可以的。

public class Global1 {
    public static volatile int var = 1;
    public static final ArrayBlockingQueue arrayBlockingQueue = new ArrayBlockingQueue(1);

    public static void main(String[] args) {
        Thread a = new Thread(() -> {
            Global1.var++;
            arrayBlockingQueue.offer(new Object());
        });
        a.setName("thread a");
        Thread b = new Thread(() -> {
            try {
                arrayBlockingQueue.take();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            if (Global1.var == 2) {
                //do something;
                System.out.println(Thread.currentThread().getName() + " good job");
            }
        });
        b.setName("thread b");
        a.start();
        b.start();
    }
}
 
  
正确解法6--基于FutureTask
 
  
我们也可以让线程 b 等待一个 task 的执行结果。
 
  
而线程 a 在执行完修改 var 为 2 后，执行该任务，任务执行完成后，线程 b 就会被通知继续执行。
 
  
public class Global1 {
    public static volatile int var = 1;
    public static final FutureTask futureTask = new FutureTask(new Callable() {
        @Override
        public Object call() throws Exception {
            System.out.println("callable task ");
            return null;
        }
    });

    public static void main(String[] args) {
        Thread a = new Thread(() -> {
            Global1.var++;
            futureTask.run();
        });
        a.setName("thread a");
        Thread b = new Thread(() -> {
            try {
                futureTask.get();
            } catch (InterruptedException | ExecutionException e) {
                e.printStackTrace();
            }

            if (Global1.var == 2) {
                //do something;
                System.out.println(Thread.currentThread().getName() + " good job");
            }
        });
        b.setName("thread b");
        a.start();
        b.start();
    }
}
 
  
正确解法7--基于join
 
  
这个可能是最简洁直观的解法：
 
  
public class Global1 {
    public static volatile int var = 1;

    public static void main(String[] args) {
        Thread a = new Thread(() -> {
            Global1.var++;
        });
        a.setName("thread a");
        Thread b = new Thread(() -> {
            try {
                a.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            if (Global1.var == 2) {
                //do something;
                System.out.println(Thread.currentThread().getName() + " good job");
            }
        });
        b.setName("thread b");
        a.start();
        b.start();
    }
}

 
  
正确解法8--基于CompletableFuture
 
  
这个和第 6 种类似。都是基于 future。
 
  
public class Global1 {
    public static volatile int var = 1;
    public static final CompletableFuture completableFuture =
            new CompletableFuture();

    public static void main(String[] args) {
        Thread a = new Thread(() -> {
            Global1.var++;
            completableFuture.complete(new Object());
        });
        a.setName("thread a");
        Thread b = new Thread(() -> {
            try {
                completableFuture.get();
            } catch (InterruptedException | ExecutionException e) {
                e.printStackTrace();
            }

            if (Global1.var == 2) {
                //do something;
                System.out.println(Thread.currentThread().getName() + " good job");
            }
        });
        b.setName("thread b");
        a.start();
        b.start();
    }
}
 
  
非阻塞--正确解法9--忙等待
 
  
这种代码量也少，只要线程 b 在变量为 1 时，死循环就行了。
 
  
public class Global1 {
    public static volatile int var = 1;

    public static void main(String[] args) {
        Thread a = new Thread(() -> {
            Global1.var++;
        });
        a.setName("thread a");
        Thread b = new Thread(() -> {
            while (var == 1) {
                Thread.yield();
            }

            if (Global1.var == 2) {
                //do something;
                System.out.println(Thread.currentThread().getName() + " good job");
            }
        });
        b.setName("thread b");
        a.start();
        b.start();
    }
}

 
  
非阻塞--正确解法10--忙等待
 
  
忙等待的方案很多，反正就是某个条件不满足时，不阻塞自己，阻塞了会释放 cpu，我们就是不希望释放 cpu 的。
 
  
比如像下面这样也可以：
 
  
public class Global1 {
    public static volatile int var = 1;
    public static final AtomicInteger atomicInteger =
            new AtomicInteger(1);

    public static void main(String[] args) {
        Thread a = new Thread(() -> {
            Global1.var++;
            atomicInteger.set(2);
        });
        a.setName("thread a");
        Thread b = new Thread(() -> {
            while (true) {
                boolean success = atomicInteger.compareAndSet(2, 1);
                if (success) {
                    break;
                } else {
                    Thread.yield();
                }
            }

            if (Global1.var == 2) {
                //do something;
                System.out.println(Thread.currentThread().getName() + " good job");
            }
        });
        b.setName("thread b");
        a.start();
        b.start();
    }
}

 
  
暂时想了这么些，方案还是比较多的，大家可以开动脑筋，头脑风暴吧。
 
  
看看你还有什么骚操作，可以在评论区留言。
  
 
  
 
  

 以上就是本期分享了。
 
  
一道很有意思的面试题目，快加入到这场头脑风暴游戏里吧~_第2张图片
 
  
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(面试题库,面试,java,职场和发展)

        

            

                
    
                    
  • uniapp button按钮去掉默认样式
                        啊卡无敌
cssuni-app前端javascript
                        
    有时候要使用uniapp官方提供的客服和分享功能，需要用到button按钮，里面属性open-type正好可以实现这些功能，不得不使用这种方式。但是这种方式，uniapp官方默认为button按钮加了些样式，自己写的样式也无法进行完全覆盖，所以今天分享一个覆盖官方button按钮的样式button::after{border:none;}button{position:relative;displ
    
                    
    • 
                    
  • double保留两位小数的四种方法
                        小小野猪
Java基础javadouble
                        
    这里写目录标题引言方法一：使用`BigDecimal`类方法二：使用`DecimalFormat`类方法三：使用`NumberFormat`类方法四：使用`String.format`方法结论声明引言在Java编程中，我们经常遇到需要对double类型的浮点数进行精确截断或四舍五入保留两位小数的需求。由于double类型在进行浮点运算时存在精度问题，因此，为了获得期望的精确表示，我们可以采用一些专
    
                    
    • 
                    
  • .NET 9 微软官方推荐使用 Scalar 替代传统的 Swagger
                        zzlyx99
microsoft.netjavascript
                        
    在.NET9中，微软官方推荐使用Scalar替代传统的Swagger（Swashbuckle）作为API文档和交互工具。Scalar是一个现代化的API平台，支持OpenAPI/Swagger规范，提供精美的文档界面和强大的功能。一、如何在.NET9中集成Scalar安装Scalar.AspNetCore包在项目中安装Scalar.AspNetCoreNuGet包。可以通过以下命令完成：bash复
    
                    
    • 
                    
  • 动态规划与回溯算法融合【高效解决组合、排列与子集问题】
                        一键难忘
算法之翼算法动态规划代理模式
                        
    本文收录于专栏：算法之翼动态规划与回溯算法融合【高效解决组合、排列与子集问题】动态规划（DynamicProgramming）和回溯算法（Backtracking）是解决复杂问题的两种重要算法。它们在许多问题中表现出色，但当两者结合使用时，能够更高效地解决一些特定类型的问题，如子集、排列和组合问题。这篇文章将探讨动态规划与回溯算法的结合，并通过代码实例展示如何应用这种结合方法解决实际问题。动态规划
    
                    
    • 
                    
  • Spring Boot集成RocketMQ实现分布式事务
                        missterzy
分布式与微服务消息队列（MQ）java-rocketmqspringbootrocketmq
                        
    RocketMQ是由阿里巴巴集团开发的一款高性能、高可靠、分布式的开源消息中间件，它在2012年对外开源，并于2016年捐赠给Apache软件基金会，随后在2017年成为了Apache的顶级项目。RocketMQ的设计旨在满足互联网业务场景中的海量消息传递需求，尤其擅长处理高并发、大数据量以及实时计算场景。主要特点和功能包括：1.分布式架构：RocketMQ采用了分布式部署架构，允许生产者、消费者
    
                    
    • 
                    
  • 解锁.NET配置魔法：打造强大的配置体系结构
                        步、步、为营
.netoracle数据库
                        
    一、引言在.NET开发的广袤领域中，构建一个强大的配置体系结构犹如为应用程序筑牢坚实的根基，其重要性不言而喻。它是确保应用程序稳定运行的关键所在，就如同房屋的地基，只有地基稳固，房屋才能经受住各种考验。在实际的开发场景中，我们常常面临着诸多复杂的需求。例如，在不同的环境下，如开发、测试和生产环境，应用程序需要连接到不同的数据库。这就要求我们能够灵活地配置数据库连接字符串，确保应用程序在各个环境中都
    
                    
    • 
                    
  • 25-5 SQL 注入攻击 - insert注入
                        技术探索
Web安全攻防全解析sql数据库
                        
    环境准备：构建完善的安全渗透测试环境：推荐工具、资源和下载链接_渗透测试靶机下载-CSDN博客一、注入原理描述：insert注入是指通过前端注册的信息被后台通过insert操作插入到数据库中。如果后台没有做相应的处理，就可能导致insert注入漏洞。原因：后台未对用户输入进行充分验证和过滤，导致恶意用户可以利用特定的输入构造恶意代码，从而影响数据库的插入操作，或者获取敏感数据。二、注入方法注入手段
    
                    
    • 
                    
  • Maven的继承与聚合特性：大型项目管理的利器
                        时雨h
JAVAmavenpythonjava
                        
    Maven的继承与聚合特性：大型项目管理的利器一、引言在Java项目开发中，尤其是大型项目，管理项目的配置和模块构建是一项具有挑战性的任务。Maven作为一款强大的项目管理工具，提供了继承和聚合等特性，有效地解决了这些问题。本文将深入探讨Maven的继承和聚合特性，并通过实战案例展示如何在搭建微服务项目中应用它们。二、Maven工程继承关系2.1继承概念Maven继承是一种在Maven项目中让一个
    
                    
    • 
                    
  • Hutools 构建树结构
                        理想二旬不止(上班了，好像没有理想了)
Hutools工具使用记录java
                        
    详细介绍Hutools官网我们平时在进行业务开发时，经常会碰到需要构建树形结构的业务，比如常见的区域树结构└──省└──市└──区这类数据的特点就是每条数据有明确的父节点和子节点，如果没有父节点或者子节点的话，没有父节点的数据为树的顶级节点，如果没有子节点的话为树的底级节点。示例数据表及数据CREATETABLEarea(area_idBIGINTNOTNULLAUTO_INCREMENT,par
    
                    
    • 
                    
  • maven中使用jdbc
                        理想二旬不止(上班了，好像没有理想了)
#java#jdbcjava后端
                        
    用到的有数据库连接池、JDBCTemplate一、首先导入jar包mysqlmysql-connector-java8.0.25compilecom.alibabadruid1.0.9org.springframeworkspring-core4.1.2.RELEASEcompileorg.springframeworkspring-jdbc4.1.2.RELEASEcompileorg.spri
    
                    
    • 
                    
  • 解锁编程智慧：23种设计模式案例分享
                        码农技术栈
设计模式
                        
    为什么要学习设计模式？你可以把设计模式想象成一些做饭的菜谱。当我们需要做一道菜（开发一个功能）时，如果按照自己的想法随意添加调料（编写代码），很可能做出的菜味道不好（功能不稳定或有bug）。但是，如果我们按照一个成功的菜谱（设计模式）来做，就能更容易地做出美味的菜肴（开发出稳定的功能）。设计模式就是一些在软件开发中经常被使用的“菜谱”，它们可以帮助我们更好地组织代码、提高代码的可读性和可维护性。这
    
                    
    • 
                    
  • openresty+lua实现实时写kafka
                        sky@梦幻未来
大数据openrestynginxopenrestylua
                        
    一.背景在使用openresty+lua+nginx+flume，通过定时切分日志发送kafka的方式无法满足实时性的情况下，小编开始研究openresty+lua+nginx+kafka实时写kafka，从而达到数据实时性，和高性能保证。二.实现1.openresty安装nginx，以及lua的使用请看博主上一篇博客https://blog.csdn.net/qq_29497387/articl
    
                    
    • 
                    
  • Kafka的Partition故障恢复机制与HW一致性保障-Epoch更新机制详解
                        大树~~
#Kafkajavakafka分布式后端
                        
    在分布式系统中，节点的故障是不可避免的。为了确保系统的高可用性和数据的一致性，Kafka设计了一系列机制来应对Broker或Partition的故障。本文将详细解析Kafka的Partition故障恢复机制和HW一致性保障-Epoch更新机制，帮助深入理解Kafka在面对故障时的处理逻辑和一致性保障手段。一、Partition故障恢复机制1.概述Kafka中的每个Topic被划分为多个Partit
    
                    
    • 
                    
  • MacOS下载安装Logisim（图文教程）
                        Roc-xb
macosLogisimjdk
                        
    本章教程主要介绍如何在MacOS系统中安装Logisim。一、Logisim是什么？Logisim是一个用于电子逻辑门电路模拟的教育工具软件。它允许用户通过图形界面构建和测试复杂的数字逻辑电路，如加法器、解码器、编码器、寄存器、内存等，从而帮助学生理解计算机硬件的工作原理。二、如何判断当前Mac是什么架构的？打开终端，输入：uname-a即可查看，常见的架构有：x86_64和aarch64例如：这
    
                    
    • 
                    
  • spring cloud之gateway和JWT回顾
                        晨的挥霍
springcloudgatewayspring
                        
    最开始学习时，没怎么用，只知道它是网关，当时因为经常使用Nginx做网关，慢慢就淡忘了，最近为了代码整合性，就使用它，非常棒。关于JWT以前也使用，后面调用基本以第三方接口开发的比较多，当时自己的服务，添加自己的规则生成token整合gateway网关1、pomorg.springframework.bootspring-boot-starter-actuatororg.springframewo
    
                    
    • 
                    
  • C语言青蛙跳台阶问题
                        共享家9527
c语言
                        
    在算法学习中，青蛙跳台阶问题是一个经典的递归和动态规划入门案例。它通过简单的场景，揭示了复杂的算法思想，非常适合初学者理解递归与动态规划的核心概念。一、问题描述一只青蛙要跳上n级台阶，每次它可以跳1级或者2级台阶。那么，青蛙跳上n级台阶总共有多少种不同的跳法呢？二、解题思路递归思路：-对于第n级台阶，青蛙到达它的方式要么是从第n-1级台阶跳1级上来，要么是从第n-2级台阶跳2级上来。-所以，跳上n
    
                    
    • 
                    
  • 2023年数学建模动态规划算法在最短路径问题中的应用：以Floyd算法为例
                        人工智能_SYBH
算法matlab数据结构动态规划
                        
    订阅专栏后9月比赛期间会分享思路及Matlab代码数学建模是将实际问题抽象化为数学问题，并采用数学工具和技巧进行求解的过程。在实际应用中，数学建模是解决问题的一种有效方法。本文将介绍Floyd算法在数学建模中的应用。Floyd算法是解决最短路径问题的一种经典动态规划算法。最短路径问题是指在一个加权有向图中，从一个源节点到其他各节点的最短路径问题。在实际应用中，最短路径问题广泛应用于交通运输、通信网
    
                    
    • 
                    
  • Spring BeanWrapper的嵌套属性操作技巧
                        t0_54coder
springjava后端个人开发
                        
    在Spring框架中，BeanWrapper是一个强大的工具，用于操作JavaBean的属性。它不仅可以设置简单的属性值，还能处理嵌套属性、集合元素等复杂场景。本文将通过几个实例，详细介绍如何使用BeanWrapper来操作嵌套的Bean实例。一、嵌套Bean的设置假设我们有两个类：Employee和Department。Employee包含一个Department类型的属性。我们可以通过Bean
    
                    
    • 
                    
  • Hibernate快速入门：基于H2内存数据库的ORM实践
                        t0_54coder
数据库hibernateoracle个人开发
                        
    在当今的软件开发中，ORM（对象关系映射）框架已经成为简化数据库操作的重要工具之一。Hibernate作为Java领域中非常流行的ORM框架，能够帮助开发者将Java类映射到数据库表中，从而减少大量的数据库操作代码。本文将通过一个简单的示例，介绍如何使用Hibernate结合H2内存数据库，快速实现一个简单的ORM应用。一、项目依赖配置在开始之前，我们需要配置项目的依赖。这里我们使用Maven作为
    
                    
    • 
                    
  • MySQL常用命令大全
                        DK_521
数据库mysql数据库
                        
    目录1、mysql服务的启动和停止2、登陆mysql3、增加新用户4、操作数据库Ⅰ、显示数据库列表:Ⅱ、显示库中的数据表：Ⅲ、显示数据表的结构：Ⅳ、建库与删库：Ⅴ、建表与删表：Ⅵ、清空表中记录：Ⅶ、显示表中的记录：Ⅷ、往表中加入记录：Ⅹ、更新表中数据5、导出和导入数据Ⅰ.导出数据：Ⅱ.导入数据:Ⅲ.将文本数据导入数据库:6、退出MYSQL命令打开Linux或MacOS的Terminal（终端）直接
    
                    
    • 
                    
  • Docker多架构镜像构建踩坑记
                        一直学下去
docker容器adm64arm64多架构
                        
    背景公司为了做信创项目的亮点，需要将现有的一套在X86上运行的应用系统迁移到ARM服务器上运行，整个项目通过后端Java，前端VUEJS开发通过CICD做成Docker镜像在K8S里面运行。但是当前的CICD产品不支持ARM的镜像构建，于是只能手工构建ARM镜像。以下是一些踩坑的记录，希望能帮大家少踩坑构建环境本地电脑DeepinLinux23(Windows的WSL和其他的Linux系统都可以）
    
                    
    • 
                    
  • Maven修改默认编码格式UTF-8
                        程柯梦想
mavenjava
                        
    文章目录查看当前编码格式修改编码格式查看修改后编码查看当前编码格式cmd命令C:\Users>mvn-vApacheMaven3.9.9(8e8579a9e76f7d015ee5ec7bfcdc97d260186937)Mavenhome:D:\develop\apache-maven-3.9.9Javaversion:1.8.0_421,vendor:OracleCorporation,runt
    
                    
    • 
                    
  • 算法：数据结构与算法（总结）
                        鲲鹏飞九万里
算法算法数据结构java
                        
    数据结构与算法文章目录数据结构与算法一、数据结构1.1BST、AVL、Red-BlackBST1.2Trie字典树、LRUCache、布隆过滤器1.3Union-find并查集1.4数组ArrayList、链表LinkedList、跳表SkipList跳表[Skiplist](https://gitee.com/lf-ren/java-re-new-builder/blob/master/proj
    
                    
    • 
                    
  • Pygubu：Tkinter界面设计的得力助手
                        牧怡泳

                        
    Pygubu：Tkinter界面设计的得力助手pygubuAsimpleGUIbuilderforthepythontkintermodule项目地址:https://gitcode.com/gh_mirrors/py/pygubuPygubu，一个专为Python开发者打造的轻量级GUI构建器，采用Python编程语言实现。它简化了基于Tkinter模块的图形用户界面的创建过程，让快速原型设计和
    
                    
    • 
                    
  • 数据结构基础之《（16）—链表题目》
                        csj50
数据结构数据结构
                        
    一、链表问题1、对于笔试，不用太在乎空间复杂度，一切为了时间复杂度2、对于面试，时间复杂度依然放在第一位，但是一定要找到空间最省的方法二、快慢指针逻辑：慢指针一次走1步快指针一次走2步当快指针走完的时候，慢指针应该来到中点的位置1、输入链表头节点，奇数长度返回中点，偶数长度返回上中点2、输入链表头节点，奇数长度返回中点，偶数长度返回下中点3、输入链表头节点，奇数长度返回中点前一个，偶数长度返回上中
    
                    
    • 
                    
  • C语言指针
                        小宝哥Code
C语言c语言算法开发语言
                        
    指针是C语言的一大特色，也是其最强大和灵活的部分之一。指针的本质是一个变量，它存储的是另一个变量的内存地址。通过指针，可以间接访问和操作内存中的数据。本节将全面讲解C语言中的指针，包括基础知识、常见用法、高级技巧以及注意事项。1.指针的基础知识1.1什么是指针指针是一个变量，它的值是另一个变量的地址（内存位置）。地址：内存中每个变量都有一个唯一的地址。指针变量：用于存储这个地址的变量。指针的声明数
    
                    
    • 
                    
  • C语言：四种判断大端和小端的方法
                        blammmp
c语言算法开发语言
                        
    方法一：intmain(){inta=1;if(*(char*)&a==1){printf("小端");}else{printf("大端");}return0;}方法二：intcheck_sys(){inta=1;if(*(char*)&a==1)return1;elsereturn0;}intmain(){intret=check_sys();if(ret==1){printf("小端");}e
    
                    
    • 
                    
  • 【SpringBoot 】dynamic 动态数据源配置连接池（转）
                        binqian
springspringboot数据库oracle
                        
    前言在复杂的业务场景中，我们经常需要使用多数据源来满足不同的数据访问需求。DynamicDatasource为我们提供了一种灵活切换不同数据源的解决方案。但是多数据源配置连接池以及说明文档都是收费的。本篇博文将详细介绍如何配置和优化DynamicDatasource的连接池，包括Druid和HikariCP，以及如何根据项目需求进行选择。连接池配置连接池是数据库连接管理的核心组件，它可以显著提高数
    
                    
    • 
                    
  • Java 大视界 -- Java 大数据中的自然语言生成技术与实践（63）
                        青云交
大数据新视界Java大视界大数据自然语言生成基于规则模型基于统计模型基于深度学习模型新闻写作智能客服
                        
    亲爱的朋友们，热烈欢迎来到青云交的博客！能与诸位在此相逢，我倍感荣幸。在这飞速更迭的时代，我们都渴望一方心灵净土，而我的博客正是这样温暖的所在。这里为你呈上趣味与实用兼具的知识，也期待你毫无保留地分享独特见解，愿我们于此携手成长，共赴新程！一、欢迎加入【福利社群】点击快速加入：青云交灵犀技韵交响盛汇福利社群点击快速加入2：2024CSDN博客之星创作交流营（NEW)二、本博客的精华专栏：大数据新视
    
                    
    • 
                    
  • DuckDB：详细解析CMakeLists.txt
                        Whoisbug
SQL引擎服务器duckdb存储引擎sqlcppjava
                        
    引言CMake简介CMake（Cross-PlatformMake）是一种跨平台的构建系统生成器，用于管理和自动化软件的构建过程。它通过编写配置文件（通常是CMakeLists.txt）来定义项目的构建规则，支持多种编译器和操作系统，能够生成本地化的构建文件（如Makefile、VisualStudio解决方案等）。CMake广泛应用于以下场景：跨平台项目：需要在多种操作系统上构建和部署的项目。大
    
                    
    • 
                                
  • [黑洞与暗粒子]没有光的世界
                                    comsci

                                    
         无论是相对论还是其它现代物理学,都显然有个缺陷,那就是必须有光才能够计算 
 
     但是,我相信,在我们的世界和宇宙平面中,肯定存在没有光的世界.... 
 
     那么,在没有光的世界,光子和其它粒子的规律无法被应用和考察,那么以光速为核心的 
 
&nbs
    
                                
    • 
                                
  • jQuery Lazy Load 图片延迟加载
                                    aijuans
jquery
                                    
    基于 jQuery 的图片延迟加载插件，在用户滚动页面到图片之后才进行加载。 
对于有较多的图片的网页，使用图片延迟加载，能有效的提高页面加载速度。 
 
 版本： 
 

  jQuery v1.4.4+ 
 

  jQuery Lazy Load v1.7.2 
 
 
 注意事项： 
 
 
 需要真正实现图片延迟加载，必须将真实图片地址写在 data-original 属性中。若 src
    
                                
    • 
                                
  • 使用Jodd的优点
                                    Kai_Ge
jodd
                                    
    1.  简化和统一 controller ，抛弃 extends SimpleFormController ，统一使用 implements Controller 的方式。 
2.  简化 JSP 页面的 bind, 不需要一个字段一个字段的绑定。 
3.  对 bean 没有任何要求，可以使用任意的 bean 做为 formBean。 
  
使用方法简介
    
                                
    • 
                                
  • jpa Query转hibernate Query
                                    120153216
Hibernate
                                    
    public List<Map> getMapList(String hql,
			Map map) {
		org.hibernate.Query jpaQuery = entityManager.createQuery(hql);
		if (null != map) {
			for (String parameter : map.keySet()) {
				jp
    
                                
    • 
                                
  • Django_Python3添加MySQL/MariaDB支持
                                    2002wmj
mariaDB
                                    
    现状 
首先，[email protected] 中默认的引擎为 django.db.backends.mysql 。但是在Python3中如果这样写的话，会发现 django.db.backends.mysql 依赖 MySQLdb[5] ，而 MySQLdb 又不兼容 Python3 于是要找一种新的方式来继续使用MySQL。 MySQL官方的方案 
首先据MySQL文档[3]说，自从MySQL
    
                                
    • 
                                
  • 在SQLSERVER中查找消耗IO最多的SQL
                                    357029540
SQL Server
                                    
    返回做IO数目最多的50条语句以及它们的执行计划。 
select top 50   
 
(total_logical_reads/execution_count) as avg_logical_reads,  
 
(total_logical_writes/execution_count) as avg_logical_writes,  
 
(tot
    
                                
    • 
                                
  • spring UnChecked 异常 官方定义！
                                    7454103
spring
                                    
      如果你接触过spring的 事物管理！那么你必须明白 spring的 非捕获异常！ 即 unchecked 异常！ 因为 spring 默认这类异常事物自动回滚！！ 
 
 
 
 
public static boolean isCheckedException(Throwable ex)
    {
   return !(ex instanceof RuntimeExcep
    
                                
    • 
                                
  • mongoDB 入门指南、示例
                                    adminjun
javamongodb操作
                                    
    一、准备工作 
1、 下载mongoDB 
下载地址：http://www.mongodb.org/downloads 
选择合适你的版本 
相关文档：http://www.mongodb.org/display/DOCS/Tutorial 
2、 安装mongoDB 
A、 不解压模式： 
将下载下来的mongoDB-xxx.zip打开，找到bin目录，运行mongod.exe就可以启动服务，默
    
                                
    • 
                                
  • CUDA 5 Release Candidate Now Available
                                    aijuans
CUDA
                                    
    The CUDA 5 Release Candidate is now available at http://developer.nvidia.com/<wbr></wbr>cuda/cuda-pre-production. Now applicable to a broader set of algorithms, CUDA 5 has advanced fe
    
                                
    • 
                                
  • Essential Studio for WinRT网格控件测评
                                    Axiba
JavaScripthtml5
                                    
    Essential Studio for WinRT界面控件包含了商业平板应用程序开发中所需的所有控件，如市场上运行速度最快的grid 和chart、地图、RDL报表查看器、丰富的文本查看器及图表等等。同时，该控件还包含了一组独特的库，用于从WinRT应用程序中生成Excel、Word以及PDF格式的文件。此文将对其另外一个强大的控件——网格控件进行专门的测评详述。 
 
 
网格控件功能 
1、
    
                                
    • 
                                
  • java 获取windows系统安装的证书或证书链
                                    bewithme
windows
                                    
      
    有时需要获取windows系统安装的证书或证书链，比如说你要通过证书来创建java的密钥库  。 
有关证书链的解释可以查看此处 。 
  
public static void main(String[] args) {
		SunMSCAPI providerMSCAPI = new SunMSCAPI();
		S
    
                                
    • 
                                
  • NoSQL数据库之Redis数据库管理(set类型和zset类型)
                                    bijian1013
redis数据库NoSQL
                                    
    4.sets类型 
        Set是集合，它是string类型的无序集合。set是通过hash table实现的，添加、删除和查找的复杂度都是O(1)。对集合我们可以取并集、交集、差集。通过这些操作我们可以实现sns中的好友推荐和blog的tag功能。 
        sadd：向名称为key的set中添加元
    
                                
    • 
                                
  • 异常捕获何时用Exception，何时用Throwable
                                    bingyingao

                                    
    用Exception的情况 
 try { 
       //可能发生空指针、数组溢出等异常 
        } catch (Exception e) { 
         
    
                                
    • 
                                
  • 【Kafka四】Kakfa伪分布式安装
                                    bit1129
kafka
                                    
    在http://bit1129.iteye.com/blog/2174791一文中，实现了单Kafka服务器的安装，在Kafka中，每个Kafka服务器称为一个broker。本文简单介绍下，在单机环境下Kafka的伪分布式安装和测试验证   1. 安装步骤 
  
Kafka伪分布式安装的思路跟Zookeeper的伪分布式安装思路完全一样，不过比Zookeeper稍微简单些(不
    
                                
    • 
                                
  • Project Euler
                                    bookjovi
haskell
                                    
    Project Euler是个数学问题求解网站，网站设计的很有意思，有很多problem，在未提交正确答案前不能查看problem的overview，也不能查看关于problem的discussion thread，只能看到现在problem已经被多少人解决了，人数越多往往代表问题越容易。 
    看看problem 1吧： 
 Add all the natural num
    
                                
    • 
                                
  • Java-Collections Framework学习与总结-ArrayDeque
                                    BrokenDreams
Collections
                                    
            表、栈和队列是三种基本的数据结构，前面总结的ArrayList和LinkedList可以作为任意一种数据结构来使用，当然由于实现方式的不同，操作的效率也会不同。 
        这篇要看一下java.util.ArrayDeque。从命名上看
    
                                
    • 
                                
  • 读《研磨设计模式》-代码笔记-装饰模式-Decorator
                                    bylijinnan
java设计模式
                                    
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ 
 
 



import java.io.BufferedOutputStream;
import java.io.DataOutputStream;
import java.io.FileOutputStream;
import java.io.Fi
    
                                
    • 
                                
  • Maven学习(一)
                                    chenyu19891124
Maven私服
                                    
        学习一门技术和工具总得花费一段时间，5月底6月初自己学习了一些工具，maven+Hudson+nexus的搭建，对于maven以前只是听说，顺便再自己的电脑上搭建了一个maven环境，但是完全不了解maven这一强大的构建工具，还有ant也是一个构建工具，但ant就没有maven那么的简单方便，其实简单点说maven是一个运用命令行就能完成构建，测试，打包，发布一系列功
    
                                
    • 
                                
  • [原创]JWFD工作流引擎设计----节点匹配搜索算法(用于初步解决条件异步汇聚问题) 补充
                                    comsci
算法工作PHP搜索引擎嵌入式
                                    
    本文主要介绍在JWFD工作流引擎设计中遇到的一个实际问题的解决方案，请参考我的博文"带条件选择的并行汇聚路由问题"中图例A2描述的情况(http://comsci.iteye.com/blog/339756),我现在把我对图例A2的一个解决方案公布出来，请大家多指点 
 
 节点匹配搜索算法(用于解决标准对称流程图条件汇聚点运行控制参数的算法) 
 
 需要解决的问题：已知分支
    
                                
    • 
                                
  • Linux中用shell获取昨天、明天或多天前的日期
                                    daizj
linuxshell上几年昨天获取上几个月
                                    
    在Linux中可以通过date命令获取昨天、明天、上个月、下个月、上一年和下一年 
 
 
# 获取昨天 
date -d 'yesterday'  # 或 date -d 'last day' 
# 获取明天 
date -d 'tomorrow'   # 或 date -d 'next day' 
# 获取上个月 
date -d 'last month' 
# 
    
                                
    • 
                                
  • 我所理解的云计算
                                    dongwei_6688
云计算
                                    
          在刚开始接触到一个概念时，人们往往都会去探寻这个概念的含义，以达到对其有一个感性的认知，在Wikipedia上关于“云计算”是这么定义的，它说： 
 
        Cloud computing is a phrase used to describe a variety of computing co
    
                                
    • 
                                
  • YII CMenu配置
                                    dcj3sjt126com
yii
                                    
    Adding id and class names to CMenu 
We use the id and htmlOptions to accomplish this. Watch.   
//in your view
$this->widget('zii.widgets.CMenu', array(
	'id'=>'myMenu',
	'items'=>$this-&g
    
                                
    • 
                                
  • 设计模式之静态代理与动态代理
                                    come_for_dream
设计模式
                                    
    静态代理与动态代理 
        代理模式是java开发中用到的相对比较多的设计模式，其中的思想就是主业务和相关业务分离。所谓的代理设计就是指由一个代理主题来操作真实主题，真实主题执行具体的业务操作，而代理主题负责其他相关业务的处理。比如我们在进行删除操作的时候需要检验一下用户是否登陆，我们可以删除看成主业务，而把检验用户是否登陆看成其相关业务
    
                                
    • 
                                
  • 【转】理解Javascript 系列
                                    gcc2ge
JavaScript
                                    
    理解Javascript_13_执行模型详解 
 
  摘要: 在《理解Javascript_12_执行模型浅析》一文中,我们初步的了解了执行上下文与作用域的概念，那么这一篇将深入分析执行上下文的构建过程，了解执行上下文、函数对象、作用域三者之间的关系。函数执行环境简单的代码:当调用say方法时，第一步是创建其执行环境，在创建执行环境的过程中，会按照定义的先后顺序完成一系列操作:1.首先会创建一个
    
                                
    • 
                                
  • Subsets II
                                    hcx2013
set
                                    
    Given a collection of integers that might contain duplicates, nums, return all possible subsets. 
Note: 
 
 Elements in a subset must be in non-descending order. 
 The solution set must not conta
    
                                
    • 
                                
  • Spring4.1新特性——Spring缓存框架增强
                                    jinnianshilongnian
spring4
                                    
    目录 
Spring4.1新特性——综述 
Spring4.1新特性——Spring核心部分及其他 
Spring4.1新特性——Spring缓存框架增强 
Spring4.1新特性——异步调用和事件机制的异常处理 
Spring4.1新特性——数据库集成测试脚本初始化 
Spring4.1新特性——Spring MVC增强 
Spring4.1新特性——页面自动化测试框架Spring MVC T
    
                                
    • 
                                
  • shell嵌套expect执行命令
                                    liyonghui160com

                                    
      
  
一直都想把expect的操作写到bash脚本里,这样就不用我再写两个脚本来执行了,搞了一下午终于有点小成就,给大家看看吧. 
  系统:centos 5.x 
  
1.先安装expect 
yum -y install expect 
  
2.脚本内容: 
cat auto_svn.sh 
  
#!/bin/bash

    
                                
    • 
                                
  • Linux实用命令整理
                                    pda158
linux
                                    
    0. 基本命令   　　linux 基本命令整理   　 
　1. 压缩 解压   　　tar -zcvf a.tar.gz a   #把a压缩成a.tar.gz   　　tar -zxvf a.tar.gz     #把a.tar.gz解压成a   　 
　2. vim小结   　　2.1 vim替换   　　:m,ns/word_1/word_2/gc  
    
                                
    • 
                                
  • 独立开发人员通向成功的29个小贴士
                                    shoothao
独立开发
                                    
      
 概述：本文收集了关于独立开发人员通向成功需要注意的一些东西,对于具体的每个贴士的注解有兴趣的朋友可以查看下面标注的原文地址。  
   
 
 明白你从事独立开发的原因和目的。 
 保持坚持制定计划的好习惯。 
 万事开头难，第一份订单是关键。 
 培养多元化业务技能。 
 提供卓越的服务和品质。 
 谨小慎微。 
 营销是必备技能。 
 学会组织，有条理的工作才是最有效率的。 
 “独立
    
                                
    • 
                                
  • JAVA中堆栈和内存分配原理
                                    uule
java
                                    
    1、栈、堆  
1.寄存器：最快的存储区, 由编译器根据需求进行分配,我们在程序中无法控制.2. 栈：存放基本类型的变量数据和对象的引用，但对象本身不存放在栈中，而是存放在堆（new 出来的对象）或者常量池中（字符串常量对象存放在常量池中。）3. 堆：存放所有new出来的对象。4. 静态域：存放静态成员（static定义的）5. 常量池：存放字符串常量和基本类型常量（public static f
    
                                
    •