并发编程之关键字（synchronized、volatile）

　　并发编程主要设计两个关键字：一个是synchronized，另一个是volatile。下面主要讲解这两个关键字，并对这两个关机进行比较。

synchronized

　　 synchronized是通过JMV种的monitorenter和monitorexit指令实现同步。monitorenter指令是在编译后插入到同步代码的开始位置，而monitorexit插入到同步代码的结束位置和异常位置。每一个对象都与一个monitor相关联，当monitor被只有后，它将处于锁定状态。

　　当一个线程试图访问同步代码时，它必须先获得锁；退出或者抛出异常时，必须释放锁。Java中，每一个对象都可以作为锁。具体的表现形式有3种：

• 对于普通的同步方法，锁是当前的实例对象（this对象）

权限修饰符 synchronized 返回值类型 函数名（形参列表..）{
       //函数体
}

• 对于静态同步方法，锁是当前类的Class对象

权限修饰符 static synchronized 返回值类型 函数名（形参列表..）{
       //函数体
}

• 对于同步方法块，锁是Synchronized括号中配置的对象
  • 锁对象必须是多线程共享的对象，否则锁不住

Synchronized（锁）{
   //需要同步的代码块
}

　　注意：在同步代码块/同步方法中调用sleep()不会释放锁对象，调用wait()会释放锁对象

　　Synchronized提供了一种排他式的数据同步机制，某个线程在获取monitor lock的时候可能会被阻塞，而这种阻塞有两个明显的缺陷：1. 无法控制阻塞时长； 2. 阻塞不能被中断

public class SyncDefect {

    /**
     *线程休眠一个小时
     */
    public synchronized void syncMethod(){
        try {
            TimeUnit.HOURS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }


    public static void main(String[] args) throws InterruptedException {
        SyncDefect defect = new SyncDefect();
        new Thread(defect::syncMethod,"t1").start();

        //休眠3毫秒后启动线程t2，确保t1先进入同步方法
        TimeUnit.MILLISECONDS.sleep(3);
        Thread t2 = new Thread(defect::syncMethod, "t2");
        t2.start();

        //休眠3毫秒后中断线程t2，确保t2已经启动
        TimeUnit.MILLISECONDS.sleep(3);
        t2.interrupt();

        System.out.println(t2.isInterrupted()); //true
        System.out.println(t2.getState());  //BLOCKED
    }
}

 　　针对synchronized的两个缺点，可以使用BooleanLock来解决

public interface Lock {

    void lock() throws InterruptedException;

    /**
     * 指定获取锁的超时时间
     * @param mills 等待获取锁的最大时间
     * @throws InterruptedException
     * @throws TimeoutException
     */
    void lock(long mills) throws InterruptedException, TimeoutException;

    void unlock();

    List<Thread> getBlockedThreads();
}

public class BooleanLock implements Lock {

    /**
     * 记录取得锁的线程
     */
    private Thread currentThread;
    /**
     * Bollean开关，标志锁是否已经被获取
     */
    private boolean locked = false;

    private List<Thread> blockedList = new ArrayList<>();

    @Override
    public void lock()  {
        //使用同步代码块的方式获取锁
        synchronized (this) {
            Thread currentThread = Thread.currentThread();
            //当锁已经被某个线程获取，将当前线程加入阻塞队列，并使用this.wait()释放thisMonitor
            while (locked){
                try {
                    if(!blockedList.contains(currentThread)){
                        blockedList.add(currentThread);
                    }
                    this.wait();
                } catch (InterruptedException e) {
                    blockedList.remove(currentThread);
                    e.printStackTrace();
                }
            }

            blockedList.remove(currentThread);
            this.locked = true;
            this.currentThread = currentThread;
        }
    }

    @Override
    public void lock(long mills) throws InterruptedException, TimeoutException {
        synchronized (this){
            if(mills <= 0) {//时间不合法，调用默认的lock()
                this.lock();
            } else {
                long remainingMills = mills;
                long endMills = System.currentTimeMillis() + remainingMills;
                while (locked) {
                    if (remainingMills <= 0) {//在指定的时间内未获取锁或者当前线程被其它线程唤醒，抛出异常
                        throw new TimeoutException(Thread.currentThread().getName()+" can't get lock during "+mills);
                    }
                    if(!blockedList.contains(Thread.currentThread())){
                        blockedList.add(Thread.currentThread());
                    }
                    //等待remainingMills后重新尝试获取锁
                    this.wait(remainingMills);
                    remainingMills = endMills - System.currentTimeMillis();
                }
                blockedList.remove(Thread.currentThread());
                this.locked = true;
                this.currentThread = Thread.currentThread();
            }
        }
    }

