- 浏览: 810250 次
- 性别:
- 来自: 西安
文章分类
- 全部博客 (307)
- struts (8)
- hibernate (3)
- spring (32)
- opensourceproject (12)
- javaScript (9)
- primeton EOS (2)
- journey of heart (10)
- Design pattern (6)
- ejb (17)
- point (37)
- Linux&Unix (22)
- ibatis (10)
- AJAX (6)
- DB (26)
- Protocol (6)
- chart (4)
- web server (11)
- webservice (7)
- integration (3)
- tuxedo (5)
- ext (4)
- android (1)
- c/c++ (12)
- JVM (1)
- paginationFrame (2)
- code (2)
- report (1)
- High-performance web (1)
- svn (1)
- JQuery (1)
- workDaily (2)
- cloud (16)
- Python (8)
- English (2)
- shell (5)
- googleCode (1)
- nio (1)
- hyper-v (1)
- debug (3)
- vbs (2)
- openstack (3)
- K8S (1)
- Mesos (0)
- Spark (0)
- Marathon (0)
最新评论
-
钱图大展:
chao2751021 写道lib包哪里去下载,找不到
大型网站用户行为记录的一个实现--基于clickStream(第一部分) -
钱图大展:
无法下载
大型网站用户行为记录的一个实现--基于clickStream(第一部分) -
fm395728572:
shell脚本中用到了环境变量,但是获取不到,例如脚本中有一句 ...
ganymed-ssh2 for Java -
liuhanjiang:
我qq147229234
大型网站用户行为记录的一个实现--基于clickStream(第一部分) -
liuhanjiang:
博主 我利用您提供的方法实现博文中介绍的clickstream ...
大型网站用户行为记录的一个实现--基于clickStream(第一部分)
ThreadLocal的使用
1前言
在多线程中,有时会使用到类ThreadLocal,为了弄清楚其中的意义,特地翻看了源代码,总结了一下,但是其中有自己的想法,不免有错误,见谅。
2概述
该类并不是Thread,而是提供了线程局部变量。功能比较简单。就是为每一个使用该变量的线程都提供一个变量值的副本,即每一个线程都可以独立地改变自己的副本,而不会和其它线程的副本冲突。这里有个预备知识,对于jvm来说,分为主工作区和线程工作区。意义比较简单,主工作区是实例的所有线程共有,线程工作区是实例的每个线程专有的工作区,其中包括一些主工作区的一些实例字段数据的拷贝。这其中还有很多知识,必须先学习一下关于多线程的有关知识。如果不明白就很难理解这个类的意义和使用,但这些不在本文档的范围之内。
3ThreadLocal的设计
它的位置在包java.lang下面。里面有一个静态内部类ThreadLocalMap,类似于hashMap的设计,用于存储每一个线程的变量的副本,就不多说了。还包括四个方法。
1 initialValue():该方法是一个受保护的方法,而且它在类中的返回值是null。基于这两点已经很明显它是应该由子类去实现的,通常使用一个内部匿名类对ThreadLocal进行子类化,该方法返回此线程局部变量的当前线程的初始值,这个方法只有在一个线程第1次调用get()或者set(Object)时才执行,并且仅执行1次。
2 get(): 返回此线程局部变量的当前线程副本中的值。
3 set(Object value): 将此线程局部变量的当前线程副本中的值设置为指定值.
4 remove():移除此线程局部变量的值。在jdk1.5中使用。
在API中给出的例子也是比较好的,如下:
public class SerialNum {
// The next serial number to be assigned
private static int nextSerialNum = 0;
private static ThreadLocal serialNum = new ThreadLocal() {
protected synchronized Object initialValue() {
return new Integer(nextSerialNum++);
}
};
public static int get() {
return ((Integer) (serialNum.get())).intValue();
}
}
每个线程都保持一个对其线程局部变量副本的隐式引用,只要线程是活动的并且 ThreadLocal 实例是可访问的;在线程消失之后,其线程局部实例的所有副本都会被垃圾回收(除非存在对这些副本的其他引用)。
4区别
ThreadLocal和其它所有的同步机制都是为了解决多线程中的对同一变量的访问冲突,在普通的同步机制中,是通过对象加锁来实现多个线程对同一变量的安全访问的。在1.5以前的版本中,synchronized是自动释放锁。在JDK1.5的版本中,提供了类java.util.concurrent.locks.Lock。它比synchronized更精确和有更高的性能。这时该变量是多个线程共享的,使用这种同步机制需要有较强的多线程基础和编程经验,因为需要知道对变量进行读写的时机,什么时候需要锁定这个对象,又什么时候需要释放该对象的锁等等很多问题。所有这些都是因为多个线程共享了资源造成的。而ThreadLocal就从另一个角度来解决多线程的并发访问,ThreadLocal会为每一个线程维护一个和该线程绑定的变量的副本,从而隔离了多个线程的数据,每一个线程都拥有自己的变量副本,从而也就没有必要对该变量进行同步了。ThreadLocal提供了线程安全的共享对象,在编写多线程代码的时候,就可以把不安全的变量封装进ThreadLocal,当然也可以把该对象的特定于线程的状态封装进ThreadLocal。
5总结
同步机制是为了同步多个线程对相同资源的并发访问,是为了多个线程之间进行通信的有效方式;而ThreadLocal是隔离多个线程的数据共享。
个人认为,如果有较强的多线程的基础,还是应该使用synchronized来进行控制。ThreadLocal的出现只是为了简化一部分人的编程,使编程更容易。减小出错的概率。
当然,既然JDK提供了这样的功能,在适当的情况可以使用。所以,如果你需要进行多个线程之间进行通信,则使用同步机制;如果需要隔离多个线程之间的共享冲突,可以使用ThreadLocal。
Threadlocal模式,和singleton不一样,singleton是说在整个应用程序中保证只有一个实例,而Threadlocal是指每线程有唯一实例。Servlet的 “单实例,多线程”是指多个线程共享一个实例,因此会有同步的问题
Threadlocal 测试:
AnotherThread.java
package cn.com.xinli.usp.test; public class AnotherThread implements Runnable { public void run(){ TestThreadLocal ttl = new TestThreadLocal(); int number1 = ttl.get(); System.out.println("another number1 is " + number1); } }
TestThreadLocal.java
package cn.com.xinli.usp.test; public class TestThreadLocal { // The next serial number to be assigned private static int nextSerialNum = 0; private static ThreadLocal serialNum = new ThreadLocal() { protected synchronized Object initialValue() { return new Integer(nextSerialNum++); } }; public static int get() { return ((Integer) (serialNum.get())).intValue(); } public static void main(String[] args) { System.out.println("@@@"); System.out.println("%%%"); TestThreadLocal ttl = new TestThreadLocal(); int number1 = ttl.get(); System.out.println("number1 is " + number1); int number2 = ttl.get(); System.out.println("number2 is " + number2); new Thread(new AnotherThread()).start(); new Thread(new AnotherThread()).start(); } }
运行结果:
number1 is 0
number2 is 0
another number1 is 1
another number1 is 2
分析:
由此可见,对于同一个线程,都维护一个自己的局部变量。这在并发环境中可以很好的防止线程间共享资源的冲突。ThreadLocal 实例通常是类中的私有静态字段,它们希望将状态与某一个线程(例如,用户 ID 或事务 ID)相关联。
使用ThreadLocal 模式写的 1。数据库帮助类 2。HibernateUtil 帮助类
1.数据库帮助类 (ConnectionFactory.java ,TransactionUtil.java)
package cn.com.xinli.usp.test;
import java.sql.*;
import cn.com.xinli.usp.db.common.DBUtil;
/**
*
* <p>Title:数据库链接工厂 </p>
* @author 罗代均 ldj_work@126.com
* @version 1.0
*/
public class ConnectionFactory
{
private static ConnectionFactory instance = new ConnectionFactory();
private ConnectionFactory()
{
}
public static ConnectionFactory getInstace() {
return instance;
}
public static Connection getConnection()
{
Connection conn = (Connection) TransactionUtil.local.get();
System.out.println("%%^^:"+TransactionUtil.local.get());
try {
if (conn == null || conn.isClosed())
{
conn = ConnectionFactory.buildConnection();
TransactionUtil.local.set(conn);
conn.setAutoCommit(false);
return conn;
}
else
{
return conn;
}
} catch (SQLException ex)
{
ex.printStackTrace();
return null;
}
}
//具体获得数据库连接方法,这里为了演示,使用jdbc直接获得,实际项目可从DataSource获得连接
public static Connection buildConnection()
{
System.out.println("conn***********");
try
{
return DBUtil.getConnection();
}
catch (Exception e)
{
// TODO Auto-generated catch block
e.printStackTrace();
return null;
}
/*
String url =
"jdbc:mysql://localhost/testdb?useUnicode=true&characterEncoding=utf8";
String driver = "com.mysql.jdbc.Driver";
String user = "root";
String password = "123";
try
{
Class.forName(driver).newInstance();
System.out.println("Build Connection......");
return DriverManager.getConnection(url, user, password);
}
catch (Exception ex1)
{
ex1.printStackTrace();
return null;
}
*/
}
public static void close(ResultSet rs, Statement st,Connection conn) {
if (rs != null) {
try {
rs.close();
} catch (SQLException ex) {
}
rs = null;
}
if (st != null)
{
try {
st.close();
} catch (SQLException ex1) {
}
st = null;
}
if(conn!=null)
{
try {
conn.close();
} catch (SQLException ex1) {
}
conn = null;
}
}
}
TransactionUtil.java
package cn.com.xinli.usp.test;
import java.sql.Connection;
import java.sql.SQLException;
public class TransactionUtil
{
private static final ConnectionFactory connFactory;
static
{
connFactory = ConnectionFactory.getInstace();
}
public static final ThreadLocal local = new ThreadLocal();
/**
* 开始事务
*/
public static void beginTransaction() {
Connection conn = (Connection) local.get();
try {
if (conn == null || conn.isClosed()) {
conn = connFactory.buildConnection();
local.set(conn);
}
conn.setAutoCommit(false);
} catch (SQLException ex) {
ex.printStackTrace();
}
}
/**
* 提交事务
*/
public static void commit() {
Connection conn = (Connection) local.get();
if (conn != null) {
try {
conn.commit();
conn.setAutoCommit(true);
} catch (SQLException ex) {
throw new RuntimeException(ex.getMessage());
}
}
}
/**
* 回滚事务
*/
public static void rollback() {
Connection conn = (Connection) local.get();
if (conn != null)
{
try
{
System.out.println("rollback........");
conn.rollback();
} catch (SQLException ex)
{
throw new RuntimeException(ex.getMessage());
}
}
}
/**
* 结束事务
*/
public static void endTransaction() {
Connection conn = (Connection) local.get();
local.set(null);
if (conn != null) {
try {
System.out.println("close connection.....");
conn.close();
} catch (SQLException ex) {
throw new RuntimeException(ex.getMessage());
}
conn = null;
}
}
}
使用方法:
try
{
PreparedStatement psmt = null;
ResultSet rs=null;
Connection conn=ConnectionFactory.getConnection();
psmt=conn.prepareStatement("select * from usp_log");
rs=psmt.executeQuery();
while(rs.next())
{
System.out.println(rs.getString(1));
}
ConnectionFactory.close(rs,psmt,conn);
}
catch(Exception e)
{
e.printStackTrace();
}
事务处理:
try {
TransactionUtil.benginTransaction(); //开始事务
dao.add(emp);
//其它业务逻辑
TransactionUtil.commit(); //提交事务
TransactionUtil.endTransaction //结束事务
} catch (DaoException ex) {
this.roolback(); //出现异常,会滚事务
throw new ServiceException(ex.getMessage());
}
HibernateUtil.java帮助类
import org.apache.log4j.Logger;
import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
public class HibernateUtil {
private static final Logger log = Logger.getLogger(HibernateUtil.class);
private static final SessionFactory sessionFactory;
static {
log.info("HibernateUtil:开始初始化Hibernate SessionFactory对象 *****************************************************************************");
try {
sessionFactory = new Configuration().configure().buildSessionFactory();
} catch (Throwable ex) {
log.error("创建SessionFactory失败:",ex);
ex.printStackTrace();
throw new ExceptionInInitializerError(ex);
}
log.info("*************************************************** HibernateUtil:结束初始化Hibernate SessionFactory对象 ");
}
public static final ThreadLocal tLocalsess = new ThreadLocal();
public static final ThreadLocal tLocaltx = new ThreadLocal();
// 取得Session
public static Session currentSession() throws Exception {
Session session = (Session) tLocalsess.get();
// 打开一个新的session,如果当前不可用
try {
if (session == null || !session.isOpen()) {
session = openSession();
tLocalsess.set(session);
}
} catch (HibernateException e) {
log.error("获得Session失败",e);
e.printStackTrace();
throw new Exception("获得session失败",e);
}
return session;
}
// 关闭Session
public static void closeSession() {
Session session = (Session) tLocalsess.get();
tLocalsess.set(null);
try {
if (session != null && session.isOpen())
{
session.close();
log.debug("关闭session");
}
} catch (HibernateException e) {
log.error("关闭Session失败",e);
e.printStackTrace();
}
}
// 开始事务
public static void beginTransaction() throws Exception {
// 声明Transaction类型对象tx,并赋初值
Transaction tx = (Transaction) tLocaltx.get();
try {
if (tx == null) {
tx = currentSession().beginTransaction();
tLocaltx.set(tx);
}
} catch (HibernateException e) {
log.error("开始事务失败",e);
e.printStackTrace();
throw new Exception("开始事务失败",e);
}
}
// 关闭事务
public static void comitTransaction() throws Exception {
Transaction tx = (Transaction) tLocaltx.get();
try {
if (tx != null && !tx.wasCommitted() && !tx.wasRolledBack()) {
tx.commit();
tLocaltx.set(null);
}
} catch (HibernateException e) {
log.error("提交事务失败:",e);
e.printStackTrace();
throw new Exception("提交事物失败",e);
}
}
// 事务回滚
public static void rollbackTransaction() {
Transaction tx = (Transaction) tLocaltx.get();
try {
tLocaltx.set(null);
if (tx != null && !tx.wasCommitted() && !tx.wasRolledBack()) {
tx.rollback();
}
} catch (HibernateException e) {
log.error("事务回滚失败:",e);
e.printStackTrace();
}
}
private static Session openSession() throws HibernateException {
return getSessionFactory().openSession();
}
public static SessionFactory getSessionFactory() throws HibernateException {
return sessionFactory;
}
}
发表评论
-
eclipse link 方式管理插件
2012-02-24 15:55 1543以配置tomcat插件为例: (条件:F:\eclip ... -
使用mapinfo 开发GIS 应用
2011-03-18 06:56 12871. mapJ 对象是在tomcat启动的时候 从web ... -
java mail adapter
2011-01-21 12:23 15272011.04.27: 使用jmail 发送中文标题的 ... -
4种调用https服务的方式
2011-01-05 23:45 8775以前在网厅的时候,请求计费的账单开 ... -
正则表达式30分钟入门教程
2010-11-17 12:58 1470正则表达式30分钟入门教程 -
java 异常层次
2010-05-26 16:14 1328Java 中的异常类,包括内置的异常类以及自定义的异常类,都直 ... -
java 解惑你知多少 (转载)
2010-04-26 12:43 1193(1) http://jiangzhengjun.it ... -
jvm调优
2010-04-16 15:35 1278(1) http://pengjiaheng.itey ... -
谈谈重构
2010-04-15 13:34 1309代码重构阅读心得[转] http://www.cnblogs ... -
session会话跟踪的一个小例子
2010-03-14 18:16 1861内容包括: 必备知识: ... -
cookie机制和session机制的区别
2010-03-14 17:06 1192一、cookie机制和sessio ... -
Cookie详解
2010-03-14 16:02 1393Cookie在英文中是小甜品 ... -
什么是Cookie?
2010-03-14 15:06 1445按照Netscape官方文档中 ... -
任务、进程和线程的区别(转)
2010-02-04 17:16 2274任务(task)是最抽象 ... -
加密,解密,认证,数字签名,公钥私钥
2010-01-13 20:42 2323Bob,Alice和数字证书 网络安全中最知名的 ... -
JNI
2009-12-26 14:09 1576JNI是Java Native Inter ... -
JSON在处理hibernate中的cascade对象时的解决方案
2009-12-24 22:12 1520如果数据间存在级联关系,在hibernate中极容易嵌套而 ... -
digester框架 将 XML->JavaBean
2009-11-08 17:38 1746digester组件简化了xml文 ... -
什么是P问题、NP问题和NPC问题
2009-10-25 20:20 2045什么是P问题、NP问题和NPC问题 出自mat ... -
用Fat Jar Eclipse Plug-In打包可执行jar文件
2009-09-30 08:29 3958Fat Jar Eclipse Plug-In [FJEP] ...
相关推荐
学习ThreadLocal,了解其中的原理,以及学习其中的优点!避免坑点!!
这个压缩包 "Quartz-ThreadLocal.rar" 内含的学习资源很可能是关于如何在 Quartz 调度器中结合使用 ThreadLocal 的示例。 Quartz 的核心功能包括: 1. **作业与触发器**:在 Quartz 中,任务被称为“作业”(Job)...
Java并发编程学习之ThreadLocal源码详析 ThreadLocal是Java并发编程中的一种机制,用于解决多线程访问共享变量的问题。它可以使每个线程对共享变量的访问都是线程安全的,使得多线程编程变得更加简单。 ...
- `HttpClient学习笔记.doc`: 可能包含了关于Apache HttpClient的使用教程,包括如何创建HTTP请求,执行GET和POST操作,以及设置请求头和处理响应等内容。 - `HTTP中Get与Post的区别.doc`: 深入解析HTTP协议中的GET...
在IT行业中,线程安全和事务管理是两个非常重要的概念,尤其在多线程环境下的分布式系统中。本文将深入探讨ThreadLocal的使用以及...通过深入学习源码和实际应用,我们可以更好地理解其工作原理,并在实践中灵活运用。
通过深入源码学习,我们可以更好地理解Spring如何在多线程环境中优雅地管理事务,以及如何利用ThreadLocal来优化并发性能。同时,了解数据库连接池的工作原理也有助于我们更好地配置和使用连接池,提升应用程序的...
ThreadLocal,全称为`java.lang.ThreadLocal`,是Java中一个非常重要的工具类,它主要用于在多线程环境中提供线程局部变量。...学习并理解ThreadLocal的原理和使用方法对于编写高效、安全的多线程Java程序至关重要。
【ThreadLocal那点事儿编程开发技术共6页.pdf】 这篇文档深入探讨了Java中的ThreadLocal类,这是一个在多线程编程中非常关键的工具。...如果你希望深入理解ThreadLocal,这份文档无疑是一个很好的学习资源。
ThreadLocal是Java编程语言中的一个线程局部变量类,它为每个线程提供了一个独立的变量副本,使得每个线程可以独立地改变自己的副本,而不会影响其他线程所...这有助于深入学习和掌握Java并发编程中的这一重要工具。
在Java中,有多种方式可以实现线程间的数据共享和对象独立,其中ThreadLocal是常用的工具之一。 在多线程环境下,共享数据通常会引发线程安全问题,比如上述例子中的“张三给李四转钱”场景,如果两个线程同时操作...
标题“Hibernage_Session_Manager_ThreadLocal”涉及到的是Hibernate框架中的一种优化策略——使用ThreadLocal管理Session。...理解这些知识点对于深入学习Hibernate和优化Java Web应用的数据库操作至关重要。
Java单线程ThreadLocal串值问题解决方案主要介绍了Java单线程ThreadLocal串值问题解决方案,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值。 ThreadLocal简介 ThreadLocal是Java中...
ThreadLocal是Java编程中一个非常重要的工具类,它允许我们在多线程环境下为每个线程创建独立的变量副本。在每个线程内部,ThreadLocal变量就像一个私有的局部变量,不同线程之间的副本互不干扰,确保了数据的安全性...
Java ThreadLocal 是一个非常重要的工具类,它提供了一种在多线程环境下为每个线程维护独立变量副本的机制。这种机制使得各个线程能够拥有自己的变量实例,而不会互相干扰,降低了数据共享的复杂性。 ### 应用场景 ...
主要介绍了Java ThreadLocal的设计理念与作用,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
计算机技术、IT咨询、人工智能AI理论介绍,学习参考资料 计算机技术、IT咨询、人工智能AI理论介绍,学习参考资料 计算机技术、IT咨询、人工智能AI理论介绍,学习参考资料 计算机技术、IT咨询、人工智能AI理论介绍,...
在学习Java过程中,自己收集了很多的Java的学习资料,分享给大家,有需要的欢迎下载,希望对大家有用,一起学习,一起进步。
本教程“Struts2 学习 2”将深入探讨Struts2的核心概念和技术,通过一系列文档帮助你掌握这个框架的关键要点。 一、ActionContext的理解与应用 在“第九讲 ActionContext.docx”中,你将学习到ActionContext是...
为了实现线程安全,我们需要使用原子操作、 volatile关键字、ThreadLocal变量或者通过同步机制(如synchronized和Lock)来保护共享资源。 本学习资料包将覆盖以上所述的多线程基础、线程池原理、并发工具的使用以及...
在Java编程领域,无锁编程是一种高级的并发控制技术,旨在提高多线程环境下的程序性能和可伸缩...学习这些内容,有助于开发者深入理解Java并发编程,提升在多线程环境下的编程能力,从而设计出更加高效、可扩展的系统。