ReentrantLock与synchronized的区别

目录

一、synchronized用法

修饰一个普通方法

写法一：修饰一个方法

写法二：修饰一个代码块

EG:

修饰一个静态方法

修饰一个代码块

修饰一个类

总结：

二、ReentrantLock 

特点：

对synchronized的举例中的计数器类进行重构

三、ReentrantLock和Synchronized比较

一、synchronized用法

synchronized是Java中的关键字，是一种同步锁和可重入锁

会自动释放锁

修饰一个普通方法

        该方法称为同步方法

        作用范围：整个方法

        作用对象：调用这个方法的对象 ，默认为：this

         有两种写法 ：作用是等价的，都是锁定整个方法的内容

写法一：修饰一个方法

public synchronized void doth() {
	//……
}

写法二：修饰一个代码块

public void doth() {
	synchronized(this) {
		//……
	}
}

EG:

      分别在两个线程里面进行加1和减1，最终的count为0；

//计数器类
public class Counter {
	
	// 用于计数的公共变量
	public static int count = 0;
	
	// 递增
	public synchronized void add() {
		for (int i = 0; i < 10000; i++) {
			Counter.count += 1;
		}
	}
	
	// 递减
	public synchronized void dec() {
		for (int i = 0; i < 10000; i++) {
			Counter.count -= 1;
		}
	}
}

 main主函数：

public static void main(String[] args) throws InterruptedException {
	Counter count = new Counter();
	Thread t1 = new Thread() {
		@Override
		public void run() {
			count.add();
		}
	};
	Thread t2 = new Thread() {
		@Override
		public void run() {
			count.dec();
		}
	};
	t1.start();
	t2.start();
	
	t1.join();
	t2.join();
	
	System.out.println(count.count);

}

结果：

结果解析：

         1.使用当前对象this充当锁，完成对该方法的锁定【持有了这把锁】

         2.并发过程中，同一时刻只能有一个线程进入该方法 ，使得别的线程进入阻塞状态： 

修饰一个静态方法

        作用范围：整个方法

        作用对象：调用这个类的所有对象，默认为：该Class对象

         注意：静态方法是属于类的而不属于对象的

public synchronized static void method() {
   // TODO：……
}

public  static void dosth() {
	synchronized(this.getClass) {
		//DOTO……
	}
}

修饰一个代码块

        可以称为同步代码块

        作用范围：{ }大括号括起来的代码块

        作用对象：调用这个代码块的对象。

修饰一个类

        作用范围：{ }大括号括起来的代码块

        作用对象：调用这个类的所有对象。

class Clazz{
    public void doth() {
        synchronized(Clazz.class) {
            //……
        }
    }
}

总结：

1、 无论synchronized关键字加在方法上还是对象上，如果它作用的对象是非静态的，则它取得的锁是对象；如果synchronized作用的对象是一个静态方法或一个类，则它取得的锁是对类，该类所有的对象同一把锁。 
2、每个对象只有一个锁（lock）与之相关联，谁拿到这个锁谁就可以运行它所控制的那段代码。 
3、实现同步是要很大的系统开销作为代价的，甚至可能造成死锁，所以尽量避免无谓的同步控制

二、ReentrantLock 

 是在Java1.5引入的显示锁，在编程中：必须先创建锁，结束后在finally中正确释放锁

   代码：

public  void add() {
	lock.lock();
	
	try {
			
        //……
	}finally {
		lock.unlock();
	}
	
}	

 在java.util.concurrent包，它提供了大量更高级的并发功能，简化程序编写 。

特点：

1.是一个可重入锁【可以被同一个线程多次获取】

2.是一个独占锁【在同一时间点只能被一个线程持有】

4.可以尝试加锁【新增】，

    代码：

if ( lock.tryLock(1,TimeUnit.SECONDS) ) {
	try{
	}
	finally{
		lock.unlock();
	}
}

4.不会自动释放锁

3.支持公平锁【在构造函数中传入true】通过一个FIFO等待队列管理获取该锁的线程

4.默认为非公平锁 ：不管是否在队列里，都会竞争该锁

对synchronized的举例中的计数器类进行重构

public class Counter {
	public  final ReentrantLock lock = new  ReentrantLock();
	
    public static int count=0;
 
	public  void add() {	
		lock.lock();
		for(int i=1;i<=100000;i++) {
			try {
				Demo01_Counter.count+=i;
			}finally {
				lock.unlock();
			}
		}
	}
	
	public  void dec() {
		lock.lock();
		for(int i=1;i<=100000;i++) {
			try {
				Demo01_Counter.count-=i;
			}finally {
				lock.unlock();
			}
		}
	}	
}

三、ReentrantLock和Synchronized比较