对象和变量的并发访问

     线程同步的目标是对并发数据做同步的写操作，需要在代码块中设定一定的同步区域，在此同步区域内做并发数据的写操作。线程安全包括原子性和可见性，java的同步机制都是围绕这两个方面进行的。线程安全的核心在于“外修互斥，内修可见”。实现线程同步的方式如下所示：

1、使用synchronized关键字

      synchronized修饰的方法或者代码块为同步区域，在同步区域内使用的共享变量在使用时，会从主存中获取值，离开同步区域时，将值写回到主存中。对于同一个锁，同步区域是互斥执行的，可以保证一个同步区域的解锁发生在下一个加锁操作之前。synchronized关键字包含了monitor enter和monitor exit两个JVM命令，可保证任何时候任何线程在执行到monitor enter成功之前都必须从主存获取数据，在monitor exit运行成功之后，共享变量被更新后的值必须刷入主存。

       当一个线程获得一个对象锁之后，再次请求此对象锁时，可以再次获得该对象的锁，即一个synchronized方法或程序块的内部调用本类的其他synchronized方法或程序块，是永远可以得到锁的。当同步区域出现异常时，锁会自动释放掉。

       synchronized程序块优于synchronized方法是因为同步区域变小有利于提升执行效率；对象锁不用this，有利于不同类的方法对共享变量的同步操作；对象锁用this，适合简单的只在一个类下的同步。synchronized修饰静态方法或者是静态程序块，相当于加锁到类文件上，与加锁到对象上有明显的区别，类锁相当于对类的所有对象加锁。由于String常量池的缓存功能，String类型的锁会带来被广泛共享，所以String类型的变量大部分情况下不可以作为锁来使用。同步是一种机制，不具备继承性。当父类中存在同步区域时，子类也需要在重载时提供同步。

      在使用synchronized关键字时，需要注意：锁对象不可以为空；作用域太大，影响执行效率；同一个锁对象才可以锁共同的逻辑业务区；多个锁对象交叉容易导致死锁。

       脏读是不同线程对共享变量的写操作出现了不同步的情况，要保证对共享变量的写操作都发生在同步区域就可以消除脏读。

2、使用volatile关键字

       volatile修饰的变量具备两层语义：保证了不同线程对共享变量操作时的可见性；禁止对指令进行重排序操作。volatile关键字修饰的指令不会重排序，但是对于volatile前后无依赖指令可以随便排序。

       volatile使用的场景：开关控制利用可见性的特点；状态标记利用顺序性特点；Singleton设计模式的double-check也是利用了顺序性特点。

     volatile和synchronized的区别：

• 使用上：volatile只能修饰变量，synchronized可以修饰方法和代码块。volatile修饰的变量可以为null；synchronized关键字同步语句块的monitor对象不能为null。

• 原子性上：volatile无法保证原子性；synchronized是一种排他机制，无法被中途打断，可以保证原子性。

• 可见性上：volatile使用机器指令（偏硬件）“lock；”的方式迫使其他线程工作内存中的数据失效，不得不到主内存中进行再次加载，可以做到可见性；synchronized借助JVM的monitor enter和monitor exit，使用排他方式将同步代码串行化，在monitor exit时所有共享资源都会被刷新到主存中，可以做到可见性。

• 有序性上：volatile禁止JVM编译器及处理器对其进行重排序，可保证有序性；synchronized修饰的同步方法可以保证有序性，同步代码块中的代码指令也会发生指令重排序，这种顺序性是以程序的串行化执行换来的。

• 其他：volatile不会使线程陷入阻塞；synchronized会使线程进入阻塞状态。

atomic是java中的可以同步类，类中的操作可以做到线程安全，当调用原子类中的操作的过程是非线程安全的，有可能会产生脏读的情况。

3、并发编程的3个重要特征

     并发编程的三个重要特征是原子性、有序性、可见性。

• 原子性是指一次操作或者多次操作中，要么所有操作全部得到执行并不受任何因素的干扰中断，要么所有操作都不执行。在Java中，对基本数据类型变量的读取和赋值操作都是原子性的，对引用类型变量的读取和赋值操作也是原子性的。简单的读取和赋值操作是原子性的，将一个变量赋值给另一个变量的操作不是原子性。多个原子性的操作在一起就不再是原子性操作。JVM只保证了基本读取和赋值的原子性操作，其他均不保证。如果想让某些代码片段具有原子性，需要使用synchronized或者lock处理。

