How java uses ThreadLocal to store thread-specific objects

Use ThreadLocal to store thread-specific objects

ThreadLocal provides thread-specific objects that can be accessed at any time during the entire thread life cycle, which greatly facilitates the implementation of some logic.

There are two main common usages of ThreadLocal:

1. Save the thread context object to avoid multi-level parameter passing;

2. Save non-thread-safe objects to avoid concurrent calls from multiple threads.

1. Save the thread context object to avoid multi-level parameter passing

Here, take the setting and use of paging parameters in the source code of the PageHelper plug-in as an example.

Set paging parameter code:

/** 分页方法类 */public abstract class PageMethod {    /** 本地分页 */
    protected static final ThreadLocal<Page> LOCAL_PAGE = new ThreadLocal<Page>();    /** 设置分页参数 */
    protected static void setLocalPage(Page page) {
        LOCAL_PAGE.set(page);
    }    /** 获取分页参数 */
    public static <T> Page<T> getLocalPage() {        return LOCAL_PAGE.get();
    }    /** 开始分页 */
    public static <E> Page<E> startPage(int pageNum, int pageSize, boolean count, Boolean reasonable, Boolean pageSizeZero) {
        Page<E> page = new Page<E>(pageNum, pageSize, count);
        page.setReasonable(reasonable);
        page.setPageSizeZero(pageSizeZero);
        Page<E> oldPage = getLocalPage();        if (oldPage != null && oldPage.isOrderByOnly()) {
            page.setOrderBy(oldPage.getOrderBy());
        }
        setLocalPage(page);        return page;
    }
}

Use paging parameter code:

/** 虚辅助方言类 */public abstract class AbstractHelperDialect extends AbstractDialect implements Constant {    /** 获取本地分页 */
    public <T> Page<T> getLocalPage() {        return PageHelper.getLocalPage();
    }    /** 获取分页SQL */
    @Override
    public String getPageSql(MappedStatement ms, BoundSql boundSql, Object parameterObject, RowBounds rowBounds, CacheKey pageKey) {
        String sql = boundSql.getSql();
        Page page = getLocalPage();
        String orderBy = page.getOrderBy();        if (StringUtil.isNotEmpty(orderBy)) {
            pageKey.update(orderBy);
            sql = OrderByParser.converToOrderBySql(sql, orderBy);
        }        if (page.isOrderByOnly()) {            return sql;
        }        return getPageSql(sql, page, pageKey);
    }
    ...
}

Use paging plug-in code:

/** 查询用户函数 */public PageInfo<UserDO> queryUser(UserQuery userQuery, int pageNum, int pageSize) {
    PageHelper.startPage(pageNum, pageSize);
    List<UserDO> userList = userDAO.queryUser(userQuery);
    PageInfo<UserDO> pageInfo = new PageInfo<>(userList);    return pageInfo;
}

If you want to pass paging parameters through function parameters Passing query statements step by step is impossible unless the MyBatis related interface functions are modified.

2. Save non-thread-safe objects to avoid concurrent calls from multiple threads

When writing date formatting tool functions, the first thing that comes to mind is as follows:

/** 日期模式 */private static final String DATE_PATTERN = "yyyy-MM-dd";/** 格式化日期函数 */public static String formatDate(Date date) {    return new SimpleDateFormat(DATE_PATTERN).format(date);
}

Among them, each DateFormat must be initialized for every call, resulting in low performance. After defining DateFormat as a constant, the writing method is as follows:

/** 日期格式 */private static final DateFormat DATE_FORMAT = new SimpleDateFormat("yyyy-MM-dd");/** 格式化日期函数 */public static String formatDate(Date date) {    return DATE_FORMAT.format(date);
}

Since SimpleDateFormat is not thread-safe, when multiple threads call the formatDate function at the same time, the return result will be different from expected. Inconsistent. If ThreadLocal is used to define thread-specific objects, the optimized code is as follows:

/** 本地日期格式 */private static final ThreadLocal<DateFormat> LOCAL_DATE_FORMAT = new ThreadLocal<DateFormat>() {    @Override
    protected DateFormat initialValue() {        return new SimpleDateFormat("yyyy-MM-dd");
    }
};/** 格式化日期函数 */public static String formatDate(Date date) {    return LOCAL_DATE_FORMAT.get().format(date);
}

This is the implementation method before there is a thread-safe date formatting tool class. After JDK8, it is recommended to use DateTimeFormatter instead of SimpleDateFormat, because SimpleDateFormat is thread-unsafe, while DateTimeFormatter is thread-safe. Of course, you can also use thread-safe date formatting functions provided by third parties, such as Apache's DateFormatUtils tool class.

Note: ThreadLocal has a certain risk of memory leaks. Try to call the remove function to clear the data before the end of the business code.

The above is the detailed content of How java uses ThreadLocal to store thread-specific objects. For more information, please follow other related articles on the PHP Chinese website!