线程安全是多线程编程时一个非常重要的概念。一般而言，一个类或者程序所提供的接口对于线程来说是原子操作或者多个线程之间的切换不会导致该接口的执行结果存在二义性,我们认为这个类或者程序是线程安全的。在拥有共享资源的多线程并行执行的程序中，线程安全是通过同步机制保证各个线程都可以正常且正确的执行，不会出现数据污染的情况。在java多线程编程中，针对线程安全我们需要考虑任务的并行和并发，资源共享，是否产生竞态，程序的原子性，可见性，有序性等。

1.串行、并行和并发

    串行和并行指的是任务的执行方式。串行是指多个任务时，各个任务按顺序执行，完成一个之后才能进行下一个；并行指的是多个任务可以同时执行。如下图：我们先洗衣服，洗完衣服之后再做饭，做完饭之后再烧水，按照顺序一件一件的执行就是串行，当我们同时打开洗衣机洗衣服，打开蒸饭锅做饭和烧水，三件事同时执行则是并行。

    并发和并行是即相似又有区别的两个概念，并行是指两个或者多个事件在同一时刻发生；而并发是指两个或多个事件在同一时间间隔内发生。在多道程序环境下，并发性是指在一段时间内宏观上有多个程序在同时运行，但在单处理机系统中，每一时刻却仅能有一道程序执行，故微观上这些程序只能是分时地交替执行。倘若在计算机系统中有多个处理机，则这些可以并发执行的程序便可被分配到多个处理机上，实现并行执行，即利用每个处理机来处理一个可并发执行的程序，这样，多个程序便可以同时执行。例如：同样是洗衣服，做饭，烧水，我们只投入一个人，当做饭事这人先摘洗完菜，然后停下来去洗衣服，衣服洗到一半这人又去打水烧水，之后再回去炒菜……整个过程这个人是在以交替的方式或者等待某件事完成的时间去做其他事情，这种场景则是并发。
    多线程编程的实质就是将任务的处理方式有串行改为并发，即实现并发化，已发挥并发的优势。在一个处理器一次只能运行一个线程的情况下，由于处理器可以使用时间片分配的技术来实现同一段时间内运行多个线程，应此一个处理器就可以实现并发。如果我们有多个处理，每个处理器在同一时刻运行一个线程则可以实现并行。

2.原子性、可见性、有序性

   线程安全问题概括来说主要表现在三个方面：原子性，可见性和有序性。

1）原子性

   原子性的字面意思是表示不可分割的。在java多线程编程中，对于涉及共享变量访问的操作，若该操作除了执行线程以外的任意其他线程来看是不可分割的，那么我们认为该操作就是原子操作，对应的我们称该操作具有原子性。而其中的“不可分割”是指访问某个共享变量的操作从执行线程以外的其他线程来看，该操作要么执行结束要么从未发生，而其他线程不会看到该操作执行了部分的中间效果，这也是我们在多线程编程过程中对某个方法或者代码块使用synchronized或者锁的依据所在。

import lombok.Data;
import java.util.concurrent.ThreadLocalRandom;

@Data
public class AtomicityDemo {
    private User user;

    public AtomicityDemo( User user){
        this.user = user;
    }
    /**
     * 在多线程操作中非原子性操作
     * @param id
     * @param name
     */
    public  void setUser(int id,String name){
        try{
            user.setId(id);
            ThreadLocalRandom random = ThreadLocalRandom.current();
            Thread.sleep(random.nextInt(10));
            user.setName(name);
            System.out.println(user);
        }catch (Exception e){
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        User user = new User(1,"test");
        AtomicityDemo atomicityDemo = new AtomicityDemo(user);
        Thread t1 = new Thread(new Task(atomicityDemo));
        Thread t2 = new Thread(new Task(atomicityDemo));
        t1.start();
        t2.start();
    }
    @Data
    public static class User{
        private int id;
        private String name;
        public User(int id,String name){
            this.id = id;
            this.name = name;
        }
        @Override
        public String toString(){
            return "id:"+id+",name:"+name;
        }
    }

    public static class Task implements Runnable {
        private AtomicityDemo  demo;
        public  Task(AtomicityDemo  demo){
            this.demo=demo;
        }
        @Override
        public void run() {
            int n=0;
            while (n<10){
                demo.setUser(n,"name"+n);
                n ++;
            }

        }
    }
}

运行结果：

id:0,name:name0
id:1,name:name1
id:2,name:name0
id:1,name:name2
id:3,name:name3
id:4,name:name1
id:2,name:name4
id:5,name:name2
id:3,name:name5
id:3,name:name5
id:4,name:name6
id:7,name:name4
id:5,name:name7
id:8,name:name5
id:6,name:name8
id:9,name:name9
id:9,name:name6
id:7,name:name7
id:8,name:name8
id:9,name:name9

   在上边的例子中，我们会发现id和name并没有按照我们的想法出现在运行结果上，有很多地方id和name之后编号是不一致的，这说明我们的编码AtomicityDemo的setUser方法里的操作并不是原子性的，在一个线程操作期间另外的一个线程读取或者更新该操作访问的共享变量而导致了干扰和冲突的可能，user的信息有可能被多个线程交叉更新。当在AtomicityDemo的setUser方法前加上synchronized，在运行则没有这种情况。
   在java中有两种方式来实现原子性：一种是使用锁（Lock）,锁具有排它性，可以保障一个共享变量在任意一个时刻只能被一个线程访问。另一种方法是利用处理器专门提供的CAS指令，CAS指令实现原子性的方式与缩实现原子性的方式实质是相同的，差别是在于锁通常是在软件层次实现的，而CAS是直接在硬件层次的实现的，可以看做“硬件锁”。

2）可见性

   在java多线程编程中,可见性是指一个线程对共享变量更新的结果对于读取相应该共享变量的其他线程是否可见的问题。比如一个线程对某些共享变量更新之后，而后续访问这些变量的线程可能无法立刻读取这个更新的结果，甚至永远无法读取这个更新的结果，这就是多线程编程中线程安全的可见性问题，在过程中如果线程对共享变量更新之后，后续访问这些变量可以读取到更新后的结果，则这个线程对共享变量的更新对其他线程是可见的，否则就是不可见的。线程的不可见会使其他线程一直读取不到共享变量的最新值而导致程序出现我们所不期望的结果，这对多线程编程来说是非常严重的。

2）有序性

   java内存模型中，允许编译器和处理器对指令进行重排序，但是重排序过程不会影响单线程程序的执行，却会影响到多线程并发执行的正确性。多线程的有序性是指在什么情况下一个处理器运行的一个线程所执行的内存访问操作在另一个处理器上运行的其他线程看起来是乱序的，但是却不影响其他线程的执行的正确性。
注：上文中很多概念摘抄自《java多线程编程实战指南》，然后思考压缩总结出来。