在JAVA中,synchronized锁可能是我们最早接触的锁了,在 JDK1.5之前synchronized是一个重量级锁,相对于juc包中的Lock,synchronized显得比较笨重。庆幸的是在 Java 6 之后 Java 官方从 JVM 层对synchronized进行优化,所以现在的 synchronized 锁效率也优化得很不错。而本文则主要通过各种简单的demo来阐述synchronized锁的各种用法以及使用synchronized锁的相关注意事项。
这里的synchronized类锁的作用范围是类级别的,它不会因为同一个类的不同对象执行而失效。
1、synchronized分别修饰同一个类的静态方法和当前类时互斥
public class SynchronizeAndClassLock2 {
public static void main(String[] args) throws Exception {
new Thread(() -> {
// new了一个ClassLock2对象
new ClassLock2().test1();
// ClassLock2.test1();
}).start();
new Thread(() -> {
// new了另一个ClassLock2对象
new ClassLock2().test2();
// ClassLock2.test2();
}).start();
}
}
class ClassLock2 {
public synchronized static void test1(){
System.out.println(new Date() + " " + Thread.currentThread().getName() + " begin...");
try {
TimeUnit.SECONDS.sleep(1);
} catch (Exception e) {}
System.out.println(new Date() + " " + Thread.currentThread().getName() + " end...");
}
public static void test2(){
// 【注意】synchronized (SynchronizeAndClassLock2.class)不会互斥
synchronized (ClassLock2.class) {
System.out.println(new Date() + " " + Thread.currentThread().getName() + " begin...");
try {
TimeUnit.SECONDS.sleep(1);
} catch (Exception e) {}
System.out.println(new Date() + " " + Thread.currentThread().getName() + " end...");
}
}
}
运行结果:
【结论】两个线程同时分别执行一个被synchronized修饰static方法,一个有synchnized(该类)代码块的static方法,锁生效,虽然是不同对象,因为是两个线程使用的同一个类锁。反之如果是修饰的不同类,肯定不会互斥,因为类锁不同。例如将test2方法的synchronized (ClassLock2.class)这句改成synchronized (
SynchronizeAndClassLock2.class),这时候不会互斥。
2、synchronized修饰同一个类的两个静态方法时互斥
public class SynchronizeAndClassLock {
public static void main(String[] args) throws Exception {
new Thread(() -> {
// new了一个ClassLock对象
new ClassLock().test1();
}).start();
new Thread(() -> {
// new了另一个ClassLock对象
new ClassLock().test2();
}).start();
}
}
class ClassLock {
public synchronized static void test1(){
System.out.println(new Date() + " " + Thread.currentThread().getName() + " begin...");
try {
TimeUnit.SECONDS.sleep(1);
} catch (Exception e) {}
System.out.println(new Date() + " " + Thread.currentThread().getName() + " end...");
}
// 【注意】public static void test2(){ 不会互斥,因为此时test2没有使用类锁。
public synchronized static void test2(){
System.out.println(new Date() + " " + Thread.currentThread().getName() + " begin...");
try {
TimeUnit.SECONDS.sleep(1);
} catch (Exception e) {}
System.out.println(new Date() + " " + Thread.currentThread().getName() + " end...");
}
}
运行结果:
【结论】两个线程分别同时执行同一个类产生的不同对象的两个不同 synchronized static方法,类锁生效,虽然是不同对象,因为两个线程使用的是同一个类锁。反之,如果test2方法没有synchronized修饰的话,即使只有test1方法被synchronized修饰,这时候两个方法也不会互斥,一个没有锁,一个有锁,所以自然不会互斥。
3、synchronized分别修饰同一个静态对象时互斥
public class SynchronizeAndClassLock10 {
public static void main(String[] args) throws Exception {
new Thread(() -> {
new RunObject1().test1();
}).start();
new Thread(() -> {
new RunObject2().test2();
}).start();
}
}
class RunObject1 {
public static void test1(){
// 【1】synchronized (StaticLock2.staticLock1) {
synchronized (StaticLock2.staticLock) {
System.out.println(new Date() + " " + Thread.currentThread().getName() + " begin...");
try {
TimeUnit.SECONDS.sleep(1);
} catch (Exception e) {}
System.out.println(new Date() + " " + Thread.currentThread().getName() + " end...");
}
}
}
class RunObject2 {
public static void test2() {
// 【2】synchronized (StaticLock2.staticLock2) {
synchronized (StaticLock2.staticLock) {
System.out.println(new Date() + " " + Thread.currentThread().getName() + " begin...");
try {
TimeUnit.SECONDS.sleep(1);
} catch (Exception e) {}
System.out.println(new Date() + " " + Thread.currentThread().getName() + " end...");
}
}
}
class StaticLock2 {
public static Object staticLock = new Object();
}
运行结果:
【结论】synchronized分别修饰同一个类的静态对象时互斥,反过来,如果是修饰不同的静态对象,肯定不会互斥,比如将上面代码中标【1】和【2】的synchronized代码结合使用。
这里的synchronized对象锁的作用范围是对象级别的,也就是说只作用于同一个对象,如果是同一个类的两个不同的对象是不会互斥的,也就是是没有效果的。
1、synchronized修饰同一个类对象的两个非静态方法时互斥
public class SynchronizeAndClassLock10 {
public static void main(String[] args) throws Exception {
new Thread(() -> {
new RunObject1().test1();
}).start();
new Thread(() -> {
new RunObject2().test2();
}).start();
}
}
class RunObject1 {
public static void test1(){
// 【1】synchronized (StaticLock2.staticLock1) {
synchronized (StaticLock2.staticLock) {
System.out.println(new Date() + " " + Thread.currentThread().getName() + " begin...");
try {
TimeUnit.SECONDS.sleep(1);
} catch (Exception e) {}
System.out.println(new Date() + " " + Thread.currentThread().getName() + " end...");
}
}
}
class RunObject2 {
public static void test2() {
// 【2】synchronized (StaticLock2.staticLock2) {
synchronized (StaticLock2.staticLock) {
System.out.println(new Date() + " " + Thread.currentThread().getName() + " begin...");
try {
TimeUnit.SECONDS.sleep(1);
} catch (Exception e) {}
System.out.println(new Date() + " " + Thread.currentThread().getName() + " end...");
}
}
}
class StaticLock2 {
public static Object staticLock = new Object();
}
运行结果:
【结论】两个线程同时执行被synchronized修饰的相同对象的不同(相同)方法,锁生效,因为是相同的对象锁被两个线程使用。
2、synchronized分别修饰同一个类对象的非静态方法和当前对象时互斥
public class SynchronizeAndObjectLock3 {
public static void main(String[] args) throws Exception {
// 【注意】当且仅当是同一个SynchronizeAndObjectLock3对象
SynchronizeAndObjectLock3 synchronizeAndObjectLock3 = new SynchronizeAndObjectLock3();
new Thread(() -> {
synchronizeAndObjectLock3.test1();
}).start();
new Thread(() -> {
synchronizeAndObjectLock3.test2();
}).start();
}
public void test1(){
synchronized(this) {
System.out.println(new Date() + " " + Thread.currentThread().getName() + " begin...");
try {
TimeUnit.SECONDS.sleep(1);
} catch (Exception e) {}
System.out.println(new Date() + " " + Thread.currentThread().getName() + " end...");
}
}
public synchronized void test2(){
System.out.println(new Date() + " " + Thread.currentThread().getName() + " begin...");
try {
TimeUnit.SECONDS.sleep(1);
} catch (Exception e) {}
System.out.println(new Date() + " " + Thread.currentThread().getName() + " end...");
}
}
运行结果:
【结论】snchronized修饰非静态方法与synchronized(this)互斥,所以,snchronized修饰非静态方法实质锁的是当前对象。
3、synchronized修饰不同对象的两个非静态方法时不会互斥
public class SynchronizeAndObjectLock {
public static void main(String[] args) throws Exception {
new Thread(() -> {
// 这里new 了一个SynchronizeAndObjectLock对象
new SynchronizeAndObjectLock().test1();
}).start();
new Thread(() -> {
// 这里new 了另一个SynchronizeAndObjectLock对象
new SynchronizeAndObjectLock().test2();
}).start();
}
public synchronized void test1(){
System.out.println(new Date() + " " + Thread.currentThread().getName() + " begin...");
try {
TimeUnit.SECONDS.sleep(1);
} catch (Exception e) {}
System.out.println(new Date() + " " + Thread.currentThread().getName() + " end...");
}
public synchronized void test2(){
System.out.println(new Date() + " " + Thread.currentThread().getName() + " begin...");
try {
TimeUnit.SECONDS.sleep(1);
} catch (Exception e) {}
System.out.println(new Date() + " " + Thread.currentThread().getName() + " end...");
}
}
运行结果:
【结论】两个线程同时执行被synchronized修饰的不同对象的不同(相同)方法,锁未生效,因为两个线程使用的是不同的对象锁。
4、synchronized代码块修饰同一个对象时互斥
public class SynchronizeAndObjectLock5 {
private Object objectLock = new Object();
public static void main(String[] args) throws Exception {
SynchronizeAndObjectLock5 synchronizeAndObjectLock5 = new SynchronizeAndObjectLock5();
new Thread(() -> {
synchronizeAndObjectLock5.test1();
}).start();
new Thread(() -> {
synchronizeAndObjectLock5.test2();
}).start();
}
public void test1(){
synchronized(objectLock) {
System.out.println(new Date() + " " + Thread.currentThread().getName() + " begin...");
try {
TimeUnit.SECONDS.sleep(1);
} catch (Exception e) {}
System.out.println(new Date() + " " + Thread.currentThread().getName() + " end...");
}
}
public void test2(){
synchronized(objectLock) {
System.out.println(new Date() + " " + Thread.currentThread().getName() + " begin...");
try {
TimeUnit.SECONDS.sleep(1);
} catch (Exception e) {}
System.out.println(new Date() + " " + Thread.currentThread().getName() + " end...");
}
}
}
运行结果:
【结论】synchronized代码块修饰同一个对象时互斥,如果synchronized代码块修饰的是不同对象,就不会互斥。
public class ClassAndObjectLock {
public static void main(String[] args) throws Exception {
new Thread(() -> {
ClassAndObjectLock.test1();
}).start();
new Thread(() -> {
new ClassAndObjectLock().test2();
}).start();
}
public static void test1(){
synchronized (ClassAndObjectLock.class) {
System.out.println(new Date() + " " + Thread.currentThread().getName() + " begin...");
try {
TimeUnit.SECONDS.sleep(1);
} catch (Exception e) {}
System.out.println(new Date() + " " + Thread.currentThread().getName() + " end...");
}
}
public void test2(){
synchronized (this) {
System.out.println(new Date() + " " + Thread.currentThread().getName() + " begin...");
try {
TimeUnit.SECONDS.sleep(1);
} catch (Exception e) {}
System.out.println(new Date() + " " + Thread.currentThread().getName() + " end...");
}
}
}
运行结果:
【结论】能够看到,类锁和对象锁互不相斥,因为是相互独立的。
1、synchronized锁不带超时功能
synchronized锁是不带超时功能的,而ReentrantLock的tryLock具备带超时功能,在指定时间没获取到锁,这个线程就会苏醒,有助于预防死锁的产生。
2、唤醒/等待需要synchronized锁
public class NotifyNeedSynchronized {
public static Object lock = new Object();
public static void main(String[] args) throws Exception{
// 抛出IllegalMonitorStateException
//lock.notify();
lock.wait();
}
}
运行结果:
【结论】使用Object的wait和notify等方法时,必须要使用synchronized锁,否则会抛出
IllegalMonitorStateException。
3、synchronized锁不能被中断
首先为了模拟synchronized锁不可中断,我们先将这两个线程进入死锁,再用main线程中断其中一个线程,来看被中断的线程能不能释放锁并被唤醒。
public class DeadLockCannotInterruptDemo {
private static Object lock1 = new Object();
private static Object lock2 = new Object();
public static void main(String[] args) throws Exception {
Thread threadA = new Thread(new Runnable() {
@Override
public void run() {
synchronized (lock1) {
System.out.println(Thread.currentThread().getName() + " get lock1");
try {
Thread.sleep(10);
synchronized (lock2) {
System.out.println(Thread.currentThread().getName() + " get lock2");
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
});
Thread threadB = new Thread(new Runnable() {
@Override
public void run() {
synchronized (lock2) {
System.out.println(Thread.currentThread().getName() + " get lock2");
try {
Thread.sleep(10);
synchronized (lock1) {
System.out.println(Thread.currentThread().getName() + " get lock1");
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
});
threadA.start();
threadB.start();
TimeUnit.SECONDS.sleep(3);
System.out.println("main thread begin to interrupt " + threadA.getName() + " and " + threadA.getName() + " will release lock1...");
threadA.interrupt();
}
}
运行结果:
【结论】如运行结果所示,在main线程中断Thread-0后,Thread-0并不会释放锁并醒过来。所以ReentrantLock的tryLock或lockInterruptibly也是可以被中断的。
5、synchronized锁可重入
public class SynchronizeAndReentrant2 {
int i = 1;
public static void main(String[] args) throws Exception {
SynchronizeAndReentrant2 synchronizeAndReentrant = new SynchronizeAndReentrant2();
synchronizeAndReentrant.test1();
}
public synchronized void test1(){
System.out.println(" test1 method is called " + i++ + "st time..." );
while(i < 5) {
test1();
}
}
}
运行结果:
public class SynchronizeAndReentrant {
public static void main(String[] args) throws Exception {
SynchronizeAndReentrant synchronizeAndReentrant = new SynchronizeAndReentrant();
synchronizeAndReentrant.test1();
}
public synchronized void test1(){
System.out.println(" test1 method is called...");
test2();
}
public synchronized void test2(){
System.out.println(" test2 method is called...");
}
}
运行结果:
5、使用synchronized锁时需尽量缩小范围用来保证性能
使用synchronized锁时,我们需要尽量缩小锁的范围,去尽可能的提高性能。可以不锁方法就不要锁方法,建议尽量使用synchronized代码块去降低锁的范围。拿下面的一段netty源码为例:
// ServerBootstrap.java
public <T> ServerBootstrap childOption(ChannelOption<T> childOption, T value) {
if (childOption == null) {
throw new NullPointerException("childOption");
}
if (value == null) {
synchronized (childOptions) {
childOptions.remove(childOption);
}
} else {
synchronized (childOptions) {
childOptions.put(childOption, value);
}
}
return this;
}
能够发现,找到并发访问代码的临界区,并不用synchronized锁全部代码,尽量避免使用synchronized来修饰方法。
这篇文章通过demo简单梳理了下对synchronized的各种用法和注意事项,希望能够对你有所帮助,如果有哪里不对或者可以改进的地方也欢迎在评论区指正,记得点赞+关注支持一下哟,祝大家早日富可敌国!