Java线程安全和非线程安全

发布时间:2018-05-08作者:laosun阅读(524)

Java线程安全和非线程安全

ArrayList是非线程安全的,Vector是线程安全的;HashMap是非线程安全的,HashTable是线程安全的;StringBuilder是非线程安全的,StringBuffer是线程安全的

    非线程安全的现象模拟

    这里就使用ArrayList和Vector二者来说明。


    下面的代码,在主线程中new了一个非线程安全的ArrayList,然后开1000个线程分别向这个ArrayList里面添加元素,每个线程添加100个元素,等所有线程执行完成后,这个ArrayList的size应该是多少?应该是100000个?

    public class Main {
    	
    	public static void main(String[] args) {
    		// 用来测试的ArrayList
    		List<Object> list = new ArrayList<Object>();
    
    		// 线程数量(1000)
    		int threadCount = 1000;
    
    		// 用来让主线程等待threadCount个子线程执行完毕
    		CountDownLatch countDownLatch = new CountDownLatch(threadCount);
    
    		// 启动threadCount个子线程
    		for (int i = 0; i < threadCount; i++) {
    			Thread thread = new Thread(new MyThread(list, countDownLatch));
    			thread.start();
    		}
    
    		try {
    			// 主线程等待所有子线程执行完成,再向下执行
    			countDownLatch.await();
    		} catch (InterruptedException e) {
    			e.printStackTrace();
    		}
    
    		// List的size
    		System.out.println(list.size());
    	}
    
    }
    
    class MyThread implements Runnable {
    	private List<Object> list;
    
    	private CountDownLatch countDownLatch;
    
    	public MyThread(List<Object> list, CountDownLatch countDownLatch) {
    		this.list = list;
    		this.countDownLatch = countDownLatch;
    	}
    
    	public void run() {
    		// 每个线程向List中添加100个元素
    		for (int i = 0; i < 100; i++) {
    			list.add(new Object());
    		}
    
    		// 完成一个子线程
    		countDownLatch.countDown();
    	}
    }

    运行上面的程序,输出结果:


    99946


    上面的输出结果发现,并不是预想中的100000,多运行几次可以发现每次结果都不一样。


    这就是非线程安全带来的问题了。上面的代码如果用于生产环境,就会有隐患就会有BUG了。


    再用线程安全的Vector来进行测试,上面代码改变一处,new ArrayList<Object>()改成new Vector<Object>(),再运行程序,输出结果:


    100000


    无论运行多少次,输出结果都是100000,因为Vector是线程安全的,在多线程操作同一个Vector对象时,不会有任何问题。


    有兴趣的话还可以再换成LinkedList试试,同样还会出现ArrayList类似的问题,因为LinkedList也是非线程安全的。


    二者如何取舍

    非线程安全是指多线程操作同一个对象可能会出现问题。而线程安全则是多线程操作同一个对象不会有问题。


    线程安全可能会使用很多synchronized关键字来同步控制,所以必然会导致性能的降低。


    所以在使用的时候,如果是多个线程操作同一个对象,那么使用线程安全的Vector;否则,就使用效率更高的ArrayList。


    非线程安全!=不安全

    有人在使用过程中有一个不正确的观点:我的程序是多线程的,不能使用ArrayList要使用Vector,这样才安全。


    非线程安全并不是多线程环境下就不能使用。注意我上面有说到:多线程操作同一个对象。注意是同一个对象。比如最上面那个模拟,就是在主线程中new的一个ArrayList然后多个线程操作同一个ArrayList对象。


    如果是每个线程中new一个ArrayList,而这个ArrayList只在这一个线程中使用,那么肯定是没问题的。


    线程安全的实现

    线程安全可以通过线程同步控制来实现的,例如synchronized关键字。


    在这里,我用代码分别实现了一个非线程安全的计数器和线程安全的计数器Counter,并对他们分别进行了多线程测试。


    非线程安全的计数器:

    public class Main {
    	
    	public static void main(String[] args) {
    		// 计数器
    		Counter counter = new Counter();
    
    		// 线程数量(1000)
    		int threadCount = 1000;
    
    		// 用来让主线程等待threadCount个子线程执行完毕
    		CountDownLatch countDownLatch = new CountDownLatch(threadCount);
    
    		// 启动threadCount个子线程
    		for (int i = 0; i < threadCount; i++) {
    			Thread thread = new Thread(new MyThread(counter, countDownLatch));
    			thread.start();
    		}
    
    		try {
    			// 主线程等待所有子线程执行完成,再向下执行
    			countDownLatch.await();
    		} catch (InterruptedException e) {
    			e.printStackTrace();
    		}
    
    		// 计数器的值
    		System.out.println(counter.getCount());
    	}
    
    }
    
    class MyThread implements Runnable {
    	private Counter counter;
    
    	private CountDownLatch countDownLatch;
    
    	public MyThread(Counter counter, CountDownLatch countDownLatch) {
    		this.counter = counter;
    		this.countDownLatch = countDownLatch;
    	}
    
    	public void run() {
    		// 每个线程向Counter中进行10000次累加
    		for (int i = 0; i < 10000; i++) {
    			counter.addCount();
    		}
    
    		// 完成一个子线程
    		countDownLatch.countDown();
    	}
    }
    
    class Counter {
    	private int count = 0;
    
    	public int getCount() {
    		return count;
    	}
    
    	public void addCount() {
    		count++;
    	}
    }

    上面的测试代码中,开启1000个线程,每个线程对计数器进行10000次累加,最终输出结果应该是10000000。


    但是上面代码中的Counter未进行同步控制,所以非线程安全。


    输出结果:


    9963727


    稍加修改,把Counter改成线程安全的计数器:

    class Counter {
    	private int count = 0;
    
    	public int getCount() {
    		return count;
    	}
    
    	public synchronized void addCount() {
    		count++;
    	}
    }

    上面只是在addCount()方法中加上了synchronized同步控制,就成为一个线程安全的计数器了。再次运行,输出结果:


    10000000


1 +1

版权声明

 Java  源码  扩展

 请文明留言

0 条评论