1.1 线程安全

线程安全概念：当多个线程访问某一个类（对象或方法时），这个类始终都能表现出正确的行为，那么这个类（对象或方法）就是线程安全的。
synchronized：可以在任意对象及方法上加锁，而加锁的这段代码称为“互斥区”或“临界区”

下面看一个例子：
MyThread.java

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在选择线程的时候是随机的。

现在来理解一下synchronized 关键字，他可以理解为一把锁，当一个线程进去了run方法的时候，就相当于是对run方法加了一把锁，那么其他线程就只能在门外等待，无法进入run方法，当线程执行完成后，其他的几个线程会竞争这把锁。

其实这里会带来一些问题，现在的线程数比较少，但是线程数比较多的时候呢，下面就来看看实际情况。

这是我的电脑，平时占用cpu基本也就是10%一下，看一下运行这几个线程的时候cpu占用情况如何：

看到了吧，几个线程运行，cpu之间爆表，如果是一千个？一万个线程呢？cpu会不会爆掉，实际在运行的时候情况可能更加复杂，爆掉的几率那是杠杠的。

因为我们的run方法一次只能执行一个线程，其他线程都要在外面等待，这是一个问题，第二个问题是前一个线程出来的时候，其他的线程都要进行竞争。

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