知识汲取者
知识汲取者

【源码篇】ThreadLocal源码解析（主打的就是通俗易懂，言简意赅）

文章目录

  • ThreadLocal学习笔记
    • 前言
    • 1、TheadLocal基本介绍
    • 2、ThreadLocal基本使用
    • 3、体验ThreadLocal的优点
      • 3.1 ThreadLocal与synchronized的比较
      • 3.2、ThreadLoca的应用场景
    • 4、ThreadLocal的内部原理
      • 4.1 ThreadLocal内部结构
      • 4.2 ThreadLocal常用方法分析
        • 4.2.1 set原理分析
        • 4.2.2 get原理分析
        • 4.2.3 remove原理分析
      • 4.3 ThreadLocalMap源码分析
        • 4.3.1 ThreadLocal基本结构
    • 5、ThreadLocal存在的问题
      • 5.1 内存泄漏问题
      • 5.2 Hash冲突问题
    • 相关面试题

ThreadLocal学习笔记

前言

本文主要是对ThreadLocal的源码进行解析，从而在面对面试官提问ThreadLoca相关方面的问题时，更加有底气一点，因为很多面试题光死记硬背心中会有疑惑，同时记得不够劳，所以这里我选择花点时间阅读一下ThreadLocal的源码，从而对ThreadLocal有更加深刻的了解，从目录也可以看出本文的内容大致是讲什么（主要有set、get、remove三个常用方法的源码解析，以及ThreadLocal常见的问题内存泄露问题、Hash冲突问题、同时相关面试题也被我整理在另外一个20w字的.md文档，想要的可以评论区回复666即可领取），关于特别深层次的东西我暂且没有深究，毕竟我还是一个菜鸟小白，等以后工作之后再抽空慢慢研究

1、TheadLocal基本介绍

  • 什么是ThreadLocal?

    • Java官方文档中的描述：ThreadLocal类用来提供线程内部的局部变量，这些局部变量在多线程下访问（通过get\set方法访问）时，能够保障各个线程的变量相对独立与其它线程内的局部变量，ThreadLocal实例通常来说都是private state 类型的，用于关联线程和线程上下文
    • 我的理解：ThreadLocal相当于是一个容器，每一个线程都有与之对应的ThreadLocal容器，就类似于Session一样，可以用来存储数据，同时每个容器都相互隔离、互不影响

  • ThreadLocal是用来干什么的？

    • 提供线程内部的局部变量，减少同一个线程内多个函数或组件之间一些公共变量传递的复杂度

  • ThreadLocal的适用场景有哪些？

    • 数据库连接管理：在多线程环境中，每个线程需要独立地获取数据库连接，使用 ThreadLocal 可以避免线程之间的连接共享和线程安全问题。
    • 用户身份认证：在 Web 应用中，每个用户需要进行身份认证，使用 ThreadLocal 可以将用户身份信息存储在 ThreadLocal 中，确保用户身份信息在线程中独立存在，并且不会被其他线程访问到。（这个很常用）
    • 事务管理：在多线程环境中，事务管理可能会存在线程安全问题，使用 ThreadLocal 可以将事务信息存储在 ThreadLocal 中，确保每个线程之间的事务互不干扰。
    • 线程安全工具类：在某些情况下，我们需要使用线程安全的工具类，例如 SimpleDateFormat 和 Random 等，但这些工具类本身并不是线程安全的。使用 ThreadLocal 可以将这些非线程安全的工具类变为线程安全的。
    • 线程上下文信息传递：在多线程环境中，有时需要将某些信息从一个线程传递到另一个线程，使用 ThreadLocal 可以将信息存储在 ThreadLocal 中，然后在另一个线程中获取这些信息。

    Spring的事务隔离就是使用ThreadLocal+AOP来解决的；线程池+ThreadLocal解决SimpleDateFormat线程安全问题

  • 如何使用ThreadLocal？

    主要是调用ThreadLocal的get和set方法，set方法将数据存储到ThreadLocal中，然后get获取当前线程绑定的ThreadLocal中对应的数据

知识拓展：线程上下文

线程上下文（Thread Context）是指在一个线程中执行代码时，该线程所拥有的所有上下文信息，包括线程的状态、线程的优先级、线程的堆栈信息、线程的局部变量、线程的环境变量等。线程上下文可以影响线程的行为和执行结果。

  • 线程上下文的分类：
    • 线程状态上下文：包括线程的状态（如 NEW、RUNNABLE、BLOCKED、WAITING、TIMED_WAITING 和 TERMINATED 等）和优先级。
    • 线程堆栈上下文：包括线程的堆栈信息，如栈帧、方法调用链等。
    • 线程局部变量上下文：包括线程的局部变量、参数等信息。
    • 线程环境变量上下文：包括线程的环境变量、系统属性等信息。
  • 线程上下文的作用：
    • 传递参数：可以在一个线程中的方法之间传递参数，而不需要将参数显式地传递给每个方法。
    • 状态保存：可以保存线程的状态和执行上下文，以便在需要时恢复线程的执行状态。
    • 线程隔离：可以将线程的数据隔离开来，避免多个线程之间的数据共享和竞争。
    • 环境隔离：可以将线程的环境变量和系统属性隔离开来，避免对全局环境造成影响。
    • 调试支持：可以在调试时查看线程的状态和执行上下文，帮助定位问题。

2、ThreadLocal基本使用

  • ThreadLocal中的常用API

    API 描述
    ThreadLocal() ThreadLocal函数的构造方法，用于创建ThreadLocal对象
    public void set(T value) 设置当前线程中绑定的局部变量
    public T get() 获取当前线程中绑定的局部变量
    public void remove() 移除当前线程中绑定的局部变量

实例一：

不使用ThreadLocal，在多线程情况下进行存取变量

public class MyDemo01 {

    private String content;
    private String getContent(){
        return content;
    }
    private void setContent(String content){
        this.content = content;
    }

    public static void main(String[] args) {
        MyDemo01 demo = new MyDemo01();
        demo.setContent(Thread.currentThread().getName()+"的数据");
        System.out.println(Thread.currentThread().getName() + "===>" + demo.getContent());
        for (int i = 0; i < 5; i++) {
            Thread thread = new Thread(new Runnable() {
                @Override
                public void run() {
                    // 存数据
                    demo.setContent(Thread.currentThread().getName() + "的数据");
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    // 取数据
                    System.out.println(Thread.currentThread().getName()+ "===>" + demo.getContent());
                }
            });
            thread.setName("线程"+i);
            thread.start();
        }
    }
}

结果展示：

可以发现多线程先，一个线程存数据，一个线程取数据，同一个线程并不能百分百拿到它原本存进去的数据

【源码篇】ThreadLocal源码解析（主打的就是通俗易懂，言简意赅）_第1张图片

备注：由于线程存在随机性，当所有线程都拿到自己存的数据，纯属巧合，可以多试几次才能出现不同的情况

上面代码的运行图如下所示（可能有点抽象）：

【源码篇】ThreadLocal源码解析（主打的就是通俗易懂，言简意赅）_第2张图片

实例二：

使用ThreadLocal在多线程下存取变量

public class MyDemo02 {
    private ThreadLocal<String> threadLocal = new ThreadLocal<>();

    private String content;

    private String getContent() {
        return threadLocal.get();
    }

    private void setContent(String content) {
        threadLocal.set(content);
    }

    public static void main(String[] args) {
        MyDemo02 demo = new MyDemo02();
        demo.setContent(Thread.currentThread().getName()+"的数据");
        System.out.println(Thread.currentThread().getName() + "===>" + demo.getContent());
        for (int i = 0; i < 5; i++) {
            Thread thread = new Thread(new Runnable() {
                @Override
                public void run() {
                    // 存数据
                   demo.setContent(Thread.currentThread().getName() + "的数据");
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    // 取数据
                    System.out.println(Thread.currentThread().getName() + "===>" + demo.getContent());
                }
            });
            thread.setName("线程" + i);
            thread.start();
        }
    }
}

【源码篇】ThreadLocal源码解析（主打的就是通俗易懂，言简意赅）_第3张图片

上面代码运行示意图如下所示：

【源码篇】ThreadLocal源码解析（主打的就是通俗易懂，言简意赅）_第4张图片

3、体验ThreadLocal的优点

3.1 ThreadLocal与synchronized的比较

  • 作用不同：synchronized主要是针对对象或者类的，主要是防止多个线程同时执行一个代码块产生的问题；ThreadLocal主要针对变量的，主要是防止共享变量在多线程下产生的安全问题
  • 机制不同：synchronized 是采用锁（互斥锁）的机制，保证一次只有一个线程执行代码，在前一个线程执行代码期间其他线程都处于等待状态
