Java的并发

Java的并发

一、同步访问共享的可变数据

1.1 关键词synchronized

关键词synchronized 可以保证在同一时刻，只有一个线程可以执行某一个方法，或者某一个代码块。

1.2 同步的概念

同步不仅可以阻止一个线程看到对象出于不一致的状态之中，它还可以保证进入同步方法或者同步代码块的每个线程，都能看到由同一个锁保护的之前所有的修改效果。

为了在线程之间进行可靠的通信，也为了互斥访问，同步是必要的。

（1）同步是一种互斥的方式

当一个对象被一个线程修改的时候，可以阻止另一个线程观察到对象内部不一致的状态。

对象被创建的时候出于一致的状态。当有方法访问它的时候，它就被锁定了。这些方法观察到对象的状态，并且可能会引起状态转变，即把对象从一种一致的状态转换成另一种一致的状态。正确地使用同步可以保证没有任何方法会看到对象出于不一致的状态中。

（2）如果没有同步，一个线程的变化就不能被其他线程看到

1.3 Java语言规范保证读或者写一个变量是原子的，除非这个变量的类型为long或者double

换句话说，读取一个非long或double类型的变量，可以保证返回值是某个线程保存在该变量中的，即使多个线程在没有同步的情况下并发地修改这个变量也是如此。

你可能听说过，为了提高性能，在读或写原子数据的时候，应该避免使用同步。这个建议是非常危险的而错误的。虽然语言规范保证了线程在读取原子数据的时候，不会看到任意的数据，但是它并不保证一个线程写入的值对于另一个线程将是可见的。

1.4 千万不要使用Thread.stop方法

因为Thread.stop本质上是不安全的——使用它会导致数据遭到破坏。

要阻止一个线程妨碍另一个线程，建议的做法是让第一个线程轮询一个boolean域。这个域一开始为false，但是可以通过第二个线程设置为true，以表示第一个线程将终止自己。

下面的例如，由于没有同步，就不能保证后台线程何时“看到“主线程对stopRequested对值所做的改变：

public class StopThread {
   

    private static boolean stopRequested;

    public static void main(String[] args) throws InterruptedException {
   
        Thread backgroundThread = new Thread(()->{
   
           int i=0;
           while (!stopRequested){
   
               i++;
           }
        });
        backgroundThread.start();

        TimeUnit.SECONDS.sleep(1);
        stopRequested = true;
    }
}

没有同步，虚拟机将把一下代码：

           while (!stopRequested){
   
               i++;
           }

转变成这样：

if(!stopRequested){
   
		while(true)
			i++;
}

这种优化称作提升。结果是一个活性失败：程序并没有得到提升。

修正这个问题的一种方式是同步访问stopRequested域。

1.5 除非读和写操作都被同步，否则无法保证同步能起作用

注意读方法和读方法都被同步了。

/**
 * @Date 2020/2/16
 * @Author lifei
 */
public class StopThread {
   
    private static boolean stopRequested;

    private static synchronized void requestStop(){
   
        stopRequested = true;
    }

    private static synchronized  boolean stopRequested(){
   
        return stopRequested;
    }

    public static void main(String[] args) throws InterruptedException {
   
        Thread backgroundThread = new Thread(()->{
   
            int i=0;
            while (!stopRequested()){
   
                i++;
            }
        });
        backgroundThread.start();

        TimeUnit.SECONDS.sleep(1);
        requestStop();
    }
}

1.6 volatile修饰符的使用

StopThread中被同步方法的动作即使没有同步也是原子的。换句话说，这些方法的同步只是为了它的通信效果，而不是为了互斥访问。

如果stopRequested被声明为volatile,第二种版本的StopThread中的锁就可以省略。虽然volatile修饰符不执行互斥访问，但它可以保证任何一个线程在读取该域的时候都将看到最近刚刚被写入的值。

public class StopThread {
   

    private static volatile boolean stopRequested;

    public static void main(String[] args) throws InterruptedException {
   
        Thread backgroundThread = new Thread(()->{
   
            int i=0;
            while (!stopRequested){
   
                i++;
            }
        });
        backgroundThread.start();

        TimeUnit.SECONDS.sleep(1);
        stopRequested = true;
    }
}

1.7 使用volatile时应该小心

因为增量操作符(++)不是原子的。下面的程序会出现**安全性失败**：这个程序会计算出错误的结果。

    // Broken - require synchronization!
    private static volatile int nextSerialNumber = 0;
    
    public static int generateSerialNumber(){
   
        return nextSerialNumber++;
    }

1.8 了解和使用类库

上面的代码还可以改用AtomicLong类，它是java.util.concurrent.atomic的组成部分。这个包为单个变量上进行免锁定、线程安全的编程提供了基本类型。

虽然volatile提供了同步的通信效果，但这个包还提供了原子性：

    private static final AtomicLong nextSerialNumberAtomic = new AtomicLong();
    
    public static long generateSerialNumberAtomic(){
   
        return nextSerialNumberAtomic.getAndIncrement();
    }

二、避免过度的同步

为了避免活性失败和安全性失败，在一个被同步的方法或者代码块中，永远不要放弃对客户端的控制。

换句话说，在一个被同步的区域内部，不要调用设计成要被覆盖的方法，或者是由客户端以函数对象的形式提供的方法。

从包含该同步区域的类的角度来看，这样的方法是外来的。

这个类不知道该方法会做什么事情，也无法控制它。根据外来方法的作用，从同步区域中调用它会导致异常、死锁或者数据损坏。

2.1 异常和死锁

下面的代码，它实现了一个可以观察到的集合包装。该类允许客户端在将元素添加到集合中时预订通知。这就是观察者模式。

ObservableSet这个类在可重用的ForwardingSet上实现的：

/**
 * @Date 2020/2/17
 * @Author lifei
 */
public interface SetObserver<E> {
   

    // Invoked when an element is added to the observable set
    void added