    @Override
    public void unlock() {
        synchronized (this) {
            if(Thread.currentThread() == currentThread) {
                this.locked = false;
                this.notifyAll();
            }
        }
    }

    @Override
    public List<Thread> getBlockedThreads() {
        return Collections.unmodifiableList(blockedList);
    }
}

/**
* 测试阻塞中断
*/
public class BooleanLockInterruptTest {

    private final Lock lock = new BooleanLock();

    public void syncMethod() {
        try {
            lock.lock();
            System.out.println(Thread.currentThread().getName()+" get lock.");
            TimeUnit.HOURS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            System.out.println("BLOCKED THREAD :"+lock.getBlockedThreads());
            lock.unlock();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        BooleanLockInterruptTest test = new BooleanLockInterruptTest();

        new Thread(test::syncMethod,"t1").start();
        TimeUnit.MILLISECONDS.sleep(3);
        Thread t2 = new Thread(test::syncMethod, "t2");
        t2.start();
        TimeUnit.MILLISECONDS.sleep(3);
        t2.interrupt();
        System.out.println(t2.isInterrupted()); //true
        System.out.println(t2.getState());  //RUNNABLE
    }
}

/**
* 测试超时
*/
public class BooleanLockTimeOutTest {

    private final Lock lock = new BooleanLock();

    public void syncTimeOutMethod() {
        try {
            lock.lock(1000);
            System.out.println(Thread.currentThread().getName()+" get lock.");
            TimeUnit.HOURS.sleep(1);
        } catch (InterruptedException | TimeoutException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    
    public static void main(String[] args) throws InterruptedException {
        BooleanLockTimeOutTest test = new BooleanLockTimeOutTest();

        new Thread(test::syncTimeOutMethod,"t1").start();
        TimeUnit.MILLISECONDS.sleep(3);
        new Thread(test::syncTimeOutMethod, "t2").start();
    }
}

 　　针对是synhronized还有一些概念及相关知识点需要补充

• Monitor
• 每一个对象都与一个Monitor相关联，一个monitor的lock在某一刻只能被一个线程获取。
• monitor有一个计数器，当为0时，该monitor的lock未被获取；当有线程持获取monitor时，则monitor计数器加一，释放时减一。
• Monitor分为This Monitor和Class Monitor。This Monitor对应类的实例方法，Class Monitor对应类的静态方法。
• synchronized关键字实例方法时，争取的是同一个monitor的锁，与之关联的引用是ThisMonitor的实例引用。即：同一个类中的不同多线程方法，使用的是同一个锁。
• 将静态方法声明为synchronized。该静态方法被调用后，对应的class对象将会被锁住（使用的是ClassMonitor）。其他线程无法调用该class对象的所有静态方法， 直到资源被释放。
• Synchronized使用wait()进入条件对象的等待集，使用notifyAll()/notify()唤醒等待集中的线程。

public synchronized void transfer(int from , int to,
   double amount) throws InterruptedException{
        while(accounts[from] < amount){
            //wait on intrinsic object lock’s single condition
             wait();
        }
        accounts[from] -= amount;
        accounts[to] += amount;
        //notify all threads waiting on the condition
        notifyAll();
}

volatile

　　volatile是轻量级的synchronized，它为实例域的同步访问提供了一种免锁机制，不会引起线程上下文的切换和调度。它在多处理器开发中保证了共享变量的“可见性“，如果一个属性被声明成volatile，Java模型会确保所有的线程看到这个变量的值时一致的。【volatile变量不能提供原子性】

　　volatile主要用来锁住一个属性，在对该属性的值进行写操作时，会将数据写回主存，并将CPU里缓存了该内存地址的数据无效。【线程在对volatile修饰的变量进行读写操作时，会首先检查线程缓存的值是否失效，如果失效，就会从主存中把数据读到线程缓存里】。 volatile本质上就是告诉JVM当前变量的值需要从主存中读取，当前变量的值被修改后直接刷新到主存中，且不需要被编译器优化（即：禁止命令重排）。

　　使用示范：

private volatile boolean done;
public boolean isDone(){
    return done;
}
public void setDone(boolean done){
    this.done = done;
}

// Same as

private boolean done;
public synchronized boolean isDone(){
    return done;
}
public synchronized void setDone(boolean done){
    this.done = done;
}

比较synchronized和volatile

	volatile	synchronized
作用对象	实例变量、类变量	方法、代码块
原子性	不具备	具备
可见性	具备	具备
可见性原理	使用机器指令的方式迫使其它工作内存中的变量失效	利用monitor锁的排它性实现
是否会指令重排	否	是
是否造成线程阻塞	否	是