synchronized ThreadLocal
原理 同步机制采用“以时间换空间”的方式，只提供了一份变量，让不同的线程排队访问 采用了“以空间换时间”的方式，为每一个线程提供一份变量的副本，从而实现同时访问互不干扰
侧重点 多个线程之间访问资源的同步 多线程中让每个线程之间的数据互相隔离

示例

示例一：

不使用ThreadLocal，在多线程下存取变量

/**
 * @author ghp
 * @date 2023/2/11
 * @title 不使用ThreadLocal存取变量
 * @description
 */
public class MyDemo01 {

    private String content;

    private String getContent() {
        return content;
    }

    private void setContent(String content) {
        this.content = content;
    }

    public static void main(String[] args) {
        MyDemo01 demo = new MyDemo01();
        demo.setContent(Thread.currentThread().getName() + "的数据");
        System.out.println(Thread.currentThread().getName() + "===>" + demo.getContent());
        for (int i = 0; i < 5; i++) {
            Thread thread = new Thread(new Runnable() {
                @Override
                public void run() {
                    // 存数据
                    demo.setContent(Thread.currentThread().getName() + "的数据");
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    // 取数据
                    System.out.println(Thread.currentThread().getName() + "===>" + demo.getContent());
                }
            });
            thread.setName("线程" + i);
            thread.start();
        }
    }
}

【源码篇】ThreadLocal源码解析（主打的就是通俗易懂，言简意赅）_第5张图片

示例二：

使用ThreadLocal，在多线程下存取变量

/**
 * @author ghp
 * @date 2023/2/12
 * @title 使用ThreadLocal存取变量
 * @description
 */
public class MyDemo02 {
    private ThreadLocal<String> threadLocal = new ThreadLocal<>();

    private String content;

    private String getContent() {
        return threadLocal.get();
    }

    private void setContent(String content) {
        threadLocal.set(content);
    }

    public static void main(String[] args) {
        MyDemo02 demo = new MyDemo02();
        demo.setContent(Thread.currentThread().getName()+"的数据");
        System.out.println(Thread.currentThread().getName() + "===>" + demo.getContent());
        for (int i = 0; i < 5; i++) {
            Thread thread = new Thread(new Runnable() {
                @Override
                public void run() {
                    // 存数据
                   demo.setContent(Thread.currentThread().getName() + "的数据");
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    // 取数据
                    System.out.println(Thread.currentThread().getName() + "===>" + demo.getContent());
                }
            });
            thread.setName("线程" + i);
            thread.start();
        }
    }
}

【源码篇】ThreadLocal源码解析（主打的就是通俗易懂，言简意赅）_第6张图片

示例三：

使用 synchronized 在多线程下存取变量

/**
 * @author ghp
 * @date 2023/2/12
 * @title 使用synchronized锁
 * @description
 */
public class MyDemo03 {

    private String content;

    private String getContent() {
        return this.content;
    }

    private void setContent(String content) {
        this.content = content;
    }

    public static void main(String[] args) {
        MyDemo03 demo = new MyDemo03();
        demo.setContent(Thread.currentThread().getName()+"的数据");
        System.out.println(Thread.currentThread().getName() + "===>" + demo.getContent());
        for (int i = 0; i < 5; i++) {
            Thread thread = new Thread(new Runnable() {
                @Override
                public void run() {
                    synchronized (MyDemo03.class){
                        // 存数据
                        demo.setContent(Thread.currentThread().getName() + "的数据");
                        try {
                            Thread.sleep(100);
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                        // 取数据
                        System.out.println(Thread.currentThread().getName() + "===>" + demo.getContent());
                    }
                }
            });
            thread.setName("线程" + i);
            thread.start();
        }
    }
}

【源码篇】ThreadLocal源码解析（主打的就是通俗易懂，言简意赅）_第7张图片

3.2、ThreadLoca的应用场景

本小节演示使用ThreadLocal解决单一数据库连接，SimpleDateFormat线程不安全问题，多参数传递问题

示例

示例一：使用ThreadLocal保障Service和Dao层的连接对象一致

场景：在进行购买书籍时，我们需要先查询库存，判断库存是否充足，库存充足则用户余额扣除，然后书的数量-1。

这一过程涉及到两个两张表的操作，tb_user 和 tb_book，在进行两张表的SQL操作时，我们需要引入事务，但是引入事务，想要事务生效我们需要保障：

  1. service层和DAO层的连接对象保持一致
  2. 每个线程的连接对象前后需保持一致

常见的解决方案：

  1. 加锁：将数据库连接对象锁住

    优点：实现简单；缺点：性能较低

  2. 注入：将service层的连接对象直接注入到dao层（这个方法很常见）

    优点：实现简单；缺点：提高了代码的耦合性，降低了程序的性能

  3. 线程隔离连接对象：使用ThreadLocal存储连接对象

    数据传递：保证每一个线程绑定的数据，在需要的地方直接获取，减少了代码的耦合性

    线程隔离：各个线程之间的数据相互隔离，又具备并发性，避免同步带来的性能损耗

示例二：使用ThreadLocal解决SimpleDateFormat线程安全

场景：在多线程下，调用SimpleDateFormat的prase方法对字符串进行日期格式化（这个场景很常见）

import java.text.ParseException;
import java.text.SimpleDateFormat;

/**
 * @author ghp
 * @date 2023/4/12
 * @title
 * @description 测试SimpleDateFormat是否线程安全
 */
public class MyDemo04 {
    private static SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");

    public static void main(String[] args) {
        // 创建10个线程，每个线程都调用SimpleDateFormat对字符串进行日期格式化
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                dateFormat();
            }).start();
        }
    }

    /**
     * 将字符串解析为日期
     */
    private static void dateFormat() {
        try {
            String date = simpleDateFormat.parse("2023-4-5").toString();
            System.out.println("date = " + date);
        } catch (ParseException e) {
            throw new RuntimeException(e);
        }
    }
}

直接报错：

【源码篇】ThreadLocal源码解析（主打的就是通俗易懂，言简意赅）_第8张图片

  • 报错原因

    当我们使用SimpleDateFormat的parse()方法时，parse()方法会先调用calendar.clear()方法，然后调用Calendar.add()方法，如果一个线程先调用了add()方法，然后另一个线程调用了clear()方法，这个时候 parse()就会报错。所以说==SimpleDateFormat是线程不安全的==

  • 解决方法：使用ThreadLocal+线程池

    import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @author ghp
 * @date 2023/4/12
 * @title
 * @description 使用 ThreadLocal 解决 SimpleDateFormat 线程不安全问题
 */
public class MyDemo05 {

    private static ThreadLocal<SimpleDateFormat> threadLocal =
            new ThreadLocal<SimpleDateFormat>(){
                @Override
                protected SimpleDateFormat initialValue() {
                    return new SimpleDateFormat("yyyy-MM-dd");
                }
            };

    private static final ExecutorService executorService = Executors.newFixedThreadPool(10);

    public static void main(String[] args) {
        // 调用线程池，每个线程都调用SimpleDateFormat对字符串进行日期格式化
        for (int i = 0; i < 10; i++) {
            executorService.execute(()->{
                dateFormat();
            });
        }
        // 关闭线程池
        executorService.shutdown();
    }

    /**
     * 将字符串解析为日期
     */
    private static void dateFormat() {
        try {
            String date = threadLocal.get().parse("2023-4-5").toString();
            System.out.println("date = " + date);
        } catch (ParseException e) {
            throw new RuntimeException(e);
        }
    }

}

    这里还提供另一种方法，直接不用SimpleDateFormat，改用 Java8 提供的DateTimeFormatter进行日期的格式化，如下所示：

    import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

/**
 * @author ghp
 * @date 2023/4/12
 * @title
 * @description 测试 Java8 提供的 DateTimeFormatter 是否线程安全
 */
public class MyDemo06 {

    private static final DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");

    public static void main(String[] args) {
        final int threadCount = 1000;
        // 创建10个线程，每个线程都调用 LocalDateTime 对字符串进行日期格式化
        for (int i = 0; i < threadCount; i++) {
            new Thread(()->{
                dateFormat();
            }).start();
        }
    }

    /**
     * 将字符串解析为日期
     */
    private static void dateFormat() {
        String date = LocalDateTime.parse("2020-03-30 08:08:08", dateTimeFormatter).toString();
        System.out.println("date = " + date);
    }

}

    ==注意：==LocalDateTime直接解析 yyyy-MM-dd 格式的日期，会直接报错，具体解决方法这里不作过多解释，详情请参考这篇文章：关于yyyy-MM-dd格式日期字符串,解析成LocalDateTime遇到的问题

