线程同步

最新推荐文章于 2022-09-17 16:37:54 发布

明月几时有1116

最新推荐文章于 2022-09-17 16:37:54 发布

阅读量517

点赞数

分类专栏： Java Thread

Java Thread 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

java允许多线程并发控制，当多个线程同时操作一个可共享的资源变量时（如数据的增删改查），将会导致数据不准确，相互之间产生冲突，因此加入同步锁以避免在该线程没有完成操作之前，被其他线程的调用，从而保证了该变量的唯一性和准确性。

Synchronized关键字
上面说了，java用synchronized关键字做为多线程并发环境的执行有序性的保证手段之一。当一段代码会修改共享变量，这一段代码成为互斥区或临界区，为了保证共享变量的正确性，synchronized标示了临界区。典型的用法如下：

public synchronized void add(int num) {  
     balance = balance + num;  
}  
public synchronized void withdraw(int num) {  
     balance = balance - num;  
}

对于add(int num)这种情况，锁就是这个方法所在的对象。同理，如果方法是public static synchronized void add(int num)，那么锁就是这个方法所在的class。
理论上，每个对象都可以做为锁，但一个对象做为锁时，应该被多个线程共享，这样才显得有意义，在并发环境下，一个没有共享的对象作为锁是没有意义的。假如有这样的代码：

public class ThreadTest{  
  public void test(){  
     Object lock=new Object();  
     synchronized (lock){  
        //do something  
     }  
  }  
}

lock变量作为一个锁存在根本没有意义，因为它根本不是共享对象，每个线程进来都会执行Object lock=new Object();每个线程都有自己的lock，根本不存在锁竞争。

每个锁对象都有两个队列，一个是就绪队列，一个是阻塞队列，就绪队列存储了将要获得锁的线程，阻塞队列存储了被阻塞的线程，当一个被线程被唤醒 (notify)后，才会进入到就绪队列，等待cpu的调度。当一开始线程a第一次执行account.add方法时，jvm会检查锁对象account 的就绪队列是否已经有线程在等待，如果有则表明account的锁已经被占用了，由于是第一次运行，account的就绪队列为空，所以线程a获得了锁，执行account.add方法。如果恰好在这个时候，线程b要执行account.withdraw方法，因为线程a已经获得了锁还没有释放，所以线程 b要进入account的就绪队列，等到得到锁后才可以执行。
一个线程执行临界区代码过程如下：
1 获得同步锁
2 清空工作内存
3 从主存拷贝变量副本到工作内存
4 对这些变量计算
5 将变量从工作内存写回到主存
6 释放锁
可见，synchronized既保证了多线程的并发有序性，又保证了多线程的内存可见性。

生产者/消费者模式
生产者/消费者模式其实是一种很经典的线程同步模型，很多时候，并不是光保证多个线程对某共享资源操作的互斥性就够了，往往多个线程之间都是有协作的。

声明一个盘子，只能放一个鸡蛋

import java.util.ArrayList;  
import java.util.List;  
  
public class Plate {  
  
    List<Object> eggs = new ArrayList<Object>();  
  
    public synchronized Object getEgg() {  
        while(eggs.size() == 0) {  
            try {  
                wait();  
            } catch (InterruptedException e) {  
            }  
        }  
  
        Object egg = eggs.get(0);  
        eggs.clear();// 清空盘子  
        notify();// 唤醒阻塞队列的某线程到就绪队列  
        System.out.println("拿到鸡蛋");  
        return egg;  
    }  
  
    public synchronized void putEgg(Object egg) {  
        while(eggs.size() > 0) {  
            try {  
                wait();  
            } catch (InterruptedException e) {  
            }  
        }  
        eggs.add(egg);// 往盘子里放鸡蛋  
        notify();// 唤醒阻塞队列的某线程到就绪队列  
        System.out.println("放入鸡蛋");  
    }  
      
    static class AddThread extends Thread{  
        private Plate plate;  
        private Object egg=new Object();  
        public AddThread(Plate plate){  
            this.plate=plate;  
        }  
          
