java多线程之-同步

多线程中的同步问题

当多个线程同时访问同一资源时，由于对资源的读写操作并不是原子性的，因此可能会出现同步问题。
比如下面这样：

class MyThread implements Runnable{     int a = 100 ;    @Override    public void run() {        // TODO Auto-generated method stub        while(true){            try {                Thread.sleep(1000);            } catch (InterruptedException e) {                // TODO Auto-generated catch block                e.printStackTrace();            }            a --;            System.out.println(a);        }    } }MyThread thread = new MyThread();        new Thread(thread).start();        new Thread(thread).start();        new Thread(thread).start();

三个线程同时对统一资源a进行自减操作，随机运行一次的结果如下：

明显可以看出这里出现了资源同步的问题，出现这个问题的原因就是对资源的操作不是原子操作，当某一线程是改变了资源的状态并试图写到内存中时，另一个线程也对其进行了改变，这就导致了问题。

synchronized关键字

并发程序想要正确的运行，必须具备三个条件：原子性、有序性和可见性。
为了解决这一问题，我们可以用到关键字synchronized，它可以保证对资源的操作满足上述三个要求。
synchronized用于经典的生产者和消费者问题：

class Product{     public int m = 10;//商品数量     public int size = 10;     public synchronized void produce(){         while(m >= size){             try {                wait();//释放锁，当前线程挂起，等待唤醒。这个方法必须跟同步一同出现            } catch (InterruptedException e) {                // TODO Auto-generated catch block                e.printStackTrace();            }         }         m++;         System.out.println("Producer生产了一个，总共有："+m+"个商品" );         notifyAll();//唤醒所有挂起的线程     }     public synchronized void consume(){         while(m <= 0){             try {                wait();            } catch (InterruptedException e) {                // TODO Auto-generated catch block                e.printStackTrace();            }         }         m--;         System.out.println("Consumer消费了一个，总共有："+m+"个商品");         notifyAll();     } } class Producer implements Runnable{    private Product product;    public Producer(Product product){        this.product = product;    }    @Override    public void run() {        // TODO Auto-generated method stub        while(true){            try {                Thread.sleep(1000);            } catch (InterruptedException e) {                // TODO Auto-generated catch block                e.printStackTrace();            }            product.produce();        }    } } class Consumer implements Runnable{    private Product product;    public Consumer(Product product){        this.product = product;    }    @Override    public void run() {        // TODO Auto-generated method stub        while(true){            try {                Thread.sleep(1000);            } catch (InterruptedException e) {                // TODO Auto-generated catch block                e.printStackTrace();            }            product.consume();        }    } }public class ProduceConsumerTest {    public static void main(String[] args){        Product product = new Product();        Producer producer = new Producer(product);        Consumer consumer = new Consumer(product);        new Thread(producer).start();        new Thread(consumer).start();        new Thread(consumer).start();    }}

生产者Producer负责生产商品，消费者Consumer负责消费商品，商品Product中有produce()跟consume()两个方法，如果这两个方法没有用关键字synchronized修饰成同步方法，那么打印出来的数据可以看出有同步问题。
通过synchronized关键字，将对Product的一系列操作变为原子操作，避免了同步问题。

volatile关键字

volatile用来修饰变量，它并不能保证所修饰的对象具有原子性，但可以保证其具有有序性、可见性。
我们知道，对基本数据类型变量的读取和赋值是原子性操作，即这些操作无法被中断。所以通过volatile修饰基本数据类型的变量可以防止同步问题。比如下面的例子：

     private int a ;     private synchronized void set(int a){         this.a = a ;     }     private synchronized int get(){         return a;     }

基本数据类型有两个原子操作方法 set()与get()，为了避免同步问题，可以讲方法修饰为同步方法。这里其实可以用更轻量级的volatile来做，如下：

     volatile int a ;     private void set(int a){         this.a = a ;     }     private int get(){         return a;     }

因为对a的两个方法都是原子操作，因此加入volatile关键字后，又赋予了其有序性跟可见性，这样就满足了同步的三大要素。采用volatile实现同步机制需要注意以下几点：

• volatile变量是一种稍弱的同步机制在访问volatile变量时不会执行加锁操作，因此也就不会使执行线程阻塞，因此volatile变量是一种比synchronized关键字更轻量级的同步机制
• 从内存可见性的角度看，写入volatile变量相当于退出同步代码块，而读取volatile变量相当于进入同步代码块
• 在代码中如果过度依赖volatile变量来控制状态的可见性，通常会比使用锁的代码更脆弱，也更难以理解。仅当volatile变量能简化代码的实现以及对同步策略的验证时，才应该使用它。一般来说，用同步机制会更安全些
• 加锁机制（即同步机制）既可以确保可见性又可以确保原子性，而volatile变量只能确保可见性，原因是声明为volatile的简单变量如果当前值与该变量以前的值相关，那么volatile关键字不起作用，也就是说如下的表达式都不是原子操作：“count++”、“count = count+1”

所以，当满足以下两个条件时，才应该使用volatile变量：
- 对变量的写入操作不依赖当前值，或者只有单个线程更新变量的值
- 变量没有包含在具有替他变量的不变式中。

Lock实现同步

除了以上两种方式外，还有一种通过Lock来实现同步的。比如对第一个例子进行改写：

class MyThread implements Runnable{    int a = 100 ;    private Lock lock;    public MyThread(){        lock = new ReentrantLock();    }    @Override    public void run() {        // TODO Auto-generated method stub        while(true){            lock.lock();            try {                Thread.sleep(1000);                a --;                System.out.print(a+" ");            } catch (InterruptedException e) {                // TODO Auto-generated catch block                e.printStackTrace();            }finally{                lock.unlock();            }        }    } }

通过lock将需要同步的代码块变为同步。

好了，三种同步方式到这里就介绍完了。