示例三：使用ThreadLocal解决过度传参

场景：一个方法要调用好多个方法，并且每一个方法都要传递参数

不使用ThreadLocal：

/**
 * @author ghp
 * @date 2023/4/12
 * @title
 * @description 使用ThreadLocal解决过度传参
 */
public class MyDemo07 {

    void A(User user){
        getInfo(user);
        checkInfo(user);
        log(user);
        ....
    }

    private void log(User user) {
        ...
    }

    private void checkInfo(User user) {
        ...
    }

    private void getInfo(User user) {
        ...
    }
}

使用ThreadLocal：

/**
 * @author ghp
 * @date 2023/4/12
 * @title
 * @description 使用ThreadLocal解决过度传参
 */
public class MyDemo07 {

    private static ThreadLocal<User> threadLocal = new ThreadLocal<>();

    void A(User user){
        threadLocal.set(user);
        getInfo();
        checkInfo();
        log();
        ....
    }

    private void log() {
        User user = threadLocal.get();
        ...
    }

    private void checkInfo() {
        User user = threadLocal.get();
        ...
    }

    private void getInfo() {
        User user = threadLocal.get();
        ...
    }
}

使用ThreadLocal后，能够有效降低层与层之间的耦合，比如我们在登录时，我们可以直接将登录的用户信息存入ThreadLocal中，这样其它层要使用ThreadLocal，可以直接通过ThreadLocal获取，一来降低了层与层之间的代码耦合，二来也保障了线程安全

4、ThreadLocal的内部原理

4.1 ThreadLocal内部结构

  • 早期的ThreadLocal（JDK1.8以前）：每一个ThreadLocal都创建一个Map，然后使用Thread作为Map的key，要存储的局部变量作为Map的value

    【源码篇】ThreadLocal源码解析（主打的就是通俗易懂，言简意赅）_第9张图片

  • JDK1.8中的ThreadLocal：每一个ThreadLocal都维护一个ThreadLocalMap，然后使用ThreadLocal的实例对象作为Map的key，以一个Object对象作为Map的value。具体过程如下所示：

    1）每一个Thread线程内部都有一个Map（ThreadLocalMap）

    2）Map里面存储的ThreadLocal对象（key）和线程的变量副本（value）

    3）Thread内部的Map有ThreadLocal维护，ThreadLocalMap中变量副本的存取有ThreadLocal实例对象操作

    4）对于不同的线程，每次获取变量副本，别的线程都不能获取当前线程的变量副本，每个变量副本都形成了隔离

    【源码篇】ThreadLocal源码解析（主打的就是通俗易懂，言简意赅）_第10张图片

  • JDk1.8中ThreadLocal设计相较于早期ThreadLocal设计的好处：

    • 内存优化，每一个Map存储的Entry数量都变少了。因为早期ThreadLocalMap中Entry的数量取决于线程的数量，每一个线程都有与之对应的Entry；而JDK1.8中Entry的数量取决于ThreadLocal的数量，一个ThreadLocal对应一个Entry
    • GC优化，早期Thead销毁，ThreadLocalMap对象仍有可能会存在，但在JDk1.8中当Thread销毁时，ThreadLocalMap也会随之销毁，从而减少了内存的使用
    • 数据结构优化：在 JDK 8 中，ThreadLocal 引入了一个名为 InternalThreadLocalMap 的类来存储线程的局部变量副本。这种改变提高了对局部变量的访问效率。由于 InternalThreadLocalMap 使用开放寻址法解决哈希冲突，并且引入了数组长度和 size 字段，相较于之前的版本，使得 ThreadLocal 在并发环境下的性能得到了明显的提升。

4.2 ThreadLocal常用方法分析

方法声明 描述
protected T initialValue() 返回当前线程局部变量的初始值
public void set( T value) 设置当前线程绑定的局部变量
public T get() 获取当前线程绑定的局部变量
public void remove() 移除当前线程绑定的局部变量

4.2.1 set原理分析

  • set

    set方法执行流程：

    获取当前线程
    获取当前线程对应的ThreadLocalMap对象
    将传入的值存入Entry中
    key为当前线程对应的ThreadLocal
    value为存入的值

    A. 首先获取当前线程

    B. 然后获取与当前线程绑定的Map

    C. Map不为空，直接设置当前的值，key为ThreadLocal，value为传入的值

    D. Map为空，创建应该Map，然后设置值

        /**
     * 设置当前线程对应的ThreadLocal的值
     
     * @param value 将要保存到当前线程对应ThreadLocal中的值
     */
    public void set(T value) {
        // 获取当前线程
        Thread t = Thread.currentThread();
        // 获取当前线程对应ThreadLocalMap对象
        ThreadLocalMap map = getMap(t);
        if (map != null)
            // map存在就设置值
            map.set(this, value);
        else
            // map不存在，就创建map然后设置值
            createMap(t, value);
    }

    /**
     * 获取当前线程Thread对应维护的ThreadLocalMap对象
     
     * @param t 当前线程
     * @return 当前线程对应维护的ThreadLocalMap对象
     */
    ThreadLocal.ThreadLocalMap getMap(Thread t) {
        // threadLocals是Thread对应的一个成员变量
        return t.threadLocals;
    }

    /**
     * 为当前线程创建一个ThreadLocalMap对象
     * @param t 当前线程
     * @param firstValue 将要保存到当前线程对应ThreadLocal中的值
     */
    void createMap(Thread t, T firstValue) {
// 这里的this，表示调用ThreadLocalMap()方法的ThreadLocal对象（也就是现在new出来的这个ThreadLocal对象）
        t.threadLocals = new ThreadLocal.ThreadLocalMap(this, firstValue);
    }

    ThreadLocalMap的构造方法：

            ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
            // 初始化一个Entry
            table = new Entry[INITIAL_CAPACITY];
            // 计算key应该存在的位置
            int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
            // 将Entry放到指定的位置
            table[i] = new Entry(firstKey, firstValue);
            size = 1;
            // 设置数组大小 16*2/3=10，类似于HashMap中的 0.75*16=12
            setThreshold(INITIAL_CAPACITY);
        }

4.2.2 get原理分析

  • get

    get方法执行流程：

    获取当前线程
    获取当前线程对应的ThreadLocalMap
    获取ThreadLocalMap中的Entry

    ​ A. 首先获取当前线程，并根据当前线程获取一个Map

    ​ B. 如果获取的Map不为空，则将参数设置到Map中（当前ThreadLocal的引用作为key）

    ​ C. 如果Map为空，则给该线程创建 Map，并设置初始值

        /**
     * 获取当前线程存入ThreadLocal中的值
     
     * @return value
     */
	public T get() {
        // 获取当前线程
        Thread t = Thread.currentThread();
        // 获取当前线程对应的ThreadLocal
        ThreadLocalMap map = getMap(t);
        if (map != null) {
            // 获取Entry
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null) {
                // 如果Entry不为空，直接返回当前线程存入的值
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }
        // ThreadLocalMap为空
        /*
        	初始化 : 有两种情况有执行当前代码
        	第一种情况: map不存在，表示此线程没有维护的ThreadLocalMap对象
        	第二种情况: map存在, 但是没有与当前ThreadLocal关联的entry
         */
        return setInitialValue();
    }


    /**
     * 初始化
     *
     * @return the initial value 初始化后的值
     */
    private T setInitialValue() {
        // 调用initialValue获取初始化的值
        // 此方法可以被子类重写, 如果不重写默认返回null
        T value = initialValue();
        // 获取当前线程对象
        Thread t = Thread.currentThread();
        // 获取此线程对象中维护的ThreadLocalMap对象
        ThreadLocalMap map = getMap(t);
        // 判断map是否存在
        if (map != null)
            // 存在则调用map.set设置此实体entry
            map.set(this, value);
        else
            // 1）当前线程Thread 不存在ThreadLocalMap对象
            // 2）则调用createMap进行ThreadLocalMap对象的初始化
            // 3）并将 t(当前线程)和value(t对应的值)作为第一个entry存放至ThreadLocalMap中
            createMap(t, value);
        // 返回设置的值value
        return value;
    }

    initialValue方法源码：

    ​ A. 首先获取当前线程，并根据当前线程获取一个Map

    ​ B. 如果获取的Map不为空，则移除当前ThreadLocal对象对应的entry

     	/**
     * 删除当前线程中保存的ThreadLocal对应的实体entry
     */
     public void remove() {
        // 获取当前线程对象中维护的ThreadLocalMap对象
         ThreadLocalMap m = getMap(Thread.currentThread());
        // 如果此map存在
         if (m != null)
            // 存在则调用map.remove
            // 以当前ThreadLocal为key删除对应的实体entry
             m.remove(this);
     }

