2023.07.11java面试总结

java的中间件用过哪些 ？ 用过redis 什么数据会存储在redis中

Redis通常用于以下场景中存储数据：

1. 缓存：Redis可以用作缓存存储，将经常访问的数据存储在内存中，以提高读取性能。通过将数据存储在Redis中，应用程序可以避免频繁地访问数据库或其他外部数据源，从而加快响应时间。

2. 会话管理：Redis可以用于存储会话数据，以实现分布式会话管理。通过将会话数据存储在Redis中，可以实现跨多个应用程序实例的会话共享和负载均衡。

3. 排行榜/计数器：Redis提供了高效的有序集合和计数器功能，可以用于实现排行榜、计数器和统计功能。通过将数据存储在有序集合中，可以轻松地进行排名、排序和范围查询操作。

4. 发布/订阅：Redis支持发布/订阅模式，可以用于实现实时消息传递和事件通知。通过将数据发布到特定的频道，订阅者可以接收到相关的消息，并进行相应的处理。

5. 分布式锁：Redis提供了原子操作和过期时间功能，可以用于实现分布式锁。通过使用Redis的原子操作和过期时间，可以确保在分布式环境中只有一个进程可以访问共享资源，从而避免竞态条件和数据不一致的问题。

请注意，以上只是一些常见的使用场景，实际上Redis还可以用于其他许多不同的用途。具体的使用场景应根据实际需求和系统架构进行选择和实施。

进程 线程有什么区别

- 进程是程序的执行实例，是操作系统分配资源的基本单位。每个进程都有自己的地址空间、文件描述符和其他系统资源。进程之间是相互独立的，它们通过进程间通信（IPC）来进行数据交换和协作。

- 线程是进程内的执行单元，是操作系统调度的基本单位。一个进程可以包含多个线程，它们共享进程的地址空间和系统资源。线程之间可以通过共享内存来进行数据交换和协作。

总结来说，进程是操作系统分配资源的基本单位，而线程是进程内的执行单元。进程之间是相互独立的，而线程之间共享进程的资源。线程的创建和切换开销较小，因此多线程的程序可以更高效地利用系统资源和提高响应性能。

以下是一个使用多线程的示例：

import threading

def print_numbers():
    for i in range(1, 6):
        print(i)

def print_letters():
    for letter in ['A', 'B', 'C', 'D', 'E']:
        print(letter)

# 创建两个线程
thread1 = threading.Thread(target=print_numbers)
thread2 = threading.Thread(target=print_letters)

# 启动线程
thread1.start()
thread2.start()

# 等待线程结束
thread1.join()
thread2.join()

在上述代码中，我们创建了两个线程thread1和thread2，分别执行print_numbers和print_letters函数。通过调用start方法启动线程，线程会并发执行。最后，通过调用join方法等待线程结束。

线程状态有哪些

线程可以处于以下几种状态：

1. 新建（New）：线程被创建但尚未开始执行。

2. 就绪（Runnable）：线程已经准备好执行，但还未获得CPU执行时间。

3. 运行（Running）：线程正在执行。

4. 阻塞（Blocked）：线程暂时停止执行，等待某个条件的满足。

5. 等待（Waiting）：线程暂时停止执行，等待其他线程的通知。

6. 超时等待（Timed Waiting）：线程暂时停止执行，等待一段时间或其他条件的满足。

7. 终止（Terminated）：线程执行完毕或出现异常而终止。

并行和并发是什么

并行和并发是两个与多线程相关的概念。

- 并行是指同时执行多个任务或操作。在并行计算中，多个任务可以同时进行，每个任务都在不同的处理器核心或计算单元上执行。并行可以显著提高程序的执行速度和系统的吞吐量。

- 并发是指多个任务或操作在同一时间段内交替执行。在并发计算中，多个任务通过时间片轮转或其他调度算法交替执行，每个任务在一段时间内执行一部分工作，然后切换到下一个任务。并发可以提高系统的响应性能和资源利用率。

以下是一个使用Java的示例，演示并行和并发的区别：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ParallelAndConcurrentExample {
    public static void main(String[] args) {
        // 并行执行任务
        ExecutorService parallelExecutor = Executors.newFixedThreadPool(2);
        parallelExecutor.submit(() -> {
            for (int i = 1; i <= 5; i++) {
                System.out.println("Parallel Task 1: " + i);
            }
        });
        parallelExecutor.submit(() -> {
            for (int i = 1; i <= 5; i++) {
                System.out.println("Parallel Task 2: " + i);
            }
        });
        parallelExecutor.shutdown();

        // 并发执行任务
        ExecutorService concurrentExecutor = Executors.newFixedThreadPool(2);
        concurrentExecutor.submit(() -> {
            for (int i = 1; i <= 5; i++) {
                System.out.println("Concurrent Task 1: " + i);
            }
        });
        concurrentExecutor.submit(() -> {
            for (int i = 1; i <= 5; i++) {
                System.out.println("Concurrent Task 2: " + i);
            }
        });
        concurrentExecutor.shutdown();
    }
}

