java编程思想笔记-并发之并发锁(一)

1.使用synchronized关键字

synchronized 是 java语言的关键字，当它用来修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码。

package com.tij.thread.source;
/**
 * 
 * @author wenruo
 * @date 2017-8-7
 *
 */
public abstract class IntGenerator {
    private volatile boolean canceled = false;

    public abstract int next();

    public void cancel() {
        this.canceled = true;
    }

    public boolean isCanceled() {
        return canceled;
    }
}

package com.tij.thread.source;
/**
 * 
 * @author wenruo
 * @date 2017-8-7
 *
 */
public class EventGenerator extends IntGenerator {

    //将域设置为private是必须的，否则synchronized关键字
    //无法防止其他任务直接访问与，这样会产生冲突
    private int currentEventValue=0;
    /*
     * 同步规则：
     *      如果一个变量可能接下来被另一个线程读取，或者正在读取一个上一次已经被另外一个线程改变过的变量
     * 那么必须使用同步，并且读写线程必须使用相同的监视器同步
     * 
     * synchronized
     *      synchronized关键字可以让线程锁住整个对象，这个对象被
     *      synchronized修饰的方法被调用完成前，任何线程都不能调用这个对象的任何方法
     * 
     * synchronized static
     *      在类的范围内防止对static数据的并发访问
     *      static获取到的锁，是属于类的锁。非static方法获取到的锁，是属于当前对象的锁，它们之间不会产生互斥
     */
    @Override
    public synchronized int next() {
        //自增过程会被打断
        ++currentEventValue;
        ++currentEventValue;
        //System.out.println(currentEventValue);
        return currentEventValue;
    }



}

package com.tij.thread.source;
/**
 * 
 * @author wenruo
 * @date 2017-8-7
 *
 */
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class EventChecker implements Runnable {

    private IntGenerator generator;
    private final int id;

    public EventChecker(IntGenerator generator, int id) {
        this.generator = generator;
        this.id = id;
    }

    @Override
    public void run() {
        /*
         * 检测数据是否是偶数，如果是则继续运行，否则修改cancel，并退出循环
         */
        while (!generator.isCanceled()) {
            int value=generator.next();
            System.out.println("value--->"+value);
            if (value%2!=0) {
                System.out.println(value+" not even");
                generator.cancel();
            }
        }
    }

    public static void test(IntGenerator gp,int count){
        System.out.println("press control-C to exit");
        ExecutorService exec=Executors.newCachedThreadPool();
        for (int i = 0; i < count ; i++) {
            exec.execute(new EventChecker(gp, i));
        }
        exec.shutdown();
    }

    public static void test(IntGenerator gp){
        test(gp,10);
    }

}

package com.tij.thread.source;

import java.util.concurrent.TimeUnit;
/**
 * 
 * @author wenruo
 * @date 2017-8-7
 *
 */
public class EvenTest {
    public static void main(String[] args) {
        EventChecker.test(new EventGenerator());
        try {
            TimeUnit.MILLISECONDS.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

2.使用Lock

但是使用Lock锁的方法，可以更细粒度的处理资源问题，也有处理异常便利

public class MutexEvenGenerator extends IntGenerator {

    private int currentEventValue=0;
    private Lock lock=new ReentrantLock();
    /*
     * 与synchronized关键字相比，通过lock和unlock方法，可以在程序抛异常时，去做维护工作
     * 也可以更细粒度的控制加锁与释放锁
     */
    @Override
    public int next() {
        lock.lock();
        try {
            ++currentEventValue;
            Thread.yield();
            ++currentEventValue;
            return currentEventValue;
        }finally{
            lock.unlock();
        }
    }

}

public class AttemptLocking {
    private ReentrantLock lock=new ReentrantLock();

    public void untimed(){
        boolean captured=lock.tryLock();
        try {
            System.out.println("trylock:"+captured);
        }finally{
            if (captured) {
                lock.unlock();
            }
        }
    }

    public void timed(){
        boolean captured=false;
        try {
            //若在两秒内仍然未获取到锁则返回false
            captured=lock.tryLock(2,TimeUnit.SECONDS);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        try {
            System.out.println("tryLock(2,TimeUnit.SECONDS):"+captured);
        }finally{
            if (captured) {
                lock.unlock();
            }
        }
    }
}

public class AttemptingLockingTest {
    public static void main(String[] args) {
        final AttemptLocking al=new AttemptLocking();
        al.untimed();
        al.timed();
    }
}

3.原子性与可视性

3.1内存屏障
内存屏障（memory barrier）是一个CPU指令。基本上，它是这样一条指令： a) 确保一些特定操作执行的顺序； b) 影响一些数据的可见性(可能是某些指令执行后的结果)。编译器和CPU可以在保证输出结果一样的情况下对指令重排序，使性能得到优化。插入一个内存屏障，相当于告诉CPU和编译器先于这个命令的必须先执行，后于这个命令的必须后执行。内存屏障另一个作用是强制更新一次不同CPU的缓存。例如，一个写屏障会把这个屏障前写入的数据刷新到缓存，这样任何试图读取该数据的线程将得到最新值，而不用考虑到底是被哪个cpu核心或者哪颗CPU执行的。
内存屏障（memory barrier）和volatile什么关系？上面的虚拟机指令里面有提到，如果你的字段是volatile，Java内存模型将在写操作后插入一个写屏障指令，在读操作前插入一个读屏障指令。这意味着如果你对一个volatile字段进行写操作，你必须知道：1、一旦你完成写入，任何访问这个字段的线程将会得到最新的值。2、在你写入前，会保证所有之前发生的事已经发生，并且任何更新过的数据值也是可见的，因为内存屏障会把之前的写入值都刷新到缓存。

3.2volatile关键字:
(1).获得long或者double变量的原子性操作(通常不要利用原子性来解决同步问题)
(2).确保应用中的可视性，例如一个线程修改了某个域，但是其他的线程再次访问这个变量可能不会看到这个修改，因为jvm对此进行了优化，对这个域使用volatile关键字后，禁止了jvm的优化，使修改动作可以立即被其它线程看到
(3).注意：在状态真正独立于程序内其他内容时才能使用 volatile ，并且仅仅volatile关键字是不能实现域的原子性操作，不要将volatile用在getAndOperate场合，仅仅set或者get的场景是适合volatile的