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的