1. 悲观锁与乐观锁
- 悲观锁:认为自己在使用数据的时候一定会有别的线程来修改数据,因此在获取数据的时候会先加锁,确保数据不会被别的线程修改。synchroized和Lock的实现类都是
- 乐观锁:认为自己在使用数据时不会有别的线程修改数据或资源,所以不会加锁。如果这个数据没有被更新,当前线程将自己修改的数据成功写入。如果数据已被修改,则根据自定义不同操作,比如放弃修改,重抢试锁。判断规则:1. 版本号机制Version、2. CAS算法,Java原子类中的递增操作就是通过CAS自旋实现
2. synchronized关键字
synchronized锁的是整个资源类。同一时刻,只能有一个线程访问被synchronized修饰的方法。
// 线程操作资源类
class Phone{
public synchronized void sendEmail() {
System.out.println("sendEmail");
}
// 被synchronized修饰,同一时刻,只能允许一个线程访问类中的一个synchronized方法
public synchronized void sendSMS() {
System.out.println("sendSMS");
}
// 没有被synchronized修饰,多个线程可以同时访问
public void hello() {
System.out.println("Hello");
}
}
public class demo02 {
public static void main(String[] args) {
Phone phone1 = new Phone();
Phone phone2 = new Phone();
new Thread(()->{
phone1.sendEmail();
}, "t1").start();
// try {
// TimeUnit.MILLISECONDS.sleep(200);
// } catch (InterruptedException e) {
// throw new RuntimeException(e);
// }
new Thread(()->{
phone1.sendSMS();
// phone2.hello();
// phone1.sendSMS();
}, "t2").start();
}
}
以下情况会先打印 Email :
// 线程操作资源类
class Phone{
public synchronized void sendEmail() {
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.println("sendEmail");
}
public synchronized void sendSMS() {
System.out.println("sendSMS");
}
}
public class demo02 {
public static void main(String[] args) {
Phone phone = new Phone();
new Thread(()->{
phone.sendEmail();
}, "t1").start();
try {
TimeUnit.MILLISECONDS.sleep(200);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
new Thread(()->{
phone.sendSMS();
}, "t2").start();
}
}
先打印 SMS :
public static void main(String[] args) {
Phone phone1 = new Phone();
Phone phone2 = new Phone();
new Thread(()->{
phone1.sendEmail();
}, "t1").start();
try {
TimeUnit.MILLISECONDS.sleep(200);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
new Thread(()->{
// phone.sendSMS();
// phone2.hello();
phone2.sendSMS();
}, "t2").start();
}
方法被static和synchronized修饰时,synchronized锁是类锁而不是实例锁,也即锁的是模板类。
先打印 Email :
// 线程操作资源类
class Phone{
public static synchronized void sendEmail() {
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.println("sendEmail");
}
public static synchronized void sendSMS() {
System.out.println("sendSMS");
}
public void hello() {
System.out.println("Hello");
}
}
public class demo02 {
public static void main(String[] args) {
Phone phone1 = new Phone();
// Phone phone2 = new Phone();
new Thread(()->{
phone1.sendEmail();
}, "t1").start();
try {
TimeUnit.MILLISECONDS.sleep(200);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
new Thread(()->{
// phone.sendSMS();
// phone2.hello();
phone1.sendSMS();
}, "t2").start();
}
}
public class demo02 {
public static void main(String[] args) {
Phone phone1 = new Phone();
Phone phone2 = new Phone();
new Thread(()->{
phone1.sendEmail();
}, "t1").start();
try {
TimeUnit.MILLISECONDS.sleep(200);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
new Thread(()->{
// phone.sendSMS();
// phone2.hello();
phone2.sendSMS();
}, "t2").start();
}
}
static synchronized锁的是Object模板类,synchronized锁是实例锁。两个不是同一把锁。
打印SMS:
// 线程操作资源类
class Phone{
public static synchronized void sendEmail() {
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.println("sendEmail");
}
public synchronized void sendSMS() {
System.out.println("sendSMS");
}
public void hello() {
System.out.println("Hello");
}
}
public class demo02 {
public static void main(String[] args) {
Phone phone1 = new Phone();
Phone phone2 = new Phone();
new Thread(()->{
phone1.sendEmail();
}, "t1").start();
try {
TimeUnit.MILLISECONDS.sleep(200);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
new Thread(()->{
// phone.sendSMS();
// phone2.hello();
phone2.sendSMS();
}, "t2").start();
}
}
public static void main(String[] args) {
Phone phone1 = new Phone();
Phone phone2 = new Phone();
new Thread(()->{
phone1.sendEmail();
}, "t1").start();
try {
TimeUnit.MILLISECONDS.sleep(200);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
new Thread(()->{
// phone.sendSMS();
// phone2.hello();
phone1.sendSMS();
}, "t2").start();
}
有两个monitorexit是为了防止出现异常,保证锁一定会被释放。代码中有抛异常的只会有一个monitorexit。
public class demo03 {
Object o = new Object();
Book book = new Book();
// 一般来说,会有一个monitorenter和两个monitorexit。但在代码中,直接写throw异常,则只会有一个monitorenter和一个monitorexit
public void test01() {
/**
* 任何一个对象都可以成为一个锁 class Book extends Object
* 在HotSpot虚拟机中,monitor采用ObjectMonitor实现
* 每个对象天生都带着一个对象监视器
* 每一个被锁住的对象都会和 Monitor关系起来
*/
synchronized (book) {
System.out.println("Hello World");
}
}
// 设置ACC_SYNCHRONIZED字段,会先持有锁,再执行方法
public synchronized void test02() {
System.out.println("Hello World");
}
// 设置ACC_STATIC, ACC_SYNCHRONIZED字段,判别是class锁,还是实例锁
public static synchronized void test03() {
System.out.println("Hello");
}
public static void main(String[] args) {
System.out.println("Hello");
}
}