这是一篇关于 Synchronized
锁和 Lock
锁的超详细的万字博文,博文中列举了大量的例子用于理解,相信深度阅读本博文后,玩转 Synchronized
锁和 Lock
锁轻轻松松,有手就行!
synchronized 锁,传统的队列锁;
sychronized
可以保证在同一时刻只有一个线程可以执行某个方法或某个代码块(临界区),同时 synchronized
可以保证一个线程的变化可见。
只有共享资源读写访问才需要同步化,如果不是共享资源就没有必要同步。
修饰实例方法,对当前实例进行加锁,进入同步代码前需获得当前实例的锁;
修饰静态方法,对类对象加锁,要先获得当前类对象的锁;
修饰代码块,指定加锁对象,对给定对象加锁,要先获得给定对象的锁;
2.1 同步方法(静态方法、实例方法):
用 sychronized
修饰的方法就叫做同步方法,保证 A 线程执行该方法的时候,其他线程只能在方法外等着。
synchronized public void doWorlk(){
...
}
对于非静态类方法,同步锁就是 this
(实例对象);
对于静态类方法,同步锁是当前方法所在类的字节码对象(类对象);
2.2 同步代码块:
syschronized(同步锁){
....
}
同步锁:在任何时候最多只能有一个线程有同步锁,其他线程只能在代码块外等着。
为保证每个线程都能正常执行原子操作,Java 引入了线程同步机制。Java 程序运行可以使用任何对象作为同步监听对象,但一般把当前并发访问的共同资源作为同步监听对象。
举例子:
package com.idiot.demo1;
public class Test1 {
public static void main(String[] args) throws InterruptedException {
// 并发:多线程操作同一个资源类,
Ticket ticket = new Ticket();
// @FunctionalInterface 函数式接口
new Thread(() -> {
for (int i = 1; i < 20; i++) {
//把资源类丢入线程
ticket.sale();
}
}, "A").start();
new Thread(() -> {
for (int i = 1; i < 20; i++) {
ticket.sale();
}
}, "B").start();
new Thread(() -> {
for (int i = 1; i < 20; i++) {
ticket.sale();
}
}, "C").start();
}
}
class Ticket {
//共卖30张票
private int number = 30;
// 卖票的方式
public synchronized void sale() {
if (number > 0) {
System.out.println(Thread.currentThread().getName() + "卖出了第" + (number--) + "票,剩余:" + number);
}
}
}
当多个线程同时对一个对象的一个方法进行操作,只有一个线程能够抢到锁。因为一个对象只有一把锁,一个线程获取了该对象的锁之后,其他线程无法获取该对象的锁,就不能访问该对象的其他 synchronized
实例方法,但是可以访问非 synchronized
修饰的方法。
Lock 锁是一个接口,其所有的实现类为
ReentrantLock
(可重入锁);ReentrantReadWriteLock.ReadLock
(可重入读写锁的读锁);ReentrantReadWriteLock.WriteLock
(可重入读写锁的写锁);Lock 锁提供了比使用 synchronized
方法和语句可获得的更广泛的锁定操作。Lock 接口的实现允许锁在不同的作用范围内获取和释放,并允许以任何顺序获取和释放多个锁。随着灵活的增加,也带来了更多的责任。不使用块结构锁就失去了使用 synchronized
方法和语句时会出现的锁自动释放功能。在大多数情况下,应使用以下语句:
Lock l = ...;
l.lock();//加锁
try {
// access the resource protected by this lock
} finally {
l.unlock();//解锁
}
加锁和解锁出现在不同作用范围中是,需谨慎确保锁定是所执行的所有代码用 try-finall
或 try-catch
保护,以确保在必要时释放锁。
package com.idiot.demo1;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class LockDemo {
public static void main(String[] args) {
final Ticket2 ticket = new Ticket2();
new Thread(() -> {
for (int i = 0; i < 40; i++) {
ticket.sale();
}
}, "A").start();
new Thread(() -> {
for (int i = 0; i < 40; i++) {
ticket.sale();
}
}, "B").start();
new Thread(() -> {
for (int i = 0; i < 40; i++) {
ticket.sale();
}
}, "C").start();
}
}
//lock三部曲
//1、 Lock lock=new ReentrantLock();
//2、 lock.lock() 加锁
//3、 finally=> 解锁:lock.unlock();
class Ticket2 {
private int number = 30;
// 创建锁
Lock lock = new ReentrantLock();
//卖票的方式
public void sale() {
lock.lock(); // 开启锁
try {
if (number > 0) {
System.out.println(Thread.currentThread().getName() + "卖出了第" + (number--) + "张票剩余" + number + "张票");
}
}finally {
lock.unlock(); // 关闭锁
}
}
}
1、Synchronized
内置的 Java 关键字;Lock 是一个 Java 类;
2、Synchronized
无法判断获取锁的状态;Lock 可以判断;
3、Synchronized
会自动释放锁;Lock 必须要手动加锁和手动释放锁,可能会遇到死锁;
4、Synchronized
线程1(获得锁->阻塞)、线程2(等待);Lock 就不一定会一直等待下去,Lock 会有一个 trylock
去尝试获取锁,不会造成长久的等待;
5、Synchronized
是可重入锁,不可以中断的,非公平的;Lock,可重入的,可以判断锁,可以自己设置公平锁和非公平锁;
6、Synchronized
适合锁少量的代码同步问题,Lock 适合锁大量的同步代码;
面试题:单例模式,排序算法,生产者和消费者,死锁;
package com.idiot.demo1;
public class A {
public static void main(String[] args) {
Data data = new Data();
new Thread(()->{
for (int i = 0; i < 10; i++) {
try {
data.increment();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
},"A").start();
new Thread(()->{
for (int i = 0; i < 10; i++) {
try {
data.decrement();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
},"B").start();
}
}
// 判断等待,业务,通知
class Data { // 数字 资源类
private int number = 0;
//+1
public synchronized void increment() throws InterruptedException {
if (number != 0) { //0
// 等待
this.wait();
}
number++;
System.out.println(Thread.currentThread().getName() + "=>" + number);
// 通知其他线程,我+1完毕了
this.notifyAll();
}
//-1
public synchronized void decrement() throws InterruptedException {
if (number == 0) { // 1
// 等待
this.wait();
}
number--;
System.out.println(Thread.currentThread().getName() + "=>" + number);
// 通知其他线程,我-1完毕了
this.notifyAll();
}
}
思考:如果有A,B,C,D四个线程,会出现什么情况?
会出现虚假唤醒问题,即除了输出0,1,还会有其他输出;
尝试之后的运行结果:
只需要将 if
改为 while
即可:
package com.idiot.demo1;
public class A {
public static void main(String[] args) {
Data data = new Data();
new Thread(()->{
for (int i = 0; i < 10; i++) {
try {
data.increment();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
},"A").start();
new Thread(()->{
for (int i = 0; i < 10; i++) {
try {
data.decrement();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
},"B").start();
new Thread(()->{
for (int i = 0; i < 10; i++) {
try {
data.increment();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
},"C").start();
new Thread(()->{
for (int i = 0; i < 10; i++) {
try {
data.decrement();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
},"D").start();
}
}
// 判断等待,业务,通知
class Data { // 数字 资源类
private int number = 0;
//+1
public synchronized void increment() throws InterruptedException {
while (number != 0) { //0
// 等待
this.wait();
}
number++;
System.out.println(Thread.currentThread().getName() + "=>" + number);
// 通知其他线程,我+1完毕了
this.notifyAll();
}
//-1
public synchronized void decrement() throws InterruptedException {
while (number == 0) { // 1
// 等待
this.wait();
}
number--;
System.out.println(Thread.currentThread().getName() + "=>" + number);
// 通知其他线程,我-1完毕了
this.notifyAll();
}
}
通过 Lock
找到 Condition
:
package com.idiot.demo1;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class B {
public static void main(String[] args) {
Data2 data = new Data2();
new Thread(()->{
for (int i = 0; i < 10; i++) {
try {
data.increment();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
},"A").start();
new Thread(()->{
for (int i = 0; i < 10; i++) {
try {
data.decrement();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
},"B").start();
new Thread(()->{
for (int i = 0; i < 10; i++) {
try {
data.increment();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
},"C").start();
new Thread(()->{
for (int i = 0; i < 10; i++) {
try {
data.decrement();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
},"D").start();
}
}
// 判断等待,业务,通知
class Data2 { // 数字 资源类
private int number = 0;
Lock lock = new ReentrantLock();
Condition condition = lock.newCondition();
//condition.await(); 等待
//condition.signalAll(); 唤醒全部
//+1
public void increment() throws InterruptedException {
lock.lock();
try {
while (number != 0) { //0
condition.await();
}
number++;
System.out.println(Thread.currentThread().getName() + "=>" + number);
condition.signalAll();
} catch (Exception e){
e.printStackTrace();
} finally {
lock.unlock();
}
}
//-1
public void decrement() throws InterruptedException {
lock.lock();
try {
while (number == 0) { //0
condition.await();
}
number--;
System.out.println(Thread.currentThread().getName() + "=>" + number);
condition.signalAll();
} catch (Exception e){
e.printStackTrace();
} finally {
lock.unlock();
}
}
}
任何一个新的技术,绝对不是仅仅只是覆盖了原来的技术,更有优势和补充!Condition
精准的通知和唤醒线程;
可以从上面的运行截图中发现,A,B,C,D的输出是随机的,并不是我们想要的有序输出,这是就要使用 Condition
的精准通知和唤醒功能了;
package com.idiot.demo1;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class C {
public static void main(String[] args) {
Data3 data = new Data3();
new Thread(()->{
for (int i = 0; i < 10; i++) {
data.printA();
}
},"A").start();
new Thread(()->{
for (int i = 0; i < 10; i++) {
data.printB();
}
},"B").start();
new Thread(()->{
for (int i = 0; i < 10; i++) {
data.printC();
}
},"C").start();
}
}
class Data3{ // 资源类 Lock
private int number = 1; // 1A 2B 3C
private Lock lock = new ReentrantLock();
private Condition condition1 = lock.newCondition();
private Condition condition2 = lock.newCondition();
private Condition condition3 = lock.newCondition();
public void printA(){
lock.lock();
try {
while (number!=1){
condition1.await();
}
System.out.println(Thread.currentThread().getName()+"=>A");
number = 2;
condition2.signal();
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
public void printB(){
lock.lock();
try {
while (number!=2){
condition2.await();
}
System.out.println(Thread.currentThread().getName()+"=>B");
number = 3;
condition3.signal();
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
public void printC(){
lock.lock();
try {
while (number!=3){
condition3.await();
}
System.out.println(Thread.currentThread().getName()+"=>C");
number = 1;
condition1.signal();
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
}
深刻理解锁,判断锁的是谁;
可以把锁理解为上厕所,两个方法一把锁,就好比只有一个厕所,里面已经有人在上了,且把门锁了,那么另一个人只能在门外等里面的人上完解锁出来,才能进去上厕所;
8锁,就是关于锁的8个问题:
1、标准情况下,两个线程先打印“发短信”还是“打电话”?
package com.idiot.lock8;
public class Test1 {
public static void main(String[] args) {
Phone phone = new Phone();
new Thread(()->{
phone.send();
},"A").start();
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(()->{
phone.call();
},"B").start();
}
}
class Phone{
//synchronized 锁的对象是方法的调用者
//两个方法用的是同一个锁,谁先拿到谁先执行!
public synchronized void send(){
System.out.println("发短信");
}
public synchronized void call(){
System.out.println("打电话");
}
}
运行结果:毋庸置疑的是发短信先输出,因为 send()
方法先拿到 synchronized
锁,call()
方法只能等 send()
执行完之后释放锁了,才能得到 synchronized
锁;
发短信
打电话
2、如果将 send()
方法内部延迟四秒,两个线程先打印“发短信”还是“打电话”?
public synchronized void send(){
try {
TimeUnit.SECONDS.sleep(4);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("发短信");
}
运行结果:依然是发短信先输出,因为两个方法调用的是同一个对象,且 send()
方法先拿到 synchronized
锁,哪怕该方法内部睡眠了,也要等它执行完才能运行下一个线程,不会出现抢占的情况;
发短信
打电话
3、 增加了一个普通方法后,先执行“发短信”还是 “hello”?
package com.idiot.lock8;
import java.util.concurrent.TimeUnit;
public class Test2 {
public static void main(String[] args) {
Phone2 phone = new Phone2();
new Thread(()->{
phone.send();
},"A").start();
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(()->{
phone.hello();
},"B").start();
}
}
class Phone2{
//synchronized 锁的对象是方法的调用者
public synchronized void send(){
try {
TimeUnit.SECONDS.sleep(4);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("发短信");
}
//不是同步方法,不受锁的影响
public void hello(){
System.out.println("hello");
}
}
运行结果:hello 先输出,因为 hello()
只是一个普通方法,不受 synchronized
锁的影响,send()
方法睡眠的时候,hello()
方法借机抢占 CPU 或者说 CPU 自行调度使其先执行;
hello
发短信
4、 两个对象,两个同步方法,先打印“发短信”还是“打电话”?
package com.idiot.lock8;
import java.util.concurrent.TimeUnit;
public class Test2 {
public static void main(String[] args) {
Phone2 phone1 = new Phone2();
Phone2 phone2 = new Phone2();
new Thread(()->{
phone1.send();
},"A").start();
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(()->{
phone2.call();
},"B").start();
}
}
class Phone2{
//synchronized 锁的对象是方法的调用者
public synchronized void send(){
try {
TimeUnit.SECONDS.sleep(4);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("发短信");
}
public synchronized void call(){
System.out.println("打电话");
}
}
运行结果:打电话先输出,因为是两个不同的对象,所以有两把 synchronized
锁,两把锁互不影响,send()
方法会睡眠4秒,因此“打电话”先输出;
打电话
发短信
5、增加两个静态的同步方法,只有一个对象,先打印“发短信”还是“打电话”?
package com.idiot.lock8;
import java.util.concurrent.TimeUnit;
public class Test3 {
public static void main(String[] args) {
Phone3 phone1 = new Phone3();
new Thread(()->{
phone1.send();
},"A").start();
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(()->{
phone1.call();
},"B").start();
}
}
class Phone3{
// static 静态方法,类一加载就有了,锁的是Class
public static synchronized void send(){
try {
TimeUnit.SECONDS.sleep(4);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("发短信");
}
public static synchronized void call(){
System.out.println("打电话");
}
}
运行结果:发短信先输出,因为 static
静态方法在类加载的时候就有了,这意味着锁的不再是方法调用者了,而是 Class,因为是同一个对象,所以当 send()
方法获得 synchronized
锁之后,call()
方法只能等待;
发短信
打电话
6、增加两个静态的同步方法,有两个对象,先打印“发短信”还是“打电话”?
public static void main(String[] args) {
Phone3 phone1 = new Phone3();
Phone3 phone2 = new Phone3();
new Thread(()->{
phone1.send();
},"A").start();
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(()->{
phone2.call();
},"B").start();
}
运行结果:发短信先输出,在第五实验时已经得出结论,有 static
时,锁的是 Class,因此,虽然是两个对象,但他们是同一个 Class 模板生成的,所以共用同一把锁;
发短信
打电话
如果创建一个跟 Phone3
一模一样的 Phone4
,
Phone3 phone1 = new Phone3();
Phone4 phone2 = new Phone4();
运行结果:打电话先输出,因为两个对象是两把锁,互不影响,send()
方法又内置睡眠函数,因此 call()
方法先执行完;
打电话
发短信
7、1个静态的同步方法,1个普通的同步方法 ,一个对象,先打印“发短信”还是“打电话”?
package com.idiot.lock8;
import java.util.concurrent.TimeUnit;
public class Test4 {
public static void main(String[] args) {
Phone4 phone1 = new Phone4();
new Thread(()->{
phone1.send();
},"A").start();
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(()->{
phone1.call();
},"B").start();
}
}
class Phone4{
// static 静态方法,类一加载就有了,锁的是Class
public static synchronized void send(){
try {
TimeUnit.SECONDS.sleep(4);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("发短信");
}
public synchronized void call(){
System.out.println("打电话");
}
}
运行结果:打电话先输出,静态方法锁的是 Class,而普通方法锁的是方法的调用者,两者不是同一把锁,因此互不影响;
打电话
发短信
8、1个静态的同步方法,1个普通的同步方法 ,两个对象,先打印“发短信”还是“打电话”?
public static void main(String[] args) {
Phone4 phone1 = new Phone4();
Phone4 phone2 = new Phone4();
new Thread(()->{
phone1.send();
},"A").start();
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(()->{
phone2.call();
},"B").start();
}
运行结果:打电话先输出,在第七实验的时候,同一个对象的情况两者锁的都不是同一把锁,更何况两个对象呢;
打电话
发短信