这里不做原理分析，列举了7种情况，意在我们使用synchronized时更加有底气
。下面的情况都是围绕这个姑且称为定理的东西来讲的
synchronized作用于方法上，有static的修饰时锁定的是调用这个方法的对象
无static修饰时锁定的是拥有这个方法的类的class
情况1
public class test02 {
public static void main(String[] args) {
data data1 = new data();
data data2 = new data();
new Thread(()->{
data1.printA();
},"A").start();
new Thread(()->{
data2.printB();
},"B").start();
//data.printA(); 先执行，虽然休眠了2秒,但是锁住了data的class,故还是根据执行上下文顺序执行
//data.printB(); 后执行
}
static class data {
/**
* @method synchronized锁的是data.class
*/
public static synchronized void printA() {
try {
TimeUnit.SECONDS.sleep(2);
System.out.println("A");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
/**
* @method 生产者
*/
public static synchronized void printB() {
System.out.println("B");
}
}
}
情况2
public class test03 {
public static void main(String[] args) {
data data1 = new data();
data data2 = new data();
new Thread(() -> {
data1.printA();
}, "A").start();
new Thread(() -> {
data2.printB();
}, "B").start();
//data.printB(); 先执行，虽然休眠了2秒,data1锁住的是data对象。data2锁定的是data的class，
// 锁定的范围不一致，因此A有休眠后执行
//data.printA(); 后执行
}
static class data {
/**
* @method synchronized锁的是调用这个方法的对象
*/
public static synchronized void printA() {
try {
TimeUnit.SECONDS.sleep(2);
System.out.println("A");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
/**
* @method 生产者
*/
public synchronized void printB() {
System.out.println("B");
}
}
}
情况3
public class test04 {
public static void main(String[] args) {
data data = new data();
new Thread(()->{
data.printA();
},"A").start();
new Thread(()->{
data.printB();
},"B").start();
//data.printA(); 先执行，虽然休眠了2秒,但是锁住了data对象,根据执行上下文顺序执行
//data.printB(); 后执行
}
static class data {
/**
* @method synchronized锁的是data.class
*/
public synchronized void printA() {
try {
Thread.sleep(2000);
System.out.println("A");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
/**
* @method 生产者
*/
public synchronized void printB() {
System.out.println("B");
}
}
}
情况4
public class test05 {
public static void main(String[] args) {
data data = new data();
new Thread(() -> {
data.printA();
}, "A").start();
new Thread(() -> {
data.printB();
}, "B").start();
new Thread(() -> {
data.printC();
}, "C").start();
//data.printC(); 先执行,因为data.printC()不受syschronized控制
//data.printA(); 接着执行，虽然休眠了2秒,但是锁住了data对象,根据执行上下文顺序执行
//data.printB(); 后执行
}
static class data {
/**
* @method synchronized锁的是data.class
*/
public synchronized void printA() {
try {
Thread.sleep(2000);
System.out.println("A");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
/**
* @method 生产者
*/
public synchronized void printB() {
System.out.println("B");
}
public void printC() {
System.out.println("C");
}
}
}
情况5
public class test06 {
public static void main(String[] args) {
data data1 = new data();
data data2 = new data();
new Thread(() -> {
data1.printA();
}, "A").start();
new Thread(() -> {
data2.printB();
}, "B").start();
//data.printB(); 先执行,因为syschronized锁的是class,且data1.printA()休眠了2秒
//data.printA(); 后执行
}
static class data {
/**
* @method synchronized锁的是data.class
*/
public synchronized void printA() {
try {
Thread.sleep(2000);
System.out.println("A");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
/**
* @method 生产者
*/
public synchronized void printB() {
System.out.println("B");
}
}
}
情况6
public class test06 {
public static void main(String[] args) {
data data1 = new data();
data data2 = new data();
new Thread(() -> {
data1.printA();
}, "A").start();
new Thread(() -> {
data2.printB();
}, "B").start();
//data.printB(); 先执行,因为syschronized锁的是class,且data1.printA()休眠了2秒
//data.printA(); 后执行
}
static class data {
/**
* @method synchronized锁的是data.class
*/
public synchronized void printA() {
try {
Thread.sleep(2000);
System.out.println("A");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
/**
* @method 生产者
*/
public synchronized void printB() {
System.out.println("B");
}
}
}
情况7
public class test07 {
public static void main(String[] args) {
data data1 = new data();
data data2 = new data();
new Thread(() -> {
data1.printA();
}, "A").start();
new Thread(() -> {
data2.printB();
}, "B").start();
//data.printB(); 先执行，虽然休眠了2秒,data1锁住的是data对象。data2锁定的是data的class，
// 锁定的范围不一致，因此A有休眠后执行
//data.printA(); 后执行
}
static class data {
/**
* @method synchronized锁的是调用这个方法的对象
*/
public static synchronized void printA() {
try {
TimeUnit.SECONDS.sleep(2);
System.out.println("A");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
/**
* @method 生产者
*/
public static synchronized void printB() {
System.out.println("B");
}
}
}