java多线程之-同步-CSDN博客

本文链接：https://blog.csdn.net/RunningXiaoHei/article/details/78688760

多线程中的同步问题

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

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();
            }
        }
    }

 }