JAVA线程基础（synchronized、同步与异步、volatile、脏读）

一、线程安全（synchronized）

线程安全概念：当多个线程访问某一个类（对象或方法）时，这个类始终都能表现出正确的行为，那么这个类（对象或方法）就是线程安全的。

synchronized：可以在任意对象及方法上加锁，而加锁的这段代码称为“互斥区”或“临界区”
下面看一个例子： 

public class MyThread extends Thread {

    private int count = 5;

    @Override
    public void run() {
        count--;
        System.out.println(currentThread().getName() + " count = " + count);
    }

    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        Thread t1 = new Thread(myThread, "t1");
        Thread t2 = new Thread(myThread, "t2");
        Thread t3 = new Thread(myThread, "t3");
        Thread t4 = new Thread(myThread, "t4");
        Thread t5 = new Thread(myThread, "t5");

        t1.start();
        t2.start();
        t3.start();
        t4.start();
        t5.start();
    }
}

输出的结果如下：

t3 count = 3 
t2 count = 3 
t1 count = 2 
t5 count = 1 
t4 count = 0

该段代码就是使用了继承Thread类，然后实现重写run方法，run方法中，进行了count–操作，并打印了当前的线程名称，之后产生了5个线程来调用同一份资源count，这样，多个线程都去count–操作，那么如果两个线程有可能会取到相同的值，这时候打印出来的值就是相同的了。
这个结果呢，有的时候是对的，有的时候就像上面所示的那样，是错误的结果，多试几次就好了，因为谁也没办法决定cpu到底选择谁不是，所以，这个按咱们上面线程安全的定义来讲，肯定是不安全的，因为他的结果是不正确的。
那么如何避免多个线程同时获取到相同的count值呢，那么就需要用到synchronized了，将代码做如下修改：

@Override
public synchronized void run() {
    count--;
    System.out.println(currentThread().getName() + " count = " + count);
}

这样，加了synchronized 锁以后，多个线程就不会获取到相同的值了，运行结果如下：

t1 count = 4 
t5 count = 3 
t4 count = 2 
t2 count = 1 
t3 count = 0

可能大家也注意到了，尽管结果正确，但是每次打印出来的线程名称并不是按照t1-t5这样顺序执行的，那是为什么呢？因为cpu在选择线程的时候是随机的。

当多个线程访问Thread的run方法时，以排队的方式进行处理（这里排队是按照CPU分配的先后顺序而定的），一个线程必要的执行synchronized修饰的方法里的代码：

1、如果拿到锁，执行synchronized代码体内容；
2、拿不到锁，这个线程就会不断的尝试获得这把锁，直到拿到为止（等待），而且是多个线程同时去竞争这把锁。（也就是会引起线程竞争的问题）

所以，虽然锁能够解决多线程下的线程安全问题，但是会引入新的问题，所以使用的时候要慎重。

二、多个线程多个锁

多个线程中，如果每个线程操作的对象是不同的，那么就会为每个线程产生一把锁，这个时候，在不同的线程中，锁是不起作用的。

下面看一个例子：

public class MultiThread {

    private int num = 0;

    public synchronized void printNum(String tag) throws InterruptedException {
        if (tag.equals("a")) {
            num = 100;
            System.out.println("tag a, set num over!");
            Thread.sleep(1000);
        } else {
            num = 200;
            System.out.println("tag b, set num over!");
        }

        System.out.println("tag " + tag + ", num = " + num);
    }

    public static void main(String[] args) {
        MultiThread m1 = new MultiThread();
        MultiThread m2 = new MultiThread();

        Thread t1 = new Thread(() -> {
            try{
                m1.printNum("a");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        Thread t2 = new Thread(() -> {
            try{
                m2.printNum("b");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        t1.st