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的