java 并发笔记

1.java 并发中的同步，原子操作与volatile关键字用法

同步规则使用的情况：如果你正在写一个变量，它可能接下来被另一个线程读取，或者正在读取一个上一次已经被其他线程写过的变量，那么你必须使用同步，使用同一个监视器锁，并保证所有访问方法都进行了同步。

原子性操作是指不能被线程调度机制中断的操作，一旦操作开始，那么它一定可以在可能发生的上下文切换（切换至其他线程）之前执行完毕。需要注意的是，在编程中，依赖原子性是很棘手并且危险的，原子性一般可以应用于long和double之外的所有基本类型之上的简单操作，如读取或者写入基本类型变量。

由于jvm可以将64位（long和double）变量的读取写入分为两个分离的32位操作，所以这两个变量读取写入并不是原子性的，这个可以通过使用volatile关键字来定义long或double变量来解决；此外volatile还保证了多处理器系统中应用的可视性，在多处理器系统中，修改往往只是暂时性存储在本地的处理器的缓存中，而并未写入主存，这样如果如果将一个域声明为volatile的，那么对这个域进行写操作的同时，处理器会将该写操作的结果刷入主存（读操作是通过主存进行的），保证了其他处理器对写操作的可视性，这样做的意义是：如果某个域上的值其他任务不必读取最新值，那么该域的原子操作不必刷新到主存中去，因此可以不用该关键字，如果多个处理器需要保证在同一时刻读取到的值是一样的，那么这个值就必须是volatile的，否则就必须使用同步来进行访问，需要注意的是，同步也会导致相主存中进行刷新，因此如果一个域的所有访问方法都使用了synchronized来进行锁保护，就不必将其设置为volatile的了。

需要注意的是，和c++不同，java中的自增操作不是原子性例如以下代码

i++；

因此使用的时候通常使用synchronized关键字保护，然而如果涉及到性能调优等需要高效率的场合时，我们可以使用特殊的原子性变量类，如AtomicInteger、AtomicLong、AtomicReference等。  示例如下：

package concurrency;

import java.util.Timer;
import java.util.TimerTask;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * Created by xudong on 2018/7/7.
 */
public class AtomicInterTest implements Runnable {
    private AtomicInteger i = new AtomicInteger(0);
    public int getValue() {
        return  i.get();
    }
    private void evenIncrement(){
        i.addAndGet(2); //  ++i; ++i
    }
    @Override
    public void run() {
        while (true){
            evenIncrement();
        }
    }

    public static void main(String[] args) {
        //Timer 为线程调度类， 五秒执行一次， 不重复
        new Timer().schedule(new TimerTask() {
            @Override
            public void run() {
                System.err.println("Aborting");
                System.exit(0);
            }
        }, 5000 );  // 主线程 5 秒后终止
        ExecutorService exec = Executors.newCachedThreadPool();
        AtomicInterTest ai = new AtomicInterTest();
        exec.execute(ai);
//如果出现破坏原子性的情况，打印并跳出
        while(true){
            int val = ai.getValue();
            if(val % 2 != 0){
                System.out.println(val);
                exec.shutdown();
                System.exit(0);
            }
        }

    }
}

由于使用了AtomicInteger 的 自增函数， 能够保证原子性，因此该程序不会失败

2.final 关键字在不同作用域的使用

final这个修饰符代表着不可改变，不过在不同的地方代表着不同的意义

在类上面

public final class Foo{}

代表着Foo这个类不可被继承

在方法上

代表着这个方法不能被重写

public class Foo{
public final void get(){}
}
public class Fool extends Foo{
//这里不能重写父类的get()该方法
}

在字段上面

代表着这个字段不能被重新赋值，但请注意

public class Foo{
public final int i;//这里i没有赋值
public Foo(int i){
this.i = i;//那么在构造函数里则可以被首次赋值，其它该方法里绝对不行
}
}

public class Foo{
public final int i = 0;//这里i被赋值
public Foo(int i){
//那么不管是在构造函数里，还是在任何其它地方，都不能被重新赋值
}
}

但是用在字段前，只是它不能被重新赋值，不代表它不能改变本身的值。

比如像集合类List， Map ， Set 等，可以执行add，remove等方法，但是不能给对象重新赋值

final List list = new ArrayList(); // 这个list的任何行为（即方法）都是允许调用的。