4.2.3 remove原理分析

​ A. 首先获取当前线程，并根据当前线程获取一个Map

​ B. 如果获取的Map不为空，则移除当前ThreadLocal对象对应的entry

 /**
     * 删除当前线程中保存的ThreadLocal对应的实体entry
     */
     public void remove() {
        // 获取当前线程对象中维护的ThreadLocalMap对象
         ThreadLocalMap m = getMap(Thread.currentThread());
        // 如果此map存在
         if (m != null)
            // 存在则调用map.remove
            // 以当前ThreadLocal为key删除对应的实体entry
             m.remove(this);
     }

此方法的作用是 返回该线程局部变量的初始值。

（1） 这个方法是一个延迟调用方法，从上面的代码我们得知，在set方法还未调用而先调用了get方法时才执行，并且仅执行1次。

（2）这个方法缺省实现直接返回一个null。

（3）如果想要一个除null之外的初始值，可以重写此方法。（备注： 该方法是一个protected的方法，显然是为了让子类覆盖而设计的）

4.3 ThreadLocalMap源码分析

ThreadLocalMap是ThreadLocal的内部类，没有实现Map接口，用独立的方式实现了Map的功能，其内部的Entry也是独立实现

【源码篇】ThreadLocal源码解析（主打的就是通俗易懂，言简意赅）_第11张图片

4.3.1 ThreadLocal基本结构

Alt+7可以查看到ThreadLocal的内部结构

【源码篇】ThreadLocal源码解析（主打的就是通俗易懂，言简意赅）_第12张图片

  • 成员变量：

    跟HashMap类似，INITIAL_CAPACITY代表这个Map的初始容量；table 是一个Entry 类型的数组，用于存储数据；size 代表表中的存储数目； threshold 代表需要扩容时对应 size 的阈值

        /**
     * 初始容量 —— 必须是2的整次幂
     */
    private static final int INITIAL_CAPACITY = 16;

    /**
     * 存放数据的table，Entry类的定义在下面分析
     * 同样，数组长度必须是2的整次幂。
     */
    private Entry[] table;

    /**
     * 数组里面entrys的个数，可以用于判断table当前使用量是否超过阈值。
     */
    private int size = 0;

    /**
     * 进行扩容的阈值，表使用量大于它的时候进行扩容。
     */
    private int threshold; // Default to 0

  • 存储结构：

    在ThreadLocalMap中，也是用Entry来保存K-V结构数据的。不过Entry中的key只能是ThreadLocal对象，这点在构造方法中已经限定死了。另外，Entry继承WeakReference，也就是key（ThreadLocal）是弱引用，其目的是将ThreadLocal对象的生命周期和线程生命周期解绑。

    /*
 * Entry继承WeakReference，并且用ThreadLocal作为key.
 * 如果key为null(entry.get() == null)，意味着key不再被引用，
 * 因此这时候entry也可以从table中清除。
 */
static class Entry extends WeakReference<ThreadLocal<?>> {
    /** The value associated with this ThreadLocal. */
    Object value;

    Entry(ThreadLocal<?> k, Object v) {
        super(k);
        value = v;
    }
}

    在ThreadLocalMap中，也是用Entry来保存K-V结构数据的。不过Entry中的key只能是ThreadLocal对象，这点在构造方法中已经限定死了。另外，Entry继承WeakReference，也就是key（ThreadLocal）是弱引用，其目的是将ThreadLocal对象的生命周期和线程生命周期解绑。

5、ThreadLocal存在的问题

5.1 内存泄漏问题

有些程序员在使用 ThreadLocal 的过程中会发现有内存泄漏的情况发生，就猜测这个内存泄漏跟 Entry 中使用了弱引用的key有关系。这个理解其实是不对的。我们先来回顾这个问题中涉及的几个名词概念，再来分析问题。

  • 区分内存溢出和内存泄露两个概念

    • Memory overflow：内存溢出，是指没有足够的内存提供申请者使用。

    • Memory leak：内存泄漏，是指程序中己动态分配的堆内存由于某种原因程序未释放或无法释放，造成系统内存的浪费，导致程序运行速度减慢甚至系统崩溃等严重后果。内存泄漏的堆积终将导致内存溢出。

      常见导致内存泄露的原因有：程序中存在错误的对象引用处理、资源未正确关闭或释放等问题

    总结：内存溢出是申请分配的内存超过了当前系统最大内存限制，内存泄露是指已分配的内存得不到及时的释放导致内存逐渐增加，最终影响系统性能甚至导致系统崩溃

  • 弱引用相关概念、

    Java中的引用有4种类型： 强、软、弱、虚，强引用是默认的引用类型，不会被垃圾回收；软引用在内存不足时可能被回收；弱引用在垃圾回收时会被回收；虚引用几乎没有实际用途，主要用于跟踪对象被垃圾回收的活动。

    • 强引用（Strong Reference）：

      • 强引用是默认的引用类型，在代码中直接使用对象时，就是强引用。

      • 强引用指向的对象不会被垃圾回收器回收，即使内存不足时也不会进行回收。

      • 只有当没有任何强引用指向一个对象时，该对象才会被判定为可回收，且可能在之后被垃圾回收器回收。

    • 软引用（Soft Reference）：

      • 软引用用于描述一些还有用但非必需的对象。

      • 当内存不足时，垃圾回收器会根据软引用来决定是否回收对象。

      • 只有当垃圾回收器认为内存不足时，才会回收软引用指向的对象。

    • 弱引用（Weak Reference）：

      • 弱引用用于描述非必需的对象。

      • 当垃圾回收器进行垃圾回收时，无论内存是否充足，都会回收弱引用指向的对象。

      • 弱引用通常用于实现缓存或者观察者模式等场景。

    • 虚引用（Phantom Reference）：

      • 虚引用是最弱的一种引用关系，几乎没有实际用途。

      • 虚引用的主要作用是跟踪对象被垃圾回收的活动。

      • 虚引用必须与引用队列（ReferenceQueue）联合使用，当对象被垃圾回收时会被放入引用队列中。

当前ThreadLocal内存泄露这个问题主要涉及到强引用和弱引用

  • 如果 Entry 的 key 使用了强引用，会出现内存泄漏吗？我们来分析看看

    此时ThreadLocal的内存图（实线表示强引用，虚线表示弱引用）如下：

    【源码篇】ThreadLocal源码解析（主打的就是通俗易懂，言简意赅）_第13张图片

    1. 假设在业务代码中使用完 ThreadLocal ，ThreadLocal Ref被回收了。
    2. 但是因为 ThreadLocalMap 的 Entry 强引用了 ThreadLocal，造成 ThreadLocal 无法被回收。
    3. 在没有手动删除这个 Entry 以及 CurrentThread 依然运行的前提下，始终有强引用链 ThreadRef→CurrentThread→ThreadLocalMap→Entry ，Entry就不会被回收（Entry中包括了ThreadLocal实例和value），导致Entry内存泄漏。
    4. 也就是说，ThreadLocalMap中的key使用了强引用， 是无法完全避免内存泄漏的。

  • 那么ThreadLocalMap 中的 key 使用了弱引用，会出现内存泄漏吗？同样的我们来分析一下

    此时ThreadLocal的内存图（实线表示强引用，虚线表示弱引用）如下：

    【源码篇】ThreadLocal源码解析（主打的就是通俗易懂，言简意赅）_第14张图片

    1. 同样假设在业务代码中使用完 ThreadLocal ，ThreadLocal Ref被回收了。

    2. 由于ThreadLocalMap只持有ThreadLocal的弱引用，没有任何强引用指向 Threadlocal 实例, 所以 Threadlocal 就可以顺利被 GC 回收，此时 Entry 中的key=null。

    3. 但是在没有手动删除这个 Entry 以及 CurrentThread 依然运行的前提下，也存在有强引用链

      Thread Ref→CurrentThread→ThreadLocalMap→Entry，Entry就不会被回收，此时Entry中的key也就是ThreadLocal已经被GC了，但是 value 由于强引用链的存在没有被回收，所以依然会导致Entry内存泄漏。

    4. 也就是说，ThreadLocalMap中的 key 使用了弱引用， 也有可能内存泄漏。

  • 比较以上两种情况，我们就会发现，内存泄漏的发生跟ThreadLocalMap中的 key 是否使用弱引用是没有关系的。那么内存泄漏的的真正原因是什么呢？

    其实不难看出，在以上两种内存泄漏的情况中，都有两个前提：

    1. 没有手动删除这个Entry
    2. CurrentThread依然运行

    这两个前提的存在，会使得 Thread Ref→CurrentThread→ThreadLocalMap→Entry 这条强引用链一直存在，从而导致出现内存泄露，那么我们该如何较好的避免出现内存泄露问题呢？

    1. 针对第一点，只要在使用完ThreadLocal，调用其remove方法删除对应的Entry，就能避免内存泄漏；

    2. 针对第二点，由于ThreadLocalMap是Thread的一个属性，被当前线程所引用，所以它的生命周期跟Thread一样长。那么在使用完 ThreadLocal 的使用，如果当前 Thread 也随之执行结束，ThreadLocalMap自然也会被 GC 回收，从根源上避免了内存泄漏

    综上，导致ThreadLocal发生内存泄露的原因有两个：

    1. 使用完ThreadLocal后没有手动删除对应key
    2. ThreadLocalMap的生命周期跟Thread一样长

    针对第二条，我们没有更好的处理方案，特别是在使用线程池时，线程使用完不会直接被销毁也就是说CurrentThread会一直存在，但是ThreadLocal的创造者提供了一个解决方案（不能说解决，只能说降低内存泄露的概率）：ThreadLocalMap使用弱引用，key为null时调用set/getEntry方法会自动将value置为null。

    为什么这样能够降低内存泄露的概率呢？在 ThreadLocalMap 中的 set/getEntry 方法中，会对key为null（也即是ThreadLocal为null）进行判断，如果为null的话，那么是会对value置为null的。这就意味着使用完 ThreadLocal，CurrentThread依然运行的前提下，就算忘记调用 remove 方法，弱引用比强引用可以多一层保障：弱引用的 ThreadLocal 会被回收，对应的value在下一次ThreadLocalMap调用 set、get、remove中的任一方法的时候会被清除，从而大概率避免内存泄漏。

