目录
原理:
1.如果两个方法是由同一个锁对象调用的,则会按照main线程执行顺序执行
2.如果使用方法上为static synchronized代表锁的是类模板,多个对象调用多个static synchronized方法,本质上都在用同一个类模板,还是看main线程的执行顺序
3.如果两个线程,一个锁对象是类模板,一个是普通的对象,则两个线程互不影响。一般谁先执行完谁先打印
情况1+2、两个方法锁一个对象(有无sleep)
public class Test1 {
//两个锁线程,正常情况下,谁先执行? 一定是发短信先执行,再执行打电话
//我们让发短信线程睡上4s,哪个线程先执行? 一定还是发短信先执行
public static void main(String[] args) {
Phone phone = new Phone();
new Thread(()->{
phone.sendSms();
},"A").start();
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(()->{
phone.call();
},"B").start();
}
}
class Phone{
//两个方法用Synchronized锁的是同一个对象,谁先拿到谁执行,执行完毕释放锁另一个再执行
public synchronized void sendSms(){
try {
TimeUnit.SECONDS.sleep(4);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("发短信");
}
public synchronized void call() {
System.out.println("打电话");
}
}
情况3、一个对象,二个方法(一个带锁的方法,一个普通方法)
没有sleep的情况下,带锁的方法会先执行,有sleep的情况下普通方法会先于带锁的方法执行。原因在于锁方法对普通方法无效,如果没有sleep,带锁方法由于在main方法中被调用的位置靠上,会先进入JVM执行,位置靠下的普通方法会后进入JVM执行
package com.lt.lock8;
import java.util.concurrent.TimeUnit;
public class Test2 {
public static void main(String[] args) {
Phone2 phone = new Phone2();
new Thread(()->{
phone.sendSms();
},"A").start();
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(()->{
phone.hello();
},"B").start();
}
}
class Phone2{
public synchronized void sendSms(){
try {
TimeUnit.SECONDS.sleep(4);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("发短信");
}
public void hello(){
System.out.println("hello");
}
}
情况4、两个对象,两个同步方法
两个锁互不影响,同时开始执行,谁先执行完谁会显示在控制台上
package com.lt.lock8;
import java.util.concurrent.TimeUnit;
public class Test2 {
//两个锁线程,正常情况下,谁先执行? 一定是发短信先执行,再执行打电话
//我们让发短信线程睡上4s,哪个线程先执行? 一定还是发短信先执行
public static void main(String[] args) {
Phone2 phone = new Phone2();
Phone2 phone1 = new Phone2();
new Thread(()->{
phone.sendSms();
},"A").start();
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(()->{
phone1.call();
},"B").start();
}
}
class Phone2{
//两个方法用Synchronized锁的是同一个对象,谁先拿到谁执行,执行完毕释放锁另一个再执行
public synchronized void sendSms(){
try {
TimeUnit.SECONDS.sleep(4);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("发短信");
}
public synchronized void call() {
System.out.println("打电话");
}
}
情况5+6、两个静态同步方法(一个对象/两个对象)
static修饰的静态同步方法锁的是类,由于只有一个类,因此无论是否有sleep,有几个对象,永远是main方法中最上面的语句先执行。
package com.lt.lock8;
import java.util.concurrent.TimeUnit;
public class Test3 {
//两个锁线程,正常情况下,谁先执行? 一定是发短信先执行,再执行打电话
//我们让发短信线程睡上4s,哪个线程先执行? 一定还是发短信先执行
public static void main(String[] args) {
Phone3 phone = new Phone3();
Phone3 phone1 = new Phone3();
new Thread(()->{
phone.sendSms();
},"A").start();
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(()->{
phone1.call();
},"B").start();
}
}
class Phone3{
//两个方法用Synchronized锁的是同一个对象,谁先拿到谁执行,执行完毕释放锁另一个再执行
public static synchronized void sendSms(){
try {
TimeUnit.SECONDS.sleep(4);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("发短信");
}
public static synchronized void call() {
System.out.println("打电话");
}
}
情况7+8、一个静态同步方法一个同步方法(一或二个对象)
一个锁的是类模板,一个锁的是对象,二者互相不影响。main函数进入虚拟机时,一个条没走完,不影响第二个线继续走,谁先执行成功先打印谁。
package com.lt.lock8;
import java.util.concurrent.TimeUnit;
public class Test4 {
//两个锁线程,正常情况下,谁先执行? 一定是发短信先执行,再执行打电话
//我们让发短信线程睡上4s,哪个线程先执行? 一定还是发短信先执行
public static void main(String[] args) {
Phone4 phone = new Phone4();
Phone4 phone1 = new Phone4();
new Thread(()->{
phone.sendSms();
},"A").start();
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(()->{
phone1.call();
},"B").start();
}
}
class Phone4{
//两个方法用Synchronized锁的是同一个对象,谁先拿到谁执行,执行完毕释放锁另一个再执行
public static synchronized void sendSms(){
try {
TimeUnit.SECONDS.sleep(4);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("发短信");
}
public synchronized void call() {
System.out.println("打电话");
}
}
总结
new this 的是一个具体的手机对象
static Class是唯一的一个模板