多线程学习之（一）线程安全性

• 编写线程安全的代码，其核心在于要对状态访问操作进行管理，特别是对共享和可变的状态的访问。
  
  • 共享：变量可以由多个线程同时访问；
  • 可变：变量的值在其生命周期内可以发生变化（包括变量引用的对象的值的变化）；

ps：①类的局部变量是存放在java栈内存上，成员变量是存放在java的堆内存上。而java栈内存是线程私有的，java堆内存是线程共享的。所以要控制类的成员变量；②在java里，类的静态(static)变量也是共享的，所以也要控制。那么java线程安全性是需要控制的是成员变量和静态变量。

可变，如果成员变量或静态变量被 final修饰，该变量被初始化后，变量
值不能再次被赋值，所以该变量是线程安全的。

如果一个变量是共享且可变的话，想让其是线程安全的话，必须使用同步机制。

• 如果当多个线程访问同一个可变的状态变量时没有使用合适的同步，那么程序就会出现错误。有三种方式可以修复这个问题：
  
  • 不在线程之间共享该状态变量
  • 将状态变量修改为不可变的变量
  • 在访问状态变量时使用同步

ps：不在线程之间共享该状态变量，破坏了共享条件；将状态变量修改为不可变的变量，破坏了可变条件；在访问状态变量时使用同步，使用同步机制，所以三个条件，满足其一，即可使线程安全。

• 线程安全性：当多个线程访问某个类时，这个类 始终 都能表现出正确的行为。

ps：因为多线程执行的时候，可能某次因线程执行的顺序关系，造成了程序达到了预期的效果。但并不是每次执行，都能达到程序预期效果。

• 不包含成员变量和静态变量的类，它们实例化的对象成为无状态对象。无状态对象一定是线程安全的。如下面的 Person 类：

public class Person {
    public void sayHello() {
        System.out.println("Hi, Girl!");
    }
}

• 原子操作
  Person 类有一个数数方法 count（）,每次调用，计数器就会增加1。

public class Person {
    private int counter;//计数器
    //数数方法
    public void count() {
        ++counter;//每次增加1
        try {
            Thread.sleep(5);//线程睡眠5毫秒，为演示效果
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    //获取计数器的值
    public int getCounter() {
        return counter;
    }
}

下面启了4个线程，每个线程让 person 数10000次，并在线程数完10000次后，输出计数器的值。程序预期应该40000次（4 * 10000）。

public class PersonTest {

    public static void main(String[] args) {
        final Person person = new Person();
        // 人数数，从1数到10000
        Runnable runnable = new Runnable() {
            public void run() {
                for(int i = 0; i < 10000; i++) {
                    person.count();
                }
                System.out.println(Thread.currentThread().getName()
                        + "，counter=>" + person.getCounter());
            }
        };
        //启动两个线程数数
        Thread firThread = new Thread(runnable, "firThread");
        Thread secThread = new Thread(runnable, "secThread");
        Thread thiThread = new Thread(runnable, "thiThread");
        Thread fouThread = new Thread(runnable, "fouThread");
        //启动线程
        firThread.start();
        secThread.start();
        thiThread.start();
        fouThread.start();
    }
}

程序某次运行结果：

thiThread，counter=>39875
fouThread，counter=>39895
firThread，counter=>39895
secThread，counter=>39903

最后结束的线程是 secThread，计数器的值却是 39903，并不是预期的40000。

原因是，Person类非线程安全类。计数器counter是线程共享且可变的。为了让Person类变成线程安全类，可以在count（）方法上，增加同步synchronized。

    public synchronized void count() {
        ++counter;
        try {
            Thread.sleep(5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    public synchronized int getCounter() {
        return counter;
    }

再次运行 PersonTest 的 main 方法，程序执行结果：

fouThread，counter=>31884
secThread，counter=>32646
firThread，counter=>39435
thiThread，counter=>40000

程序运行结果与预期一致！

ps：原子操作，指某段代码块在同一时间内，只能有一个线程执行。代码中 ++counter，只有一行，看起来像原子操作，但是实际上并非属于原子操作。

在java中，成员变量是存放在主内存中，每个线程执行的时候，会有一个工作内存（线程私有）。执行 ++counter，其实java做了4步操作：
①从主内存中读取counter的值
②将counter写到加载到工作内存中
③将counter值+1，写到工作内存中
④方法结束后，将counter + 1 的值写到主内存中

当一个线程执行第③步还未执行第④步的时候，第二个线程执行①②操作时，读取的还是counter 没有加上1的值。这个值被称为失效值。

所以 ++counter 不是原子操作。但我们在方法上加了同步(synchronized)，每次只有一个线程能调用count（）方法，一个线程只有执行完第④步后，第二个线程才能执行，那么每次读取的counter值，都是counter + 1后的值。这样就不会有失效值的问题。