线程并发

Java并发中的3个概念：

1.原子性：即一个操作或者多个操作 要么全部执行并且执行的过程不会被任何因素打断，要么就都不执行。

2.可见性:可见性是指当多个线程访问同一个变量时，一个线程修改了这个变量的值，其他线程能够立即看得到修改的值。

3.有序性：即程序执行的顺序按照代码的先后顺序执行。

volitile

确保所有线程所看到的指定变量的值都是相同的。

举个例子，在多线程 (不使用 volatile) 环境中，每个线程会从主存中复制变量到 CPU 缓存 (以提高性能)。如果你有多个 CPU，不同线程也许会运行在不同的 CPU 上，并把主存中的变量复制到各自的 CPU 缓存中。

volatile 只能保证 “可见性”，不能保证 “原子性”。

synchronized

Synchronized是Java中解决并发问题的一种最常用的方法，也是最简单的一种方法。Synchronized的作用主要有三个：（1）确保线程互斥的访问同步代码（2）保证共享变量的修改能够及时可见（3）有效解决重排序问题。从语法上讲，Synchronized总共有三种用法：

（1）修饰普通方法

public class Sync{
    private int a = 0;
    public synchronized void add(){ 
        System.out.println("a values " + ++a);
    }
}

（2）修饰静态方法

public class Sync{
    private static int a = 0;
    public synchronized static void add(){  
        System.out.println("a values " + ++a);
    }
}

（3）修饰代码块

public class Sync{
    private int a = 0;
    public void add(){  
        synchronized(this){
            System.out.println("a values " + ++a);
        }
    }
}

Lock

在java中可以使用 synchronized 来实现多线程下对象的同步访问，为了获得更加灵活使用场景、高效的性能，java还提供了Lock接口及其实现类ReentrantLock和读写锁 ReentrantReadWriteLock。

Lock锁与条件同步：

与synchronized类似，Lock锁也可以实现条件同步。在java的concurrent包中提供了 Condition 接口及其实现类ConditionObject。

当满足一定条件时，调用Condition的await()方法使当前线程进入休眠状态进行等待。调用Condition的signalAll()方法唤醒因await()进入休眠的线程。

相比synchronized来实现同步，使用Lock实现同步主要有以下差异性：
1、使用synchronized关键字时，锁的控制和释放是在synchronized同步代码块的开始和结束位置。而在使用Lock实现同步时，锁的获取和释放可以在不同的代码块、不同的方法中。这一点是基于使用者手动获取和释放锁的特性。

2、Lock接口提供了试图获取锁的tryLock()方法，在调用tryLock()获取锁失败时返回false，这样线程可以执行其它的操作 而不至于使线程进入休眠。tryLock()方法可传入一个long型的时间参数，允许在一定的时间内来获取锁。

3、Lock接口的实现类ReentrantReadWriteLock提供了读锁和写锁，允许多个线程获得读锁、而只能有一个线程获得写锁。读锁和写锁不能同时获得。实现了读和写的分离，这一点在需要并发读的应用中非常重要，如lucene允许多个线程读取索引数据进行查询但只能有一个线程负责索引数据的构建。

4、基于以上3点，lock来实现同步具备更好的性能。

使用Lock锁及其同步条件来实现同样的一个生产者-消费者模型：

public class MessageStorageByLock {
    private int maxSize;
    private List<String> messages;

    private final ReentrantLock lock;
    private final Condition conditionWrite;//声明两个锁条件
    private final Condition conditionRead;
    public MessageStorageByLock(int maxSize) {
        this.maxSize = maxSize;
        messages = new LinkedList<String>();
        lock = new ReentrantLock(true);//true修改锁的公平性，为true时，使用lifo队列来顺序获得锁
        conditionWrite = lock.newCondition();//调用newCondition()方法，即new ConditionObject();
        conditionRead = lock.newCondition();

    }
    public void set(String message){
        //使用锁实现同步，获取所得操作，当锁被其他线程占用时，当前线程将进入休眠
        lock.lock();
        try{
            while(messages.size() == maxSize){
                    System.out.print("the message buffer is full now,start into wait()\n");
                    conditionWrite.await();//满足条件时，线程休眠并释放锁。当调用 signalAll()时。线程唤醒并重新获得锁
            }
            Thread.sleep(100);
            messages.add(message);
            System.out.print("add message:"+message+" success\n");
            conditionRead.signalAll();//唤醒因conditionRead.await()休眠的线程
        }catch (InterruptedException e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
    public String get(){
        String message = null;
        lock.lock();
        try{
            while(messages.size() == 0){
                conditionRead.await();
                System.out.print("the message buffer is empty now,start into wait()\n");
            }
            Thread.sleep(100);
            message = ((LinkedList<String>)messages).poll();
            System.out.print("get message:"+message+" success\n");
            conditionWrite.signalAll();
        }catch (InterruptedException e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
        return message;
    }
}