5.2 Hash冲突问题

  • 什么是Hash冲突？

    哈希冲突（Hash Collision）是指不同的输入数据经过哈希函数计算后得到相同的哈希值。哈希函数将输入数据映射到一个固定大小的哈希值，而在实际情况下，输入数据的数量通常远大于哈希值的范围，这就导致了可能存在多个不同的输入数据具有相同的哈希值。

  • 常见解决Hash冲突的方案有：

    • 链地址法（Chaining）：使用链表或者其他数据结构，在哈希冲突的位置上存储一个链表，将冲突的元素链接在一起。
    • 开放地址法（Open Addressing）：在发生哈希冲突时，通过探测序列的方式，尝试找到下一个可用的空槽位来存储冲突的元素。
    • 再哈希法（Rehashing）：当发生冲突时，使用另外一个哈希函数再次计算哈希值，直到找到一个空槽位来存储冲突的元素。
    • 建立更好的哈希函数：通过设计更好的哈希函数，降低哈希冲突的概率，使得哈希值的分布更加均匀。

hash冲突的解决是Map中的一个重要内容。我们以hash冲突的解决为线索，来研究一下ThreadLocalMap的核心源码

1）从 ThreadLocal 的 set 方法的源码作为入口，一步一步的深入探究

  public void set(T value) {
        Thread t = Thread.currentThread();
        ThreadLocal.ThreadLocalMap map = getMap(t);
        if (map != null)
            //调用了ThreadLocalMap的set方法
            map.set(this, value);
        else
            createMap(t, value);
    }
    
    ThreadLocal.ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
    }

    void createMap(Thread t, T firstValue) {
        	//调用了ThreadLocalMap的构造方法
        t.threadLocals = new ThreadLocal.ThreadLocalMap(this, firstValue);
    }

这个方法我们前面已经分析过, 其作用是设置当前线程绑定的局部变量 :

a. 首先获取当前线程，并根据当前线程获取一个Map

b. 如果获取的Map不为空，则将参数设置到Map中（当前ThreadLocal的引用作为key，这里调用了ThreadLocalMap的set方法）

c. 如果Map为空，则给该线程创建 Map，并设置初始值（这里调用了ThreadLocalMap的构造方法）

ThreadLocal 的 set 方法涉及到了 ThreadLocalMap 的 set 方法和构造方法，我们接着分析这两个方法

2）ThreadLocalMap的构造方法ThreadLocalMap(ThreadLocal firstKey, Object firstValue)

 /*
  * firstKey : 本ThreadLocal实例(this)
  * firstValue ： 要保存的线程本地变量
  */
ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
        //初始化table
        table = new ThreadLocal.ThreadLocalMap.Entry[INITIAL_CAPACITY];
        //计算索引(重点代码）
        int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
        //设置值
        table[i] = new ThreadLocal.ThreadLocalMap.Entry(firstKey, firstValue);
        size = 1;
        //设置阈值
        setThreshold(INITIAL_CAPACITY);
    }

可以看到构造函数首先创建一个长度为16的 Entry 数组，然后计算出 firstKey 对应的索引，然后存储到 table 中，并设置 size 和threshold，我们重点分析重点分析int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1)这行代码

a. 关于firstKey.threadLocalHashCode：

 	private final int threadLocalHashCode = nextHashCode();
    
    private static int nextHashCode() {
        return nextHashCode.getAndAdd(HASH_INCREMENT);
    }
    //AtomicInteger是一个提供原子操作的Integer类，通过线程安全的方式操作加减,适合高并发情况下的使用
    private static AtomicInteger nextHashCode =  new AtomicInteger();
     //特殊的hash值
    private static final int HASH_INCREMENT = 0x61c88647;

这里定义了一个AtomicInteger类型，每次获取当前值并加上HASH_INCREMENT，HASH_INCREMENT = 0x61c88647,这个值跟斐波那契数列（黄金分割数）有关，其主要目的就是为了让哈希码能均匀的分布在2的n次方的数组里, 也就是Entry[] table中，这样做可以尽量避免 hash 冲突。

b. 关于& (INITIAL_CAPACITY - 1)

计算 hash 的时候里面采用了hashCode & (size - 1)的算法，这相当于取模运算hashCode % size的一个更高效的实现，(size - 1) 的作用是保证计算得到的索引值在哈希表的范围之内，因为 (size - 1) 的二进制表示都是最低位全为 1，其它位全为 0。通过与运算，可以将 hashCode 的高位（对应大数值）的影响消除，只保留低位的部分，确保索引值符合哈希表的大小范围。

注意：该算法要求哈希表的大小必须是 2 的幂次方，即 size 必须是 2、4、8、16 等等，才保证在索引不越界的前提下，使得hash发生冲突的次数减小。这是因为 (size - 1) 的二进制表示中，除了最低位为 1，其它位都是 0，这样才能保证按位与运算的结果在有效的索引范围内

3）ThreadLocalMap 中的 set 方法

private void set(ThreadLocal<?> key, Object value) {
        ThreadLocal.ThreadLocalMap.Entry[] tab = table;
        int len = tab.length;
        // 计算索引(重点代码，前面分析过了）
        int i = key.threadLocalHashCode & (len-1);
        // 使用线性探测法查找元素（重点代码）
        for (ThreadLocal.ThreadLocalMap.Entry e = tab[i];
             e != null;
             e = tab[i = nextIndex(i, len)]) {
            ThreadLocal<?> k = e.get();
            //ThreadLocal 对应的 key 存在，直接覆盖之前的值
            if (k == key) {
                e.value = value;
                return;
            }
            // key为 null，但是值不为 null，说明之前的 ThreadLocal 对象已经被回收了，
           // 当前数组中的 Entry 是一个陈旧（stale）的元素
            if (k == null) {
                //用新元素替换陈旧的元素，这个方法进行了不少的垃圾清理动作，防止内存泄漏
                replaceStaleEntry(key, value, i);
                return;
            }
        }
    
    	//ThreadLocal对应的key不存在并且没有找到陈旧的元素，则在空元素的位置创建一个新的Entry。
            tab[i] = new Entry(key, value);
            int sz = ++size;
            /*
             * cleanSomeSlots用于清除那些e.get()==null的元素，
             * 这种数据key关联的对象已经被回收，所以这个Entry(table[index])可以被置null。
             * 如果没有清除任何entry,并且当前使用量达到了负载因子所定义(长度的2/3)，那么进行				 
             * rehash（执行一次全表的扫描清理工作）
             */
            if (!cleanSomeSlots(i, sz) && sz >= threshold)
                rehash();
}

   /**
     * 获取环形数组的下一个索引
     */
    private static int nextIndex(int i, int len) {
        return ((i + 1 < len) ? i + 1 : 0);
    }

