ThreadLocal 与 Synchronized 总结

news/2024/11/10 0:28:50

1.对于同步方法和对象：
无论synchronized关键字加在方法上还是对象上，它取得的锁都是对象，而不是把一段代码或函数当作锁――而且同步方法很可能还会被其他线程的不同对象访问。
解释一下“取得的锁都是对象”的意思：如果一个对象有多个synchronized方法，只要一个线程访问了这个对象中的一个synchronized方法，其它线程不能同时访问这个对象中任何一个synchronized方法，但是对于不是synchronized的方法可以访问。而对于其他线程里的另一个对象可以访问synchronized方法。

2.对于同步块：
synchronized(要锁定的对象) {……} 
当要锁定的对象为this时表示的是调用这个方法的对象。

3.对于同步static 方法：
不管调用方法的是类还是对象，锁定的都是类。即类被锁定了，只要一个线程中的对象或类访问了一个synchronized static方法，其他线程里的不管是类还是对象都不能再访问synchronized static方法了。

注：以上的对象即指一个类的实例。

再通过例子说明一下以上几点：
假设P1、P2是同一个类的不同对象，这个类中定义了以下几种情况的同步块或同步方法，P1、P2就都能够调用他们。
1．  把synchronized当作函数修饰符时，示例代码如下：

Java代码 复制代码  收藏代码
  1. 1.  Public synchronized void method(){      
  2. 2.  //….      
  3. 3.  }    


这也就是同步方法，那这时synchronized锁定的是哪个对象呢？他锁定的是调用这个同步方法对象。也就是说，当一个对象P1在不同的线程中 执行这个同步方法时，他们之间会形成互斥，达到同步的效果。但是这个对象所属的Class所产生的另一对象P2却能够任意调用这个被加了 synchronized关键字的方法。
上边的示例代码等同于如下代码：

Java代码 复制代码  收藏代码
  1. 1.  public void method()      
  2. 2.  {      
  3. 3.  synchronized (this)      //  (1)      
  4. 4.  {      
  5. 5.         //…..      
  6. 6.  }      
  7. 7.  }     


(1)处的this指的是什么呢？他指的就是调用这个方法的对象，如P1。可见同步方法实质是将synchronized作用于object reference。――那个拿到了P1对象锁的线程，才能够调用P1的同步方法，而对P2而言，P1这个锁和他毫不相干，程式也可能在这种情形下摆脱同 步机制的控制，造成数据混乱。
2．同步块，示例代码如下：

Java代码 复制代码  收藏代码
  1. 1.  public void method(SomeObject so) {      
  2. 2.  synchronized(so)      
  3. 3.  {      
  4. 4.         //…..      
  5. 5.  }      
  6. 6.  }     

这时，锁就是so这个对象，谁拿到这个锁谁就能够运行他所控制的那段代码。当有一个明确的对象作为锁时，就能够这样写程式，但当没有明确的对象作为锁，只是想让一段代码同步时，能够创建一个特别的instance变量（他得是个对象）来充当锁：

