Java 并发编程之对象的共享（二）

线程封闭

一般在单线程内访问数据就不需要同步，这种技术叫做线程封闭，在Swing中大量使用了线程封闭技术，Swing的可视人化组件和数据模型对象都不是线程安全的，Swing通过将它们封闭到Swing的事件分发线程中来实现线程安全性。

线程封闭的另一个常见应用是JDBC的Connection对象，JDBC规范并不要求Connection对象必须是线程安全的。应用程序服务器连接池是线程安全的，连接池通常会由多个线程同时访问，因此非线程安全的连接池是毫无意义的。

一个安全的线程池通常要实现下列接口

    package mysql;  
    import java.sql.*;  
    import java.sql.ResultSet;  
    public interface Pool  
    {  
        public boolean start(String dbname,String user,String psw);  //启动数据库连接池服务  
        //以下start函数将允许用户设置最低空闲连接数，最高空闲连接数,最大连接数  
        public boolean start(int lows,int maxs,int maxc,String dbname,String user,String psw);  
        public Connection getConnection();  //得到连接器  
        public boolean freeConnection(Connection con);//将连接返回到连接池中  
        public boolean close(); //清除连接池，并且关闭它（使之变得不可用）  
    }  

Ad-hoc线程封闭

 这个是指，维护线程封闭性的职责完全由程序实现来承担，Ad-hoc线程封闭是非常脆弱的。因为没有语言特性可以将对象封闭到目标线程上，事实上对线程封闭对象的引用通常保存在公有变量 中。

栈封闭

栈封闭是线程封闭的一种特例。在栈封闭中只能通过局部变量才能访问对象。

	public int loadTheArk(Collection<Animal> candidates) {
		SortedSet<Animal> animals;
		int numpairs = 0;
		Animal cnadidate = nul;
		animals = new TreeSet<Animal>(new GenderComparator());
		animals.addAll = (candidates);
		for (Animal a : animals) {
			if (candidates == null || !candidates.isPotentalMate(a)) {
				cnadidate = a;
			} else {
				ark.load(new AnimalPair(candidates, a));
				++numpairs;
				candidates = null;
			}
		}
		return numpairs;
	}

例如上面程序的Numpairs对象。无论如何都不会破坏栈封闭性。由于任何方法 都 无法 获得对基本类型的引用。同时只有一个引用指向集体animals,这个引用被封闭在局部变量中，因为也被封闭在执行线程中。

ThreadLocal类

维持线程封闭性的一种更规范的方法是使用ThreadLocal。这个类能使线程中的某个值与保存值 的对象关联起来。它提花了get与set等 访问接口或方法，这个方法为每个使用该 变量的纯种都 存有一个独立 的副本，因此get总是返回由当前执行线程在调用set时设置 的最新值。

	public static ThreadLocal<Connection> connectionHolder = new ThreadLocal<Connection>() {
		public Connection initialValue() {
			return DriverManager.getConnection(url);
		}
	};

	public static Connection getConnection() {
		return connectionHolder.get();
	}

这个ThreadLocal相当于 一个单线程池。当某个频繁执行的操作需要一个临时对象 ，例如 一个缓冲 区，而同时又希望避免在每次执行时都重新分配该临时对象，就可以使用这项技术 。

它会降低可重用性，也会在类之间引入隐含的耦合性，所以在使用格外小心 。

为此还做了一个小实验证明其线程安全性。

public class unsafe {
	public static ThreadLocal<Integer> connectionHolder = new ThreadLocal<Integer>() {
		
		@Override
		protected Integer initialValue() {
			// TODO Auto-generated method stub
			int a = 1;
			return a;
		}
	};

	public static void main(String[] Args) {
		new Thread(new Runnable() {

			@Override
			public void run() {
				// TODO Auto-generated method stub
				connectionHolder.set(2);
			}
		}).start();
		System.out.println(connectionHolder.get());
		connectionHolder.set(2);
		System.out.println(connectionHolder.get());
	}
}

输出结果 ：

1

2

证明只可以在主线程中对其进行修改。

不变性

不可变的对象一定是线程安全的。但是不可变不等于将所有的域都声明为final类型，即使这么做了那么这个对象仍然是可变的，因为在final类型的域中可以保存对可变对象的引用 。

举个栗子

import java.util.ArrayList;

public class unsafe {
	private final static java.util.List<Integer> unsafevalue = new ArrayList<Integer>();

	public static void main(String[] agrs) {
		unsafevalue.add(2);
		System.out.println(unsafevalue.get(0));
	}
}

如果这上面个类有个get方法可以得到unsafevalue，那么仍然可以对final声明的域进行修改。

当满足三个条件时，对象才是不可变的。上面final的声明只是条件之一

• 对象创建以后其状态不能被修改
• 对象所有域都是Final类型
• 对象 是正确创建的（没有this引用逸出）

再举个栗子

import java.util.ArrayList;

public final class unsafe {
	private final static java.util.List<Integer> unsafevalue = new ArrayList<Integer>();

	unsafe() {
		unsafevalue.add(2);
		unsafevalue.add(3);
		unsafevalue.add(4);
	}

	public boolean isExist(int t) {
		if (unsafevalue.contains(t)) {
			return true;
		}
		return false;
	}
}

一个好的编程习惯：

除非需要更高的可见性，否则都声明为私有域，除非需要变化，否则都声明为final类型。

安全发布的常用模式

• 在静态初始化函数中初始化一个对象引用
  
• 将对象的引用保存到volatile类型的域或者 AtomicReferance对象 中
• 将对象的引用保存到某个正确 的构造对象中Final类型域中
• 将对象 的引用保存到一个由锁保护的域中

java的线程安全库中提供了一下安全发布保证

• 通过将一个键或者值放入 Hashtable,synchronizedMap或者ConcurrentMap中，可以安全的将它发发布给任何从这个引起窗口中访问它的线程
• 通过将某个元素放入Vector,CopyOnWriteArrayList，CopyOnWriteArraySet.synchronizedList或synchronizedSet中，可以将元素安全的发布
• 通过 将某个元素放在BLockingQueue或者ConcurrentLinkedQueue中。可以将元素安全的发布

通常要发布一个静态构造的对象 ，最简单和最安全的方式就是使用静态的初始化容器

静态初始化器由JVM在类的初始化阶段执行，由于在jvm内部存在着同步机制，因为通过 这种方式初始化的任何对象 都可以安全的发布。换句话说，就是声明为静态类型的具有最高优先级。

参考资料《java 并发编程实战》