在上述代码中，我们使用Java的ExecutorService和Executors类创建了两个线程池，分别用于并行执行任务和并发执行任务。通过调用submit方法提交任务，任务会在不同的线程中执行。在并行执行的示例中，两个任务会同时执行；而在并发执行的示例中，两个任务会交替执行。

数据库死锁怎么处理，怎么避免死锁发生

数据库死锁是指两个或多个事务相互等待对方释放资源，导致无法继续执行的情况。处理和避免死锁的方法如下：

处理死锁：
1. 检测和解除死锁：可以使用死锁检测算法来检测死锁的发生，并采取相应的措施解除死锁。常见的死锁检测算法包括资源分配图算法和银行家算法。

2. 终止事务：当检测到死锁时，可以选择终止其中一个或多个事务，以解除死锁。选择终止哪个事务需要根据具体情况和优先级进行决策。

避免死锁：
1. 加锁顺序：确保所有事务按照相同的顺序获取锁。例如，如果事务A需要先获取锁1再获取锁2，那么事务B也应该按照相同的顺序获取锁。

2. 避免循环等待：尽量避免循环等待，即避免一个事务等待另一个事务所持有的资源。可以通过定义资源的顺序来避免循环等待。

3. 设置超时时间：为每个事务设置一个超时时间，如果事务在超时时间内无法获取所需的资源，则放弃该事务，以避免死锁的发生。

4. 使用事务隔离级别：选择合适的事务隔离级别，如读已提交（Read Committed）或可重复读（Repeatable Read），以减少死锁的可能性。

数据库有哪些锁

MySQL数据库中有以下几种锁：

1. 共享锁（Shared Lock）：也称为读锁，多个事务可以同时持有共享锁，用于读取数据。共享锁不阻塞其他事务的共享锁，但会阻塞其他事务的排他锁。

2. 排他锁（Exclusive Lock）：也称为写锁，只有一个事务可以持有排他锁，用于修改数据。排他锁会阻塞其他事务的共享锁和排他锁。

3. 意向共享锁（Intention Shared Lock）：用于表示事务准备获取共享锁。

4. 意向排他锁（Intention Exclusive Lock）：用于表示事务准备获取排他锁。

5. 记录锁（Record Lock）：用于锁定某个数据记录，防止其他事务修改该记录。

6. 间隙锁（Gap Lock）：用于锁定某个范围的数据记录之间的间隙，防止其他事务在该范围内插入新的记录。

7. Next-Key锁：是记录锁和间隙锁的组合，用于锁定某个范围的数据记录和间隙。

mysql怎么优化sql

1. 优化查询语句：确保查询语句使用了合适的索引，避免全表扫描。可以通过使用EXPLAIN命令来分析查询语句的执行计划，查看是否有潜在的性能问题。

2. 合理使用索引：根据查询的条件和排序需求，创建适当的索引。避免创建过多的索引，因为索引会增加写操作的开销。

3. 避免使用SELECT *：只选择需要的列，避免不必要的数据传输和内存消耗。

4. 分页查询优化：对于大数据量的分页查询，可以使用LIMIT和OFFSET来限制返回的结果集大小，避免一次性返回大量数据。

5. 优化表结构：合理设计表的结构，避免冗余字段和重复数据。使用合适的数据类型和字段长度，减少存储空间和提高查询性能。

6. 使用连接查询：对于需要关联多个表的查询，使用适当的连接方式（如内连接、左连接、右连接）来提高查询效率。

7. 缓存查询结果：对于频繁查询但不经常变化的数据，可以考虑使用缓存来减少数据库的访问次数。
 

怎么创建适合的索引

1. 选择适当的字段：选择经常用于查询和筛选的字段作为索引字段。通常，选择具有高选择性（即不重复值较多）的字段作为索引字段可以提高索引的效果。

2. 避免过多的索引：避免为每个字段都创建索引，因为索引会增加写操作的开销。只为经常用于查询和筛选的字段创建索引。

3. 考虑多列索引：对于经常一起使用的字段，可以考虑创建多列索引。多列索引可以提高查询效率，尤其是在涉及多个字段的查询条件时。

4. 选择合适的索引类型：根据查询的需求选择合适的索引类型。常见的索引类型包括B树索引、哈希索引和全文索引。B树索引适用于范围查询和排序，哈希索引适用于等值查询，全文索引适用于文本搜索。

