多线程中的同步问题
当多个线程同时访问同一资源时,由于对资源的读写操作并不是原子性的,因此可能会出现同步问题。
比如下面这样:
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将需要同步的代码块变为同步。
好了,三种同步方式到这里就介绍完了。