a. 首先还是根据 key 计算出索引 i，然后查找索引位置上的Entry

b. 若是Entry已经存在并且key等于传入的key，那么这时候直接给这个Entry赋新的value值,

c. 若是Entry存在，但是key为null，value不为null，则说明之前的ThreadLocal对象已经被GC了，这个时候需要调用 replaceStaleEntry 来更换这个 key 为空的Entry。

这里关于这里为什么要单独使用一个方法 replaceStaleEntry 来将Entry的value替换成null的原因：首先，ThreadLocalMap 中的 Entry 对象存储了线程局部变量的值。在多线程环境下，如果直接将 Entry 的 value 设置为 null，可能会导致其他线程无法正确获取到自己的线程局部变量值，从而出现线程间数据错乱或不一致的情况。其次，由于 ThreadLocalMap 是使用弱引用来引用 ThreadLocal 对象的，当 ThreadLocal 对象被 GC 后，对应的 Entry 中的 key 会变为 null。这时如果直接将 Entry 的 value 设置为 null，那么就无法区分是因为 GC 导致的 key 为 null，还是本来就是 key 和 value 都为 null 的情况

d. 不断循环检测（利用线性探测法），直到遇到为null的地方，这时候要是还没在循环过程中return，那么就在这个null的位置新建一个Entry，并且插入，同时size增加1。

e. 最后调用cleanSomeSlots，清理key为null的Entry，最后返回是否清理了Entry，接下来再判断sz 是否>= thresgold达到了rehash的条件，达到的话就会调用rehash函数执行一次全表的扫描清理。

知识拓展：线性探测法

线性探测法（Linear Probing）是一种解决哈希冲突的开放地址法之一。当发生哈希冲突时，线性探测法通过逐个检查下一个槽位，直到找到一个空闲的槽位来存储冲突的元素，若整个空间都找不到空余的地址，则产生溢出。

具体实现时，当在哈希表中插入一个元素时，如果计算得到的索引位置已经被占用，就会顺序地往后探测直到找到一个空闲的槽位。探测的方式是通过对当前索引位置进行加 1 操作，并将结果与哈希表的大小取模，以保证索引在有效范围内。如果遇到了已经被占用的槽位，则继续进行探测，直到找到一个空闲的槽位为止。

举个例子，假设当前table长度为16，也就是说如果计算出来key的hash值为14，如果table[14]上已经有值，并且其key与当前key不一致，那么就发生了hash冲突，这个时候将14加1得到15，取table[15]进行判断，这个时候如果还是冲突会回到0，取table[0],以此类推，直到可以插入。按照上面的描述，可以把Entry[] table看成一个环形数组。

相关面试题

  • 为什么使用ThreadLocal而不直接使用Session存储用户id？

    • 更加轻量级：使用ThreadLocal不需要创建和维护会话，因此可以在某些情况下更加轻量级。

      降低了层与层之间的耦合性，Service层要想获取用户id，需要从Controller层中获取Session对象，然后传入Service层中，而使用ThreadLocal后，可以直接获取Controller层无需传递多余的参数；其次，在一些类中可能无法获取Session对象的，比如公共字段填充类中，此时就无法获取用户id，这时候就可以使用ThreadLocal更加便捷

    • 更高的性能：在高并发环境下，使用ThreadLocal可以减少上下文切换的次数，从而提高性能。

    • 更好的安全性：由于ThreadLocal中的变量只能在当前线程中访问，因此不存在多线程竞争的问题，从而可以提高安全性。

参考文章：

  • 使用ThreadLocal - 廖雪峰

  • ThreadLocal使用与原理 - 傲丙

  • ThreadLocal源码解析 - 程序员小潘的博客

  • SimpleDateFormat多线程下不安全！！！解决之道 - 腾讯云开发者社区-腾讯云 (tencent.com)

  • Java学习社区

  • 关于yyyy-MM-dd格式日期字符串,解析成LocalDateTime遇到的问题

  • ThreadLocal源码深入剖析 - 简书 (jianshu.com)

  • HashMap的数学原理 - 掘金 (juejin.cn)