        public void run(){  
            for(int i=0;i<5;i++){  
                plate.putEgg(egg);  
            }  
        }  
    }  
      
    static class GetThread extends Thread{  
        private Plate plate;  
        public GetThread(Plate plate){  
            this.plate=plate;  
        }  
          
        public void run(){  
            for(int i=0;i<5;i++){  
                plate.getEgg();  
            }  
        }  
    }  
      
    public static void main(String args[]){  
        try {  
            Plate plate=new Plate();  
            Thread add=new Thread(new AddThread(plate));  
            Thread get=new Thread(new GetThread(plate));  
            add.start();  
            get.start();  
            add.join();  
            get.join();  
        } catch (InterruptedException e) {  
            e.printStackTrace();  
        }  
        System.out.println("测试结束");  
    }  
}

如果一个线程获得了锁lock，进入了同步块，执行lock.wait()，那么这个线程会进入到lock的阻塞队列。如果调用 lock.notify()则会通知阻塞队列的某个线程进入就绪队列。

volatile关键字
volatile是java提供的一种同步手段，只不过它是轻量级的同步，为什么这么说，因为volatile只能保证多线程的内存可见性，不能保证多线程的执行有序性。而最彻底的同步要保证有序性和可见性，例如synchronized。任何被volatile修饰的变量，都不拷贝副本到工作内存，任何修改都及时写在主存。因此对于volatile修饰的变量的修改，所有线程马上就能看到，但是volatile不能保证对变量的修改是有序的。什么意思呢？假如有这样的代码：

public class VolatileTest{  
  public volatile int a;  
  public void add(int count){  
       a=a+count;  
  }  
}

当一个VolatileTest对象被多个线程共享，a的值不一定是正确的，因为a=a+count包含了好几步操作，而此时多个线程的执行是无序的，因为没有任何机制来保证多个线程的执行有序性和原子性。volatile存在的意义是，任何线程对a的修改，都会马上被其他线程读取到，因为直接操作主存，没有线程对工作内存和主存的同步。所以，volatile的使用场景是有限的，在有限的一些情形下可以使用 volatile 变量替代锁。要使 volatile 变量提供理想的线程安全,必须同时满足下面两个条件:
1)对变量的写操作不依赖于当前值。
2)该变量没有包含在具有其他变量的不变式中
volatile只保证了可见性，所以Volatile适合直接赋值的场景，如

public class VolatileTest{  
  public volatile int a;  
  public void setA(int a){  
      this.a=a;  
  }  
}

在没有volatile声明时，多线程环境下，a的最终值不一定是正确的，因为this.a=a;涉及到给a赋值和将a同步回主存的步骤，这个顺序可能被打乱。如果用volatile声明了，读取主存副本到工作内存和同步a到主存的步骤，相当于是一个原子操作。所以简单来说，volatile适合这种场景：一个变量被多个线程共享，线程直接给这个变量赋值。这是一种很简单的同步场景，这时候使用volatile的开销将会非常小。

Volatile与Synchronized
JVM规范规定了任何一个线程修改了volatile变量的值都需要立即将新值更新到主内存中, 任何线程任何时候使用到volatile变量时都需要重新获取主内存的变量值
两者区别
1.volatile本质是在告诉jvm当前变量在寄存器（工作内存）中的值是不确定的，需要从主存中读取；synchronized则是锁定当前变量，只有当前线程可以访问该变量，其他线程被阻塞住。
2.volatile仅能使用在变量级别；synchronized则可以使用在变量、方法、和类级别的
3.volatile仅能实现变量的修改可见性，不能保证原子性；而synchronized则可以保证变量的修改可见性和原子性
4.volatile不会造成线程的阻塞；synchronized可能会造成线程的阻塞。
5.volatile标记的变量不会被编译器优化（禁止指令重排序优化，即执行顺序与程序顺序一致）；synchronized标记的变量可以被编译器优化