Java代码 复制代码  收藏代码
  1. 1.  class Foo implements Runnable      
  2. 2.  {      
  3. 3.         private byte[] lock = new byte[0];  // 特别的instance变量      
  4. 4.      Public void method()      
  5. 5.  {      
  6. 6.         synchronized(lock) { //… }      
  7. 7.  }      
  8. 8.  //…..      
  9. 9.  }   

 
注：零长度的byte数组对象创建起来将比任何对象都经济――查看编译后的字节码：生成零长度的byte[]对象只需3条操作码，而Object lock = new Object()则需要7行操作码。
3．将synchronized作用于static 函数，示例代码如下：

Java代码 复制代码  收藏代码
  1. 1.  Class Foo      
  2. 2.  {      
  3. 3.  public synchronized static void method1()   // 同步的static 函数      
  4. 4.  {      
  5. 5.  //….      
  6. 6.  }      
  7. 7.  public void method2()      
  8. 8.  {      
  9. 9.         synchronized(Foo.class)   //  class literal(类名称字面常量)      
  10. 10. }      
  11. 11.        }     

 



代码中的method2()方法是把class literal作为锁的情况，他和同步的static函数产生的效果是相同的，取得的锁很特别，是当前调用这个方法的对象所属的类（Class，而不再是由这个Class产生的某个具体对象了）。
记得在《Effective Java》一书中看到过将 Foo.class和 P1.getClass()用于作同步锁还不相同，不能用P1.getClass()来达到锁这个Class的目的。P1指的是由Foo类产生的对象。
能 够推断：假如一个类中定义了一个synchronized的static函数A，也定义了一个synchronized 的instance函数B，那么这个类的同一对象Obj在多线程中分别访问A和B两个方法时，不会构成同步，因为他们的锁都不相同。A方法的锁是Obj所 属的那个Class，而B的锁是Obj所属的这个对象。
搞清楚synchronized锁定的是哪个对象，就能帮助我们设计更安全的多线程程序。

1、synchronized实例方法

Java代码 复制代码  收藏代码
  1. synchronized void method(){   
  2.   ...   
  3. }  



在功能上,它相当于

Java代码 复制代码  收藏代码
  1. void method() {   
  2.      synchronized (this) {   
  3.     ...   
  4.     }   
  5. }  



2、synchronized类方法

Java代码 复制代码  收藏代码
  1. class Something {   
  2.    static synchronized void method(){   
  3.      ...   
  4.    }   
  5. }  

 

 



在功能上,它相当于

Java代码 复制代码  收藏代码
  1. class Something {   
  2.     static void method() {   
  3.       synchronized (Something.class){   
  4.        ...   
  5.     }   
  6.   }   
  7. }  



3、如果我们也可以自定义方法来实现相当于synchronized类似的功能,代码如下:

Java代码 复制代码  收藏代码
  1. void method() {   
  2.     lock();   
  3.     try{   
  4.        ...   
  5.     }finally{   
  6.        unlock();   
  7.     }   
  8. }  


以上的代码就是一个Before/After Pattern的一种实现方式
举例：
下面中Mutex类这种用来进行共享互斥的机制,一般称为mutex。

Java代码 复制代码  收藏代码
  1. public class Gate {   
  2.     private int counter = 0;   
  3.     private String name = "Nobody";   
  4.     private String address = "Nowhere";   
  5.     private final Mutex mutex = new Mutex();   
  6.     public void pass(String name, String address) { // 并非synchronized   
  7.         mutex.lock();   
  8.         try {   
  9.             this.counter++;   
  10.             this.name = name;   
  11.             this.address = address;   
  12.             check();   
  13.         } finally {   
  14.             mutex.unlock();   
  15.         }   
  16.     }   
  17.     public String toString() { // 并非synchronized   
  18.         String s = null;   
  19.         mutex.lock();   
  20.         try {   
  21.             s = "No." + counter + ": " + name + ", " + address;   
  22.         } finally {   
  23.             mutex.unlock();   
  24.         }   
  25.         return s;   
  26.     }   
  27.     private void check() {   
  28.         if (name.charAt(0) != address.charAt(0)) {   
  29.             System.out.println("***** BROKEN ***** " + toString());   
  30.         }   
  31.     }   
  32. }  



设计简单的Mutex类1:

Java代码 复制代码  收藏代码
  1. public final class Mutex {   
  2.     private boolean busy = false;   
  3.     public synchronized void lock() {   
  4.         while (busy) {   
  5.             try {   
  6.                 wait();   
  7.             } catch (InterruptedException e) {   
  8.             }   
  9.         }   
  10.         busy = true;   
  11.     }   
  12.     public synchronized void unlock() {   
  13.         busy = false;   
  14.         notifyAll();   
  15.     }   
  16. }  



设计完善的Mutex类2:

Java代码 复制代码  收藏代码
  1. public final class Mutex {   
  2.     private long locks = 0;   
  3.     private Thread owner = null;   
  4.     public synchronized void lock() {   
  5.         Thread me = Thread.currentThread();   
  6.         while (locks > 0 && owner != me) {   
  7.             try {   
  8.                 wait();   
  9.             } catch (InterruptedException e) {   
  10.             }   
  11.         }   
  12.         // locks == 0 || owner == me   
  13.         owner = me;   
  14.         locks++;   
  15.     }   
  16.     public synchronized void unlock() {   
  17.         Thread me = Thread.currentThread();   
  18.         if (locks == 0 || owner != me) {   
  19.             return;   
  20.         }   
  21.         // locks > 0 && owner == me   
  22.         locks--;   
  23.         if (locks == 0) {   
  24.             owner = null;   
  25.             notifyAll();   
  26.         }   
  27.     }   
  28. }  




4、我们看到synchronized块的时候，要先思考"synchronized是在保护什么",然后进一步思考"获取谁的锁定来保护的呢"
   要调用synchronized实例方法的纯种，一定会获取thid的锁定。一个实例的锁定，同一个时间内，只能有个线程可以得到。
   如果实例不同，那锁定也不同了。使用synchronized块的时候，特别需要考虑"获取谁的锁定来保护的呢"这种情况。因为
   synchronized需要明确地指明要获取的是哪个对象的锁定。例如：
 

Java代码 复制代码  收藏代码
  1. synchronized (obj) {   
  2.     ...   
  3.   }  


  这样的程序代码中，obj就是我们所要获取锁定的对象。请小心这个对象不可心写错,获取错误对象的锁定，就好想要保护自己
  自己的家，却把别人家的门给锁定了。

 

1．区别ThreadLocal 与 synchronized

  • ThreadLocal是一个线程隔离(或者说是线程安全)的变量存储的管理实体（注意：不是存储用的），它以Java类方式表现；
  • synchronized是Java的一个保留字，只是一个代码标识符，它依靠JVM的锁机制来实现临界区的函数、变量在CPU运行访问中的原子性。

两者的性质、表现及设计初衷不同，因此没有可比较性。

2.理解ThreadLocal中提到的变量副本
    事实上，我们向ThreadLocal中set的变量不是由ThreadLocal来存储的，而是Thread线程对象自身保存。当用户调用ThreadLocal对象的set(Object o)时，该方法则通过Thread.currentThread()获取当前线程，将变量存入Thread中的一个Map内，而Map的Key就是当前的ThreadLocal实例。请看源码，这是最主要的两个函数，能看出ThreadLocal与Thread的调用关系：

Java代码 复制代码  收藏代码
  1. public void set(T value) {   
  2.         Thread t = Thread.currentThread();   
  3.         ThreadLocalMap map = getMap(t);   
  4.         if (map != null)   
  5.             map.set(this, value);   
  6.         else  
  7.             createMap(t, value);   
  8. }   
  9.   
  10. ThreadLocalMap getMap(Thread t) {   
  11.         return t.threadLocals;   
  12. }  
public void set(T value) {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
}

ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
}