• 可见性是指一个线程对共享变量进行了修改，那么其他线程可以立即看到修改后的最新值。在多线程的环境下，如果某个线程首次读取共享变量，则首先到主存中获取该变量，然后存入工作内存中，以后只需要在工作内存中读取该变量即可。Java提供了三种方式来保证可见性：使用关键字volatile；使用synchronized关键字；使用JUC提供的显式锁Lock。

• 有序性是指程序代码在执行过程中的先后顺序，由于Java在编译器以及运行期的优化，导致代码的执行顺序未必就是开发者编写代码时的顺序。在单线程的环境下，指令重排不会影响有序性，但是在多线程环境下，指令重排会影响程序的正确执行。Java提供了三种方式来保证有序性：使用volatile关键字；使用synchronized关键字；使用显式锁Lock关键字。

       Java内存模型中具备一些天生的有序性规则，这个规则称为Happens-before原则。具体的体现有：

• 程序次序规则：在一个线程内，代码按照编写时的次序执行，编写在后面的操作发生在编写在前面的操作之后。

• 锁定规则：一个unlock操作要先行发生对于同一个锁的lock操作。

• volatile变量规则：对一个变量的写操作要早于对这个变量之后的读操作。

• 传递规则：操作A先于操作B，操作B先于操作C，那么操作A先于操作C

• 线程启动规则：Thread对象的start方法先行发生于对该线程的任何动作。

• 线程中断规则：对线程执行interrupt操作优先于捕获中断信号

• 线程终结规则：线程中所有操作要先行发生于线程的终止检测

• 对象终结规则：一个对象的初始化完成要先行发生于finalize方法

     

4、脏读和线程死锁

        脏读是对共享变量的操作除了同步方法之外，还存在则非同步的操作。

        死锁是多线程下产生的问题，只要出现多个线程出现循环依赖资源的情况，就会发生死锁。死锁是程序设计的bug。导致死锁的原因有：1、交叉锁，最容易导致死锁的原因；2、内存不足；3一问一答式数据交换，如服务器错过了客户端请求；4、数据库锁；5、文件锁；6、死循环引起死锁，一般称为系统假死，最难排查的死锁现象，重现困难，系统资源使用量达到极限。系统假死时，线程堆栈信息不会发生任何死锁迹象，程序不工作，CPU占有率居高不下。     

       

5、经典代码实例

public class Subject {
public static volatile boolean status=false;
public static Integer signs=Integer.valueOf(0);
public static final Object objectLock=new Object();
}

public class ReadSubject implements Runnable{

@Override
public void run() {
synchronized(Subject.objectLock) {
System.out.println(Thread.currentThread().getName()+" is reading : "+Subject.status +" , "+Subject.signs);
}
}

}

public class WriteSubject implements Runnable{

@Override
public void run() {
synchronized(Subject.objectLock){
Subject.status=true;
Subject.signs+=1;
System.out.println(Thread.currentThread().getName()+" make changed to true, signs add 1 to "+Subject.signs);
}
}

}

public class WriteAndReadSubject implements Runnable{

@Override
public void run() {
if(Subject.status) {
readSubject();
}else {
synchronized(Subject.objectLock) {
writeSubject();
}
}
}

private void writeSubject() {
Subject.status=true;
Subject.signs+=1;
System.out.println(Thread.currentThread().getName()+" make changed to true, signs add 1 to "+Subject.signs);
}
private void readSubject() {
System.out.println(Thread.currentThread().getName()+" is reading subject");
}

}

import java.util.ArrayList;

public class BaseTest {

public static void main(String[] args) {
ReadSubject rs=new ReadSubject();
WriteSubject ws=new WriteSubject();
WriteAndReadSubject wss=new WriteAndReadSubject();
ArrayList<Thread> list=new ArrayList<Thread>();
for(int i=0;i<10;i++) {
list.add(new Thread(rs));
list.add(new Thread(ws));
list.add(new Thread(wss));
}
for(int i=0;i<list.size();i++) {
list.get(i).start();
}

}

}