线程安全和非线程安全

Java面试和笔试中经常会问到

String线程安全StringBuffer线程安全StringBuilder非线程安全

HashMap非线程安全的HashTable线程安全的vector线程安全的

但是接下来会问你，不安全为什么还会用，因为HashMap效率更高，如果想让它变成安全的，加同步锁（）

那什么叫线程安全什么叫非线程安全呢？

一、线程

什么叫做线程呢？

建议可以看一下阮一峰大神的博客：http://www.ruanyifeng.com/blog/2013/04/processes_and_threads.html

讲的非常通俗易懂，留言中的内容也要看，因为是转载的，有很多地方值得商榷。

二、线程安全和非线程安全

当多个线程同时操作同一个对象，修改某一个属性的时候，不会发生问题就称之为“线程安全”

可能会出现问题，就是“非线程安全的”

比如说ArrayList和vector来说

在主线程中，new了一个ArrayList线程，现在开100个线程，每个线程向arraylist中存放100个元素，最后ArrayList中有多少个对象，10000？

先创建一个线程类（另外一篇文章会总结学习一下线程的三种实现方式）

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

package threadTest;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CountDownLatch;

public class Test {     
        public static void test()  
        {  
            // 用来测试的List  
            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());  
        } 
         public static void main(String[] args)  
            {  
                // 进行10次测试  
                for(int i = 0; i < 10; i++)  
                {  
                    test();  
                }  
            }

}

最后结果：

99799
99814
99765
100000
99868
99830
100000
99915
99858
99830

但是有时候会产生异常

这就是所谓的非线程安全

接下来换成线程安全的vector

将test里边的ArrayList换成vector

List<Object> list = new ArrayList<Object>();  

List<Object> list = new Vector<Object>();  

100000
100000
100000
100000
100000
100000
100000
100000
100000
100000

输出结果

在多试几次，还是一样的结果，因为vector是线程安全的,换成LinkedList结果和ArrayList类似，因为LinkedList也是非线程安全的

三、如何取舍

当存在多个线程操作同一对象的时候，就采用vector等线程安全的，如果不涉及，就采用ArrayList等，因为效率高

如果想要用ArrayList也可以，线程安全必须要使用很多synchronized关键字来同步控制，加同步锁

 List<Object> list = Collections.synchronizedList(new ArrayList<Object>());  

synchronized关键字同步，但是这样会降低效率
另外一种，实在方法前边用synchronized修饰方法

 一个计数器类

class Counter
{
    private int count = 0;

    public int getCount()
    {
        return count;
    }

    public void addCount()
    {
        count++;
    }
}

创建线程类

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

主线程

public class Main
{
    public static void main(String[] args)
    {
        // 进行10次测试
        for(int i = 0; i < 10; i++)
        {
            test();
        }
    }

    public static void test()
    {
        // 计数器
        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());
    }
}

9760282
9999073
9999969
9990000
9998743
9965715
9990000
9994370
9990945
9993745

创建一个线程安全的计数器

class Counter
{
    private int count = 0;

    public int getCount()
    {
        return count;
    }

    public synchronized void addCount()
        {
            count++;
        }
}

10000000
10000000
10000000
10000000
10000000
10000000
10000000
10000000
10000000

输出结果