（有兴趣的朋友可以阅读Java的ThreadLocal源码）因此，我们可以知道，所谓的变量副本，即是对Object Reference（对象引用）的拷贝。

3.理解Thread和 ThreadLocal对变量的引用关系
    实际上Thread和ThreadLocal对变量引用关系就像是坐标系中的X轴和Y轴，是从两个维度上来组织对变量的引用的。

  • 首先说Thread。
  •     我们知道一个ThreadOne的执行会贯穿多个方法MethodA、MethodB、MethodC这些方法可能分布于不同的类实例。假设，这些方法分别使用了ThreadLocalA、ThreadLocalB、ThreadLocalC来保存线程本地变量，那么这些变量都存于ThreadOne的Map中，并使用各自的ThreadLocal实例作为key。 因此，可以认为，借助ThreanLocal的set方法，在X轴上，Thread横向关联同一线程上下文中来自多个Method的变量引用副本。



  • 接着说ThreadLocal。
  •     一个MethodA中的X变量将被多个线程ThreadOne、ThreadTwo、ThreadThree所访问。假设MethodA使用ThreadLocal存储X，通过set方法，以ThreadLocal作为key值，将不同线程来访时的不同的变量值引用保存于ThreadOne、ThreadTwo、ThreadThree的各自线程上下文中，确保每个线程有自己的一个变量值。因此，可以认为，ThreadLocal是以Method为Y轴，纵向关联了处于同一方法中的不同线程上的变量。


 

 

1、对于多线程资源共享的问题，同步机制采用了“以时间换空间”的方式，而ThreadLocal采用了“以空间换时间”的方式。前者仅提供一份变量，让不同的线程排队访问，而后者为每一个线程都提供了一份变量，因此可以同时访问而互不影响。