你可能感兴趣的:(#,Java,后端开发,java,面试,开发语言)

  • Long类型前后端数据不一致 igotyback 前端
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
  • LocalDateTime 转 String igotyback java开发语言
    importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
  • Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类qt开发语言sdl2linux
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
  • 使用 FinalShell 进行远程连接（ssh 远程连接 Linux 服务器） 编程经验分享 开发工具服务器sshlinux
    目录前言基本使用教程新建远程连接连接主机自定义命令路由追踪前言后端开发，必然需要和服务器打交道，部署应用，排查问题，查看运行日志等等。一般服务器都是集中部署在机房中，也有一些直接是云服务器，总而言之，程序员不可能直接和服务器直接操作，一般都是通过ssh连接来登录服务器。刚接触远程连接时，使用的是XSHELL来远程连接服务器，连接上就能够操作远程服务器了，但是仅用XSHELL并没有上传下载文件的功能
  • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理 STU学生网页设计 网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
    ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
  • 【华为OD机试真题2023B卷 JAVA&JS】We Are A Team 若博豆 java算法华为javascript
    华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
  • 关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript 二挡起步 web前端期末大作业javascripthtmlcss旅游风景
    ⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
  • HTML网页设计制作大作业（div+css） 云南我的家乡旅游景点 带文字滚动 二挡起步 web前端期末大作业web设计网页规划与设计htmlcssjavascriptdreamweaver前端
    Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
  • python八股文面试题分享及解析(1) Shawn________ python
    #1.'''a=1b=2不用中间变量交换a和b'''#1.a=1b=2a,b=b,aprint(a)print(b)结果：21#2.ll=[]foriinrange(3):ll.append({'num':i})print(11)结果:#[{'num':0},{'num':1},{'num':2}]#3.kk=[]a={'num':0}foriinrange(3):#0,12#可变类型，不仅仅改变
  • MYSQL面试系列-04 king01299 面试mysql面试
    MYSQL面试系列-0417.关于redolog和binlog的刷盘机制、redolog、undolog作用、GTID是做什么的？innodb_flush_log_at_trx_commit及sync_binlog参数意义双117.1innodb_flush_log_at_trx_commit该变量定义了InnoDB在每次事务提交时，如何处理未刷入（flush）的重做日志信息（redolog）。它
  • Kafka 消息丢失如何处理？ 架构文摘JGWZ 学习
    今天给大家分享一个在面试中经常遇到的问题：Kafka消息丢失该如何处理？这个问题啊，看似简单，其实里面藏着很多“套路”。来，咱们先讲一个面试的“真实”案例。面试官问：“Kafka消息丢失如何处理？”小明一听，反问：“你是怎么发现消息丢失了？”面试官顿时一愣，沉默了片刻后，可能有点不耐烦，说道：“这个你不用管，反正现在发现消息丢失了，你就说如何处理。”小明一头雾水：“问题是都不知道怎么丢的，处理起来
  • 每日算法&面试题，大厂特训二十八天——第二十天（树） 肥学 ⚡算法题⚡面试题每日精进java算法数据结构
    目录标题导读算法特训二十八天面试题点击直接资料领取导读肥友们为了更好的去帮助新同学适应算法和面试题，最近我们开始进行专项突击一步一步来。上一期我们完成了动态规划二十一天现在我们进行下一项对各类算法进行二十八天的一个小总结。还在等什么快来一起肥学进行二十八天挑战吧！！特别介绍小白练手专栏，适合刚入手的新人欢迎订阅编程小白进阶python有趣练手项目里面包括了像《机器人尬聊》《恶搞程序》这样的有趣文章
  • node.js学习 小猿L node.jsnode.js学习vim
    node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
  • 【华为OD技术面试真题 - 技术面】- python八股文真题题库（4) 算法大师 华为od面试python
    华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选**1.Python中的`with`**用途和功能自动资源管理示例：文件操作上下文管理协议示例代码工作流程解析优点2.\_\_new\_\_和**\_\_init\_\_**区别__new____init__区别总结3.**切片（Slicing）操作**基本切片语法
  • 【华为OD技术面试真题 - 技术面】-测试八股文真题题库（1） 算法大师 华为od面试python算法前端
    华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选1.黑盒测试和白盒测试的区别2.假设我们公司现在开发一个类似于微信的软件1.0版本，现在要你测试这个功能：打开聊天窗口，输入文本，限制字数在200字以内。问你怎么提取测试点。功能测试性能测试安全性测试可用性测试跨平台兼容性测试网络环境测试3.接口测试的工具你了解哪些
  • 【华为OD技术面试真题精选 - 非技术题】 -HR面，综合面_华为od hr面 一个射手座的程序媛 程序员华为od面试职场和发展
    最后的话最近很多小伙伴找我要Linux学习资料，于是我翻箱倒柜，整理了一些优质资源，涵盖视频、电子书、PPT等共享给大家！资料预览给大家整理的视频资料：给大家整理的电子书资料：如果本文对你有帮助，欢迎点赞、收藏、转发给朋友，让我有持续创作的动力！网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。需要这份系统化的资料的朋友，可以点击这里获
  • 【华为OD技术面试真题 - 技术面】- python八股文真题题库（1） 算法大师 华为od面试python
    华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选1.数据预处理流程数据预处理的主要步骤工具和库2.介绍线性回归、逻辑回归模型线性回归（LinearRegression）模型形式：关键点：逻辑回归（LogisticRegression）模型形式：关键点：参数估计与评估：3.python浅拷贝及深拷贝浅拷贝（Shal
  • Java 重写(Override)与重载(Overload) 叨唧唧的
    Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
  • 简单了解 JVM 记得开心一点啊 jvm
    目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
  • 1分钟解决 -bash: mvn: command not found，在Centos 7中安装Maven Energet!c 开发语言
    1分钟解决-bash:mvn:commandnotfound，在Centos7中安装Maven检查Java环境1下载Maven2解压Maven3配置环境变量4验证安装5常见问题与注意事项6总结检查Java环境Maven依赖Java环境，请确保系统已经安装了Java并配置了环境变量。可以通过以下命令检查：java-version如果未安装，请先安装Java。1下载Maven从官网下载：前往Apach
  • Java企业面试题3 马龙强_ java
    1.break和continue的作用(智*图)break：用于完全退出一个循环（如for,while）或一个switch语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在for循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。2.if分支语句和switch分
  • JVM、JRE和 JDK：理解Java开发的三大核心组件 Y雨何时停T Javajava
    Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
  • Java面试题精选：消息队列(二) 芒果不是芒 Java面试题精选javakafka
    一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
  • 白骑士的Java教学基础篇 2.5 控制流语句 白骑士所长 Java教学java开发语言
    欢迎继续学习Java编程的基础篇！在前面的章节中，我们了解了Java的变量、数据类型和运算符。接下来，我们将探讨Java中的控制流语句。控制流语句用于控制程序的执行顺序，使我们能够根据特定条件执行不同的代码块，或重复执行某段代码。这是编写复杂程序的基础。通过学习这一节内容，你将掌握如何使用条件语句和循环语句来编写更加灵活和高效的代码。条件语句条件语句用于根据条件的真假来执行不同的代码块。if语句‘
  • python语法——三目运算符 HappyRocking pythonpython三目运算符
    在java中，有三目运算符，如：intc=(a>b)?a:b表示c取两者中的较大值。但是在python，不能直接这样使用，估计是因为冒号在python有分行的关键作用。那么在python中，如何实现类似功能呢？可以使用ifelse语句，也是一行可以完成，格式为：aifbelsec表示如果b为True，则表达式等于a，否则等于c。如：c=(aif(a>b)elseb)同样是完成了取最大值的功能。
  • 2019考研 | 西交大软件工程 笔者阿蓉
    本科背景：某北京211学校电子信息工程互联网开发工作两年录取结果：全日制软件工程学院分数：初试350+复试笔试80+面试85+总排名：100+从五月份开始脱产学习，我主要说一下专业课和复试还有我对非全的一些看法。【数学100+】张宇，张宇，张宇。跟着张宇学习，入门视频刷一遍，真题刷两遍，错题刷三遍。书刷N多遍。从视频开始学习，是最快的学习方法。5-7月份把主要是数学学好，8-9月份开始给自己每个周
  • ArrayList 源码解析 程序猿进阶 Java基础ArrayListListjava面试性能优化架构设计idea
    ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
  • Java爬虫框架（一）--架构设计 狼图腾-狼之传说 java框架java任务html解析器存储电子商务
    一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
  • Java：爬虫框架 dingcho Javajava爬虫
    一、ApacheNutch2【参考地址】Nutch是一个开源Java实现的搜索引擎。它提供了我们运行自己的搜索引擎所需的全部工具。包括全文搜索和Web爬虫。Nutch致力于让每个人能很容易,同时花费很少就可以配置世界一流的Web搜索引擎.为了完成这一宏伟的目标,Nutch必须能够做到:每个月取几十亿网页为这些网页维护一个索引对索引文件进行每秒上千次的搜索提供高质量的搜索结果简单来说Nutch支持分
  • python怎么将png转为tif_png转tif weixin_39977276
    发国外的文章要求图片是tif，cmyk色彩空间的。大小尺寸还有要求。比如网上大神多，找到了一段代码，感谢！https://www.jianshu.com/p/ec2af4311f56https://github.com/KevinZc007/image2Tifimportjava.awt.image.BufferedImage;importjava.io.File;importjava.io.Fi
  • apache ftpserver-CentOS config gengzg apache
    <server xmlns="http://mina.apache.org/ftpserver/spring/v1" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation=" http://mina.apache.o
  • 优化MySQL数据库性能的八种方法 AILIKES sqlmysql
    1、选取最适用的字段属性 　　MySQL可以很好的支持大数据量的存取，但是一般说来，数据库中的表越小，在它上面执行的查询也就会越快。因此，在创建表的时候，为了获得更好的 性能，我们可以将表中字段的宽度设得尽可能小。例如，在定义邮政编码这个字段时，如果将其设置为CHAR(255),显然给数据库增加了不必要的空间，甚至使用VARCHAR这种类型也是多余的，因为CHAR(6)就可以很
  • JeeSite 企业信息化快速开发平台 Kai_Ge JeeSite
    JeeSite 企业信息化快速开发平台 平台简介 JeeSite是基于多个优秀的开源项目，高度整合封装而成的高效，高性能，强安全性的开源Java EE快速开发平台。 JeeSite本身是以Spring Framework为核心容器，Spring MVC为模型视图控制器，MyBatis为数据访问层， Apache Shiro为权限授权层，Ehcahe对常用数据进行缓存，Activit为工作流
  • 通过Spring Mail Api发送邮件 120153216 邮件main
    原文地址：http://www.open-open.com/lib/view/open1346857871615.html 使用Java Mail API来发送邮件也很容易实现，但是最近公司一个同事封装的邮件API实在让我无法接受，于是便打算改用Spring Mail API来发送邮件，顺便记录下这篇文章。 【Spring Mail API】 Spring Mail API都在org.spri
  • Pysvn 程序员使用指南 2002wmj SVN
    源文件:http://ju.outofmemory.cn/entry/35762 这是一篇关于pysvn模块的指南. 完整和详细的API请参考 http://pysvn.tigris.org/docs/pysvn_prog_ref.html. pysvn是操作Subversion版本控制的Python接口模块. 这个API接口可以管理一个工作副本, 查询档案库, 和同步两个. 该
  • 在SQLSERVER中查找被阻塞和正在被阻塞的SQL 357029540 SQL Server
    SELECT  R.session_id AS BlockedSessionID ,          S.session_id AS BlockingSessionID ,          Q1.text AS Block
  • Intent 常用的用法备忘 7454103 .netandroidGoogleBlogF#
    Intent     应该算是Android中特有的东西。你可以在Intent中指定程序 要执行的动作（比如：view,edit,dial），以及程序执行到该动作时所需要的资料 。都指定好后，只要调用startActivity()，Android系统 会自动寻找最符合你指定要求的应用 程序，并执行该程序。 下面列出几种Intent 的用法 显示网页:
  • Spring定时器时间配置 adminjun spring时间配置定时器
    红圈中的值由6个数字组成，中间用空格分隔。第一个数字表示定时任务执行时间的秒，第二个数字表示分钟，第三个数字表示小时，后面三个数字表示日，月，年，< xmlnamespace prefix ="o" ns ="urn:schemas-microsoft-com:office:office" /> 测试的时候，由于是每天定时执行，所以后面三个数
  • POJ 2421 Constructing Roads 最小生成树 aijuans 最小生成树
    来源：http://poj.org/problem?id=2421 题意：还是给你n个点，然后求最小生成树。特殊之处在于有一些点之间已经连上了边。 思路：对于已经有边的点，特殊标记一下，加边的时候把这些边的权值赋值为0即可。这样就可以既保证这些边一定存在，又保证了所求的结果正确。 代码： #include <iostream> #include <cstdio>
  • 重构笔记——提取方法（Extract Method） ayaoxinchao java重构提炼函数局部变量提取方法
    提取方法（Extract Method）是最常用的重构手法之一。当看到一个方法过长或者方法很难让人理解其意图的时候，这时候就可以用提取方法这种重构手法。   下面是我学习这个重构手法的笔记：   提取方法看起来好像仅仅是将被提取方法中的一段代码，放到目标方法中。其实，当方法足够复杂的时候，提取方法也会变得复杂。当然，如果提取方法这种重构手法无法进行时，就可能需要选择其他
  • 为UILabel添加点击事件 bewithme UILabel
        默认情况下UILabel是不支持点击事件的，网上查了查居然没有一个是完整的答案，现在我提供一个完整的代码。   UILabel *l = [[UILabel alloc] initWithFrame:CGRectMake(60, 0, listV.frame.size.width - 60, listV.frame.size.height)]
  • NoSQL数据库之Redis数据库管理(PHP-REDIS实例) bijian1013 redis数据库NoSQL
    一.redis.php <?php //实例化 $redis = new Redis(); //连接服务器 $redis->connect("localhost"); //授权 $redis->auth("lamplijie"); //相关操
  • SecureCRT使用备注 bingyingao secureCRT每页行数
    SecureCRT日志和卷屏行数设置 一、使用securecrt时，设置自动日志记录功能。 1、在C:\Program Files\SecureCRT\下新建一个文件夹(也就是你的CRT可执行文件的路径），命名为Logs； 2、点击Options -> Global Options -> Default Session -> Edite Default Sett
  • 【Scala九】Scala核心三：泛型 bit1129 scala
    泛型类 package spark.examples.scala.generics class GenericClass[K, V](val k: K, val v: V) { def print() { println(k + "," + v) } } object GenericClass { def main(args: Arr
  • 素数与音乐 bookjovi 素数数学haskell
        由于一直在看haskell，不可避免的接触到了很多数学知识，其中数论最多，如素数，斐波那契数列等，很多在学生时代无法理解的数学现在似乎也能领悟到那么一点。     闲暇之余，从图书馆找了<<The music of primes>>和<<世界数学通史>>读了几遍。其中素数的音乐这本书与软件界熟知的&l
  • Java-Collections Framework学习与总结-IdentityHashMap BrokenDreams Collections
            这篇总结一下java.util.IdentityHashMap。从类名上可以猜到，这个类本质应该还是一个散列表，只是前面有Identity修饰，是一种特殊的HashMap。         简单的说，IdentityHashMap和HashM
  • 读《研磨设计模式》-代码笔记-享元模式-Flyweight bylijinnan java设计模式
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ import java.util.ArrayList; import java.util.Collection; import java.util.HashMap; import java.util.List; import java
  • PS人像润饰&调色教程集锦 cherishLC PS
      1、仿制图章沿轮廓润饰——柔化图像，凸显轮廓 http://www.howzhi.com/course/retouching/   新建一个透明图层，使用仿制图章不断Alt+鼠标左键选点，设置透明度为21%，大小为修饰区域的1/3左右（比如胳膊宽度的1/3），再沿纹理方向（比如胳膊方向）进行修饰。   所有修饰完成后，对该润饰图层添加噪声，噪声大小应该和
  • 更新多个字段的UPDATE语句 crabdave update
    更新多个字段的UPDATE语句                    update tableA a set (a.v1, a.v2, a.v3, a.v4) = --使用括号确定更新的字段范围
  • hive实例讲解实现in和not in子句 daizj hivenot inin
    本文转自：http://www.cnblogs.com/ggjucheng/archive/2013/01/03/2842855.html 当前hive不支持 in或not in 中包含查询子句的语法，所以只能通过left join实现。 假设有一个登陆表login(当天登陆记录,只有一个uid),和一个用户注册表regusers(当天注册用户，字段只有一个uid)，这两个表都包含
  • 一道24点的10+种非人类解法（2,3,10,10） dsjt 算法
    这是人类算24点的方法？！！！ 事件缘由：今天晚上突然看到一条24点状态，当时惊为天人，这NM叫人啊？以下是那条状态 朱明西 : 24点，算2 3 10 10，我LX炮狗等面对四张牌痛不欲生，结果跑跑同学扫了一眼说，算出来了，2的10次方减10的3次方。。我草这是人类的算24点啊。。 然后么。。。我就在深夜很得瑟的问室友求室友算 刚出完题，文哥的暴走之旅开始了 5秒后
  • 关于YII的菜单插件 CMenu和面包末breadcrumbs路径管理插件的一些使用问题 dcj3sjt126com yiiframework
    在使用 YIi的路径管理工具时，发现了一个问题。                    <?php         
  • 对象与关系之间的矛盾：“阻抗失配”效应[转] come_for_dream 对象
    概述   “阻抗失配”这一词组通常用来描述面向对象应用向传统的关系数据库（RDBMS）存放数据时所遇到的数据表述不一致问题。C++程序员已经被这个问题困扰了好多年，而现在的Java程序员和其它面向对象开发人员也对这个问题深感头痛。   “阻抗失配”产生的原因是因为对象模型与关系模型之间缺乏固有的亲合力。“阻抗失配”所带来的问题包括：类的层次关系必须绑定为关系模式（将对象
  • 学习编程那点事 gcq511120594 编程互联网
    一年前的夏天，我还在纠结要不要改行，要不要去学php？能学到真本事吗？改行能成功吗？太多的问题，我终于不顾一切，下定决心，辞去了工作，来到传说中的帝都。老师给的乘车方式还算有效，很顺利的就到了学校，赶巧了，正好学校搬到了新校区。先安顿了下来，过了个轻松的周末，第一次到帝都，逛逛吧！ 接下来的周一，是我噩梦的开始，学习内容对我这个零基础的人来说，除了勉强完成老师布置的作业外，我已经没有时间和精力去
  • Reverse Linked List II hcx2013 list
    Reverse a linked list from position m to n. Do it in-place and in one-pass. For example:Given 1->2->3->4->5->NULL, m = 2 and n = 4, return 
  • Spring4.1新特性——页面自动化测试框架Spring MVC Test HtmlUnit简介 jinnianshilongnian spring 4.1
    目录 Spring4.1新特性——综述 Spring4.1新特性——Spring核心部分及其他 Spring4.1新特性——Spring缓存框架增强 Spring4.1新特性——异步调用和事件机制的异常处理 Spring4.1新特性——数据库集成测试脚本初始化 Spring4.1新特性——Spring MVC增强 Spring4.1新特性——页面自动化测试框架Spring MVC T
  • Hadoop集群工具distcp liyonghui160com
        1. 环境描述 两个集群：rock 和 stone rock无kerberos权限认证，stone有要求认证。 1. 从rock复制到stone，采用hdfs Hadoop distcp -i hdfs://rock-nn:8020/user/cxz/input hdfs://stone-nn:8020/user/cxz/运行在rock端，即源端问题：报版本
  • 一个备份MySQL数据库的简单Shell脚本 pda158 mysql脚本
    　　主脚本（用于备份mysql数据库）： 　　该Shell脚本可以自动备份 数据库。只要复制粘贴本脚本到文本编辑器中，输入数据库用户名、密码以及数据库名即可。我备份数据库使用的是mysqlump 命令。后面会对每行脚本命令进行说明。 　　 1. 分别建立目录“backup”和“oldbackup” 　　#mkdir /backup 　　#mkdir /oldbackup 　
  • 300个涵盖IT各方面的免费资源（中）——设计与编码篇 shoothao IT资源图标库图片库色彩板字体
    A. 免费的设计资源 Freebbble:来自于Dribbble的免费的高质量作品。 Dribbble:Dribbble上“免费”的搜索结果——这是巨大的宝藏。 Graphic Burger:每个像素点都做得很细的绝佳的设计资源。 Pixel Buddha:免费和优质资源的专业社区。 Premium Pixels:为那些有创意的人提供免费的素材。
  • thrift总结 - 跨语言服务开发 uule thrift
    官网 官网JAVA例子 thrift入门介绍 IBM-Apache Thrift - 可伸缩的跨语言服务开发框架 Thrift入门及Java实例演示 thrift的使用介绍   RPC    POM： <dependency> <groupId>org.apache.thrift</groupId>
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他