文章目录
一、传统的Synchronized (关键字)
- 一个买票案例
package com.wlw.demo01;
/**
* 真正的多线程开发
* 线程就是一个单独的资源类,没有任何的附属操作! (只有属性和方法)
*/
public class SaleTicketDemo01 {
public static void main(String[] args) {
//多线程操作
//并发:多线程操作同一个资源类,把资源类丢入线程
final Ticket ticket = new Ticket();
//@FunctionalInterface 函数式接口 jdk1.8之后 可用lambda表达式来代替
new Thread(new Runnable() {
public void run() {
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();
}
}
//资源类
//属性+方法
//oop
class Ticket{
private int number = 50;
//synchronized的本质就是将多个线程放进一个队列,并对共享的资源加锁,之后获得锁的线程才能使用这个资源
public synchronized void sale(){
if(number > 0){
System.out.println(Thread.currentThread().getName()+"卖了第"+(number--)+"张票,"+"还剩"+number);
}
}
}
二、lock锁 (lock是一个接口)
2.1 ReentrantLock 可重入锁中的公平锁与非公平锁
-
Lock lock = new ReentrantLock();
-
点进去看一下源码
-
/** * Creates an instance of {@code ReentrantLock}. * This is equivalent to using {@code ReentrantLock(false)}. */ public ReentrantLock() { sync = new NonfairSync(); //非公平锁 } /** * Creates an instance of {@code ReentrantLock} with the * given fairness policy. * * @param fair {@code true} if this lock should use a fair ordering policy */ public ReentrantLock(boolean fair) { sync = fair ? new FairSync() : new NonfairSync(); //FairSync()为公平锁 }
-
非公平锁: 十分不公平,可以插队;(默认为非公平锁) (这个可以保证运行时间短的线程先执行完,不用一直等待前面的需要很多时间才能执行完的线程)
-
公平锁: 十分公平,必须先来后到(严格按照先来后到的顺序执行);
2.2与Synchronized不同的加锁方式的买票案例(Lock锁)
- lock锁 三部曲
- 1、 Lock lock=new ReentrantLock(); 创建锁
- 2、 lock.lock() 加锁
- 3、 finally块中 解锁:lock.unlock();
package com.wlw.demo01;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* SaleTicketDemo01 用的是synchronized 关键字加锁,SaleTicketDemo02用lock锁
*/
public class SaleTicketDemo02 {
public static void main(String[] args) {
//多线程操作
//并发:多线程操作同一个资源类,把资源类丢入线程
Ticket2 ticket = new Ticket2();
//@FunctionalInterface 函数式接口 jdk1.8之后 可用lambda表达式来代替
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 = 50;
Lock lock = new ReentrantLock(); //创建一个可重入锁
public void sale(){
lock.lock(); //加锁
try {
//业务代码
if(number > 0){
System.out.println(Thread.currentThread().getName()+"卖了第"+(number--)+"张票,"+"还剩"+number);
}
} catch (Exception e){
e.printStackTrace();
}
finally {
lock.unlock(); //解锁
}
}
}
三、Synchronized 和 Lock区别
- 1、Synchronized 内置的Java关键字,Lock是一个Java接口(在jvm层面,Lock是个java类)
- 2、Synchronized 无法判断获取锁的状态,Lock可以判断是否获取到锁;
- 3、Synchronized 会自动释放锁(a 线程执行完同步代码会释放锁 ;b 线程执行过程中发生异常会释放锁),lock必须要手动加锁和手动释放锁!(unlock()方法释放锁,否则容易造成线程死锁;)
- 4、用synchronized关键字的两个线程1和线程2,如果当前线程1获得锁,线程2线程等待。如果线程1阻塞,线程2则会一直等待下去, lock就不一定会一直等待下去,lock会有一个trylock去尝试获取锁,不会造成长久的等待,如果尝试获取不到锁,线程可以不用一直等待就结束了;
- 5、Synchronized 是可重入锁,不可以中断的,默认就是非公平的;Lock,可重入的,可以判断锁,可以自己设置公平锁和非公平锁(默认是非公平的,如果创建可重入锁时加了true就是获得公平锁);
- 6、Synchronized 适合锁少量的代码同步问题,Lock适合锁大量的同步代码;