2、ThreadLocal使用场合主要解决多线程中数据因并发产生不一致问题。ThreadLocal为每个线程的中并发访问的数据提供一个副本，通过访问副本来运行业务，这样的结果是耗费了内存，单大大减少了线程同步所带来性能消耗，也减少了线程并发控制的复杂度。

 

3、ThreadLocal不能使用基本数据类型，只能使用Object类型。ThreadLocal的使用比synchronized要简单得多。

ThreadLocal和Synchonized都用于解决多线程并发访问。但是ThreadLocal与synchronized有本质的区别。
synchronized是利用锁的机制，使变量或代码块在某一时该只能被一个线程访问。
而ThreadLocal为每一个线程都提供了变量的副本，使得每个线程在某一时间访问到的并不是同一个对象，这样就隔离了多个线程对数据的数据共享。而Synchronized却正好相反，它用于在多个线程间通信时能够获得数据共享。

 

4、Synchronized用于线程间的数据共享，而ThreadLocal则用于线程间的数据隔离。

 

示例1：

Java代码 复制代码  收藏代码
  1. //线程局部变量   
  2.     protected static ThreadLocal<Connection>  threadLocalCon = new ThreadLocal<Connection>();   
  3.        
  4.     /*  
  5.      * 获取数据库连接  
  6.      */  
  7.     public static  Connection getCon() {   
  8.   
  9.         Connection con = threadLocalCon.get();   
  10.         System.out.println("当前线程名称="+Thread.currentThread().getName()+",con="+con);   
  11.         try {   
  12.             if (con == null || con.isClosed()) {   
  13.                 Class.forName(driver);   
  14.                 con = DriverManager.getConnection(url, username, password);   
  15.                 threadLocalCon.set(con);   
  16.                    
  17.                 System.out.println("当前线程="+Thread.currentThread().getName()+",新建连接"+con);   
  18.                 System.out.println("当前线程="+Thread.currentThread().getName()+",threadLocalCon.get()="+threadLocalCon.get());   
  19.                 try {   
  20.                     System.out.println("当前线程="+Thread.currentThread().getName()+",开始休眠");   
  21.                     Thread.currentThread().sleep(10000);   
  22.                     System.out.println("当前线程="+Thread.currentThread().getName()+",结束休眠");   
  23.                 } catch (InterruptedException e) {   
  24.                     // TODO Auto-generated catch block   
  25.                     e.printStackTrace();   
  26.                 }   
  27.             }   
  28.         } catch (ClassNotFoundException e) {   
  29.             e.printStackTrace();   
  30.         } catch (SQLException e) {   
  31.             e.printStackTrace();   
  32.         }   
  33.         return con;   
  34.     }  
