ThreadLocal 与 Synchronized 总结

m635674608

浏览: 5041333 次
性别:
来自: 南京

最近访客更多访客>>

wusuosuo

yijiaomuqing

millerchu

xdung

博主相关

博客

微博

相册

留言

关于我

文章分类

社区版块

存档分类

博客分类：

java

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

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

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

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

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

Java代码

1. Public synchronized void method(){
2. //….
3. }

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

Java代码

1. public void method()
2. {
3. synchronized (this) // (1)
4. {
5. //…..
6. }
7. }

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

Java代码

1. public void method(SomeObject so) {
2. synchronized(so)
3. {
4. //…..
5. }
6. }

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

Java代码

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

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

Java代码

1. Class Foo
2. {
3. public synchronized static void method1() // 同步的static 函数
4. {
5. //….
6. }
7. public void method2()
8. {
9. synchronized(Foo.class) // class literal(类名称字面常量)
10. }
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代码

synchronized void method(){
...
}

在功能上,它相当于

Java代码

void method() {
synchronized (this) {
...
}
}

2、synchronized类方法

Java代码

class Something {
static synchronized void method(){
...
}
}

在功能上,它相当于

Java代码

class Something {
static void method() {
synchronized (Something.class){
...
}
}
}

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

Java代码

void method() {
lock();
try{
...
}finally{
unlock();
}
}

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

Java代码

public class Gate {
private int counter = 0;
private String name = "Nobody";
private String address = "Nowhere";
private final Mutex mutex = new Mutex();
public void pass(String name, String address) { // 并非synchronized
mutex.lock();
try {
this.counter++;
this.name = name;
this.address = address;
check();
} finally {
mutex.unlock();
}
}
public String toString() { // 并非synchronized
String s = null;
mutex.lock();
try {
s = "No." + counter + ": " + name + ", " + address;
} finally {
mutex.unlock();
}
return s;
}
private void check() {
if (name.charAt(0) != address.charAt(0)) {
System.out.println("***** BROKEN ***** " + toString());
}
}
}

设计简单的Mutex类1:

Java代码

public final class Mutex {
private boolean busy = false;
public synchronized void lock() {
while (busy) {
try {
wait();
} catch (InterruptedException e) {
}
}
busy = true;
}
public synchronized void unlock() {
busy = false;
notifyAll();
}
}

设计完善的Mutex类2:

Java代码

public final class Mutex {
private long locks = 0;
private Thread owner = null;
public synchronized void lock() {
Thread me = Thread.currentThread();
while (locks > 0 && owner != me) {
try {
wait();
} catch (InterruptedException e) {
}
}
// locks == 0 || owner == me
owner = me;
locks++;
}
public synchronized void unlock() {
Thread me = Thread.currentThread();
if (locks == 0 || owner != me) {
return;
}
// locks > 0 && owner == me
locks--;
if (locks == 0) {
owner = null;
notifyAll();
}
}
}

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

Java代码

synchronized (obj) {
...
}

这样的程序代码中，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代码

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;
}

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。

接着说ThreadLocal。

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

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

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

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

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

示例1：

Java代码

//线程局部变量
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;
}

//线程局部变量
	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个线程先后发出请求：