并发编程2-安全的发布对象

悠悠 2022-08-06 11:22 132阅读 0赞

前文只是介绍了volitale关键字能够关闭重排序，缓存寄存器等优化来防止可见性发生问题。

但是并发编程更多的是对发布(放到可以供其他线程访问的区域，比如static 集合等)的对象进行多线程处理，这里讨论下如何能够安全的发布这些对象。

通常有如下的手段：

## 栈限制  ##

局部变量，也就是方法内的变量，因为线程私有栈，因此这个变量也是私有的，不会存在并发问题。 当然这个不是解决线程共享对象的，实际上我们写的代码中大多数的对象都是这样使用的，因此没有故意去注意并发仍然运行起来没有问题。

## 线程限制 ##

使用ThreadLocal来把一个对象变成线程内共享。 也不是解决线程间共享的，其很适用于保存线程内很多地方都会用到的大对象。

package com.prince.concurrent;  
      
    import java.sql.Connection;  
    import java.sql.DriverManager;  
    import java.sql.SQLException;  
      
    public class ConnectionManager {  
      
        private static ThreadLocal<Connection> connectionHolder = new ThreadLocal<Connection>() {  
            @Override  
            protected Connection initialValue() {  
                Connection conn = null;  
                try {  
                    conn = DriverManager.getConnection(  
                            "jdbc:mysql://localhost:3306/test", "username",  
                            "password");  
                } catch (SQLException e) {  
                    e.printStackTrace();  
                }  
                return conn;  
            }  
        };  
      
        public static Connection getConnection() {  
            return connectionHolder.get();  
        }  
      
        public static void setConnection(Connection conn) {  
            connectionHolder.set(conn);  
        }  
    }

原理上比较简单。 在虚拟机上维护了一个map,可以根据当前线程id得到另外一个map,然后根据当前ThreadLocal实例来得到hold的对象。

## 线程安全的对象 ##

这种对象内部使用了锁或者其他的机制，保证了每个方法都是安全的。  JVM在性能和安全上的考虑对很多类都提供了两个版本的实现，安全的和不安全的。比如

AtomicInteger 和Integer

StringBuffer 和StringBuilder

Vector和ArrayList

HashTable和HashMap等等。

**AtomicInteger 和Integer**

class CounterNoSafe{
    	private Integer count = 0;
    	public void addOne(){
    		count++;
    	}
    	
    	public Integer getCount(){
    		return count;
    	}
    }
    
    class CounterSafe{
    	private AtomicInteger count = new AtomicInteger(0);
    	public void addOne(){
    		count.getAndIncrement();
    	}
    	
    	public Integer getCount(){
    		return count.get();
    	}
    }

private void testAtomicInteger() throws InterruptedException{
    		final CounterNoSafe counter1 = new CounterNoSafe();
    		new Thread(){
    			public void run() {
    				for (int i = 0; i < 1000; i++) {
    					counter1.addOne();
    				}
    			};
    		}.start();
    		
    		for (int i = 0; i < 1000; i++) {
    			counter1.addOne();
    		}
    		
    		TimeUnit.SECONDS.sleep(2);
    		
    		System.out.println(counter1.getCount());
    		
    		
    		final CounterSafe counter2 = new CounterSafe();
    		new Thread(){
    			public void run() {
    				for (int i = 0; i < 1000; i++) {
    					counter2.addOne();
    				}
    			};
    		}.start();
    		
    		for (int i = 0; i < 1000; i++) {
    			counter2.addOne();
    		}
    		
    		TimeUnit.SECONDS.sleep(2);
    		
    		System.out.println(counter2.getCount());
    	}

将会打印 1327 2000.

可见不安全的计数器是有问题的。

AtomicInteger并不是通过锁的机制来解决并发问题的，而是使用如下的代码：

public final int getAndIncrement() {
            for (;;) {
                int current = get();
                int next = current + 1;
                if (compareAndSet(current, next))
                    return current;
            }
        }

这样可以获得更好的性能， 之后还会讨论

**StringBuffer和StringBuilder**

private void testStringBufferAndBuilder() throws InterruptedException {
    		final StringBuffer sbf = new StringBuffer();
    		new Thread(){
    			public void run() {
    				for (int i = 0; i < 10000; i++) {
    					sbf.append(1);
    				}
    			};
    		}.start();
    		
    		for (int i = 0; i < 10000; i++) {
    			sbf.append(1);
    		}
    		TimeUnit.SECONDS.sleep(2);
    		
    		System.out.println(sbf.length());
    		
    		final StringBuilder sbd = new StringBuilder();
    		new Thread(){
    			public void run() {
    				for (int i = 0; i < 10000; i++) {
    					sbd.append(1);
    				}
    			};
    		}.start();
    		
    		
    		for (int i = 0; i < 10000; i++) {
    			sbd.append(1);
    		}
    		
    		TimeUnit.SECONDS.sleep(2);
    		
    		System.out.println(sbd.length());
    	}

将会打印2000和17836

这个是因为StringBuilder是线程不安全的，因此在并发写入的时候，内部状态出现了错误。   但是它相对快一点，单线程的时候可以使用。

集合的并发后面再说