//线程局部变量
	protected static ThreadLocal<Connection>  threadLocalCon = new ThreadLocal<Connection>();
	
	/*
	 * 获取数据库连接
	 */
	public static  Connection getCon() {

		Connection con = threadLocalCon.get();
		System.out.println("当前线程名称="+Thread.currentThread().getName()+",con="+con);
		try {
			if (con == null || con.isClosed()) {
				Class.forName(driver);
				con = DriverManager.getConnection(url, username, password);
				threadLocalCon.set(con);
				
				System.out.println("当前线程="+Thread.currentThread().getName()+",新建连接"+con);
				System.out.println("当前线程="+Thread.currentThread().getName()+",threadLocalCon.get()="+threadLocalCon.get());
				try {
					System.out.println("当前线程="+Thread.currentThread().getName()+",开始休眠");
					Thread.currentThread().sleep(10000);
					System.out.println("当前线程="+Thread.currentThread().getName()+",结束休眠");
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} catch (SQLException e) {
			e.printStackTrace();
		}
		return con;
	}

 

 

启动2个线程先后发出请求：



 

小结：

1、线程局部变量threadLocalCon为每一个线程分别提供一个该变量的副本，所以，每个线程第一次访问该变量时，通过get()取得的值都是null。

2、客户端的每一次请求，服务端都会新建一个线程为其服务，一次请求结束，相对应的线程也随之随之结束。

 

示例2、

在getCon()方法中加上synchronized关键字，再次执行（两次请求之间发起时间间隔短于10秒），看效果：

 

 

小结：
 1、synchronized是利用锁的机制，使变量或代码块在某一时该只能被一个线程访问，第一个线程在getCon()执行完成之前，第二个线程只能等待。

 

文章来自于：

http://www.iteye.com/topic/179040

http://huangqiqing123.iteye.com/blog/1428071

http://javabeezer.iteye.com/blog/644561

http://lighter.iteye.com/blog/133136

 


http://www.niftyadmin.cn/n/3298010.html

相关文章

腾讯十周年，看看你的QQ是什么时候注册的？

腾讯十周年，看看你的QQ是什么时候注册的？

最近&#xff0c;腾讯十周年放出了一个有趣的功能&#xff0c;可以查询&#xff08;http://10.qq.com/&#xff09;你的QQ是什么时候注册的&#xff0c;还能统计出你的好友分布。我的结果如下&#xff1a; 我现在用的QQ注册于2000年07月29日&#xff0c;QQ年龄8.3年。 转载于:h…
阅读更多...
Java JUC高并发编程(五)-线程池Fork/Join异步回调

Java JUC高并发编程(五)-线程池Fork/Join异步回调

目录 一、ThreadPool线程池 1、概述 2、线程池的架构 3、线程池使用方式 4、线程池底层原理 5、线程池的七个参数 6、线程池底层工作流程 7、拒绝策略 8、自定义线程池 二、Fork/Join分支合并框架 1、概述 2、Fork/Join分支合并框架 三、CompletableFuture异步回调…
阅读更多...
动态代理 jdk as cglib asm

动态代理 jdk as cglib asm

jdk的代理分为静态代理和动态代理&#xff0c;静态代理用的很少&#xff0c;一般都是动态代理&#xff0c;CGLIB代理是生成的目标类的子类&#xff0c;所以类和方法不能声明为final的&#xff0c;要不然就会有问题jdk的代理是必须要实现接口的&#xff0c;而CGLIB不是&#xff…
阅读更多...
Docker学习(一)-简介

Docker学习(一)-简介

目录 一、概述 二、Docker安装 Docker安装前提条件 Docker的基本组成 Docker架构图 Docker安装 hello-word示例&#xff1a; 三、Docker运行原理 四、Docker常用命令 1、帮助命令 2、镜像命令 3、容器命令 五、Docker镜像原理 Docker镜像加载原理 六、Docker容器…
阅读更多...
不能失去你所以我为你改变自己

不能失去你所以我为你改变自己

不能失去你所以我为你改变自己从 喷嚏网--读书、培训、8小时外的健康生活! 之 [铂程斋] 作者&#xff1a;xilei1 那时候洛洛和陈果已通过网络“相识”了两年。洛洛是石家庄的&#xff0c;而陈果是长沙的。两人聊得很开心&#xff0c;一直以来也很默契。两个人常常想到一起&…
阅读更多...
用mstsc連接服務器收到超出最大連接數的問題

用mstsc連接服務器收到超出最大連接數的問題

方法一:在win2003里面copy一個sysdir/windows/system32/tsadmin.exe文件運行連接,將那幾個占坑不拉s的人給踢出去,然后重新連接 方法二:運行里面輸入mstsc /console /v:yourservernameorIP:port連接(以前可以用,但不知道為什,我手下的幾臺服務器都無法用) 转载于:https://www.c…
阅读更多...
Docker学习(二)-DockerFile

Docker学习(二)-DockerFile

目录 一、DockerFile解析 DockerFile构建过程解析 DockerFile保留字指令 二、本地镜像发布到阿里云 一、DockerFile解析 DockerFile是用来构建Docker镜像的构建文件&#xff0c;是由一系列命令和参数构成的脚本。 构建三步骤&#xff1a; 1、编写DockerFile文件 2、doc…
阅读更多...
有状态as无状态之线程问题

有状态as无状态之线程问题

有状态就是有数据存储功能。有状态对象(Stateful Bean)&#xff0c;就是有实例变量的对象 &#xff0c;可以保存数据&#xff0c;是非线程安全的。在不同方法调用间不保留任何状态。 无状态就是一次操作&#xff0c;不能保存数据。无状态对象(Stateless Bean)&#xff0c;就是没…
阅读更多...
最新文章

Copyright @ 2022~2023