以下是一个示例，演示如何为MySQL数据库中的表创建索引：

-- 创建单列索引
CREATE INDEX idx_name ON table_name (column_name);

-- 创建多列索引
CREATE INDEX idx_name ON table_name (column1, column2);

-- 创建唯一索引
CREATE UNIQUE INDEX idx_name ON table_name (column_name);

-- 创建全文索引
CREATE FULLTEXT INDEX idx_name ON table_name (column_name);

java怎么处理多线程，保证线程安全

Java中可以通过以下几种方式来处理多线程并保证线程安全：

1. 使用synchronized关键字：通过在方法或代码块前加上synchronized关键字，可以确保同一时间只有一个线程可以执行该方法或代码块。这样可以避免多个线程同时访问共享资源导致的竞态条件。

public synchronized void synchronizedMethod() {
    // 线程安全的代码
}

public void synchronizedBlock() {
    synchronized (this) {
        // 线程安全的代码
    }
}

2. 使用ReentrantLock类：ReentrantLock是Java提供的可重入锁，可以通过lock()和unlock()方法来控制代码块的访问。与synchronized关键字相比，ReentrantLock提供了更灵活的锁定机制，可以实现更复杂的同步需求。

import java.util.concurrent.locks.ReentrantLock;

private ReentrantLock lock = new ReentrantLock();

public void synchronizedBlock() {
    lock.lock();
    try {
        // 线程安全的代码
    } finally {
        lock.unlock();
    }
}

3. 使用volatile关键字：volatile关键字用于修饰变量，可以确保变量的可见性和禁止指令重排序。使用volatile关键字修饰的变量在多线程环境下可以保证线程安全

private volatile int count = 0;

java线程池用过没有怎么使用，常用配置与那些

线程池是一种用于管理和复用线程的机制。以下是使用Java线程池的常见配置和使用方法：

1. 创建线程池：可以使用Executors类提供的静态方法来创建线程池。常见的创建方法有newFixedThreadPool、newCachedThreadPool和newScheduledThreadPool。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

// 创建固定大小的线程池
ExecutorService executor = Executors.newFixedThreadPool(5);

// 创建可缓存的线程池
ExecutorService executor = Executors.newCachedThreadPool();

// 创建定时任务线程池
ExecutorService executor = Executors.newScheduledThreadPool(5);

2. 提交任务：使用线程池的execute方法或submit方法来提交任务。execute方法用于提交不需要返回结果的任务，submit方法用于提交需要返回结果的任务。

executor.execute(new Runnable() {
    public void run() {
        // 任务逻辑
    }
});

Future<String> future = executor.submit(new Callable<String>() {
    public String call() throws Exception {
        // 任务逻辑
        return "result";
    }
});

3. 配置线程池：可以通过ThreadPoolExecutor类的构造方法或set方法来配置线程池的参数，如核心线程数、最大线程数、线程空闲时间等。

import java.util.concurrent.ThreadPoolExecutor;

ThreadPoolExecutor executor = new ThreadPoolExecutor(
    5, // 核心线程数
    10, // 最大线程数
    60, // 线程空闲时间
    TimeUnit.SECONDS, // 时间单位
    new LinkedBlockingQueue<Runnable>() // 任务队列
);

4. 关闭线程池：在不再需要使用线程池时，应该调用shutdown方法来关闭线程池。这会等待所有任务执行完毕后关闭线程池。

executor.shutdown();

count* 和count1 和count字段的区别

1. count(*)会统计表中所有的行数,包括NULL值。2. count(列名)会统计该列非NULL的值的个数。例如表中有一列数据:

sql
id   num
1    10
2    20
3    NULL

那么:- count(*):会返回3,包含所有的行数。
- count(num):会返回2,不包含num列为NULL的行。count(1)与count(*)作用相同,都会统计所有的行数。count(字段)在统计时会忽略NULL值,因此count(*)或count(1)通常被用于统计行数,而count(列名)用于统计该列非空值的个数。需要注意的是, count(列名)在该列为NULL时可能会影响查询优化器生成执行计划,可能会额外增加文件排序等操作,因此当仅仅需要统计行数时,推荐使用count(*)或count(1)。

ddl和ttl是什么

- ddl代表数据定义语言（Data Definition Language），用于定义数据库的结构，包括创建表、修改表结构、删除表等操作。常见的ddl语句包括CREATE TABLE、ALTER TABLE和DROP TABLE等。

- ttl代表生存时间（Time to Live），用于设置数据在数据库中的存活时间。当数据的生存时间超过设定的时间后，数据库会自动删除该数据。ttl通常用于缓存和日志等场景，可以有效控制数据的存储时间和释放资源。